Page History

version: '3.8'

services:
  ravendb:
    image: ravendb/ravendb:ubuntu-latest
    container_name: ravendb
    ports:
      - "9000:8080"
    environment:
      - RAVEN_Setup_Mode=None
      - RAVEN_License_Eula_Accepted=true
    volumes:
      - ravendb_data:/ravendb/data
      - ravendb_logs:/ravendb/logs

volumes:
  ravendb_data:
  ravendb_logs:

public class Member
{
    public string Id { get; set; } // RavenDB는 기본적으로 Id를 문서 키로 사용
    public string Name { get; set; }
    public string Email { get; set; }
    public int Age { get; set; }
}

public class MemberRepository
{
    private readonly IDocumentStore _store;

    public MemberRepository(IDocumentStore store)
    {
        _store = store ?? throw new ArgumentNullException(nameof(store));
    }

    public void AddMember(Member member)
    {
        using (var session = _store.OpenSession())
        {
            session.Store(member);
            session.SaveChanges();
        }
    }

    public Member GetMemberById(string id)
    {
        using (var session = _store.OpenSession())
        {
            return session.Load<Member>(id);
        }
    }

    public void UpdateMember(Member member

public class Member
{
    public string Id { get; set; } // RavenDB는 기본적으로 Id를 문서 키로 사용
    public string Name { get; set; }
    public string Email { get; set; }
    public int Age { get; set; }
}

public class MemberRepository
{
    private readonly IDocumentStore _store;

    public MemberRepository(IDocumentStore store)
    {
        _storeusing (var session = store ?? throw new ArgumentNullException(nameof(store));
    }

_store.OpenSession())
     public void AddMember(Member member){
    {
        using (var sessionexistingMember = _storesession.OpenSessionLoad<Member>(member.Id));
        {
    if (existingMember       session.Store(member);!= null)
            session.SaveChanges();
{
         }
    }

   existingMember.Name public Member GetMemberById(string id)
= member.Name;
      {
        using (var sessionexistingMember.Email = _store.OpenSession())member.Email;
        {
        existingMember.Age = member.Age;
             return   session.Load<Member>SaveChanges(id);
            }
        }
    }

    public void UpdateMemberDeleteMember(Memberstring memberid)
    {
        using (var session = _store.OpenSession())
        {
            var existingMembermember = session.Load<Member>(member.Idid);
            if (existingMembermember != null)
            {
                existingMember.Name = member.Namesession.Delete(member);
                existingMember.Email = member.Email;
session.SaveChanges();
            }
       existingMember.Age = member.Age; }
    }
}

public class MemberRepositoryTest : TestKitXunit
{
    private readonly   session.SaveChanges()IDocumentStore _store;
    private readonly MemberRepository _repository;
     }
    public MemberRepositoryTest(ITestOutputHelper output) : }base(output)
    }{

    public  void DeleteMember(string id)
    { // RavenDB 임베디드 서버 초기화
        using_store (var= session = _store.OpenSession())new DocumentStore
        {
            var memberUrls = session.Load<Member>(id);
       new[] { "http://localhost:9000" }, // 로컬 RavenDB URL
     if (member != null)
    Database        {= "net-core-labs"
        };
        session_store.DeleteInitialize(member);

        // MemberRepository 초기화
        _repository = new session.SaveChangesMemberRepository(_store);
    }
    
    }[Fact]
    public void AddMember_ShouldAddMemberSuccessfully()
    }{
    }
}

using ActorLib.Persistent.Model;
using Raven.Client.Documents;
using Raven.Client.Documents.Indexes.Vector;
using Raven.Client.Documents.Linq;

namespace ActorLib.Persistent;

public class TravelReviewRepository
{
    private readonly IDocumentStore _store;

    public TravelReviewRepository(IDocumentStore store)
    {
        _store = store ?? throw new ArgumentNullException(nameof(store));
    }

    public void AddReview(TravelReview review)
    {
        using (var session = _store.OpenSession())
        {
            session.Store(review);
            session.SaveChanges();
        }
    }

