public async Task <IEnumerable <CarEngineWithGearboxModel> > GetEngineGearboxPairsByModelIdAsync(int id)
{
var items = await ReadRepository
.GetAsync(_engineGearboxFiltersProvider.ByModelId(id), _engineGearboxRelationsProvider.JoinGearboxAndEngine);
return(Mapper.Map <IEnumerable <CarEngineWithGearboxModel> >(items));
}
public void FindBy_Should_Return_The_Dummy_Data_And_All_Count_As_One(Mock <ISessionManager> mockSessionManager, DefaultSession session, Dummy data)
{
//Arrange
mockSessionManager.Setup(m => m.Current)
.Returns(session);
var options = new DbContextOptionsBuilder <DummyContext>()
.UseInMemoryDatabase("DummyDb")
.Options;
using (var context = new DummyContext(options, mockSessionManager.Object))
{
var repository = new WriteRepository <DummyContext, Dummy>(context);
repository.Add(data);
}
//Act
List <Dummy> list;
using (var context = new DummyContext(options, mockSessionManager.Object))
{
var repository = new ReadRepository <DummyContext, Dummy>(context);
list = repository.FindBy(e => e.Id == data.Id).ToList();
}
//Assert
list.Count.Should().Be(1);
list.First().Should().BeEquivalentTo(data);
}
public ActionResult AfisareMasini()
{
var repo = new ReadRepository();
var masinaRepo = repo.IncarcaListaMasini22222();
// masinaRepo = repo.IncarcaListaMasini();
var etc = masinaRepo.Select(_ => _.CIV.ToString()).Distinct().ToList();
var eventRepo = repo.IncarcaListaDeEvenimente();
// List<Masina> nouaMasina = masinaRepo.Select(_=>_.CIV).Distinct().ToList();
// var distincIndex = masinaRepo.FindIndex(_ => _.CIV.Text).Distinct();
List <MasinaMVC> masina = new List <MasinaMVC>();
foreach (Masina x in masinaRepo)
{
Console.WriteLine(x.CIV.ToString());
string ceva = x.CIV.ToString();
var mVC = new MasinaMVC(
x.CIV.ToString(), x.Tip, x.Marca.ToString(), x.ToString(), x.An.ToString(), x.Pret.ToString(), x.Kilometraj.ToString(),
x.Descriere.ToString(), x.Motorizare.ToString(), x.Culoare.ToString(), x.Putere.ToString(),
x.CapacitateCilindrica.ToString()
);
mVC.Stare = x.stare;
masina.Add(mVC);
}
ViewBag.Model = masina;
return(View(masina));
}
public async Task <IEnumerable <StatisticsDateCountModel> > GetStatisticsForLastDays(uint daysCount)
{
var endDate = DateTime.UtcNow.Date;
var startDate = endDate.AddDays(-daysCount);
var query = await ReadRepository.GetQueryableAsync(_filtersProvider.ByCreatedDate(startDate, endDate));
var items = await query
.GroupBy(x => x.CreateDate.Date)
.Select(x => new { Date = x.Key, Count = x.Count() })
.ToDictionaryAsync(x => x.Date, x => x.Count);
for (var date = startDate; date < endDate; date = date.AddDays(1))
{
if (!items.ContainsKey(date))
{
items.Add(date, 0);
}
}
return(items
.Select(x => new StatisticsDateCountModel {
Date = x.Key, Count = x.Value
})
.OrderBy(x => x.Date));
}
static void Main(string[] args)
{
MagistralaCommands.Instance.Value.InregistreazaProcesatoareStandard();
MagistralaEvenimente.Instanta.Value.InregistreazaProcesatoareStandard();
MagistralaEvenimente.Instanta.Value.InchideInregistrarea();
List <Eveniment> eve = new List <Eveniment>();
var writeRepo = new WriteRepository();
var readRepo = new ReadRepository();
var masina = new Masina(new PlainText("WV Passat"), 2005, new CIV("EI309MNN"), new SerieSasiu("ALABALAPR"));
var mecanic = new Mecanic(new PlainText("Nelutu"), 1);
var client = new Client(new PlainText("Orlando"), 1);
var comanda = new Comanda(mecanic, client, new IDComanada(1), masina, "reparatie turbina");
writeRepo.PlaseazaComanda(comanda);
//var commandPlasareComanda = new CommandPlasareComanda();
//MagistralaCommands.Instance.Value.Trimite(commandPlasareComanda);
//AtlierAuto.Evenimente.ProcesatorPlasareComanda procesatorPlasareComanda = new ProcesatorPlasareComanda()
//AtelierAuto.Evenimente.ProcesatorPlasareComanda procesatorPlasareComanda = new AtelierAuto.Evenimente.ProcesatorPlasareComanda();
// SalvareEvenimente(comanda);
//readRepo.CautaComanda(new Guid());
// readRepo.IncarcaDinListaDeEvenimente();
//eve = ReadRepository.IncarcaDinListaDeEvenimente();
Console.ReadLine();
Console.ReadKey();
}
public override async Task <ContestType> HandleAsync(GetContestTypeForHomeQuery query)
{
return(await ReadRepository.Set <Contest>()
.Where(x => x.Id == query.Id)
.Select(x => x.ContestType)
.SingleOrDefaultAsync());
}
public DeliveryRequestPromoteCommandValidator(IGenericReadRepository readRepository, IDeliveryRequestFiltersProvider deliveryRequestFiltersProvider) : base(readRepository)
{
_deliveryRequestFiltersProvider = deliveryRequestFiltersProvider;
RuleFor(x => x.DeliveryRequestId)
.NotEmptyWithMessage()
.MustExistsWithMessageAsync(DeliveryRequestExists)
.CustomAsync(async(deliveryRequestId, context, cancellationToken) =>
{
var query = await ReadRepository.GetQueryableAsync(deliveryRequestFiltersProvider.ById(deliveryRequestId));
var deliveryRequestStatus = (DeliveryRequestStatuses)query.Select(x => x.StatusId).FirstOrDefault();
string errorMessage;
switch (deliveryRequestStatus)
{
case DeliveryRequestStatuses.Opened:
errorMessage = "Delivery request is not assigned to the user.";
break;
case DeliveryRequestStatuses.Closed:
errorMessage = "Delivery request is closed.";
break;
default:
errorMessage = string.Empty;
break;
}
if (!string.IsNullOrEmpty(errorMessage))
{
context.AddFailure(nameof(DeliveryRequestAssignCommand.DeliveryRequestId), errorMessage);
}
});
}
public ActionResult CautaComanda()
{
var repo = new ReadRepository();
comandaRepo = ReadRepository.IncarcaDinListaDeComenzi();
var eventRepo = ReadRepository.IncarcaDinListaDeEvenimente();
List <ComandaMvc> comanda = new List <ComandaMvc>();
foreach (Comanda c in comandaRepo)
{
// string idCom = c.iDComanda.ToString();
/* var mVC = new ComandaMvc(
* x.CIV.ToString(), x.Tip, x.Marca.ToString(), x.Model.ToString(), x.An.ToString(), x.Pret.ToString(), x.Kilometraj.ToString(),
* x.Descriere.ToString(), x.Motorizare.ToString(), x.Culoare.ToString(), x.Putere.ToString(),
* x.CapacitateCilindrica.ToString()
* ); */
var mvc = new ComandaMvc(c.mecanic.nume, c.mecanic.idMecanic, c.client.nume, c.client.idClient,
c.iDComanda, c.masina.Model, c.masina.anFabricatie, c.masina.civ, c.masina.serieSasiu,
c.cerereClient);
comanda.Add(mvc);
}
ViewBag.Model = comanda;
return(View(comanda));
}
private static async Task HandleReadEventsCommandAsync(VoiceCommandServiceConnection connection)
{
try
{
ReadRepository ReadRepository = new ReadRepository();
//Genero un mensaje de espera para que el usuario vea
var userMessage = new VoiceCommandUserMessage();
userMessage.DisplayMessage = "Buscando eventos próximos ..";
userMessage.SpokenMessage = "Buscando eventos próximos ";
var response = VoiceCommandResponse.CreateResponse(userMessage);
await connection.ReportProgressAsync(response);
var today = DateTime.Now.Date;
var notices = await ReadRepository.GetNextEvents();
if (notices.Count > 1)
{
userMessage.SpokenMessage =
userMessage.DisplayMessage =
$"El dia de hoy se realizan {notices.Count} eventos";
var tile = new VoiceCommandContentTile();
tile.ContentTileType = VoiceCommandContentTileType.TitleOnly;
var titleList = new List <VoiceCommandContentTile>();
var count = 0;
foreach (var noticeModel in notices)
{
if (count <= 5)
{
titleList.Add(new VoiceCommandContentTile
{
Title = noticeModel.Title.ToString(),
ContentTileType = VoiceCommandContentTileType.TitleWithText,
TextLine1 = noticeModel.Date.ToString()
});
++count;
}
}
response = VoiceCommandResponse.CreateResponse(userMessage, titleList);
await connection.ReportProgressAsync(response);
}
else
{
if (notices != null)
{
userMessage.SpokenMessage =
userMessage.DisplayMessage =
$"Usted tiene {notices.First().Title} eventos próximos";
response = VoiceCommandResponse.CreateResponse(userMessage);
}
}
await connection.ReportSuccessAsync(response);
}
catch (Exception ex)
{
throw;
}
}
public ActionResult AfisareComenzi()
{
//var repo = new ReadRepository();
// comandaRepo = ReadRepository.IncarcaDinListaDeComenzi();
var comandaRepo = ReadRepository.IncarcaDinListaDeEvenimente();
// List<ComandaMvc> comanda = new List<ComandaMvc>();
// foreach (Comanda c in comandaRepo)
//{
// string idCom = c.iDComanda.ToString();
/* var mVC = new ComandaMvc(
* x.CIV.ToString(), x.Tip, x.Marca.ToString(), x.Model.ToString(), x.An.ToString(), x.Pret.ToString(), x.Kilometraj.ToString(),
* x.Descriere.ToString(), x.Motorizare.ToString(), x.Culoare.ToString(), x.Putere.ToString(),
* x.CapacitateCilindrica.ToString()
* ); */
/* var mvc = new ComandaMvc(c.mecanic.nume, c.mecanic.idMecanic, c.client.nume, c.client.idClient,
* c.iDComanda, c.masina.Model, c.masina.anFabricatie, c.masina.civ, c.masina.serieSasiu,
* c.cerereClient);
*/
comandaMcv = comandaRepo.Select(c => new ComandaMvc {
mecanic = c.mecanic, client = c.client, iDComanda = c.iDComanda, stareComanda = c.stareComanda,
masina = c.masina, cerereClient = c.cerereClient, cost = c.cost, evaluareMecanic = c.evaluareMecanic
}).ToList();
//comanda.Add(mvc);
// }
ViewBag.Model = comandaMcv;
return(View(comandaMcv));
}
public void GetByIdAsync_Should_Return_The_Expected_Data(Mock <ISessionManager> mockSessionManager, DefaultSession session, Dummy data)
{
//Arrange
mockSessionManager.Setup(m => m.Current)
.Returns(session);
var options = new DbContextOptionsBuilder <DummyContext>()
.UseInMemoryDatabase("DummyDb")
.Options;
using (var context = new DummyContext(options, mockSessionManager.Object))
{
var repository = new WriteRepository <DummyContext, Dummy>(context);
repository.Add(data);
}
//Act
Task <Dummy> dummyData;
using (var context = new DummyContext(options, mockSessionManager.Object))
{
var repository = new ReadRepository <DummyContext, Dummy>(context);
dummyData = repository.GetByIdAsync(data.Id);
}
//Assert
dummyData.Result.Should().BeEquivalentTo(data);
}
public override async Task <SortingQueryResult> HandleAsync(SortingQuery query)
{
var contest = await ReadRepository.Set <Contest>()
.Include(x => x.ContestAreas)
//.Include($"{nameof(Contest.ContestAreas)}.{nameof(ContestArea.Area)}")
//.Include($"{nameof(Contest.ContestRegistrations)}.{nameof(ContestRegistration.Participant1)}")
//.Include($"{nameof(Contest.ContestRegistrations)}.{nameof(ContestRegistration.StudyPlace)}")
.SingleOrDefaultAsync(m => m.Id == query.ContestId);
if (contest == null)
{
throw new EntityNotFoundException();
}
var compClassIds = contest.ContestAreas
.Where(ca => !string.IsNullOrEmpty(ca.SortingCompClassIds))
.SelectMany(c => c.SortingCompClassIds.Split(',', StringSplitOptions.RemoveEmptyEntries))
.Select(int.Parse)
.ToArray();
var viewModel = new SortingViewModel();
_mapper.Map(contest, viewModel);
var res = new SortingQueryResult
{
ViewModel = viewModel,
CompClassIds = compClassIds,
};
return(res);
}
private async Task SendNotificationAsync()
{
try
{
ReadRepository ReadRepository = new ReadRepository();
var events = await ReadRepository.GetNextEvents();
if (events == null && events.Count > 0)
{
return;
}
ToastNotifier notifier = ToastNotificationManager.CreateToastNotifier();
XmlDocument content = ToastNotificationManager.GetTemplateContent(
ToastTemplateType.ToastImageAndText01);
var texts = content.GetElementsByTagName("text");
texts[0].InnerText = $"Usted tiene un evento próximo!!";
texts[1].InnerText = $"El evento {events.First().Title} , se realizara el dia {events.First().Date.ToLocalTime()}";
var image = content.GetElementsByTagName("image");
image[0].InnerText = events.First().Image;
notifier.Show(new ToastNotification(content));
}
catch (Exception ex)
{
throw;
}
}
private async Task <List <ContestRegistration> > GetContestRegistrationsAsync(int contestId, ContestType contestType)
{
if (contestType == ContestType.Collegiate)
{
return(await ReadRepository.Set <TeamContestRegistration>()
.Include(r => r.Contest)
.Include(r => r.Participant1)
.Include(r => r.Participant2)
.Include(r => r.Participant3)
.Include(r => r.ReserveParticipant)
.Include(r => r.Trainer)
.Include(r => r.Manager)
.Include(r => r.StudyPlace.City)
.Include(r => r.ContestArea.Area)
.Where(r => r.ContestId == contestId)
.Cast <ContestRegistration>()
.ToListAsync());
}
return(await ReadRepository.Set <IndividualContestRegistration>()
.Include(r => r.Contest)
.Include(r => r.Participant1)
.Include(r => r.Trainer)
.Include(r => r.Manager)
.Include(r => r.StudyPlace.City)
.Include(r => r.ContestArea.Area)
.Where(r => r.ContestId == contestId)
.Cast <ContestRegistration>()
.ToListAsync());
}
public void SucceedIfAllDependenciesSupplied()
{
var serviceProvider = new ServiceCollection()
.AddFileService()
.BuildServiceProvider();
var target = new ReadRepository(serviceProvider, _defaultConnection);
}
public void FindByAsync_Should_Should_Return_The_Dummy_Data_And_All_Count_As_More_Than_One(Mock <ISessionManager> mockSessionManager, DefaultSession session, Dummy data1, Dummy data2)
{
//Arrange
mockSessionManager.Setup(m => m.Current)
.Returns(session);
var options = new DbContextOptionsBuilder <DummyContext>()
.UseInMemoryDatabase("DummyDb")
.Options;
string name = "berdan";
data1.Name = name;
data2.Name = name;
using (var context = new DummyContext(options, mockSessionManager.Object))
{
var repository = new WriteRepository <DummyContext, Dummy>(context);
repository.Add(data1);
repository.Add(data2);
}
//Act
List <Dummy> list;
using (var context = new DummyContext(options, mockSessionManager.Object))
{
var repository = new ReadRepository <DummyContext, Dummy>(context);
list = repository.FindByAsync(e => e.Name == name).Result;
}
//Assert
list.Count.Should().BeGreaterThan(1);
}
public OrderPromoteCommandValidator(IGenericReadRepository readRepository, IOrderFiltersProvider orderFiltersProvider, IOrderRelationsProvider orderRelationsProvider) : base(readRepository)
{
_orderFiltersProvider = orderFiltersProvider;
RuleFor(x => x.OrderId)
.NotEmptyWithMessage()
.MustExistsWithMessageAsync(OrderExists)
.CustomAsync(async(orderId, context, cancellationToken) =>
{
var query = await ReadRepository.GetQueryableAsync(_orderFiltersProvider.ById(orderId), orderRelationsProvider.JoinDeliveryRequest);
var orderInfo = query
.Select(x => new
{
OrderStatus = x.StatusId,
DeliveryRequestStatus = x.DeliveryRequest != null ? x.DeliveryRequest.StatusId : (int?)null
})
.FirstOrDefault();
if ((OrderStatuses)orderInfo.OrderStatus == OrderStatuses.Completed)
{
context.AddFailure(nameof(OrderPromoteCommand.OrderId), "Order is completed.");
return;
}
if (orderInfo.DeliveryRequestStatus.HasValue && (DeliveryRequestStatuses)orderInfo.DeliveryRequestStatus != DeliveryRequestStatuses.Closed)
{
context.AddFailure(nameof(OrderPromoteCommand.OrderId), "You cannot promote the order until the corresponding delivery request is completed.");
}
});
}
private static void Main(string[] args)
{
ISerializer serializer = new OtusXmlSerializer();
var game = new Game(serializer);
IGameObject human = new Human();
game.AddObject(human);
game.Save();
//========================================================
IApiClientFactory apiClientFactory = new ApiClientFactory();
IApiClient client1 = apiClientFactory.CreateClient("http://our.api.com");
IApiClient client2 = apiClientFactory.CreateClient("ws://our.api.com");
// добавляем логгирование
client1 = new ApiClientWithLogging(client1);
client2 = new ApiClientWithLogging(client2);
// вызываем методы
client1.SendRequest();
client2.SendRequest();
//=============
IReadRepository <object> r = new ReadRepository <string>();
IWriteRepository <string> w = new WriteRepository <object>();
}
public override async Task <ContestRegistrationViewModel> HandleAsync(GetContestRegistrationForCreateQuery query)
{
var contest = await ReadRepository.Set <Contest>()
//.Include(x => x.ContestAreas).ThenInclude(y => y.Area)
.Include($"{nameof(Contest.ContestAreas)}.{nameof(ContestArea.Area)}")
.SingleOrDefaultAsync(m => m.Id == query.ContestId);
if (contest == null)
{
throw new EntityNotFoundException();
}
var viewModel = CreateContestRegistrationViewModel(contest.ContestType);
viewModel.ContestName = contest.Name;
viewModel.ContestId = contest.Id;
viewModel.ContestTrainerCont = contest.TrainerCount;
viewModel.ParticipantType = contest.ParticipantType;
viewModel.IsAreaRequired = contest.IsAreaRequired;
viewModel.IsProgrammingLanguageNeeded = contest.IsProgrammingLanguageNeeded;
viewModel.IsOutOfCompetitionAllowed = contest.IsOutOfCompetitionAllowed;
viewModel.IsEnglishLanguage = contest.IsEnglishLanguage;
viewModel.ShowRegistrationInfo = contest.ShowRegistrationInfo;
var user = await _userManager.FindByEmailAsync(_currentUserService.Email);
user.StudyPlace = await ReadRepository.FindAsync <StudyPlace>(user.StudyPlaceId);
switch (user.UserType)
{
case UserType.Trainer:
viewModel.TrainerId = user.Id;
break;
case UserType.Pupil:
viewModel.Participant1Id = user.Id;
break;
case UserType.Student:
if (contest.ParticipantType == ParticipantType.Pupil)
{
viewModel.TrainerId = user.Id;
}
else
{
viewModel.Participant1Id = user.Id;
}
break;
}
if (contest.ParticipantType == ParticipantType.Pupil && user.StudyPlace is School ||
contest.ParticipantType == ParticipantType.Student && user.StudyPlace is Institution)
{
viewModel.StudyPlaceId = user.StudyPlaceId;
viewModel.CityId = user.StudyPlace.CityId;
}
return(viewModel);
}
public override async Task <List <City> > HandleAsync(GetCitiesForInstitutionQuery query)
{
var result = await ReadRepository.Set <City>()
.OrderBy(item => item.Name)
.ToListAsync();
return(result);
}
public async Task <IEnumerable <CarEngineWithGearboxModel> > GetAllEngineGearboxPairsAsync()
{
var items = await ReadRepository.GetAllAsync <EngineSupportsGearbox>(_engineGearboxRelationsProvider.JoinGearboxAndEngine);
var result = items.GroupBy(x => new { x.ModelId, x.EngineId }).Select(x => x.First());
return(Mapper.Map <IEnumerable <CarEngineWithGearboxModel> >(result));
}
private async Task <bool> CarAmountIsValid(OrderFromStockCreateCommand command, CancellationToken cancellationToken)
{
var query = await ReadRepository.GetQueryableAsync(_carStockFiltersProvider.ById(command.CarId));
var amount = query.Select(x => x.Amount).FirstOrDefault();
return(amount >= 1);
}
public FormMain()
{
_context = new DawidPerdekContext();
_writeStudentRepository = new WriteRepository <Student>(_context);
_readStudentRepository = new ReadRepository <Student>(_context);
_userQuery = new UserQuery(_context);
InitializeComponent();
}
public async Task <UserSignInModel> GetSignInInfoAsync(LogInInfo logInCommand)
{
var user = await ReadRepository.GetSingleAsync(_userFiltersProvider.ActiveByEmail(logInCommand.Email), _userRelationsProvider.JoinRole);
return(user != null && user.PasswordHash.Equals(logInCommand.PasswordHash, StringComparison.OrdinalIgnoreCase)
? Mapper.Map <UserSignInModel>(user)
: null);
}
public override async Task <List <Region> > HandleAsync(GetRegionsForCityQuery query)
{
var result = await ReadRepository.Set <Region>()
.OrderBy(item => item.Name)
.ToListAsync();
return(result);
}
public override void Proceseaza(Eveniment e)
{
string titlu = e.Detalii;
Carte c = ReadRepository.CautaCarte(titlu);
c.DataImprumut = DateTime.Now;
c.Stare = StareCarte.Imprumutata;
MagistralaEvenimente.CartiUser.Add(c);
}
private async Task <bool> SupplierExists(int?id, CancellationToken cancellationToken)
{
if (id.HasValue)
{
return(await Task.Run(() => ReadRepository.ValidateExists(_filtersProvider.ById(id.Value)), cancellationToken));
}
return(true);
}
public FormSellerPanel(Seller currentSeller, KamilCieślikLab4PdContext context, ReadRepository <MenuProduct> readMenuProductRepository, WriteRepository <Order> writeOrderRepository)
{
_products = new List <MenuProduct>();
_context = context;
_readMenuProductRepository = readMenuProductRepository;
_writeOrderRepository = writeOrderRepository;
_currentSeller = currentSeller;
InitializeComponent();
SetCurrentSellerName();
}
//Muestro una noticia random
private static async Task <EventModel> GetRandomNotice()
{
ReadRepository ReadRepository = new ReadRepository();
var noticeInDay = await ReadRepository.GetNextEvents();
var random = new Random();
var number = random.Next(0, noticeInDay.Count - 1);
return(noticeInDay[number]);
}
public override async Task <List <Email> > HandleAsync(GetEmailsQuery query)
{
var emails = await ReadRepository.Set <Email>()
.AutoFilter(query)
.OrderByDescending(x => x.Id)
.Take(100)
.ToListAsync();
return(emails);
}
public ActionResult Clear()
{
var repository = new ReadRepository(new ConfigConnectionSettings("data"));
foreach (var retreat in repository.All("SELECT * FROM [Retreats]", Enumerable.Empty<KeyValuePair<string, object>>()))
bus.Send(new CurrentCancelRetreatCommand { AggregateRootId = retreat.Id });
foreach (var participant in repository.All("SELECT * FROM [Participants]", Enumerable.Empty<KeyValuePair<string, object>>()))
bus.Send(new CurrentUnregisterParticipantCommand { AggregateRootId = participant.Id });
return this.RedirectToAction<ParticipantController>(c => c.List());
}
public IEnumerable<Event> GetAll()
{
var repository = new ReadRepository(new ConfigConnectionSettings("event"));
var events = repository.All("SELECT * FROM [Events] WHERE [AggregateRootId] != 'e20193e2-3fac-41ed-9bd1-0d6d61d65c97' ORDER BY [DateTime]", Enumerable.Empty<KeyValuePair<string, object>>());
//var events = repository.All("SELECT * FROM [Events] ORDER BY [DateTime]", Enumerable.Empty<KeyValuePair<string, object>>());
var formatter = new BinaryFormatter();
foreach (var @event in events)
{
var stream = new MemoryStream((byte[])@event.Event);
yield return formatter.Deserialize(stream) as Event;
}
}
static void Main(string[] args)
{
var readRepository = new ReadRepository(new ConfigConnectionSettings("event"));
var writeRepository = new WriteRepository(new ConfigConnectionSettings("event"));
var binaryFormatter = new BinaryFormatter();
var snapshots = readRepository.All("SELECT * FROM [Snapshots] ORDER BY [DateTime]", Enumerable.Empty<KeyValuePair<string, object>>());
foreach (var snapshot in snapshots)
{
var actual = binaryFormatter.Deserialize(new MemoryStream((byte[])snapshot.Snapshot)) as Event;
var stream = new MemoryStream();
new XmlSerializer(actual.GetType()).Serialize(stream, actual);
var content = stream.ToArray();
var xmlpair = new KeyValuePair<string, object>("@Xml", content);
var typepair = new KeyValuePair<string, object>("@Type", actual.ToString());
var idpair = new KeyValuePair<string, object>("@Id", snapshot.Id);
writeRepository.Do("UPDATE [Snapshots] SET [SnapshotXml] = @Xml, [Type] = @Type WHERE [Id] = @Id", new[] { xmlpair, typepair, idpair });
}
var events = readRepository.All("SELECT * FROM [Events] ORDER BY [DateTime]", Enumerable.Empty<KeyValuePair<string, object>>());
foreach (var @event in events)
{
var actual = binaryFormatter.Deserialize(new MemoryStream((byte[])@event.Event)) as Event;
var stream = new MemoryStream();
new XmlSerializer(actual.GetType()).Serialize(stream, actual);
var content = stream.ToArray();
var xmlpair = new KeyValuePair<string, object>("@Xml", content);
var typepair = new KeyValuePair<string, object>("@Type", actual.ToString());
var idpair = new KeyValuePair<string, object>("@Id", @event.Id);
System.Threading.Thread.Sleep(10);
writeRepository.Do("UPDATE [Events] SET [EventXml] = @Xml, [Type] = @Type WHERE [Id] = @Id", new[] { xmlpair, typepair, idpair });
}
}
public RetreatController(IBus bus)
{
repository = new ReadRepository(new ConfigConnectionSettings("data"));
this.bus = bus;
}
public DahliaEventStore()
{
readRepository = new ReadRepository(new ConfigConnectionSettings("event"));
writeRepository = new WriteRepository(new ConfigConnectionSettings("event"));
}
public TimelineController()
{
repository = new ReadRepository(new ConfigConnectionSettings("event"));
}
