/// <summary>
/// Update existing citizen.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <ResultBase> UpdateAsync(CitizenDto model)
{
try
{
if (model == null)
{
return(ResultBase.Failure("Model is empty."));
}
var citizen = await this.Db.Citizens.SingleOrDefaultAsync(x => x.Id == model.Id);
if (citizen == null)
{
return(ResultBase.Failure("Citizen not found."));
}
citizen.Update(model);
await this.Db.SaveChangesAsync();
return(ResultBase.Success());
}
catch (ArgumentException argumentException)
{
return(ResultBase.Failure(argumentException.Message));
}
catch (Exception exception)
{
Log.Logger.Error(exception, "Error in Citizen Update method.");
return(ResultBase.Failure($"Error in Citizen Update method."));
}
}
/// <summary>
/// Creates new citizen.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <Result <int> > CreateAsync(CitizenDto model)
{
try
{
if (model == null)
{
return(Result <int> .Failure("Model is empty."));
}
var citizen = new Citizen(model);
this.Db.Citizens.Add(citizen);
await this.Db.SaveChangesAsync();
return(Result <int> .Success(citizen.Id));
}
catch (ArgumentException argumentException)
{
return(Result <int> .Failure(argumentException.Message));
}
catch (Exception exception)
{
Log.Logger.Error(exception, "Error in Citizen Create method.");
return(Result <int> .Failure($"Error in Citizen Create method."));
}
}
private void Validate(CitizenDto model)
{
if (string.IsNullOrEmpty(model.FirstName) || model.FirstName.Length > 250)
{
throw new ArgumentException("First name is required and must be 250 characters or less.");
}
if (string.IsNullOrEmpty(model.LastName) || model.LastName.Length > 250)
{
throw new ArgumentException("Last name is required and must be 250 characters or less.");
}
if (string.IsNullOrEmpty(model.Email) && string.IsNullOrEmpty(model.Phone))
{
throw new ArgumentException("Some form of contact info is required. Phone, email, or both.");
}
if (!string.IsNullOrWhiteSpace(model.Email) && model.Email.Length > 250)
{
throw new ArgumentException("Email must be 250 characters or less.");
}
if (!string.IsNullOrWhiteSpace(model.Phone) && model.Phone.Length > 50)
{
throw new ArgumentException("Phone must be 50 characters or less.");
}
}
public void Update(CitizenDto model)
{
this.Validate(model);
this.FirstName = model.FirstName;
this.LastName = model.LastName;
this.Email = model.Email;
this.Phone = model.Phone;
}
public Task <CitizenDto> IfCitizenInDbAsync(CitizenDto citizenDto)
{
CitizenDto cDto = (from Citizen c in _context.Citizens
where c.CitizenID == citizenDto.CitizenID
select _mapper.Map <CitizenDto>(c)).FirstOrDefault();
return(Task.FromResult(cDto));
}
public HttpResponseMessage Post([FromBody] CitizenDto citizenDto)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Missing values"));
}
_citizenService.Add(citizenDto);
return(Request.CreateResponse(HttpStatusCode.OK, "Citizen added in National Population Register"));
}
public async Task <ResultDto> UpdateAsync(CitizenDto citizen)
{
await _repository.UpdateAsync(new[] { CitizenDto.ToEntity(citizen) }).ConfigureAwait(false);
return(new ResultDto
{
IsSuccessed = true,
Message = "Citizen has been updated",
Error = null
});
}
public async Task <CitizenDto> UpdateCitizenToken(CitizenDto citizenDto)
{
Citizen citizen = (from Citizen c in _context.Citizens
where c.CitizenID == citizenDto.CitizenID
select c).SingleOrDefault();
citizen.TokenFireBase = citizenDto.TokenFireBase;
await _context.SaveChangesAsync();
return(citizenDto);
}
public async Task <SearchResultDto> SearchAsync(SearchDto search)
{
var entities = await _repository.SearchAsync(SearchDto.ToCriteria(search), search.Skip, search.Take).ConfigureAwait(false);
return(new SearchResultDto
{
Citizens = entities?.Select(a => CitizenDto.FromEntity(a)).ToArray(),
IsSuccessed = true,
Message = null,
Error = null
});
}
public async Task <GetResultDto> GetAsync(int id)
{
var entity = await _repository.GetAsync(id).ConfigureAwait(false);
return(new GetResultDto
{
Citizen = CitizenDto.FromEntity(entity),
IsSuccessed = true,
Message = null,
Error = null
});
}
public async Task <ActionResult <CitizenDto> > LoginCitizen(CitizenDto citizenDto)
{
CitizenDto cDto = await _citizen.IfCitizenInDbAsync(citizenDto);
if (cDto == null)
{
return(NotFound());
}
try
{
cDto = await _citizen.UpdateCitizenToken(citizenDto);
}
catch (DbUpdateException)
{
return(BadRequest(new { message = "erreur interne" }));
}
return(cDto);
}
public static CitizenModel FromDto(CitizenDto dto)
{
if (dto == null)
{
return(null);
}
return(new CitizenModel
{
id = dto.Id,
cdate = dto.Cdate,
udate = dto.Udate,
first_name = dto.FirstName,
last_name = dto.LastName,
patronymic = dto.Patronymic,
inn = dto.Inn,
snils = dto.Snils,
birth_date = dto.BirthDate,
death_date = dto.DeathDate
});
}
public async Task <IHttpActionResult> Put([FromBody] CitizenDto model)
{
return(this.ProcessResult(await this.Service.UpdateAsync(model)));
}
