public async Task <ActionResult <Carrier> > PostCarrier(Carrier carrier)
{
_context.Carrier.Add(carrier);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetCarrier", new { id = carrier.Id }, carrier));
}
public async Task SeedAsync(DeliveryContext context, IWebHostEnvironment webHostEnvironment)
{
var policy = CreatePolicy(nameof(DeliveryContextSeed));
await policy.ExecuteAsync(async() =>
{
using (context)
{
if (!context.DeliveryStatuses.Any())
{
context.DeliveryStatuses.AddRange(GetPredefinedDeliveryStatus());
await context.SaveChangesAsync();
}
//TODO: Only for demo purposes
if (!context.Clients.Any())
{
var identityGuid = Guid.NewGuid();
var client = new Client(identityGuid, "ClientFirstName", "ClientLastName", "+123456789");
context.Clients.Add(client);
await context.SaveChangesAsync();
}
await context.SaveEntitiesAsync();
}
});
}
public async Task <IActionResult> PutOrderAssignmentReason(int id, OrderAssignmentReason orderAssignmentReason)
{
if (id != orderAssignmentReason.ID)
{
return(BadRequest());
}
_context.Entry(orderAssignmentReason).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderAssignmentReasonExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutOrderAssignment(int id, OrderAssignment orderAssignment)
{
if (id != orderAssignment.ID)
{
return(BadRequest());
}
_context.Entry(orderAssignment).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
/*if (!OrderAssignmentExists(id))
* {
* return NotFound();
* }
* else
* {
* throw;
* }*/
throw;
}
return(NoContent());
}
public async Task <IActionResult> PutItemCategory(int id, ItemCategory itemCategory)
{
if (id != itemCategory.ID)
{
return(BadRequest());
}
_context.Entry(itemCategory).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItemCategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutUser(int id, User user)
{
if (id != user.ID)
{
return(BadRequest());
}
_context.Entry(user).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <TEntity> CreateAsync(TEntity entity)
{
var newEntity = _dbSet.Add(entity);
await _context.SaveChangesAsync();
return(newEntity);
}
public async Task <IActionResult> Create([Bind("id,adress,kitchen,name,spec,string_id")] Restaurants restaurants)
{
if (ModelState.IsValid)
{
_context.Add(restaurants);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(restaurants));
}
public async Task <IHttpActionResult> Add([FromBody] Food fd)
{
if (fd != null)
{
_db.Foods.Add(fd);
await _db.SaveChangesAsync();
return(Ok());
}
else
{
return(BadRequest());
}
}
public async Task <IHttpActionResult> Add([FromBody] Client cl)
{
if (cl != null)
{
_db.Clients.Add(cl);
await _db.SaveChangesAsync();
return(Ok(_db.Clients.OrderByDescending(p => p.ClientId)
.FirstOrDefault().ClientId));
}
else
{
return(BadRequest());
}
}
public async Task <IHttpActionResult> Add([FromBody] Address ad)
{
if (ad != null)
{
_db.Addressess.Add(ad);
await _db.SaveChangesAsync();
return(Ok(_db.Addressess.OrderByDescending(p => p.AddressId)
.FirstOrDefault().AddressId));
}
else
{
return(BadRequest());
}
}
public async Task <Address> AddNewAddress(Address address)
{
_context.Address.Add(address);
await _context.SaveChangesAsync();
throw new NotImplementedException();
}
public async Task <AppUser> CreateUser(AppUser user)
{
_context.AppUsers.Add(user);
await _context.SaveChangesAsync();
return(user);
}
public async Task <IActionResult> Create(Order order)
{
db.Orders.Add(order);
await db.SaveChangesAsync();
return(RedirectToAction("OrderIndex"));
}
public async Task <IHttpActionResult> Add([FromBody] object json)
{
Order order = JsonConvert.DeserializeObject <Order>(json.ToString());
if (order != null)
{
_db.Orders.Add(order);
await _db.SaveChangesAsync();
return(Ok());
}
else
{
return(BadRequest());
}
}
public async Task <DeliveryRequestDto> CreateDeliveryRequestAsync(CreateDeliveryRequestDto model)
{
var request = model.MapToDeliveryRequest();
await _context.AddAsync(request);
await _context.SaveChangesAsync();
return(request.MapToDeliveryRequestDto());
}
public async Task <IActionResult> PutItem(int id, Item item)
{
if (id != item.ID)
{
return(BadRequest());
}
_context.Entry(item).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(NoContent());
}
public async Task <bool> AddHeader()
{
try
{
var header = new DeliveryHeader()
{
DeliveryId = Guid.NewGuid(),
ConfigurationID = 2,
Created = DateTime.Now
};
await context.DeliveryHeaders.AddAsync(header);
await context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
}
return(false);
}
public async Task SaveNewRiderAsync(RiderViewModel model)
{
var rider = new Rider
{
IsAccountActive = true,
IsAvailable = false,
AppUserId = model.AppUserId,
CreatedAt = DateTime.Now,
RiderDetails = new RiderDetails {
AssignedParish = model.AssignedParish,
LicencePlate = model.LicencePlate,
TRN = model.TRN,
Vehicle = model.Vehicle
}
};
_context.Riders.Add(rider);
await _context.SaveChangesAsync();
var appUser = _context.AppUserRoles.Add(new AppUserRoles {
AppRoleId = 3, AppUserId = model.AppUserId.Value
});
await _context.SaveChangesAsync();
}
public async Task CreateRequestForCommandAsync <T>(Guid id)
{
var exists = await ExistAsync(id);
var request = exists
? throw new DeliveryDomainException($"Request with {id} already exists")
: new ClientRequest
{
Id = id,
Name = typeof(T).Name,
Time = DateTime.UtcNow
};
_context.Add(request);
await _context.SaveChangesAsync();
}
public async Task Create(UsuarioDTO usuario)
{
try
{
_context.Usuarios.Add(usuario);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException.InnerException.Message.Contains("Email"))
{
throw new Exception("O email já foi cadastrado.");
}
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
throw new Exception("Erro no banco de dados");
}
}
public async Task <IActionResult> PutDeliveryItem(long id, DeliveryItem deliveryItem)
{
double doubleval1, doubleval2;
if (!double.TryParse(deliveryItem.Latitude, out doubleval1) ||
!double.TryParse(deliveryItem.Longitude, out doubleval2))
{
return(BadRequest());
}
if (double.IsNaN(doubleval1) || double.IsNaN(doubleval2))
{
return(BadRequest());
}
if (id != deliveryItem.Id)
{
return(BadRequest());
}
_context.Entry(deliveryItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DeliveryItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task InsertDelivery(Delivery delivery)
{
_context.Deliveries.Add(delivery);
await _context.SaveChangesAsync();
}
public async Task <int> AddNewStore(Store newStore)
{
_context.Stores.Add(newStore);
return(await _context.SaveChangesAsync());
}