Esempio n. 1
0
 private bool HasProperties(OrderData order, AddOrderModel addOrderModel, int clientId) =>
 order.Name == addOrderModel.Name &&
 order.Surname == addOrderModel.Surname &&
 DateTime.Compare(order.CheckIn, addOrderModel.CheckIn) == 0 &&
 DateTime.Compare(order.CheckOut, addOrderModel.CheckOut) == 0 &&
 order.RoomId == addOrderModel.RoomId &&
 order.ClientId == clientId;
Esempio n. 2
0
        public AddOrderModel Validate(AddOrderModel fltAddOrderModel)
        {
            _orderAbstractContext.AddOrderModel = fltAddOrderModel;
            _orderAbstractContext.DbContext     = this.Context;
            DomesticOrderAbstractValidate orderAmountValidate = new OrderAmountValidate();                                    //价格验证
            DomesticOrderAbstractValidate sameFlightValidate  = new SameFlightValidate();                                     //是否存在相同行程相同乘客的订单
            DomesticOrderAbstractValidate czValidate          = new CorpCzValidate();                                         //CZ航司特殊要求验证
            DomesticOrderAbstractValidate jdValidate          = new CorpJdValidate();                                         //JD航司特殊要求验证
            //DomesticOrderAbstractValidate aduitValidate = new CorpAuditValidate();//差旅订单审核验证
            DomesticOrderAbstractValidate corpWhiteListValidate = new CorpWhiteListValidate(_checkPassengerIsInWhiteListBll); //白名单匹配
            DomesticOrderAbstractValidate buyRemarkValidate     = new B2GBuyRemarkValidate();                                 //B2G采购备注验证
            DomesticOrderAbstractValidate corpOrderValidate     = new CorpOrderValidate();                                    //公司客户订单验证
            DomesticOrderAbstractValidate unUsedTicketValidate  = new UnUsedTicketValidate();                                 //是否存在未使用票号

            orderAmountValidate.SetNextNode(sameFlightValidate);
            sameFlightValidate.SetNextNode(czValidate);
            czValidate.SetNextNode(jdValidate);
            jdValidate.SetNextNode(corpWhiteListValidate);
            corpWhiteListValidate.SetNextNode(buyRemarkValidate);
            buyRemarkValidate.SetNextNode(corpOrderValidate);
            corpOrderValidate.SetNextNode(unUsedTicketValidate);

            orderAmountValidate.ActionValidate(_orderAbstractContext);
            return(fltAddOrderModel);
        }
Esempio n. 3
0
        public AddOrderModel AddOrder(AddOrderModel addOrderModel)
        {
            var orderModel = CreateOrderModel(addOrderModel);

            orderModelList.Add(orderModel);
            return(addOrderModel);
        }
Esempio n. 4
0
 public async Task <ActionResult <int> > AddOrder([FromBody] AddOrderModel value)
 {
     return(Ok(await _mediator.Send(new AddOrderRequest()
     {
         Model = value
     })));
 }
        public async Task Add(AddOrderModel model)
        {
            var entity = _mapper.Map <Order>(model);

            _repository.Add(entity);

            await _repository.SaveChangesAsync();
        }
Esempio n. 6
0
 /// <summary>
 /// 下配送单接口
 /// </summary>
 /// <param name="accessTokenOrAppId">AccessToken或AppId(推荐使用AppId,需要先注册)</param>
 /// <param name="data">请求数据</param>
 /// <param name="timeOut">代理请求超时时间(毫秒)</param>
 /// <returns></returns>
 public static AddOrderJsonResult AddOrder(string accessTokenOrAppId, AddOrderModel data, int timeOut = Config.TIME_OUT)
 {
     return(WxOpenApiHandlerWapper.TryCommonApi(accessToken =>
     {
         var urlFormat = Config.ApiMpHost + "/cgi-bin/express/local/business/order/add?access_token={0}";
         return CommonJsonSend.Send <AddOrderJsonResult>(accessToken, urlFormat, data, timeOut: timeOut);
     }, accessTokenOrAppId));
 }
Esempio n. 7
0
        public async Task <IActionResult> Save(AddOrderModel model)
        {
            var user = User.Identity.Name;

            model.UserId = user;
            await _orderService.Add(model);

            return(Ok());
        }
Esempio n. 8
0
 private void SetupOrderRepositoryAddAsyncMock(AddOrderModel addOrderModel, int clientId)
 => orderRepositoryMock
 .Setup(repository =>
        repository.AddAsync(It.Is <OrderData>(order =>
                                              HasProperties(
                                                  order,
                                                  addOrderModel,
                                                  clientId))))
 .ReturnsAsync((OrderData)null);
