public DeliveryViewModel CreateDelivery(int deliveryId, string recepient, string item)
{
if (recepient == null)
{
throw new ArgumentNullException(nameof(recepient), "Recepient is null");
}
var user = GetUser(recepient);
if (user == null)
{
throw new InvalidOperationException("User cannot be found");
}
if (item == null)
{
throw new ArgumentNullException(nameof(item), "Item is null");
}
var newDelivery = new DeliveryViewModel
{
DeliveryId = deliveryId,
Recepient = recepient,
DeliveryItem = item,
Status = (int)DeliveryStatus.InProgress,
SentDate = DateTime.Now
};
return(_deliveryRepository.Create(newDelivery.ToDelivery()).ToDeliveryViewModel());
}
public Bill InitializeBill(DeliveryOrderCreateModel deliveryOrderCreateDto, string initiatorName)
{
User addressee = _userRepository.FindByEmail(deliveryOrderCreateDto.AddresseeEmail);
if (addressee == null)
{
throw new NoSuchUserException();
}
Way way = _wayRepository.FindByLocalitySand_IdAndLocalityGet_Id(deliveryOrderCreateDto.LocalitySandId
, deliveryOrderCreateDto.LocalityGetId);
if (way == null)
{
throw new NoSuchWayException();
}
Delivery newDelivery = getBuildDelivery(deliveryOrderCreateDto, addressee, way);
_deliveryRepository.Create(newDelivery);
User user = _userRepository.FindByName(initiatorName);
if (user == null)
{
throw new NoSuchUserException();
}
Bill buildBill = getBuildBill(newDelivery
, calculateDeliveryCost(deliveryOrderCreateDto.DeliveryWeight, way)
, user);
_billRepository.Create(
buildBill);
_billRepository.Save();
return(buildBill);
}
public async Task <EntityValidationResult <Delivery> > SendJob(Delivery data)
{
try
{
var result = new EntityValidationResult <Delivery>();
var validationResult = _validator.Validate(data);
result.IsValid = validationResult.IsValid;
result.Object = data;
if (validationResult.IsValid)
{
data.Id = Guid.NewGuid();
_deliveryRepository.Create(data);
await _deliveryRepository.SaveAsync();
}
else
{
result.Errors = validationResult.Errors.Select(x => new EntityValidationFailure {
PropertyName = x.PropertyName, ErrorMessage = x.ErrorMessage
}).ToList();
}
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
private Response CreateDelivery(dynamic args)
{
int? lifetime = args.lifetime;
DeliveryObject newDelivery = _repository.Create(args.title, _systemClock.Now, lifetime.HasValue ? TimeSpan.FromSeconds(lifetime.Value) : TimeSpan.FromDays(1));
return(Response.AsJson(newDelivery)
.WithContentType("application/json")
.WithStatusCode(HttpStatusCode.Created));
}
public IActionResult DeliveryConfirm()
{
string directory = Directory.GetCurrentDirectory() + "\\tempFiles\\";
DataContractJsonSerializer jsonFormatter = new DataContractJsonSerializer(typeof(Delivery));
Delivery delivery = null;
using (FileStream fs = new FileStream(directory + "Delivery.json", FileMode.Open))
{
delivery = (Delivery)jsonFormatter.ReadObject(fs);
}
System.IO.File.Delete(directory + "Delivery.json");
_deliveryRepository.Create(delivery);
return(View(delivery));
}
public async Task <DeliveryDto> Create(IExecutionContext executionContext, DeliveryDto entity)
{
AssertExecutionContext(executionContext);
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (executionContext.UserRole != Role.User)
{
throw new UnauthorizedException("Only user can create delivery");
}
var created = await _deliveryRepo.Create(_deliveryMapper.To(entity));
return(_deliveryMapper.From(created));
}
public IActionResult Create([Bind("DeliveryId,CheckId,Address,ShippingDate,DeliveryDate,DeliveryPrice")] Delivery delivery)
{
if (ModelState.IsValid)
{
if (delivery.ShippingDate > delivery.DeliveryDate)
{
this.ModelState["DeliveryDate"].Errors.Clear();
this.ModelState["DeliveryDate"].Errors.Add("Дата доставки не може бути раніше, ніж дата відправлення!");
this.ModelState["ShippingDate"].Errors.Clear();
this.ModelState["ShippingDate"].Errors.Add("Дата відправлення не може бути пізніше, ніж дата доставки!");
ViewData["CheckId"] = new SelectList(_furnituresalerepository.GetAll(), "CheckId", "CheckId", delivery.CheckId);
return(View(delivery));
}
_deliveryrepository.Create(delivery);
return(RedirectToAction(nameof(Index)));
}
ViewData["CheckId"] = new SelectList(_furnituresalerepository.GetFurnitureSalesInfo(), "CheckId", "CheckId", delivery.CheckId);
return(View(delivery));
}
public Delivery Create(Guid id, Guid customerId, string fao)
{
if (!CurrentUser.HasRole(UserRole.Member))
{
throw new DomainValidationException(Messages.InsufficientSecurityClearance, "CurrentUser");
}
if (id == Guid.Empty)
{
throw new ArgumentException("An ID must be supplied for the pending item.");
}
var delivery = new Delivery();
delivery.Id = id;
delivery.DeliveryNoteNumber = _entityIdProvider.GetIdFor <Delivery>();
delivery.Customer = GetCustomer(customerId);
delivery.CreatedBy = CurrentUser;
delivery.DateCreated = AppDateTime.GetUtcNow();
delivery.Fao = fao;
ValidateAnnotatedObjectThrowOnFailure(delivery);
_deliveryRepository.Create(delivery);
return(delivery);
}
public Delivery Create([FromBody] Delivery delivery)
{
Repo.Create(delivery);
return(delivery);
}
public async Task Execute(IJobExecutionContext context)
{
_repository.Create("Test delivery", DateTime.Now, TimeSpan.FromDays(1));
}
//[Authorize(Policy = PermissionsList.PermissionsOrderAdd)]
public async Task <IActionResult> AddOrder([FromBody] OrderModel order)
{
var dishNames = order.Dishes.Select(d => d.Name).ToList();
List <Dish> dishes = (List <Dish>) await _orderRepository.GetDishList(dishNames);
bool isPaid = false;
if (dishes.Count == 0 ||
User.Identity.Name != null ||
!ModelState.IsValid)
{
return(BadRequest());
}
Guid orderId = Guid.NewGuid();
decimal totalPrice = 0;
var lineItems = new List <lineItemType>();
List <OrderDish> orderDishes = new List <OrderDish>();
var userId = User.Claims.Where(c => c.Type == ClaimTypes.NameIdentifier).FirstOrDefault();
User orderUser = await _userRepository.GetUserById(userId.Value);
Order newOrder = new Order()
{
Id = orderId,
User = orderUser,
OrderTime = DateTime.Now,
OrderExpirationTime = DateTime.Now.AddHours(1),
IsForDelivery = order.IsForDelivery,
IsCancelled = false,
IsClosed = false
};
dishes.ForEach(dish =>
{
var quantity = order.Dishes.Where(d => d.Name == dish.Name).FirstOrDefault().Quantity;
lineItems.Add(new lineItemType
{
itemId = dish.Id.ToString(),
name = dish.Name,
quantity = quantity,
unitPrice = (decimal)dish.DishPrice
});
orderDishes.Add(new OrderDish
{
Id = Guid.NewGuid(),
Dish = dish,
Order = newOrder,
Quantity = quantity
});
totalPrice += (decimal)dish.DishPrice * quantity;
});
newOrder.TotalPrice = (float)totalPrice;
newOrder.OrderItems = orderDishes;
switch (order.PaymentType)
{
case PaymentTypes.CreditCard:
{
var creditCard = new creditCardType
{
cardNumber = order.CreditCard.CardNumber,
expirationDate = order.CreditCard.ExpirationDate,
cardCode = order.CreditCard.CCV
};
var billingAddress = new customerAddressType
{
firstName = order.BillingAddressModel.FirstName,
lastName = order.BillingAddressModel.LastName,
address = order.BillingAddressModel.Address,
city = order.BillingAddressModel.City,
zip = order.BillingAddressModel.ZIP
};
var response = ChargeCreditCard.Run(creditCard, billingAddress, lineItems, totalPrice);
if (response.messages.resultCode != messageTypeEnum.Ok)
{
return(BadRequest(new { error = "Couldn't process transaction" }));
}
else
{
isPaid = true;
}
break;
}
case PaymentTypes.Cash:
{
break;
}
}
newOrder.IsPaid = isPaid;
_orderRepository.Create(newOrder);
if (order.IsForDelivery)
{
Address address = await _addressRepository.GetById(order.DeliveryAddress.Id);
if (address == null)
{
address = new Address()
{
Id = Guid.NewGuid(),
Name = order.DeliveryAddress.Name,
City = await _cityRepository.GetById(order.DeliveryAddress.City.Id),
Country = await _countryRepository.GetById(order.DeliveryAddress.Country.Id),
Street = order.DeliveryAddress.Street
};
_addressRepository.Create(address);
}
Delivery delivery = new Delivery()
{
Id = Guid.NewGuid(),
DeliveryAddress = address,
Order = newOrder,
IsDelivered = false
};
_deliveryRepository.Create(delivery);
}
return(Ok(new { order_id = orderId }));
}
