public DtoOrder GenerateNewOrder(DtoClient dtoClient, int?lastAddress = null)
{
try
{
EnsureArg.IsNotNull(dtoClient, nameof(dtoClient));
}
catch (Exception ex)
{
throw new BadRequest(ex);
}
var client = ClientQueries.GetClient(dtoClient.Token);
var order = new DtoOrder()
{
Client = client
};
DtoAddress selectedAddress = null;
if (lastAddress != null)
{
selectedAddress = client.Addresses?.Where(i => i.Id == lastAddress)?.FirstOrDefault() ?? dtoClient.Addresses?.FirstOrDefault();
}
else
{
order.AddressToShip = client.Addresses?.FirstOrDefault();
}
return(CheckOrder(order));
}
private void GetAtualOrder(ref DtoClient client)
{
if (client != null && client.AtualOrder == null)
{
client.AtualOrder = OrderDomain.GetIncompletLastOrder(client);
}
}
public async Task <IActionResult> Get(int id)
{
DtoClient result = await _clientService.GetClientById(id);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public void Create(ref DtoClient dtoClient)
{
var model = dtoClient.ToRepository();
var address = dtoClient.Addresses.Where(i => i.Id == 0);
var insertdId = Insert(model, "Client");
var addresses = dtoClient.Addresses.Where(i => i.Id == 0).Select(i => i.ToRepository(insertdId));
Insert(addresses, "Address");
dtoClient.Id = insertdId;
dtoClient.Addresses = GetAllAddress(dtoClient.Token);
}
public DtoOrder GetIncompletLastOrder(DtoClient client)
{
var order = OrderQueries.GetLastIncompletedOrder(client.Id);
if (order == null)
{
return(GenerateNewOrder(client));
}
return(CheckOrder(order));
}
public DtoClient CreateClient([FromBody] DtoClient client)
{
ClientDomain.SaveOrUpdate(ref client);
if (client != null)
{
Session.ClientToken = client.Token;
Session.OrderId = client.AtualOrder.Id;
Session.MobileAuthenticate = true;
return(client);
}
return(client);
}
public void UpdateClient(ref DtoClient dtoClient)
{
var model = dtoClient.ToRepository();
var dbClient = this.GetClient(dtoClient.Token);
model.Id = dbClient.Id;
if (model.PasswordHash == null)
{
model.PasswordHash = dbClient?.PasswordHash;
}
this.Update(model, "Client");
}
public static Repository.Pharma.Model.Clients.Client ToRepository(this DtoClient dto)
{
if (dto == null)
{
return(null);
}
var model = new Repository.Pharma.Model.Clients.Client();
model.Id = dto.Id;
model.Document = dto.Document;
model.Email = dto.Email;
model.DeviceId = dto.DeviceId;
model.Name = dto.Name;
model.PasswordHash = dto.PasswordHash;
model.Token = dto.Token;
return(model);
}
public IActionResult PaginateSorting([FromBody] DtoPaginationAndSorting dto)
{
bool isSortingListValid = true;
if (dto.SortingList != null)
{
isSortingListValid = SortingListValidator <DtoClient> .Validate(dto.SortingList);
}
if (isSortingListValid)
{
return(new OkObjectResult(_useCasePagSort
.PaginateSorting(dto.PageNumber, dto.TotalPageNumber, dto.SortingList)
.Select(domainEntity => DtoClient.DomainEntityToDto(domainEntity))));
}
return(new BadRequestResult());
}
public IActionResult Filter([FromBody] DtoFilter dtoFilter)
{
List <string> list = new List <string>();
if (dtoFilter.FilterList != null)
{
list = dtoFilter.FilterList.Where(data => (data.Contains("=") &&
FilterListValidator <DtoClient> .Validate(data))).ToList();
}
if (list.Count > 0)
{
return(new OkObjectResult(_useCaseFilter.Filter(list)
.Select(domainEntity =>
DtoClient.DomainEntityToDto(domainEntity))));
}
return(new BadRequestResult());
}
public static DtoClient ToDTO(this Repository.Pharma.Model.Clients.Client model, List <Address> address = null)
{
if (model == null)
{
return(null);
}
var dto = new DtoClient();
dto.Id = model.Id;
dto.Document = model.Document;
dto.DeviceId = model.DeviceId;
dto.Email = model.Email;
dto.Name = model.Name;
dto.Token = model.Token;
dto.Addresses = address?.Select(i => i.ToDTO()).ToList();
return(dto);
}
public void SaveOrUpdate(ref DtoClient client)
{
try
{
EnsureArg.IsNotNull(client, nameof(client));
}
catch (Exception ex)
{
throw new BadRequest(ex);
}
if (client.Token == null)
{
client.Token = Guid.NewGuid().ToString();
ClientQueries.Create(ref client);
}
GetAtualOrder(ref client);
}
public IActionResult Filter([FromBody] DtoFilterPaginationSorting dto)
{
bool isValid = false;
if (dto.SortingList != null && dto.FilterList != null)
{
isValid = dto.FilterList.All(data => data.Contains("=") &&
FilterListValidator <DtoClient> .Validate(data) &&
SortingListValidator <DtoClient> .Validate(dto.SortingList));
}
if (isValid)
{
var list = _useCaseFilterLike.FilterSorting(dto.PageNumber, dto.TotalPageNumber,
dto.FilterList, dto.SortingList);
return(new OkObjectResult(list.Select(domainEntity =>
DtoClient.DomainEntityToDto(domainEntity))));
}
return(new BadRequestResult());
}
//Method for insert employee
public JsonResult InsertUpdateClit(DtoClient c**t)
{
return(Json(ObjClient.InsertUpdateClit(c**t), JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Get Client by Id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <DtoClient> GetClientById(int id)
{
DtoClient User = await _clientRepository.GetClient().AsNoTracking().Where(c => c.Id == id).ProjectTo <DtoClient>(_mapper.ConfigurationProvider).FirstOrDefaultAsync();
return(User);
}
public IEnumerable <DtoClient> GetAll()
{
return(_useCaseClient.Read().Select(domainEntity => DtoClient.DomainEntityToDto(domainEntity)));
}
//Method for delete employee
public JsonResult DeleteClit(DtoClient c**t)
{
return(Json(ObjClient.DeleteClit(c**t), JsonRequestBehavior.AllowGet));
}
public IEnumerable <DtoClient> Paginate([FromBody] DtoPagination dto)
{
var list = _useCasePag.Paginate(dto.PageNumber, dto.TotalPageNumber);
return(list.Select(domainEntity => DtoClient.DomainEntityToDto(domainEntity)));
}
public string Post([FromBody] DtoClient dtoClient)
{
_useCaseClient.Create(dtoClient.DtoToDomainEntity());
return("Created");
}
public string Put(int id, [FromBody] DtoClient dtoClient)
{
_useCaseClient.Update(id, dtoClient.DtoToDomainEntity());
return("Updated");
}
public JsonResult ListClitSelect(DtoClient c**t)
{
return(Json(ObjClient.ListClitSelect(c**t), JsonRequestBehavior.AllowGet));
}
public DtoClient Update([FromBody] DtoClient client)
{
client.Token = Session.ClientToken;
ClientDomain.SaveOrUpdate(ref client);
return(client);
}