Esempio n. 9
0
        public static AddOrderModel ToAddModel(this OrderVM orderVM)
        {
            var model = new AddOrderModel()
            {
                CustomerId = orderVM.CustomerId,
                OrderItems = orderVM.OrderItems.Select(x => x.ToModel())
            };

            return(model);
        }
Esempio n. 10
0
        public static OrderEntity ToEntity(this AddOrderModel model)
        {
            var entity = new OrderEntity()
            {
                CustomerId = model.CustomerId,
                OrderDate  = DateTime.UtcNow
            };

            return(entity);
        }
Esempio n. 11
0
        public virtual JsonResult AddOrder(AddOrderModel model, List <HttpPostedFileBase> attachments)
        {
            if (!ModelState.IsValid)
            {
                return(Json(new ActionResponse <string> {
                    Message = LocalMessage.ValidationFailed
                }));
            }
            var addUser = _userSrv.Insert(model);

            if (!addUser.IsSuccessful)
            {
                return(Json(addUser));
            }

            model.UserId = addUser.Result;
            var userInRole = new UserInRole
            {
                UserId       = addUser.Result,
                RoleId       = int.Parse(AppSettings.EndUserRoleId),
                IsActive     = true,
                ExpireDateSh = PersianDateTime.Now.AddYears(5).ToString(PersianDateTimeFormat.Date)
            };

            if (!_userInRoleBusiness.Value.CheckExist(userInRole))
            {
                _userInRoleBusiness.Value.Insert(userInRole);
            }

            model.Status       = OrderStatus.WaitForPricing;
            model.DayToDeliver = byte.Parse(AppSettings.DefaultDayToDeliver);
            var addOrder = _orderSrv.Add(model);

            if (!addOrder.IsSuccessful)
            {
                return(Json(addUser));
            }

            var addFiles = _attachmentSrv.Insert(addOrder.Result, AttachmentType.OrderFiles, attachments);

            addOrder.Result.User = new User
            {
                FirstName    = model.FirstName,
                LastName     = model.LastName,
                Email        = model.Email,
                MobileNumber = long.Parse(model.MobileNumber)
            };

            return(Json(new
            {
                addFiles.IsSuccessful,
                addFiles.Message,
                Result = MvcExtention.RenderViewToString(this, MVC.Home.Views.Partials._AfterAdd, addOrder.Result)
            }));
        }
Esempio n. 12
0
        public IActionResult Post(AddOrderModel addOrderModel)
        {
            if (!addOrderModel.Products.Any())
            {
                return(BadRequest("Product list can not be empty."));
            }
            var totalPriceHelper = new TotalPriceHelper(addOrderModel.Client.Id);
            var totalPrice       = Math.Round(totalPriceHelper.CalculateTotalPrice(addOrderModel.Products), 2);

            return(Ok(totalPrice));
        }
Esempio n. 13
0
        public async Task AddOrderAsyncNullSessionTest()
        {
            AddOrderModel addOrderModel = CreateAddOrderModel(Token);

            SetupSessionRepositoryMock(addOrderModel.Token, null);

            DefaultResponseModel expected = CreateDeniedDefaultResponseModel();
            DefaultResponseModel actual   = await orderService.AddAsync(addOrderModel);

            Assert.AreEqual(expected.IsSuccessful, actual.IsSuccessful);
        }
Esempio n. 14
0
        private OrderModel CreateOrderModel(AddOrderModel addOrderModel)
        {
            var orderModel = new OrderModel
            {
                Id         = GenerateOrderId(),
                Client     = addOrderModel.Client,
                Products   = addOrderModel.Products,
                TotalPrice = GetTotalPrice(addOrderModel)
            };

            return(orderModel);
        }
Esempio n. 15
0
 public IActionResult Post(AddOrderModel addOrderModel)
 {
     try
     {
         var result = orderRepository.AddOrder(addOrderModel);
         return(Ok(result));
     }
     catch (Exception ex)
     {
         return(BadRequest($"An error occured during adding new product.\n{ex.Message}"));
     }
 }
Esempio n. 16
0
        public async Task AddOrderAsyncRoomIsNotAvailableTest()
        {
            AddOrderModel addOrderModel = CreateAddOrderModel(Token);
            SessionData   sessionData   = CreateSessionData();

            SetupSessionRepositoryMock(addOrderModel.Token, sessionData);
            SetupRoomAvailabilityHandlerMock(addOrderModel, DatesAreValid, RoomIsNotAvailable);

            DefaultResponseModel expected = CreateDeniedDefaultResponseModel();
            DefaultResponseModel actual   = await orderService.AddAsync(addOrderModel);

            Assert.AreEqual(expected.IsSuccessful, actual.IsSuccessful);
        }
