public async Task <IHttpActionResult> AddNewOrder(NewOrderViewModel order)
{
if (!ModelState.IsValid)
{
return(Ok(new ResponseModel <string>(ResponseStatus.BadRequest, null, "Invalid order data.")));
}
var user = GetUserInformationFromToken();
if (user == null || string.IsNullOrEmpty(user.UserId))
{
return(BadRequest("Invalid User."));
}
var zone = await _locationService.GetZoneFromAddress(order.Lat, order.Lon, order.Address);
if (string.IsNullOrWhiteSpace(zone))
{
return(Ok(new ResponseModel <string>(ResponseStatus.BadRequest, "Sorry, we are not available in this area.", "Sorry, we are not available in this area.")));
}
order.Zone = zone;
var response = await _orderBusiness.AddNewOrder(order, user);
if (!response)
{
return(Ok(new ResponseModel <string>(ResponseStatus.BadRequest, null, "Order was not processed successfully.")));
}
return(Ok(new ResponseModel <string>(ResponseStatus.Ok, null, "Order placed successfully.")));
}
public ActionResult NewOrder(NewOrderViewModel viewModel)
{
try
{
var login = SessionHelper.GetElement <string>(SessionElement.Login);
_unitOfWork.OrderRepository.Add(new WebDBApp.Models.Order
{
User = _unitOfWork.UserRepository.Find(login),
Date = DateTime.Now,
Title = viewModel.Title,
OrderDetails = new WebDBApp.Models.OrderDetails
{
Amount = viewModel.Amount,
Description = viewModel.Description,
},
Building = _unitOfWork.BuildingRepository.Find(viewModel.SelectedBuilding),
Room = _unitOfWork.RoomRepository.Find(viewModel.SelectedRoom)
});
_unitOfWork.SaveChanges();
}
catch (Exception ex)
{
logger.Error(ex, ex.Message);
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(PartialView("~/Views/PartialViews/Error.cshtml", ex.Message));
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> New_Order(int?id, string VIN = null)
{
if (id != null)
{
var context = await _repository.ClientCard.FirstOrDefaultAsync(m => m.ClientId == id);
var model = new NewOrderViewModel
{
ClientCard = context
};
if (context == null)
{
return(HttpNotFound());
}
ViewBag.CarId = new SelectList(_repository.RelatedCars, "CarId", "Make");
return(View(model));
}
if (VIN != null)
{
var car = await _repository.RelatedCars.FirstOrDefaultAsync(m => m.VIN == VIN);
ViewBag.CarId = new SelectList(_repository.RelatedCars, "CarId", "Make", car.CarId);
return(View());
}
ViewBag.CarId = new SelectList(_repository.RelatedCars, "CarId", "Make");
return(View());
}
async void SelectRecord()
{
var newOrderViewModel = NewOrderViewModel.GetInstance();
newOrderViewModel.Part = this;
await navigationService.Back();
}
public IActionResult NewOrder()
{
NewOrderViewModel model = new NewOrderViewModel();
model.OrderDetailsList = GetItemOrderDetails();
model.Countries = _unitOfWork.Repository <Country>().GetAll().Select(c => new SelectListItem
{
Text = c.Name,
Value = c.Id.ToString()
}).OrderBy(x => x.Text).ToList();
model.Countries.Add(new SelectListItem {
Text = "--Select--", Value = "0", Selected = true
});
model.Cities = new List <SelectListItem>();
model.Locations = new List <SelectListItem>();
model.PaymentMethods = _unitOfWork.Repository <PaymentMethod>().GetAll().Select(p => new SelectListItem
{
Text = p.Name,
Value = p.Id.ToString()
}).OrderBy(s => s.Text).ToList();
model.PaymentMethods.Add(new SelectListItem {
Text = "--Select--", Value = "0", Selected = true
});
return(View(model));
}
public ActionResult Add()
{
var model = new NewOrderViewModel();
model.AllDishes = _mapper.Map <List <DishModel> >(_dishService.GetAll());
return(View(model));
}
public async Task <ActionResult> Create([Bind(Include = "SelectedCustomerID,PriorityHigh")] NewOrderViewModel order)
{
if (ModelState.IsValid)
{
if (Session["CurrentUserID"] == null)
{
RedirectToAction("Login", "Home");
}
int CurrentUserID = (int)Session["CurrentUserID"];
Order neworder = new Order
{
UserID = CurrentUserID,
customerID = order.SelectedCustomerID,
Priority = order.PriorityHigh ? 1 : 0,
order_createtime = DateTime.Now,
};
db.Orders.Add(neworder);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(order));
}
public async Task <IActionResult> SaveNewOrder(NewOrderViewModel model)
{
try
{
var client = await _dm.ClientAccessor.GetClient(model.ClientId);
List <ProductViewModel> products = new List <ProductViewModel>();
ProductEntity entity = null;
int i = 0;
int totalSum = 0;
foreach (var item in model.ProductViewModel)
{
if (item.Amount != 0)
{
entity = await _dm.ProductAccessor.GetProduct(item.Id);
entity.Amount -= item.Amount;
item.Price = entity.Price ?? default(int);
item.CountryOfOrigin = entity.CountryOfOrigin;
item.ShelfLife = entity.ShelfLife ?? default(int);
item.Name = entity.Name;
entity = await _dm.ProductAccessor.SaveProduct(entity);
}
else
{
i++;
}
}
if (i == model.ProductViewModel.Count)
{
return(View("Views/ViewRole/AccountantManager/AccountantManager.cshtml"));
}
List <ClientProductEntity> productEntityList = new List <ClientProductEntity>();
for (int j = 0; j <= model.ProductViewModel.Count - 1; j++)
{
if (model.ProductViewModel[j].Amount != 0)
{
productEntityList.Add((model.ProductViewModel[j]).ToClientProductEntity());
totalSum += model.ProductViewModel[j].Price * model.ProductViewModel[j].Amount;
}
}
OrderEntity orderEntity = new OrderEntity();
orderEntity.ClientId = model.ClientId;
orderEntity.IsExecuted = false;
orderEntity.StartDate = DateTime.Now;
orderEntity.TotalSum = totalSum;
orderEntity.ClientProductList = productEntityList;
orderEntity.Payment = PaymentState.Unpaid;
orderEntity = await _dm.OrderAccessor.SaveOrderWithList(orderEntity);
return(View("Views/ViewRole/AccountantManager/AccountantManager.cshtml"));
}
catch (Exception ex)
{
return(null);
}
}
public async Task <ActionResult <string> > CreateOrder(int userId, NewOrderViewModel order)
{
AddOrderCommand newOrder = new AddOrderCommand(userId, order.Products, order.Payment, order.contactMail);
var result = await memoryBus.Send(newOrder);
return(Ok(result));
}
public ActionResult NewOrder()
{
var viewModel = new NewOrderViewModel();
viewModel.SelectedBuilding = 0;
viewModel.Buildings = _unitOfWork.BuildingRepository.All();
return(View(viewModel));
}
public NewReservation()
{
InitializeComponent();
NewOrderViewModel vm = new NewOrderViewModel();
vm.PropertyChanged += Vm_PropertyChanged;
DataContext = vm;
}
public NewOrderForm()
{
this.InitializeComponent();
NewOrderViewModel = new NewOrderViewModel {
InkCanvas = InkCanvas
};
}
public Order(NewOrderViewModel model)
{
Comment = model.Comment;
DateBegin = model.DateBegin;
ClientId = model.ClientId;
PhoneNumber = model.PhoneNumber;
Status = Status.New;
}
/* New order */
public IActionResult Index(int?movieID = null)
{
var model = new NewOrderViewModel(db, movieID);
ViewData["Movies"] = new SelectList(model.MoviesList, "ID", "Title");
ViewData["Dates"] = new SelectList(model.DatesList, "Value", "Text");
return(View(model));
}
public IActionResult NewOrder(NewOrderViewModel model)
{
if (ModelState.IsValid)
{
return(Ok());
}
return(BadRequest());
}
async void SelectRecord()
{
var newOrderViewModel = NewOrderViewModel.GetInstance();
newOrderViewModel.Customer = this;
newOrderViewModel.LoadPriceLists();
await navigationService.Back();
}
public async Task <IActionResult> Create([Bind("DateOfDeadline, OrderName, OrderTask, FrilanserId, SpecializationRoleId")] NewOrderViewModel newOrder)
{
if (ModelState.IsValid)
{
Order order = new Order();
order.DateOfDeadline = newOrder.DateOfDeadline;
order.OrderName = newOrder.OrderName;
order.OrderTask = newOrder.OrderTask;
newOrder.SpecializationRoles = _roleManager.Roles.ToList();
if (newOrder.FrilanserId != "null")
{
order.Frilanser = await _userManager.FindByIdAsync(newOrder.FrilanserId);
order.SpecializationRole = await _roleManager.FindByNameAsync("Universal (Specialization)");
}
else if (newOrder.SpecializationRoleId != null)
{
order.SpecializationRole = await _roleManager.FindByIdAsync(newOrder.SpecializationRoleId);
}
else
{
order.SpecializationRole = await _roleManager.FindByNameAsync("Universal (Specialization)");
}
try
{
int newId = await _repository.CreateNewOrder(order, User);
string SpecializationRole = null;
if (order.SpecializationRole != null)
{
SpecializationRole = order.SpecializationRole.Name;
}
string frilanser = null;
if (order.Frilanser != null)
{
frilanser = order.Frilanser.UserName;
}
await _notifHubContext.Clients
.All
.SendAsync("NewOrderNorificationAssignedFrilanser", newId, frilanser, User.Identity.Name, order.OrderName, order.DateOfDeadline, SpecializationRole);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View(order));
}
}
else
{
return(View("Create"));
}
}
public IActionResult NewOrder()
{
NewOrderViewModel viewModel = new NewOrderViewModel
{
Action = "NewOrder"
};
return(View("FormOrder", viewModel));
}
public bool ValidateOrder(NewOrderViewModel model)
{
#region VerifyProducts
var Products = model.ProductCountList;
foreach (var product in Products)
{
var product_ = _unitOfWork.Repository <Product>().Find(x => x.Id == Convert.ToInt32(product.Key));
if (product_ == null)
{
return(false);
}
var size = model.ProductSizeList.Where(x => x.Key == product.Key).FirstOrDefault().Value;
var color = model.ProductColorList.Where(x => x.Key == product.Key).FirstOrDefault().Value;
var count = Convert.ToInt32(product.Value);
var Stockproduct_ = _unitOfWork.Repository <ProductStock>().GetAllInclude(s => s.ProductSize, c => c.Colors).Where(x => x.ProductId == Convert.ToInt32(product.Key) && x.ProductSize.Size == size && x.Colors.Color == color).FirstOrDefault();
var CountStock_ = Stockproduct_?.InQuantity - Stockproduct_?.MinQuantity;
if (Stockproduct_ == null || CountStock_ <= count)
{
return(false);
}
}
#endregion
#region VerifyCountry
var contry = _unitOfWork.Repository <Country>().Find(x => x.Id == Convert.ToInt32(model.CountryId));
if (contry == null)
{
return(false);
}
#endregion
#region VerifyCard
var PaymentMethod = _unitOfWork.Repository <PaymentMethod>().Find(x => x.Id == 1);
if (PaymentMethod == null)
{
return(false);
}
if (PaymentMethod.Id == 1)
{
if (model.CardNumber.Replace(" ", "").Length != 16 || model.CVV.Length != 3)
{
return(false);
}
}
return(true);
#endregion
}
public Order Add(string userId, NewOrderViewModel order)
{
var newOrder = new Order()
{
Name = order.Name, CustomerId = userId
};
_context.Order.Add(newOrder);
_context.SaveChanges();
return(newOrder);
}
public IActionResult Create([FromBody] NewOrderViewModel request)
{
if (!ModelState.IsValid)
{
return(BadRequest("Parametros invalidos"));
}
request.Id = _repository.Save(request);
return(CreatedAtAction(nameof(GetById), new { Id = request.Id }, request));
}
public IActionResult AddOrder(NewOrderViewModel model)
{
var order = _mapper.Map <Order>(model);
order.Date = DateTime.Now;
order.CustomerUser = _userService.GetCurrent().CustomerInfo;
order.CustomerCompany = _userService.GetCurrent().CustomerInfo.Company;
_orderRepository.Save(order);
return(RedirectToAction("Profile", "Customer"));
}
public ActionResult New()
{
var ViewModel = new NewOrderViewModel
{
Store = _Context.Stores.First()
};
return(View("OrderForm", ViewModel));
}
public void CreateFailing()
{
var model = new NewOrderViewModel();
var controller = new OrderController(null);
ValidateModel(model, controller);
var result = (StatusCodeResult)controller.Create(model);
Assert.Equal((int)HttpStatusCode.BadRequest, result.StatusCode);
}
public async Task <ActionResult <Order> > CreateOrder(NewOrderViewModel newOrderViewModel)
{
var customerEmail = HttpContext.User.GetCustomerEmail();
var shippingAddress = _mapper.Map <AddressViewModel, ShippingAddress>(newOrderViewModel.ShippingAddress);
var order = await _orderService.CreateOrderAsync(customerEmail, newOrderViewModel.DeliveryMethodId, newOrderViewModel.CartId, shippingAddress);
if (order == null)
{
return(BadRequest(new APIResponse(StatusCodes.Status400BadRequest, "Problem while creating order")));
}
return(Ok(order));
}
public IActionResult Index([FromQuery] string search = "")
{
NewOrderViewModel val = new NewOrderViewModel
{
CustomerName = client.FullName,
LocationName = locale.Name,
AvailableItems = repo.GetItems(search).OrderBy(x => x.Name).ToList(),
Purchased = items,
Counts = counts
};
return(View(val));
}
private Models.PaymentData CreatePayment(NewOrderViewModel data)
{
var paymentModel = new Models.PaymentData
{
Amount = data.TotalAmount,
Date = DateTime.Now,
LastDigitCard = data.PaymentData.Card.Substring(data.PaymentData.Card.Length - 5, 4)
};
UnitOfWork.Set <Models.PaymentData>().Add(paymentModel);
UnitOfWork.SaveChanges();
return(paymentModel);
}
public async Task Send(Order order, string shopEmail, string shopPhoneNumber, string templatePath)
{
var conf = this.configuration.Value;
var model = new NewOrderViewModel
{
Id = order.Id,
PaymentMethod = order.Payment,
Email = shopEmail,
DeliveryMethod = order.Delivery,
CustomerName = order.CustomerName,
PhoneNumber = shopPhoneNumber,
Created = order.Timestamp,
Total = order.OrderItems.Sum(x => x.Count * x.Price),
CustomerPhoneNumber = order.PhoneNumber,
CustomerAddress = order.Address,
Items = order.OrderItems.Select(x => new NewOrderItemViewModel
{
Name = x.Product.Title,
Color = x.Color,
Size = x.Size,
Id = x.Product.Id,
Price = x.Price,
Count = x.Count
}).ToList()
};
var letter = await engine.CompileRenderAsync(templatePath, model).ConfigureAwait(false);
var emailMessage = new MimeMessage();
emailMessage.From.Add(new MailboxAddress(conf.From.Name, conf.From.Address));
emailMessage.To.Add(new MailboxAddress(order.CustomerName, order.Email));
emailMessage.Subject = $"Оформлен новый заказ № {order.Id} на сайте Piligrim";
emailMessage.Body = new TextPart(MimeKit.Text.TextFormat.Html)
{
Text = letter
};
using (var client = new SmtpClient())
{
await client.ConnectAsync(conf.Smtp.Host, conf.Smtp.Port, conf.Smtp.UseSsl);
await client.AuthenticateAsync(conf.Smtp.Login, conf.Smtp.Password);
await client.SendAsync(emailMessage);
await client.DisconnectAsync(true);
}
}
public void NewOrder(NewOrderViewModel model)
{
var newOrder = new Order(model);
using (MainContext context = new MainContext())
{
var driver = context.Clients.Where(x => x.Id == model.ClientId).FirstOrDefault();
if (driver.Orders.Any(x => x.DateBegin == model.DateBegin && x.Status != Status.New && x.Status != Status.Approved))
{
throw new Exception("This driver can`t take your order!");
}
context.Orders.Add(newOrder);
}
}
public async Task <bool> AddNewOrder(NewOrderViewModel order, User orderedBy)
{
try
{
var totalOrder = await _orderRepository.GetOrderCount();
var newServiceId = (totalOrder + 1).ToString().PadLeft(OrderServiceIdLength, '0');
var newOrder = new Order
{
ServiceId = newServiceId,
OrderBy = orderedBy,
Address = order.Address,
Lat = order.Lat,
Lon = order.Lon,
Zone = order.Zone,
Promotion = await GetPromoOffer(),
Status = (int)OrderStatus.New,
OrderPlacingTime = Utilities.GetPresentDateTime(),
OrderItems = new List <OrderItem>()
};
var addMessageResponse = await _userMessageBusiness.AddUserMessage(orderedBy.UserId, (int)MessageType.NewOrder, newServiceId);
var addOrderResponse = await _orderRepository.AddNewOrder(newOrder);
if (addMessageResponse == null && !addOrderResponse)
{
return(false);
}
var notification = new Notification
{
Type = (int)NotificationType.AddNewOrder,
MessageId = addMessageResponse,
Title = Constants.NEW_ORDER_MESSAGE_TITLE,
Text = string.Format(Constants.ACK_MESSAGE_TEXT, newServiceId),
SenderUserName = orderedBy.Name,
SenderUserId = orderedBy.UserId,
ReceiverUserName = orderedBy.Name,
ReceiverUserId = orderedBy.UserId,
Status = (int)NotificationStatus.NotSent,
NotificationId = Guid.NewGuid().ToString()
};
var notificationAdd = await _notificationRepository.AddNotification(notification);
return(notificationAdd);
}
catch (Exception ex)
{
throw new Exception("Error placing order." + ex);
}
}
