public async Task <int> Handle(ImportObserversRequest message, CancellationToken token)
{
var counter = 0;
var startId = GetMaxIdObserver();
using (var reader = new StreamReader(message.File.OpenReadStream()))
{
while (reader.Peek() >= 0)
{
var fileContent = reader.ReadLine();
var data = fileContent.Split('\t');
var hashed = _hashService.GetHash(data[1]);
var observer = new Entities.Observer
{
Id = startId + counter,
IdNgo = message.IdOng,
Phone = data[0],
Name = data[2],
Pin = hashed
};
_context.Observers.Add(observer);
counter++;
}
await _context.SaveChangesAsync();
}
return(counter);
}
public async Task <OptionDto> Handle(AddOptionCommand request, CancellationToken cancellationToken)
{
var optionEntity = _mapper.Map <Option>(request.Option);
_context.Options.Add(optionEntity);
await _context.SaveChangesAsync(cancellationToken);
return(_mapper.Map <OptionDto>(optionEntity));
}
private async Task <Result> InsertOrUpdateCounties(List <CountyCsvModel> counties, CancellationToken cancellationToken)
{
var countiesIdUpdated = new List <int>();
var countiesDictionary = counties.ToDictionary(c => c.Id, y => y);
try
{
using var transaction = await _context.Database.BeginTransactionAsync(cancellationToken);
foreach (var county in _context.Counties)
{
if (countiesDictionary.TryGetValue(county.Id, out var csvModel))
{
county.Code = csvModel.Code;
county.Name = csvModel.Name;
county.NumberOfPollingStations = csvModel.NumberOfPollingStations;
county.Diaspora = csvModel.Diaspora;
county.Order = csvModel.Order;
countiesIdUpdated.Add(county.Id);
}
}
foreach (var id in countiesDictionary.Keys.Except(countiesIdUpdated))
{
var csvModel = countiesDictionary[id];
var newCounty = new Entities.County
{
Id = csvModel.Id,
Code = csvModel.Code,
Name = csvModel.Name,
NumberOfPollingStations = csvModel.NumberOfPollingStations,
Diaspora = csvModel.Diaspora,
Order = csvModel.Order
};
_context.Counties.Add(newCounty);
}
await _context.SaveChangesAsync(cancellationToken);
transaction.Commit();
}
catch (Exception exception)
{
_logger.LogError("Cannot add/update counties", exception);
return(Result.Failure("Cannot add/update counties"));
}
return(Result.Ok());
}
public async Task <int> Handle(CompleteazaRaspunsCommand message, CancellationToken cancellationToken)
{
try
{
//flat answers
var lastModified = DateTime.UtcNow;
var raspunsuriNoi = GetFlatListOfAnswers(message, lastModified);
// stergerea este pe fiecare sectie
var sectii = message.Answers.Select(a => a.PollingSectionId).Distinct().ToList();
using (var tran = await _context.Database.BeginTransactionAsync())
{
foreach (var sectie in sectii)
{
var intrebari = message.Answers.Select(a => a.QuestionId).Distinct().ToList();
// delete existing answers for posted questions on this 'sectie'
var todelete = _context.Answers
.Include(a => a.OptionAnswered)
.Where(
a =>
a.IdObserver == message.ObserverId &&
a.IdPollingStation == sectie)
//.Where(a => intrebari.Contains(a.OptionAnswered.IdQuestion))
.WhereRaspunsContains(intrebari)
;
//.Delete();
_context.Answers.RemoveRange(todelete);
await _context.SaveChangesAsync();
}
_context.Answers.AddRange(raspunsuriNoi);
var result = await _context.SaveChangesAsync();
tran.Commit();
return(result);
}
}
catch (Exception ex)
{
_logger.LogError(typeof(CompleteazaRaspunsCommand).GetHashCode(), ex, ex.Message);
}
return(await Task.FromResult(-1));
}
public Task <int> Handle(NewObserverRequest message, CancellationToken token)
{
var id = GetMaxIdObserver();
var observer = new Observer
{
Id = id,
IdNgo = message.IdOng,
Phone = message.NumarTelefon,
Name = message.Nume,
Pin = _hashService.GetHash(message.PIN)
};
_context.Observers.Add(observer);
return(_context.SaveChangesAsync());
}
protected override Task <int> HandleCore(ResetDeviceCommand request)
{
try {
Observer observer = _voteMonitorContext.Observers
.Where(o => o.Phone == request.PhoneNumber &&
o.IdNgo == request.IdNgo)
.First();
if (observer == null)
{
return(Task.FromResult(-1));
}
observer.DeviceRegisterDate = null;
observer.MobileDeviceId = null;
//observer.Pin = RandomNumberGenerator.Generate(6);
_voteMonitorContext.Update(observer);
return(_voteMonitorContext.SaveChangesAsync());
}
catch (Exception exception)
{
_logger.LogError("Exception caught during resetting of Observer device for id " + request.PhoneNumber, exception);
}
return(Task.FromResult(-1));
}
public async Task <Unit> Handle(UpdatePollingStationInfo request, CancellationToken cancellationToken)
{
try
{
var pollingStationInfo = _context.PollingStationInfos.FirstOrDefault(
p => p.IdObserver == request.IdObserver &&
p.IdPollingStation == request.IdPollingStation);
if (pollingStationInfo == null)
{
return(Unit.Value);
}
pollingStationInfo.ObserverLeaveTime = request.ObserverLeaveTime;
pollingStationInfo.LastModified = DateTime.Now;
_context.Update(pollingStationInfo);
await _context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
catch (Exception ex)
{
_logger.LogError("Error updating polling station info: ", ex);
throw;
}
}
protected override Task <string> HandleCore(ResetPasswordCommand request)
{
try
{
Observer observer = _voteMonitorContext.Observers
.Where(o => o.Phone == request.PhoneNumber &&
o.IdNgo == request.IdNgo)
.First();
if (observer == null)
{
return(Task.FromResult(String.Empty));
}
observer.Pin = RandomNumberGenerator.Generate(6);
_voteMonitorContext.Update(observer);
_voteMonitorContext.SaveChangesAsync();
return(Task.FromResult(observer.Pin));
}
catch (Exception exception)
{
_logger.LogError("Exception caught during resetting of Observer password for id " + request.PhoneNumber, exception);
}
return(Task.FromResult(String.Empty));
}
public async Task <int> Handle(UpdatePollingSectionCommand message, CancellationToken cancellationToken)
{
try
{
var pollingStationInfo = await _context.PollingStationInfos
.FirstOrDefaultAsync(a =>
a.IdObserver == message.IdObserver &&
a.IdPollingStation == message.IdPollingStation);
if (pollingStationInfo == null)
{
throw new ArgumentException("PollingStationInfo nu exista");
}
_mapper.Map(message, pollingStationInfo);
_context.Update(pollingStationInfo);
return(await _context.SaveChangesAsync());
}
catch (Exception ex)
{
_logger.LogError(new EventId(), ex.Message);
}
return(-1);
}
public async Task <bool> Handle(ResetPasswordCommand request, CancellationToken cancellationToken)
{
try
{
var observerQuery = _voteMonitorContext.Observers
.Where(o => o.Phone == request.PhoneNumber);
if (!request.Organizer)
{
observerQuery = observerQuery.Where(o => o.IdNgo == request.IdNgo);
}
var observer = observerQuery.FirstOrDefault();
if (observer == null)
{
return(false);
}
observer.Pin = _hash.GetHash(request.Pin);
_voteMonitorContext.Update(observer);
await _voteMonitorContext.SaveChangesAsync(cancellationToken);
return(true);
}
catch (Exception exception)
{
_logger.LogError("Exception caught during resetting of Observer password for id " + request.PhoneNumber, exception);
}
return(false);
}
public Task <int> Handle(ResetDeviceCommand request, CancellationToken cancellationToken)
{
try
{
var observerQuery = _voteMonitorContext.Observers
.Where(o => o.Phone == request.PhoneNumber);
if (!request.Organizer)
{
observerQuery = observerQuery.Where(o => o.IdNgo == request.IdNgo);
}
var observer = observerQuery.FirstOrDefault();
if (observer == null)
{
return(Task.FromResult(-1));
}
observer.DeviceRegisterDate = null;
observer.MobileDeviceId = null;
_voteMonitorContext.Update(observer);
return(_voteMonitorContext.SaveChangesAsync(cancellationToken));
}
catch (Exception exception)
{
_logger.LogError("Exception caught during resetting of Observer device for id " + request.PhoneNumber, exception);
}
return(Task.FromResult(-1));
}
public Task <int> Handle(OptiuneModelRequest request, CancellationToken cancellationToken)
{
var option = _mapper.Map <Option>(request.OptiuneModel);
var maxOptionId = GetMaxIdOption();
option.Id = maxOptionId;
_context.Options.Add(option);
_context.SaveChangesAsync();
return(Task.FromResult(maxOptionId));
}
public async Task <int> Handle(PollingStationCommand request, CancellationToken cancellationToken)
{
var random = new Random();
try
{
//import the new entities
using (var transaction = await _context.Database.BeginTransactionAsync(cancellationToken))
{
var id = 100;
var newPollingStations = new List <PollingStation>();
var counties = _context.Counties.ToDictionary(c => c.Code, c => c.Id);
foreach (var record in request.PollingStationsDTOs)
{
var pollingStation = _mapper.Map <PollingStation>(record);
pollingStation.Id = id++;
pollingStation.IdCounty = counties[record.CodJudet];//county.Id;
pollingStation.Coordinates = null;
pollingStation.TerritoryCode = random.Next(10000).ToString();
newPollingStations.Add(pollingStation);
}
_context.BulkInsert(newPollingStations);
foreach (var county in _context.Counties)
{
if (!_context.PollingStations.Any(p => p.IdCounty == county.Id))
{
continue;
}
var maxPollingStation = _context.PollingStations
.Where(p => p.IdCounty == county.Id)
.Max(p => p.Number);
county.NumberOfPollingStations = maxPollingStation;
_context.Counties.Update(county);
}
var result = await _context.SaveChangesAsync(cancellationToken);
transaction.Commit();
return(result);
}
}
catch (Exception ex)
{
_logger.LogError("Error while importing polling station information ", ex);
}
return(-1);
}
public Task <int> Handle(NotificationRegistrationDataCommand request, CancellationToken cancellationToken)
{
var existingRegistration =
_context.NotificationRegistrationData
.FirstOrDefault(data => data.ObserverId == request.ObserverId && data.ChannelName == request.ChannelName);
if (existingRegistration != null)
{
existingRegistration.Token = request.Token;
}
else
{
var notificationReg = new NotificationRegistrationData
{
ObserverId = request.ObserverId,
ChannelName = request.ChannelName,
Token = request.Token
};
_context.NotificationRegistrationData.Add(notificationReg);
}
return(_context.SaveChangesAsync(cancellationToken));
}
public async Task <int> Handle(AddNoteCommand request, CancellationToken cancellationToken)
{
try
{
var noteEntity = _mapper.Map <Entities.Note>(request);
_context.Notes.Add(noteEntity);
return(await _context.SaveChangesAsync(cancellationToken));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <Unit> Handle(CreatePollingStationInfo request, CancellationToken cancellationToken)
{
try
{
var pollingStationInfo = _mapper.Map <PollingStationInfo>(request);
_context.PollingStationInfos.Add(pollingStationInfo);
await _context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
catch (Exception ex)
{
_logger.LogError("Error creating polling station info: ", ex);
throw;
}
}
public async Task <int> Handle(RegisterDeviceId request, CancellationToken cancellationToken)
{
try
{
var observator = await _context.Observers.SingleAsync(a => a.Id == request.ObserverId, cancellationToken : cancellationToken);
observator.MobileDeviceId = request.MobileDeviceId;
observator.DeviceRegisterDate = DateTime.UtcNow;
return(await _context.SaveChangesAsync(cancellationToken));
}
catch (Exception ex)
{
_logger.LogError(new EventId(), ex, ex.Message);
throw ex;
}
}
public async Task <int> Handle(RegisterPollingStationCommand message, CancellationToken cancellationToken)
{
try
{
//TODO[DH] this can be moved to a previous step, before the command is executed
var pollingStation = await _context.PollingStations
.Where(a =>
a.Number == message.IdPollingStation &&
a.County.Code == message.CountyCode)
.FirstOrDefaultAsync();
if (pollingStation == null)
{
throw new ArgumentException("Sectia nu exista");
}
var formular = await _context.PollingStationInfos
.FirstOrDefaultAsync(a =>
a.IdObserver == message.IdObserver &&
a.IdPollingStation == pollingStation.Id);
if (formular == null)
{
formular = _mapper.Map <PollingStationInfo>(message);
formular.IdPollingStation = pollingStation.Id;
formular.IdObserver = message.IdObserver;
_context.Add(formular);
}
else
{
_mapper.Map(message, formular);
}
return(await _context.SaveChangesAsync());
}
catch (Exception ex)
{
_logger.LogError(new EventId(), ex.Message);
}
return(-1);
}
protected async override Task <List <GeneratedObserver> > HandleCore(ObserverGenerateCommand command)
{
List <Observer> dbObservers = new List <Observer>();
List <GeneratedObserver> generatedObservers = new List <GeneratedObserver>();
for (int i = 0; i < command.NrObservers; ++i)
{
RandomObserverBuilder builder = new RandomObserverBuilder();
dbObservers.Add(builder.build(command.IdNgo));
}
try
{
using (var tran = await _voteMonitorContext.Database.BeginTransactionAsync())
{
int latestId = _voteMonitorContext.Observers
.OrderByDescending(o => o.Id)
.FirstOrDefault()
.Id;
dbObservers = dbObservers
.Select(o => { o.Id = ++latestId; return(o); })
.ToList();
_voteMonitorContext.Observers.AddRange(dbObservers.ToArray());
var result = await _voteMonitorContext.SaveChangesAsync();
tran.Commit();
return(dbObservers
.Select(o => _mapper.Map <GeneratedObserver>(o))
.ToList());
}
}
catch (Exception ex)
{
_logger.LogError("Error during generation of random observers", ex, ex.Message);
}
return(await Task.FromResult(generatedObservers));
}
public async Task <List <GeneratedObserver> > Handle(ObserverGenerateCommand request, CancellationToken cancellationToken)
{
List <Entities.Observer> dbObservers = new List <Entities.Observer>();
List <GeneratedObserver> generatedObservers = new List <GeneratedObserver>();
for (int i = 0; i < request.NrObservers; ++i)
{
dbObservers.Add(RandomObserverBuilder.Instance(_hashService).Build(request.IdNgo));
}
try
{
using (var tran = await _voteMonitorContext.Database.BeginTransactionAsync(cancellationToken))
{
int latestId = _voteMonitorContext.Observers
.OrderByDescending(o => o.Id)
.First()
.Id;
dbObservers = dbObservers
.Select(o => { o.Id = ++latestId; return(o); })
.ToList();
_voteMonitorContext.Observers.AddRange(dbObservers.ToArray());
await _voteMonitorContext.SaveChangesAsync(cancellationToken);
tran.Commit();
return(dbObservers
.Select(o => _mapper.Map <GeneratedObserver>(o))
.ToList());
}
}
catch (Exception ex)
{
_logger.LogError("Error during generation of random observers", ex, ex.Message);
}
return(await Task.FromResult(generatedObservers));
}
public async Task <bool?> Handle(UpdatePollingStation request, CancellationToken cancellationToken)
{
try
{
var existingPollingStation = _context.PollingStations.FirstOrDefault(p => p.Id == request.Id);
if (existingPollingStation == null)
{
return(false);
}
existingPollingStation.AdministrativeTerritoryCode = request.AdministrativeTerritoryCode;
existingPollingStation.Coordinates = request.Coordinates;
existingPollingStation.Address = request.Address;
existingPollingStation.TerritoryCode = request.TerritoryCode;
existingPollingStation.Number = request.Number;
await _context.SaveChangesAsync(cancellationToken);
}
catch (Exception ex)
{
_logger.Log(LogLevel.Error, $"Error updating polling station: {request.Id}", ex);
return(null);
}
return(true);
}
public async Task <bool> Handle(DeleteFormCommand request, CancellationToken cancellationToken)
{
var form = await _context.Forms.FirstOrDefaultAsync(f => f.Id == request.FormId);
if (form == null)
{
return(false);
}
var sections = _context.FormSections.Where(s => s.IdForm == form.Id);
var sectionsIds = sections.Select(s => s.Id);
var questions = _context.Questions.Where(q => sectionsIds.Contains(q.IdSection));
var questionsIds = questions.Select(q => q.Id);
var optionsToQuestions = _context.OptionsToQuestions.Where(o => questionsIds.Contains(o.IdQuestion));
var optionsIds = optionsToQuestions.Select(o => o.IdOption);
// check if there are already saved answers
var answers = _context.Answers.Where(a => optionsIds.Contains(a.IdOptionToQuestion));
if (answers != null && answers.Any())
{
return(false);
}
var options = _context.Options.Where(o => optionsIds.Contains(o.Id));
_context.OptionsToQuestions.RemoveRange(optionsToQuestions);
_context.Options.RemoveRange(options);
_context.Questions.RemoveRange(questions);
_context.FormSections.RemoveRange(sections);
_context.Forms.Remove(form);
await _context.SaveChangesAsync();
return(true);
}
public async Task <FormDTO> Handle(AddFormQuery message, CancellationToken cancellationToken)
{
var newForm = new Entities.Form
{
Code = message.Form.Code,
CurrentVersion = message.Form.CurrentVersion,
Description = message.Form.Description,
FormSections = new List <FormSection>(),
Diaspora = message.Form.Diaspora,
Draft = message.Form.Draft,
Order = message.Form.Order
};
foreach (var(form, formIndex) in message.Form.FormSections.Select((form, formIndex) => (form, formIndex + 1)))
{
var formSection = new FormSection
{
Code = form.Code,
Description = form.Description,
OrderNumber = formIndex,
Questions = new List <Question>()
};
foreach (var(question, questionIndex) in form.Questions.Select((question, questionIndex) => (question, questionIndex + 1)))
{
var questionEntity = new Question
{
QuestionType = question.QuestionType,
Hint = question.Hint,
Text = question.Text,
Code = question.Code,
OrderNumber = questionIndex
};
var optionsForQuestion = new List <OptionToQuestion>();
foreach (var(option, optionIndex) in question.OptionsToQuestions.Select((option, optionIndex) => (option, optionIndex + 1)))
{
if (option.IdOption > 0)
{
var existingOption = _context.Options.FirstOrDefault(o => o.Id == option.IdOption);
existingOption.OrderNumber = optionIndex;
optionsForQuestion.Add(new OptionToQuestion
{
Option = existingOption,
Flagged = option.Flagged
});
}
else
{
OptionToQuestion newOptionToQuestion = _mapper.Map <OptionToQuestion>(option);
newOptionToQuestion.Option.OrderNumber = optionIndex;
optionsForQuestion.Add(newOptionToQuestion);
}
}
questionEntity.OptionsToQuestions = optionsForQuestion;
formSection.Questions.Add(questionEntity);
}
newForm.FormSections.Add(formSection);
}
_context.Forms.Add(newForm);
await _context.SaveChangesAsync();
message.Form.Id = newForm.Id;
return(message.Form);
}