Esempio n. 17
0
        public async Task <bool> AddOrderAsync(AddOrderModel model)
        {
            var result = await _orderRep.AddAsync(model.ToEntity());

            if (result != null)
            {
                foreach (var item in model.OrderItems)
                {
                    await _orderItemRep.AddAsync(item.ToEntity(result.Id));
                }
                return(true);
            }
            return(false);
        }
Esempio n. 18
0
        public OrderModel AddOrderForClient(AddOrderModel order)
        {
            OrderModel addedOrder = new OrderModel()
            {
                ID     = _ordersList.Max(x => x.ID) + 1,
                Client = _clientsList.Single(x => x.ID == order.ClientID),
                PurchasedProductsList = _productsList.Where(x => order.PurchasedProductsIDs.Contains(x.ID)).ToList(),
                OrderPrice            = 0.0m
            };

            CalculateFinalOrderPrice(addedOrder);
            _ordersList.Add(addedOrder);
            return(addedOrder);
        }
Esempio n. 19
0
        public async Task AddOrderAsyncTest()
        {
            AddOrderModel addOrderModel = CreateAddOrderModel();

            DefaultResponseModel expected = CreateDefaultResponseModel();

            SetupOrderServiceAddAsyncMock(addOrderModel, expected);

            IActionResult actual = await orderApiController.Add(addOrderModel);

            DefaultResponseModel actualValue = (DefaultResponseModel)(actual as JsonResult).Value;

            Assert.AreEqual(actualValue.Message, expected.Message);
        }
Esempio n. 20
0
        public AddOrderResult AddOrder(AddOrderModel model)
        {
            var order = _mapper.Map <Order>(model);

            order.Date          = DateTime.Now;
            order.UserId        = _userManager.FindByEmailAsync(User.Identity.Name).Result.Id;
            order.OrderStatusId = -1;
            ctx.Orders.Add(order);
            ctx.SaveChanges();
            return(new AddOrderResult()
            {
                Successful = true
            });
        }
Esempio n. 21
0
        public ActionResult AddOrder(int supplyId, int authorId = 0)
        {
            AddOrderModel model = new AddOrderModel();

            model.Authors        = providerContext.Authors().Select(c => (AuthorModel)c).ToList();
            model.SelectedAuthor = model.Authors.FirstOrDefault().Id;
            if (authorId > 0)
            {
                model.SelectedAuthor = authorId;
            }

            model.SupplyId = supplyId;
            return(View(model));
        }
        public async Task <BaseResponse <InternalOrder> > AddOrder(AddOrderModel model)
        {
            var request = new RestRequest("addOrder", Method.POST);

            request.AddParameter("auth_id", model.AuthId);
            request.AddParameter("exch_id", model.ExchId);
            request.AddParameter("mkt_id", model.MktId);
            request.AddParameter("order_type_id", model.OrderTypeId);
            request.AddParameter("price_type_id", model.PriceTypeId);
            request.AddParameter("limit_price", model.LimitPrice);
            request.AddParameter("order_quantity", model.OrderQuantity);

            return(await base.Execute <BaseResponse <InternalOrder> >(request));
        }
Esempio n. 23
0
        public void Create(AddOrderModel order)
        {
            var user   = _context.Users.Single(u => u.Id == order.UserAddedId);
            var status = (Status)order.Status;

            Order newOrder = new Order
            {
                ClientId  = order.ClientId,
                Status    = status,
                UserAdded = user
            };

            _context.Orders.Add(newOrder);
            _context.SaveChanges();
        }
Esempio n. 24
0
        public IActionResult Update(AddOrderModel model)
        {
            var orderToEdit = orderContext.Orders.ToList().Where(x => x.Id == model.OrderId).First();

            orderContext.Update(orderToEdit);

            orderToEdit.ShortDesc  = model.ShortDesc;
            orderToEdit.LongDesc   = model.LongDesc;
            orderToEdit.Price      = model.Price;
            orderToEdit.CategoryId = model.CategoryId;

            orderContext.SaveChanges();

            return(RedirectToAction("Success", "Order"));
        }
Esempio n. 25
0
        public IActionResult Add(AddOrderModel model)
        {
            var orderToAdd = new Order {
                AccountId  = accountContext.findIdByLogin(User.Identity.Name),
                ShortDesc  = model.ShortDesc,
                LongDesc   = model.LongDesc,
                Price      = model.Price,
                Date       = model.Date,
                CategoryId = model.CategoryId
            };

            orderContext.Add(orderToAdd);
            orderContext.SaveChanges();

            return(RedirectToAction("Success", "Order"));
        }