    public List<TravelReview> SearchReviews(string keyword, double latitude, double longitude, double radiusKm, string category = null)
    {
        using (var session = _store.OpenSession())
        {
            // 명시적으로 변수로 선언
            var keywordValue = keyword;
            var categoryValue = category;

            IRavenQueryable<TravelReview> query = session.Query<TravelReview>();

            if (!string.IsNullOrEmpty(keywordValue))
            {
                query = query.Search(r => r.Content, keywordValue); // 제목 검색 추가
            }

            if (!string.IsNullOrEmpty(categoryValue))
            {
                query = query.Where(r => r.Category == categoryValue); // 제목 검색 추가
            }

            // RavenDB에서 서버 측 필터링 후 클라이언트 측에서 반경 필터링
            var results = query.ToList();

            return results.Where(r =>
                6371 * Math.Acos(
                    Math.Cos(DegToRad(latitude)) * Math.Cos(DegToRad(r.Latitude)) *
                    Math.Cos(DegToRad(r.Longitude) - DegToRad(longitude)) +
                    Math.Sin(DegToRad(latitude)) * Math.Sin(DegToRad(r.Latitude))
                ) <= radiusKm).ToList();
        }
    }
    
    public List<TravelReview> SearchReviewsByRadius(double latitude, double longitude, double radiusKm)
    {
        using (var session = _store.OpenSession())
        {
            return session.Query<TravelReview>()
                .Spatial(
                    r => r.Point(x => x.Latitude, x => x.Longitude),
                    criteria => criteria.WithinRadius(radiusKm, latitude, longitude))
                .ToList();
        }
    }
    
    public List<TravelReview> SearchReviewsByVector(float[] vector, int topN = 5)
    {
        using (var session = _store.OpenSession())
        {
            var results = session.Query<TravelReview>()
                .VectorSearch(
                    field => field.WithEmbedding(x => x.TagsEmbeddedAsSingle, VectorEmbeddingType.Single),
                    queryVector => queryVector.ByEmbedding(new RavenVector<float>(vector)),
                    0.85f,
                    topN)
                .Customize(x => x.WaitForNonStaleResults())
                .ToList();

            return results;
        }
    }

    private double DegToRad(double degrees)
    {
        return degrees * (Math.PI / 180);
    }
}

public class SalesActor: ReceivePersistentActor
{
    // The unique actor id
    public override string PersistenceId => "sales-actor";
    
    // The state that will be persisted in SNAPSHOTS
    private SalesActorState _state;
    
    public SalesActor(long expectedProfit, TaskCompletionSource<bool> taskCompletion)
    {
        _state = new SalesActorState
        {
            totalSales = 0
        }; 
        
        // Process a sale:
        Command<Sale>(saleInfo =>
        {
            if (_state.totalSales < expectedProfit)
            {
                // Persist an EVENT to RavenDB
                // ===========================
                
                // The handler function is executed after the EVENT was saved successfully
                Persist(saleInfo, _ =>
                {
                    // Update the latest state in the actor
                    _state.totalSales += saleInfo.Price;

                    ConsoleHelper.WriteToConsole(ConsoleColor.Black,
                        $"Sale was persisted. Phone brand: {saleInfo.Brand}. Price: {saleInfo.Price}");

                    // Store a SNAPSHOT every 5 sale events
                    // ====================================
                    
                    if (LastSequenceNr != 0 && LastSequenceNr % 5 == 0)
                    {
                        SaveSnapshot(_state.totalSales);
                    }
                });
            }
            else if (!taskCompletion.Task.IsCompleted)
            {
                Sender.Tell(new StopSimulate());
                
                ConsoleHelper.WriteToConsole(ConsoleColor.DarkMagenta,
                    $"Sale not persisted: " +
                    $"Total sales have already reached the expected profit of {expectedProfit}");
                
                ConsoleHelper.WriteToConsole(ConsoleColor.DarkMagenta,
                    _state.ToString());
                
                taskCompletion.TrySetResult(true);
            }
        });
        
        // Handle a SNAPSHOT success msg
        Command<SaveSnapshotSuccess>(success =>
        {
            ConsoleHelper.WriteToConsole(ConsoleColor.Blue,
                $"Snapshot saved successfully at sequence number {success.Metadata.SequenceNr}");
            
            // Optionally, delete old snapshots or events here if needed
            // DeleteMessages(success.Metadata.SequenceNr);
        });
        
        // Recover an EVENT
        Recover<Sale>(saleInfo =>
        {
            _state.totalSales += saleInfo.Price;
            
            ConsoleHelper.WriteToConsole(ConsoleColor.DarkGreen,
                $"Event was recovered. Price: {saleInfo.Price}");
        });
        
        // Recover a SNAPSHOT
        Recover<SnapshotOffer>(offer =>
        {
            var salesFromSnapshot = (long) offer.Snapshot;
            _state.totalSales = salesFromSnapshot;
            
            ConsoleHelper.WriteToConsole(ConsoleColor.DarkGreen,
                $"Snapshot was recovered. Total sales from snapshot: {salesFromSnapshot}");
        });
    }
}

