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();
}