Esempio n. 26
0
        public async Task <bool> IsRoomAvailableAsync(AddOrderModel addOrderModel)
        {
            DateTime checkIn  = addOrderModel.CheckIn;
            DateTime checkOut = addOrderModel.CheckOut;

            IReadOnlyCollection <GetOrderModel> orders = await orderRepository.GetAsync();

            foreach (var order in orders)
            {
                if (IsDatesOverlay(checkIn, checkOut, DateTime.Parse(order.CheckIn), DateTime.Parse(order.CheckOut)))
                {
                    return(false);
                }
            }
            return(true);
        }
Esempio n. 27
0
        public string Run()
        {
            var client = new HttpClientGateway().Client();

            try
            {
                client.BaseAddress = _baseAddres;
                var order = new AddOrderModel()
                {
                    CustomerName = "Winnie the Pooh",
                    Description  = "Pot of Honey",
                    DueDate      = DateTime.UtcNow.ToString("o")
                };

                string orderBody;
                XmlRequestBuilder.TryBuild(order, out orderBody);
                var requestMessage = CreateRequest("orders", new StringContent(orderBody));
                var response       = client.SendAsync(requestMessage).Result;
                response.EnsureSuccessStatusCode();
                return(response.Content.ReadAsStringAsync().Result);
            }
            catch (AggregateException ae)
            {
                foreach (var e in ae.Flatten().InnerExceptions)
                {
                    Console.Write(e.Message);
                    if (e.InnerException != null)
                    {
                        Console.WriteLine(" : " + e.InnerException);
                    }
                    else
                    {
                        Console.WriteLine();
                    }
                }
            }
            catch (Exception he)
            {
                Console.WriteLine("Exception talking to server: {0}", he);
            }
            finally
            {
                client.Dispose();
            }
            return(null);
        }
Esempio n. 28
0
        public ActionResult AddOrder(AddOrderModel model)
        {
            if (ModelState.IsValid)
            {
                OrderDTO order = new OrderDTO
                {
                    Book = new BookDTO
                    {
                        Id       = model.BookId,
                        Title    = model.Title,
                        AuthorId = model.SelectedAuthor
                    },
                    Author = new AuthorDTO
                    {
                        Id = model.SelectedAuthor
                    },
                    Cost   = model.Cost,
                    Supply = new SupplyDTO
                    {
                        Id = model.SupplyId
                    }
                };
                var result = providerContext.AddOrder(order);

                if (result.Code == BusinessLayer.OperationStatusEnum.Success)
                {
                    TempData["OperationStatus"] = true;
                    TempData["OpearionMessage"] = "Книга успешно добавлена";
                }
                else
                {
                    TempData["OperationStatus"] = false;
                    TempData["OpearionMessage"] = result.Message;
                }

                return(RedirectToAction("Index", "ProviderPage"));
            }

            model.Authors = providerContext.Authors().Select(c => (AuthorModel)c).ToList();
            if (model.SelectedAuthor == 0)
            {
                model.SelectedAuthor = model.Authors.FirstOrDefault().Id;
            }

            return(View(model));
        }
        private string PostOrder(HttpClient client)
        {
            var order = new AddOrderModel()
            {
                CustomerName = "Winnie the Pooh",
                Description  = "Pot of Honey",
                DueDate      = DateTime.UtcNow.ToString("o")
            };

            string orderBody;

            XmlRequestBuilder.TryBuild(order, out orderBody);
            var requestMessage = CreateRequest("orders", new StringContent(orderBody));
            var response       = client.SendAsync(requestMessage).Result;

            response.EnsureSuccessStatusCode();
            return(response.Content.ReadAsStringAsync().Result);
        }
Esempio n. 30
0
        public async Task AddOrderAsyncValidDataTest()
        {
            AddOrderModel addOrderModel = CreateAddOrderModel(Token);
            SessionData   sessionData   = CreateSessionData();
            UserData      userData      = CreateUserData();
            ClientData    clientData    = CreateClientData();

            SetupSessionRepositoryMock(addOrderModel.Token, sessionData);
            SetupApplicationUserRepositoryMock(sessionData.UserId, userData);
            SetupClientRepositoryMock(clientData, userData.Id);
            SetupOrderRepositoryAddAsyncMock(addOrderModel, clientData.Id);
            SetupRoomAvailabilityHandlerMock(addOrderModel, DatesAreValid, RoomIsAvailable);

            DefaultResponseModel expected = CreateSuccessfulDefaultResponseModel();
            var actual = await orderService.AddAsync(addOrderModel);

            Assert.AreEqual(expected.IsSuccessful, actual.IsSuccessful);
        }