public override string PersistenceId => "sales-actor";

private SalesActorState _state;

Command<Sale>(saleInfo => { ... });

Persist(saleInfo, _ =>
{
    _state.totalSales += saleInfo.Price;
    
    if (LastSequenceNr % 5 == 0) {
        SaveSnapshot(_state.totalSales);
    }
});

Sender.Tell(new StopSimulate());
taskCompletion.TrySetResult(true);

Command<SaveSnapshotSuccess>(success => {
    Console.WriteLine(...);
});

Recover<Sale>(saleInfo => {
    _state.totalSales += saleInfo.Price;
});

Recover<SnapshotOffer>(offer => {
    _state.totalSales = (long)offer.Snapshot;
});

public class SalesSimulatorActor : ReceiveActor
{
    private readonly IActorRef _salesActor;
    private ICancelable scheduler;

    public SalesSimulatorActor(IActorRef salesActor)
    {
        _salesActor = salesActor;

        // Arrange
Schedule the first sale simulation immediately and then varevery member = new Member2 seconds:
        {
scheduler = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(TimeSpan.Zero, 
         Name = "Jane Doe",
     TimeSpan.FromSeconds(2), Self, new StartSimulate(), Self);
        Email
 = "jane.doe@example.com",
      Receive<StartSimulate>(HandleStart);
      Age = 25
  Receive<StopSimulate>(HandleStop);
      };

    private void   _repository.AddMember(member);
HandleStart(StartSimulate message)
    {
    // Act
   ConsoleHelper.WriteToConsole(ConsoleColor.Black,
      member.Age = 26;
    $"About to simulate a _repository.UpdateMember(membersale...");

        Random random = // Assertnew Random();
        varstring[] updatedMemberproducts = _repository.GetMemberById(member.Id);
     { "Apple", "Google", "Nokia", "Xiaomi", "Huawei" };

    Assert.NotNull(updatedMember);
    var randomBrand =  Assert.Equal(26, updatedMember.Age)products[random.Next(products.Length)];
    }

    [Fact]
var randomPrice =  public void DeleteMember_ShouldDeleteMemberSuccessfully()
    {
        // Arrangerandom.Next(1, 6) * 100; // 100, 200, 300, 400, or 500

        var membernextSale = new Member Sale(randomPrice, randomBrand);
        _salesActor.Tell(nextSale);
    {}
    
    private void HandleStop(StopSimulate message)
 Name = "Mark Smith",{
        scheduler.Cancel();
    Email   = "mark.smith@example.com"ConsoleHelper.WriteToConsole(ConsoleColor.DarkRed,
            "Simulation stopped");
    Age = 40
        };
        _repository.AddMember(member);

        // Act
        _repository.DeleteMember(member.Id);

        // Assert
        var deletedMember = _repository.GetMemberById(member.Id);
        Assert.Null(deletedMember);
    }
    
}