public List<PurchaseOrderDto> Save(PurchaseOrderDto po) { List<PurchaseOrderDto> poList = InitialData(); po.PoNumber = "PO010003"; poList.Add(po); return poList; }
public ActionResult REAddPo(PurchaseOrderDto po) { MaintainPurchaseOrderControl uco = new MaintainPurchaseOrderControl(); List <PurchaseOrderDto> poList = uco.Save(po); return(View("RingleERP", poList)); }
public static IEnumerable <PurchaseOrderDto> DeserializeOrders(IEnumerable <byte[]> messages) { var orders = new List <PurchaseOrderDto>(); string orderString = default; PurchaseOrderDto order = default; byte[] orderByte = default; foreach (var ob in messages) { try { orderByte = ob; orderString = Encoding.UTF8.GetString(ob); order = JsonConvert.DeserializeObject <PurchaseOrderDto>(orderString); //var po = OnDeserializeOrder(ob); orders.Add(order); } catch (Exception ex) { Console.WriteLine($"Error while process a order: {ex.Message}"); } } return(orders); }
public async Task <IActionResult> UpdatePurchaseOrder([FromRoute] int id, [FromBody] PurchaseOrderDto entityDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != entityDto.Id) { return(BadRequest()); } var entity = await _repository.GetByIdAsync(entityDto.Id); if (entity == null) { return(NotFound("Purchase does not exist")); } _mapper.Map(entityDto, entity); try { _repository.Update(entity); await _unitOfWork.SaveAsync(); } catch (Exception) { throw new Exception("An unexpected error occured. Could not update."); } return(Ok(_mapper.Map <PurchaseOrderDto>(entity))); }
private static byte[] OnCreateOrder(int index) { int maxPoNumber = Math.Max(index, _orderiIds.Count - 1); var po = new PurchaseOrderDto() { PoNumber = _orderiIds[_random.Next(0, maxPoNumber)], // CreatedDate = DateTime.Now, ThreadId = Thread.CurrentThread.ManagedThreadId, Status = OrderStates[_random.Next(0, 2)], CustomerId = Customers[_random.Next(0, 4)], OrderLineItems = new List <PurchaseOrderLineItemDto>() { new PurchaseOrderLineItemDto() { ProductId = $"Blue Widget {_productIds[_random.Next(0,_productIds.Count - 1)]}", Quantity = 54 * _random.Next(1, 100), UnitCost = (decimal)(29.99F * _random.Next(1000, 5000) / 100) }, new PurchaseOrderLineItemDto() { ProductId = $"Red Widget {_productIds[_random.Next(0,_productIds.Count - 1)]}", Quantity = 980 * _random.Next(1, 1000), UnitCost = (decimal)(45.89F * _random.Next(1000, 2000) / 100) } }.ToArray() }; var msg = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(po)); return(msg); }
public ActionResult RingleERPCopy(string poNumber) { MaintainPurchaseOrderControl uco = new MaintainPurchaseOrderControl(); PurchaseOrderDto dto = uco.CopyPo(poNumber); return(View(dto)); }
// Actualizar elemento public PurchaseOrder Update(PurchaseOrderDto purchaseOrderParam) { // Buscamos elemento a modificar var purchaseOrder = _context.PurchaseOrder.Find(purchaseOrderParam.idPurchaseOrder); // verificamos q existe if (purchaseOrder == null) { throw new AppException("Orden de compra no existe."); } // Verificamos si los datos ya existen if (purchaseOrderParam.orderTitle != purchaseOrder.orderTitle) { // purchaseOrderName has changed so check if the new purchaseOrderName is already taken if (_context.PurchaseOrder.Any(x => x.orderTitle == purchaseOrderParam.orderTitle)) { throw new AppException("La orden de compra " + purchaseOrderParam.orderTitle + " ya existe"); } } // actualizamos dato purchaseOrder.update(purchaseOrderParam, _context); // Guardar cambios _context.PurchaseOrder.Update(purchaseOrder); _context.SaveChanges(); return(purchaseOrder); }
public List <PurchaseOrderDto> Save(PurchaseOrderDto po) { List <PurchaseOrderDto> poList = InitialData(); po.PoNumber = "PO010003"; poList.Add(po); return(poList); }
/// <summary> /// The PurchaseOrders_Load /// </summary> /// <param name="sender">The sender<see cref="object"/></param> /// <param name="e">The e<see cref="EventArgs"/></param> private void PurchaseOrders_Load(object sender, EventArgs e) { RetrieveProducts(); PopulatePurchaseOrder(); _purchaseOrderDto = new PurchaseOrderDto(); _purchaseOrderDto.productDetail = new List <PurchaseOrderDetailModel>(); }
public IActionResult Post([FromBody] PurchaseOrderDto purchaseOrderDto) { if (purchaseOrderDto == null) { return(BadRequest("Purchse order object is null")); } _purchaseOrderService.Process(_mapper.Map(purchaseOrderDto)); //ideally shpuld be returning 201 with location header but for simplicity we can return 200 return(Ok()); }
public PurchaseOrderDto CopyPo(String sourcePoNumber) { PurchaseOrderDto source = InitialData().Where(p => p.PoNumber.Equals(sourcePoNumber)).SingleOrDefault(); PurchaseOrderDto target = null; if (source != null) { target = source.Clone(); target.PoNumber = string.Empty; } return(target); }
public Task <PurchaseOrderDto> CreatePurchaseOrderAsync(PurchaseOrderDto dto) { if (dto == null) { return(Task.FromResult <PurchaseOrderDto>(null)); } dto.Id = Guid.NewGuid(); list.Add(dto); return(dto.AsTask()); }
public async Task <PurchaseOrderDto> CreatePurchaseOrderAsync(PurchaseOrderDto dto) { if (!ValidateDto(dto)) { return(null); } var options = new UnitOfWorkOptions() { IsTransactional = true, Scope = TransactionScopeOption.Required, IsolationLevel = IsolationLevel.ReadCommitted }; using (var uow = _unitOfWorkManager.Begin(options)) { var priceTable = await _priceTableRepository.GetPriceTableAsync(); var purchaseOrderBuilder = PurchaseOrder.New(Notification) .UpdatePriceTable(priceTable) .WithCustomer(dto.CustomerId) .WithDiscount(dto.Discount) .AddPurchaseOrderLines(lines => { foreach (var productDto in dto.Products) { lines.AddProduct(productDto.ProductId, productDto.Quantity); } }); var purchaseOrder = await _domainService.NewPurchaseOrder(purchaseOrderBuilder); if (Notification.HasNotification()) { return(null); } await uow.CompleteAsync(); dto.Id = purchaseOrder.Id; // Handler message after create purchase order for recalculate tax moviment await Handle(new PurchaseOrderChangedMessage() { PurchaseOrderId = purchaseOrder.Id, PurchaseOrderBaseValue = purchaseOrder.BaseValue, PurchaseOrderDiscount = purchaseOrder.Discount }); } return(dto); }
public Order Map(PurchaseOrderDto purchaseOrderDto) { var order = new Order(); order.CustomerInfo = new Customer { Id = purchaseOrderDto.CustomerId }; order.Id = purchaseOrderDto.Id; order.Total = purchaseOrderDto.TotalAmount; order.ItemLines = MapItemLines(purchaseOrderDto.ItemLines); return(order); }
public Task <PurchaseOrderDto> UpdatePurchaseOrderAsync(Guid id, PurchaseOrderDto dto) { if (dto == null) { return(Task.FromResult <PurchaseOrderDto>(null)); } list.RemoveAll(c => c.Id == id); dto.Id = id; list.Add(dto); return(dto.AsTask()); }
public IHttpActionResult Get([FromUri] Guid purchaseOrderId) { var purchaseOrder = shoppingEntities.PurchaseOrders.FirstOrDefault(t => t.Id == purchaseOrderId); if (purchaseOrder == null) { throw new BadRequestException("Không có PurchaseOrder"); } var purchaseOrderDto = new PurchaseOrderDto(purchaseOrder, purchaseOrder.PurchaseOrderDetails, purchaseOrder.PurchaseOrderWorkFlows); return(Ok(purchaseOrderDto)); }
public IHttpActionResult PostCurrentUserPurchaseOrder([FromBody] PurchaseOrderDto purchaseOrderDto) { var token = ultilityService.GetHeaderToken(HttpContext.Current); var userToken = shoppingEntities.UserTokens.FirstOrDefault(t => t.Name == token); if (userToken == null) { throw new BadRequestException("Access token khong hop le"); } var user = userToken.User; using (ShoppingEntities shoppingEntities = new ShoppingEntities()) { using (var transaction = shoppingEntities.Database.BeginTransaction()) { try { var purchaseOrder = purchaseOrderDto.ToModel(); purchaseOrder.WorkFlowStatus = (int)Constant.Status.Running; purchaseOrder.WorkFlowLevel = 1; List <PurchaseOrderDetail> purchaseOrderDetails = purchaseOrderDto.PurchaseOrderDetailDtos.ConvertAll(t => t.ToModel()); shoppingEntities.PurchaseOrders.Add(purchaseOrder); shoppingEntities.PurchaseOrderDetails.AddRange(purchaseOrderDetails); shoppingEntities.PurchaseOrderWorkFlows.Add( new PurchaseOrderWorkFlow { Id = Guid.NewGuid(), UserId = user.Id, Level = 1, Status = (int)Constant.WorkFlowStatus.Approved, Reason = "", PurchaseOrderId = purchaseOrder.Id }); shoppingEntities.SaveChanges(); transaction.Commit(); } catch (Exception e) { transaction.Rollback(); } } } return(Ok()); }
public void Setup() { _stubPurchaseStatusDto = new PurchaseStatusDto { Id = Guid.NewGuid(), Name = "Ordered" }; _stubPaymentInformationDto = new PaymentInformationDto { CardCVC = "121", CardExpiry = new DateTime(), CardName = "Oliver Test", CardNumber = "1234567890123456", ID = Guid.NewGuid() }; _stubPurchaseOrderDto = new PurchaseOrderDto { Address = "Test Drive", ExternalID = 1, ID = Guid.Parse("d61a78a9-b6ad-4430-91ea-0c8d5227b6aa"), IsDeleted = false, PaymentInformation = _stubPaymentInformationDto, PaymentInformationID = _stubPaymentInformationDto.ID, Postcode = "T35T DR1", ProductID = Guid.NewGuid(), ProductName = "Testy", ProductPrice = 10.50, PurchasedBy = Guid.NewGuid(), PurchasedOn = new DateTime(), PurchaseStatus = _stubPurchaseStatusDto, Quantity = 1, Source = "Undercutters", StatusID = _stubPurchaseStatusDto.Id }; _stubOrderCreatedDto = new OrderCreatedDto { AccountName = "Testy1", CardNumber = "10490249204920492049", Id = 1, ProductEan = "1 2 4 2 3", ProductId = 1, ProductName = "Product1", PurchasedOn = new DateTime(), Quantity = 5, Success = true, TotalPrice = 10 }; _mockLogger = new Mock <ILogger <OrdersRepository> >(); _ordersRepository = new OrdersRepository(GetInMemoryContextWithSeedData(), _mockLogger.Object); }
[HttpPost("agregar")] // metodo POST para agregar elementos public IActionResult Insert([FromBody] PurchaseOrderDto purchaseOrderDto) { var purchaseOrder = _mapper.Map <PurchaseOrder>(purchaseOrderDto); // Mapear dto a entitidad try { purchaseOrder = _purchaseOrderRepository.Insert(purchaseOrder); // Guardamos el elemento purchaseOrderDto = _mapper.Map <PurchaseOrderDto>(purchaseOrder); // Mapear entitidad a dto return(Ok(purchaseOrderDto)); } catch (AppException ex) // Si ocurre un error... { return(BadRequest(new { message = ex.Message })); // Retornar mensaje de error } }
[HttpPut("actualizar")] // metodo PUT para actualizar elemento public IActionResult Update([FromBody] PurchaseOrderDto purchaseOrderDto) { var purchaseOrder = _mapper.Map <PurchaseOrder>(purchaseOrderDto); // Mapear dto a entitidad try { purchaseOrder = _purchaseOrderRepository.Update(purchaseOrderDto); // Actualizamos el elemento purchaseOrderDto = _mapper.Map <PurchaseOrderDto>(purchaseOrder); // Mapear entitidad a dto return(Ok(purchaseOrderDto)); } catch (AppException ex) { return(BadRequest(new { message = ex.Message })); // Retornar mensaje de error } }
public async Task <IActionResult> CreatePurchaseOrder([FromBody] PurchaseOrderDto entityDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var entity = _mapper.Map <PurchaseOrder>(entityDto); _repository.Add(entity); // adds the purchase order to the repository // Get the location items involved in the transaction using the locationId of the purchase order and // the itemsIds of the purchase order items. var itemIds = entityDto.PurchaseOrderItems.Select(p => p.ItemId); var locationItems = await _locationItemRepository .GetAsync(l => l.LocationId == entity.LocationId && itemIds.Contains(l.ItemId)); if (locationItems.Count() != itemIds.Count()) { return(BadRequest("Duplicate item in purchase or an item does not exist in the specified location")); } foreach (var lItem in locationItems) { lItem.Quantity += entity.PurchaseOrderItems.Single(p => p.ItemId == lItem.ItemId).Quantity; if (lItem.Quantity < 0) { return(BadRequest(new { message = "Quantity cannot be less than zero", lItem })); } _locationItemRepository.Update(lItem); } try { await _unitOfWork.SaveAsync(); var createdResult = CreatedAtAction("GetPurchaseById", new { id = entity.Id }, entity.Id); createdResult.StatusCode = 200; return(createdResult); } catch (Exception e) { throw new Exception("An unexpected error occured. Could not be added.", e); } }
public async Task <Guid> CreateOrder(PurchaseOrderDto purchaseOrder) { _logger.LogInformation("Creating an order in local database"); return(await _retryPolicy.ExecuteAsync(async() => { try { var dbEntity = await _context.PurchaseOrders.AddAsync(purchaseOrder); await _context.SaveChangesAsync(); _logger.LogInformation("Successfully created an order in local database"); return dbEntity.Entity.ID; } catch (Exception e) { _logger.LogError("Exception when trying to create a new purchase order:" + purchaseOrder + e + e.StackTrace); } return Guid.Empty; })); }
public async Task Should_Raise_Notification_On_Update_With_Specifications() { // Arrange var guid = Resolve <PurchaseOrderServiceMockManager>().PurchaseOrderGuid; var invalidProductId = Guid.NewGuid(); var dto = new PurchaseOrderDto(); dto.Products.Add(new PurchaseOrderDto.ProductDto(invalidProductId, 1)); // Act var purchaseOrder = await _appService.UpdatePurchaseOrderAsync(guid, dto); // Assert Assert.NotNull(purchaseOrder); Assert.True(LocalNotification.HasNotification()); var message = string.Format(_localizationSource.GetString(PurchaseOrder.Error.ProductsThatAreNotInThePriceTable, _culture), invalidProductId); Assert.Contains(LocalNotification.GetAll(), n => n.Message == message); }
private static IEnumerable <byte[]> OnCreateOrders(int start, int count) { var messages = new List <byte[]>(); for (int i = start; i < start + count; i++) { var po = new PurchaseOrderDto() { // PoNumber = _orderiIds[_random.Next(0, _orderiIds.Count - 1)], PoNumber = _orderiIds[i], Status = OrderStates[_random.Next(0, 2)], // CreatedDate = DateTime.Now, CustomerId = Customers[_random.Next(0, 4)], ThreadId = Thread.CurrentThread.ManagedThreadId, OrderLineItems = new List <PurchaseOrderLineItemDto>() { new PurchaseOrderLineItemDto() { ProductId = $"{ProductePrix[_random.Next(0, 4)]} Widget {_productIds[_random.Next(0,_productIds.Count - 1)]}", Quantity = 54 * _random.Next(1, 10), UnitCost = 10 * _random.Next(10, 500) / 100 }, new PurchaseOrderLineItemDto() { ProductId = $"{ProductePrix[_random.Next(0, 4)]} Widget {_productIds[_random.Next(0,_productIds.Count - 1)]}", Quantity = 90 * _random.Next(1, 100), UnitCost = 20 * _random.Next(100, 2000) / 100 } }.ToArray() }; var orderString = JsonConvert.SerializeObject(po); var orderBytes = Encoding.UTF8.GetBytes(orderString); var length = Encoding.UTF8.GetByteCount(orderString); var orderUTF8Bytes = new byte[length + 1]; Encoding.UTF8.GetBytes(orderString, 0, orderString.Length, orderUTF8Bytes, 0); orderUTF8Bytes[orderUTF8Bytes.Length - 1] = (byte)'\n'; //Array.Copy(orderByte, destOrderByte, orderByte.Length); //destOrderByte[orderByte.Length] = (byte)'\n'; messages.Add(orderUTF8Bytes); } return(messages); }
public async Task <IActionResult> ConfirmPurchaseOrderForUser(int userId) { if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } User user = await _repo.GetUser(userId); List <Offer> cart = await _repo.GetOffersCart(userId); if (cart.Count == 0) { return(BadRequest("Não há itens no carrinho do usuário")); } if (await _repo.SavePurchaseOrderForUser(user)) { // UserForReturnDto userForReturnDto = _mapper.Map<UserForReturnDto>(user); PurchaseOrderDto purchaseDto = _mapper .Map <PurchaseOrderDto>(user.CartOffers); cart = await _repo.ClearCartForUser(user); List <OfferForCartDto> listCart = null; if (cart != null) { listCart = _mapper.Map <List <OfferForCartDto> >(cart); } return(Ok(new { purchase = purchaseDto, cart = listCart })); } return(BadRequest("Houve algum problema em salvar a compra no banco")); }
public async Task <IActionResult> CreateOrder(PurchaseOrderDto orderInfo) { var token = HttpContext.Request.Headers["Authorization"]; _logger.LogInformation("Creating a new order!"); var orderId = await _ordersRepository.CreateOrder(orderInfo); if (orderId != null && orderId != Guid.Empty) { var service = _ordersFactory.Create(orderInfo.Source); var order = await service.CreateOrder(orderInfo.PaymentInformation.CardName, orderInfo.PaymentInformation.CardNumber, orderInfo.ExternalID, orderInfo.Quantity); if (order.Success == false) { _logger.LogInformation("Failed to create an order due to insufficient stock"); await _ordersRepository.UpdateOrderAsync(orderId, null, "Insucfficient Stock"); return(BadRequest("Insufficient Stock")); } if (order != null) { _logger.LogInformation("Successfully created a new order - " + orderId); var success = await _ordersRepository.UpdateOrderAsync(orderId, order, "Complete"); await _stockService.UpdateStockLevel(new SetStockLevelDto { ProductID = orderInfo.ProductID, StockLevel = orderInfo.Quantity }, token); return(Ok(success)); } ; await _ordersRepository.UpdateOrderAsync(orderId, null, "Failed"); } _logger.LogError("Failed to create a new order - reason unknown"); return(new StatusCodeResult(StatusCodes.Status500InternalServerError)); }
public async Task Should_Raise_Notification_On_Update_With_Specifications() { // Arrange var invalidProductId = Guid.NewGuid(); var dto = new PurchaseOrderDto(); dto.Products.Add(new ProductDto(invalidProductId, 1)); // Act var response = await PutResponseAsObjectAsync <PurchaseOrderDto, ErrorResponse>( $"{WebConstants.PurchaseOrderRouteName}/{PurchaseOrderAppServiceMock.purchaseOrderGuid}", dto, HttpStatusCode.BadRequest ); // Assert Assert.NotNull(response); Assert.Equal(1, response.Details.Count); var message = string.Format(_localizationSource.GetString(PurchaseOrder.Error.ProductsThatAreNotInThePriceTable, _culture), invalidProductId); Assert.Contains(response.Details, n => n.Message == message); }
public PurchaseOrderForm(string mode, DataGridViewRow row) { InitializeComponent(); _Context = new PurchaseContext(); purchaseOrderRepo = new PurchaseOrderRepository(); purchase = new PurchaseOrderDto(); if (mode != null) { this.mode = mode; if (this.mode.Equals("Create")) { Text = "Crear Solicitud de Articulo"; } if (this.mode.Equals("Edit")) { Text = "Editar Solicitud de Articulo"; this.row = row; } } }
public ActionResult REAddPo(PurchaseOrderDto po) { MaintainPurchaseOrderControl uco = new MaintainPurchaseOrderControl(); List<PurchaseOrderDto> poList = uco.Save(po); return View("RingleERP", poList); }
public void Setup() { _mockOrdersRepository = new Mock <IOrdersRepository>(); _mockOrdersFactory = new Mock <IOrdersFactory>(); _mockLogger = new Mock <ILogger <OrdersController> >(); _mockOrdersService = new Mock <IOrdersService>(); _mockStockService = new Mock <IStockService>(); _ordersController = new OrdersController(_mockOrdersRepository.Object, _mockOrdersFactory.Object, _mockLogger.Object, _mockStockService.Object); _stubPurchaseOrderDto = new PurchaseOrderDto { Address = "MockAddress", ExternalID = 1, ID = Guid.NewGuid(), IsDeleted = false, PaymentInformation = new PaymentInformationDto { ID = Guid.NewGuid(), CardCVC = "121", CardExpiry = new DateTime(), CardName = "MockOli", CardNumber = "1234567890123456" }, Postcode = "T35T TST", ProductID = Guid.NewGuid(), ProductName = "Testy Producty", ProductPrice = 50.55, PurchasedBy = Guid.NewGuid(), PurchasedOn = new DateTime(), PurchaseStatus = new PurchaseStatusDto { Id = Guid.NewGuid(), Name = "Ordered" }, Quantity = 2, Source = "Undercutters", }; _stubOrderCreatedDto = new OrderCreatedDto { Success = true, }; _stubOrderFailedToCreateDto = new OrderCreatedDto { Success = false }; _stubOrderListItem = new OrderListItemVm { Id = Guid.NewGuid(), OrderStatus = "Ordered", Price = 10.100, ProductName = "Test Product", Quantity = 5 }; _stubOrderListList = new List <OrderListItemVm>(); _stubOrderListList.Add(_stubOrderListItem); _stubOrderList = new OrderListVm { Orders = _stubOrderListList }; _stubOrderDetailVm = new OrderDetailVm { OrderPrice = 10, Address = "Test", CardholderName = "Oli", Id = Guid.NewGuid(), Last4Digits = "123", Postcode = "TSE3 231", ProductId = Guid.NewGuid(), ProductName = "Test", ProductPrice = 5.99, PurchasedOn = new DateTime(), PurchaseStatus = "Purchased", Quantity = 5, Source = "Undercutters" }; }
public void Put(Guid id, PurchaseOrderDto value) { throw new NotImplementedException(); }
public void Post(PurchaseOrderDto value) { throw new NotImplementedException(); }