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));
}
public DtoAddress Create(DtoAddress address)
{
var token = Session.ClientToken;
ClientDomain.SaveAddress(ref address, token);
return(address);
}
public static Address ToRepository(this DtoAddress dto, int?fk = null)
{
if (dto == null)
{
return(null);
}
var model = new Address()
{
Id = dto.Id,
City = dto.City,
Complement = dto.Complement,
Latitude = dto.Latitude,
Longitude = dto.Longitude,
Name = dto.Name,
Neighborhood = dto.Neighborhood,
Number = dto.Number,
PostalCode = dto.PostalCode,
Reference = dto.Reference,
State = dto.State,
Street = dto.Street,
Client_Id = fk
};
return(model);
}
public void AddAddress(ref DtoAddress address, string token)
{
var clientId = this.GetClientId(token);
var addressModel = address.ToRepository(clientId);
var insetedId = Insert(addressModel, "Address");
address.Id = insetedId;
}
public DtoOrder SetNewShipping([FromBody] DtoAddress address)
{
var clientToken = Session.ClientToken;
var result = OrderDomain.SetShippping(clientToken, address);
Session.LastSelectedAddress = address.Id;
return(result);
}
public async Task <IActionResult> Save([FromBody] DtoAddress dto)
{
var template = Mapper.Map <Address>(dto);
_context.Addresses.Add(template);
await _context.SaveChangesAsync()
.ConfigureAwait(false);
return(Ok(template.Id));
}
public List <DtoStore> GetNearStore(DtoAddress address)
{
if (address == null || (address.Latitude == null || address.Longitude == null))
{
return(null);
}
return(GetNearStore(new DtoGeolocation()
{
Latitude = address.Latitude.Value,
Longitude = address.Longitude.Value
}));
}
public async Task <IActionResult> Update([FromBody] DtoAddress dto, [FromRoute] long id)
{
var template = Mapper.Map <Address>(dto);
template.Id = id;
await _context.Addresses
.Where(x => x.Id == id)
.UpdateFromQueryAsync(_ => template)
.ConfigureAwait(false);
return(Ok(id));
}
public DtoOrder SetShippping(string clientToken, DtoAddress address)
{
try
{
EnsureArg.IsNotNullOrEmpty(clientToken, nameof(clientToken));
EnsureArg.IsNotNull(address, nameof(address));
}
catch (Exception ex)
{
throw new BadRequest(ex);
}
ClientQueries.AddAddress(ref address, clientToken);
return(SetShippping(clientToken, address.Id));
}
public void SaveAddress(ref DtoAddress address, string clientToken)
{
try
{
EnsureArg.IsNotNull(address, nameof(address));
}
catch (Exception ex)
{
throw new BadRequest(ex);
}
var client = Get(clientToken);
ClientQueries.AddAddress(ref address, clientToken);
}
public ActionResult <Address> PostAddress(DtoAddress dtoaddress, Guid tenentId, Guid userId, Guid contactId)
{
if (ModelState.IsValid)
{
Address address = new Address {
City = dtoaddress.City, State = dtoaddress.State, Country = dtoaddress.Country
};
address.Id = new Guid();
address.Contact = this._db.GetContactAsPerId(tenentId, userId, contactId);
this._db.AddAddress(address);
return(Ok("Post Successfully"));
}
return(BadRequest("Post Successfull"));
}
public DtoAddress GetAddressInfo(DtoAddress address)
{
try
{
EnsureArg.IsNotNull(address, nameof(address));
}
catch (Exception ex)
{
throw new BadRequest(ex);
}
if (address?.PostalCode != null)
{
return(GetAddressInfo(address.PostalCode));
}
return(GeocodeApi.GetAddress(address));
}
public async Task <ActionResult> PostAddress(DtoAddress dtoaddress, Guid tenentId, Guid userId, Guid contactId)
{
if (ModelState.IsValid)
{
Address address = new Address {
City = dtoaddress.City, State = dtoaddress.State, Country = dtoaddress.Country
};
address.Id = new Guid();
address.Contact = await this._contactrepo.FirstOrDefault(x => x.Id == contactId && x.User.Id == userId && x.User.Tenent.Id == tenentId);
await this._addressrepo.Add(address);
return(Ok("Post Successfully"));
}
return(BadRequest("Post Successfull"));
}
public async Task UpdateAddress_shouldReturnok()
{
var tenentid = Guid.NewGuid();
var userid = Guid.NewGuid();
var contactid = Guid.NewGuid();
var addressid = Guid.NewGuid();
var address = new Address();
var dtoaddress = new DtoAddress();
_addressRepo.Setup(y => y.FirstOrDefault(x => x.Id == addressid && x.Contact.Id == contactid &&
x.Contact.User.Id == userid && x.Contact.User.Tenent.Id == tenentid)).ReturnsAsync(address);
_addressRepo.Setup(x => x.update(address));
var result = await _addressController.PutAddress(addressid, tenentid, contactid, userid, dtoaddress);
var okresult = result as OkObjectResult;
Assert.Equal(StatusCodes.Status200OK, okresult.StatusCode);
}
public async Task AddAddress_ShouldReturnOK()
{
var dtoaddress = new DtoAddress();
var address = new Address();
var tenentid = Guid.NewGuid();
var userid = Guid.NewGuid();
var contactid = Guid.NewGuid();
var contact = new Contact();
_contactRepo.Setup(x => x.FirstOrDefault(y => y.Id == contactid &&
y.User.Id == userid &&
y.User.Tenent.Id == tenentid)).ReturnsAsync(contact);
_addressRepo.Setup(x => x.Add(address));
var result = await _addressController.PostAddress(dtoaddress, tenentid, userid, contactid);
var okresult = result as OkObjectResult;
Assert.Equal(StatusCodes.Status200OK, okresult.StatusCode);
}
public static DtoAddress ToDTO(this Address model)
{
if (model == null)
{
return(null);
}
var dto = new DtoAddress()
{
Id = model.Id,
City = model.City,
Complement = model.Complement,
Latitude = model.Latitude,
Longitude = model.Longitude,
Name = model.Name,
Neighborhood = model.Neighborhood,
Number = model.Number,
PostalCode = model.PostalCode,
Reference = model.Reference,
State = model.State,
Street = model.Street
};
return(dto);
}
public DtoAddress GetAddress(DtoAddress address)
{
string addressstr = null;
if (address.Latitude != null && address.Longitude != null)
{
return(GetAddress(address.Latitude.Value, address.Longitude.Value));
}
if (!string.IsNullOrEmpty(address.Street))
{
addressstr += address.Street;
}
if (!string.IsNullOrEmpty(address.Number))
{
addressstr += ", " + address.Number;
}
if (!string.IsNullOrEmpty(address.Neighborhood))
{
addressstr += ", " + address.Neighborhood;
}
if (!string.IsNullOrEmpty(address.City))
{
addressstr += ", " + address.City;
}
if (!string.IsNullOrEmpty(address.State))
{
addressstr += " - " + address.State;
}
if (addressstr == null && address.PostalCode != null)
{
return(GetAddress(address.PostalCode));
}
if (addressstr?.FirstOrDefault() == ',')
{
addressstr.Remove(0, 1);
}
if (addressstr?.LastOrDefault() == ',')
{
addressstr.Remove(addressstr.Length - 1, 1);
}
var response = GoogleMaps.Geocode.QueryAsync(new GoogleApi.Entities.Maps.Geocode.Request.GeocodingRequest()
{
Key = this.ApiKey,
Language = Language.PortugueseBrazil,
Region = "br",
Address = $"{address.Street}, {address.Number}, {address.Neighborhood}, {address.City} - {address.State}"
}).Result;
var result = ParserToAddress(response);
result.Id = address.Id;
result.City = result.City ?? address.City;
result.Complement = result.Complement ?? address.Complement;
result.Latitude = result.Latitude ?? address.Latitude;
result.Longitude = result.Longitude ?? address.Longitude;
result.Name = result.Name ?? address.Name;
result.Neighborhood = result.Neighborhood ?? address.Neighborhood;
result.Number = result.Number ?? address.Number;
result.PostalCode = result.PostalCode ?? address.PostalCode;
result.Reference = result.Reference ?? address.Reference;
result.State = result.State ?? address.State;
result.Street = result.Street ?? address.Street;
return(result);
}
public DtoAddress GetInfo(DtoAddress address)
{
return(ClientDomain.GetAddressInfo(address));
}
public ActionResult PutAddress(Guid addressId, Guid tenentId, Guid contactId, Guid userId, DtoAddress dtoAddress)
{
if (ModelState.IsValid)
{
Address address = this._db.GetAddres(tenentId, userId, contactId, addressId);
address.Country = dtoAddress.Country;
address.State = dtoAddress.State;
address.City = dtoAddress.City;
bool result = this._db.UpdateAddress(address);
if (result)
{
return(Ok("Successfully Updated"));
}
}
return(BadRequest("Not Updated Successfully"));
}
public DtoAddress AddAdress(int id, [FromBody] DtoAddress address)
{
return(StoreDomain.AddAdress(id, address));
}
public async Task <ActionResult> PutAddress(Guid addressId, Guid tenentId, Guid contactId, Guid userId, DtoAddress dtoAddress)
{
if (ModelState.IsValid && (await this._addressrepo.FirstOrDefault(x => x.Id == addressId && x.Contact.Id == contactId &&
x.Contact.User.Id == userId && x.Contact.User.Tenent.Id == tenentId)) != null)
{
Address address = await this._addressrepo.FirstOrDefault(x => x.Id == addressId && x.Contact.Id == contactId &&
x.Contact.User.Id == userId && x.Contact.User.Tenent.Id == tenentId);
address.Country = dtoAddress.Country;
address.State = dtoAddress.State;
address.City = dtoAddress.City;
await this._addressrepo.update(address);
return(Ok("Successfully Updated"));
}
return(BadRequest("Not Updated Successfully"));
}