public async Task <HttpResponseMessage> Stage(string id, [FromBody] SalesOrderDto data)
{
if (!ModelState.IsValid)
{
//return ActionContext.Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState.Values.SelectMany(e => e.Errors.Select(er => er.ErrorMessage)).ToString());
return(ActionContext.Request.CreateErrorResponse(HttpStatusCode.BadRequest, ActionContext.ModelState));
}
try
{
HttpClient httpClient = this.getBasicClient();
TransactionLog tLog = transactionLogService.Create(new TransactionLog());
tLog.TransactionLogK = Guid.NewGuid();
string unqTID = tLog.TransactionLogK.ToString();
httpClient.DefaultRequestHeaders.Add("X-Transaction-ID", unqTID);
string apiUri = "https://" + this.apiChorus + "/orders/" + id + "/stage";
string jsData = JsonConvert.SerializeObject(data);
var response = await httpClient.PutAsync(new Uri(apiUri), new StringContent(jsData, Encoding.UTF8, "application/json"));
tLog.Authorization = httpClient.DefaultRequestHeaders.Authorization.ToString();
tLog.BaseAddress = apiUri;
tLog.Response = response.ToString();
tLog.ResponseBody = await response.Content.ReadAsStringAsync();
transactionLogService.SaveChanges();
return(response);
}
catch (Exception e)
{
throw e;
}
}
public virtual ActionResult ExtractReceipt(long salesOrderId)
{
SalesOrderDto salesOrderDto = new SalesOrderDto();
List <SalesOrderDetailDto> salesOrderDetail = new List <SalesOrderDetailDto>();
int baseId = 0;
salesOrderDto = _orderService.FindBySalesOrderID(salesOrderId);
salesOrderDetail = _orderService.FindSalesOrderDetailBySalesOrderID(salesOrderId).ToList();
var dir = Server.MapPath(string.Format("~/{0}", Constants.ProductExcelTemplateDir));
var fileNameTemplate = string.Format("{0}{1}", Constants.ReceiptTemplate, ".xlsx");
var path = System.IO.Path.Combine(dir, fileNameTemplate);
var fileNameGenerated = string.Format("{0}{1}", salesOrderDto.SalesOrderNum, ".xlsx");
var contentType = "application/vnd.ms-excel";
var templateFile = new FileInfo(path);
//var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(path);
var package = new ExcelPackage(templateFile);
var workSheet = package.Workbook.Worksheets[1];
workSheet.Cells["A1:H1"].Value = salesOrderDto.BranchName;
workSheet.Cells["A2:H2"].Value = salesOrderDto.BranchAddress;
workSheet.Cells["A3:H3"].Value = salesOrderDto.BranchDetails;
workSheet.Cells["B5:E5"].Value = salesOrderDto.CustomerFullName;
workSheet.Cells["B6:E6"].Value = string.Empty;
workSheet.Cells["B7:E7"].Value = salesOrderDto.CustomerAddress;
//workSheet.Cells["B8:E8"].Value = "BUSINESS STYLE";
workSheet.Cells["H4"].Value = salesOrderDto.SalesOrderNum;
workSheet.Cells["H5"].Value = salesOrderDto.DateCreated;
//workSheet.Cells["H6"].Value = salesOrderDto.PaymentTerms;
baseId = 11;
for (int i = 0; i < salesOrderDetail.Count; i++)
{
workSheet.Cells["A" + baseId.ToString()].Value = salesOrderDetail[i].Quantity;
workSheet.Cells["C" + baseId.ToString()].Value = salesOrderDetail[i].UnitDesc;
workSheet.Cells["E" + baseId.ToString()].Value = salesOrderDetail[i].ProductFullDisplayWithExtension;
workSheet.Cells["G" + baseId.ToString()].Value = salesOrderDetail[i].UnitPrice;
workSheet.Cells["H" + baseId.ToString()].Value = salesOrderDetail[i].TotalPricePerItemQty;
baseId++;
}
workSheet.Cells["H27"].Value = salesOrderDetail.Sum(e => e.TotalPricePerItemQty);
var memoryStream = new MemoryStream();
//package.Save();
package.SaveAs(memoryStream);
memoryStream.Position = 0;
return(File(memoryStream, contentType, fileNameGenerated));
}
//[HttpPost]
//public void CreateCustomerOrder(CustomerOrderDto customerOrder)
//{
// var salesOrderDto = _mapper.Map<SalesOrderDto>(customerOrder);
// //var orderitemDto = _mapper.Map<OrderItemDto>(customerOrder);
// var salesordercanges = CreateSalesOrder(salesOrderDto);
// // var orderitemChanges = CreateOrderItem(orderitemDto);
//}
public int CreateSalesOrder(SalesOrderDto salesOrder)
{
var salesOrderMapped = _mapper.Map <SalesOrder>(salesOrder);
_context.SalesOrders.Add(salesOrderMapped);
var changes = _context.SaveChanges();
return(changes);
}
public void PutSalesOrderSuccess()
{
GivenSalesOrdersController();
moqSalesOrdersSet.Setup(m => m.Update(It.IsAny <SalesOrder>()));
SalesOrderDto salesOrderDto = new SalesOrderDto(salesOrders[0]);
ActionResult result = controller.PutSalesOrder(salesOrderDto.SalesOrderId, salesOrderDto);
moqSalesOrdersSet.Verify(m => m.Update(salesOrders[0]), Times.Once());
Assert.IsType <OkResult>(result);
}
public long SaveSalesOrder(SalesOrderDto newDetails)
{
this.salesOrder = newDetails.DtoToEntity();
var insertedSalesOrder = this._salesOrder.Insert(this.salesOrder);
if (insertedSalesOrder.IsNull())
{
return(0);
}
return(insertedSalesOrder.SalesOrderID);
}
public ActionResult PutSalesOrder(int salesOrderId, SalesOrderDto salesOrderDto)
{
ActionResult result = new BadRequestResult();
if (salesOrderId == salesOrderDto.SalesOrderId)
{
salesOrdersService.UpdateSalesOrder(salesOrderDto);
result = new OkResult();
}
return(result);
}
/// <summary>
/// 订单从表数据
/// </summary>
/// <returns></returns>
public async Task <string> LoadItemData([FromQuery] SalesOrderDto requestModel)
{
var detail = await salesOrderService.LoadItemDataAsync(requestModel.ID);
TableDataModel tableData = new TableDataModel()
{
count = detail.Count(),
data = mapper.Map <List <SalesOrderDetailDto> >(detail)
};
return(JsonHelper.ObjectToJSON(tableData));
}
public long UpdateSalesOrder(SalesOrderDto newDetails)
{
var details = newDetails.DtoToEntity();
var updatedSalesOrder = this._salesOrder.Update2(details);
if (updatedSalesOrder.IsNull())
{
return(0);
}
return(updatedSalesOrder.SalesOrderID);
}
public void PutSalesOrderSuccess()
{
GivenSalesOrdersController();
SalesOrderDto salesOrderDto = new SalesOrderDto(salesOrders[0]);
moqSalesOrdersService.Setup(m => m.UpdateSalesOrder(salesOrderDto));
ActionResult result = controller.PutSalesOrder(salesOrderDto.SalesOrderId, salesOrderDto);
moqSalesOrdersService.Verify(m => m.UpdateSalesOrder(salesOrderDto));
Assert.IsType <OkResult>(result);
}
public IActionResult UpdateOrder([FromBody] SalesOrderDto webSalesOrder, [FromQuery] string Key, [FromQuery] string Timestamp, [FromQuery] string Signature)
{
var sw = new Stopwatch();
sw.Start();
decimal elapsedTime = 0;
_logger.LogInformation(LoggingEvents.GET_STATUS, $"UpdateOrder post parameters: {Key}, {Timestamp}, {Signature}");
//if (string.IsNullOrEmpty(Key) || string.IsNullOrEmpty(Timestamp) || string.IsNullOrEmpty(Signature))
//{
// return Unauthorized();
//}
if (webSalesOrder == null)
{
_logger.LogInformation(LoggingEvents.INSERT_ORDER_EXCEPTION, $"UpdateOrder: Bad Request: Vendor object was not provided in body (null)");
return(BadRequest());
}
if (ModelState.IsValid == false)
{
_logger.LogInformation(LoggingEvents.INSERT_ORDER_EXCEPTION, $"UpdateOrder: Invalid Request: Invalid order values were submitted");
return(BadRequest(ModelState));
}
SalesOrderResponseDto orderResponse = new SalesOrderResponseDto();
bool success = APIController.Instance.UpdateSalesOrder(webSalesOrder, ref orderResponse);
var saveOrderResponse = Mapper.Map <SalesOrderResponseDto>(orderResponse);
if (success == false)
{
saveOrderResponse.Success = false;
saveOrderResponse.OrderNumber = string.Empty;
saveOrderResponse.ErrorCode = LoggingEvents.INSERT_ORDER_FAILED;
_logger.LogInformation(LoggingEvents.INSERT_ORDER_FAILED, "UpdateOrder failed: " + orderResponse.ErrorMessage);
}
sw.Stop();
elapsedTime = Convert.ToDecimal(sw.ElapsedMilliseconds);
saveOrderResponse.Elapsed = elapsedTime.ToString();
_logger.LogInformation(LoggingEvents.INSERT_ORDER, "UpdateOrder complete: " + saveOrderResponse.Elapsed);
return(Ok(saveOrderResponse));
}
public void PostNewSalesOrderSuccess()
{
GivenSalesOrdersController();
SalesOrderDto salesOrderDto = new SalesOrderDto(salesOrders[0]);
salesOrderDto.SalesOrderId = 0;
moqSalesOrdersService.Setup(m => m.CreateSalesOrder(salesOrderDto)).Returns((Func <SalesOrder, SalesOrder>)((s) => { s.SalesOrderId = 99; return(new SalesOrder(s)); }));
ActionResult <SalesOrderDto> result = controller.PostSalesOrder(salesOrderDto);
moqSalesOrdersService.Verify(m => m.CreateSalesOrder(salesOrderDto));
salesOrderDto.SalesOrderId = 99;
Assert.Equal(salesOrderDto, result.Value);
}
public void PostNewSalesOrderSuccess()
{
GivenSalesOrdersController();
moqSalesOrdersSet.Setup(m => m.Add(It.IsAny <SalesOrder>())).Callback <SalesOrder>((s) => { s.SalesOrderId = 99; salesOrders.Add(s); });
SalesOrderDto salesOrderDto = new SalesOrderDto(salesOrders[0]);
salesOrderDto.SalesOrderId = 0;
ActionResult <SalesOrderDto> result = controller.PostSalesOrder(salesOrderDto);
moqSalesOrdersSet.Verify(m => m.Add(It.IsAny <SalesOrder>()), Times.Once());
salesOrderDto.SalesOrderId = 99;
Assert.Equal(salesOrderDto, result.Value);
}
public IActionResult CreateSalesOrder(SalesOrderDto salesOrderDto)
{
//var salesOrderMapped = _mapper.Map<SalesOrder>(salesOrder);
SalesOrder salesOrder = new SalesOrder();
salesOrder.Customer = _context.Customers.FirstOrDefault(x => x.Id == salesOrderDto.CustomerId);
salesOrder.Warehouse = _context.Warehouses.FirstOrDefault(x => x.Id == salesOrderDto.WarehouseId);
salesOrder.OrderDate = salesOrderDto.OrderDate;
salesOrder.OrderStatus = salesOrderDto.OrderStatus;
salesOrder.ShippedDate = salesOrderDto.ShippedDate;
_context.SalesOrders.Add(salesOrder);
_context.SaveChanges();
return(Ok(salesOrder.Id));
}
public async Task CreateSalesOrderSuccess()
{
GivenHttpClient();
SalesOrderDto salesOrderDto = new SalesOrderDto {
OrderDate = DateTime.Now, CustomerId = 1, Total = 0
};
// A write operation definately needs to be rolled back!
IDbContextTransaction transaction = dbContext.Database.BeginTransaction();
HttpResponseMessage response = await httpClient.PostAsJsonAsync <SalesOrderDto>("/api/salesorders", salesOrderDto);
transaction.Rollback();
response.EnsureSuccessStatusCode();
Assert.StartsWith("application/json", response.Content.Headers.ContentType.ToString());
}
public IActionResult SaveOrder([FromBody] SalesOrderDto webSalesOrder, [FromQuery] string Key, [FromQuery] string Timestamp, [FromQuery] string Signature)
{
var sw = new Stopwatch();
sw.Start();
decimal elapsedTime = 0;
_logger.LogInformation(LoggingEvents.GET_STATUS, $"SaveOrder post parameters: {Key}, {Timestamp}, {Signature}");
//if (string.IsNullOrEmpty(Key) || string.IsNullOrEmpty(Timestamp) || string.IsNullOrEmpty(Signature))
//{
// return Unauthorized();
//}
if (webSalesOrder == null)
{
return(StatusCode(400));
}
SalesOrderResponseDto orderResponse = new SalesOrderResponseDto();
bool success = APIController.Instance.ImportSalesOrder(webSalesOrder, ref orderResponse);
var saveOrderResponse = Mapper.Map <SalesOrderResponseDto>(orderResponse);
if (success == false)
{
saveOrderResponse.Success = false;
saveOrderResponse.OrderNumber = string.Empty;
saveOrderResponse.ErrorCode = LoggingEvents.INSERT_ORDER_FAILED;
_logger.LogInformation(LoggingEvents.INSERT_ORDER_FAILED, "SaveOrder failed: " + orderResponse.ErrorMessage);
}
sw.Stop();
elapsedTime = Convert.ToDecimal(sw.ElapsedMilliseconds);
saveOrderResponse.Elapsed = elapsedTime.ToString();
_logger.LogInformation(LoggingEvents.INSERT_ORDER, "SaveOrder complete: " + saveOrderResponse.Elapsed);
return(Ok(saveOrderResponse));
}
// GET: api/salesorder
/// <summary>
/// Get a list of all sales orders
/// </summary>
/// <returns>List of all sales</returns>
public IEnumerable<SalesOrderDto> GetSalesOrders()
{
var SalesOrder = db.SalesOrders.Include(so => so.Lines);
var salesOrderDtoList = new List<SalesOrderDto>();
foreach (var salesOrder in SalesOrder)
{
var salesOrderDto = new SalesOrderDto();
salesOrderDto.Status = salesOrder.Status;
salesOrderDto.Date = salesOrder.Date;
salesOrderDto.Id = salesOrder.Id;
salesOrderDto.Total = salesOrder.Total;
salesOrderDtoList.Add(salesOrderDto);
}
return salesOrderDtoList;
}
public static IOBalanceDBV2Entity.SalesOrder DtoToEntity(this SalesOrderDto dto)
{
IOBalanceDBV2Entity.SalesOrder entity = null;
if (!dto.IsNull())
{
entity = new IOBalanceDBV2Entity.SalesOrder
{
SalesOrderID = dto.SalesOrderId,
SalesNo = dto.SalesNo,
CustomerID = dto.CustomerId,
DateCreated = dto.DateCreated,
CreatedBy = dto.CreatedBy,
IsPrinted = dto.IsPrinted,
IsCorrected = dto.IsCorrected
};
}
return(entity);
}
public void BlocksOnlySensitiveFields()
{
SalesOrder salesOrder = new SalesOrder {
SalesOrderId = 1,
OrderDate = DateTime.Now,
CustomerId = 1,
Total = 1,
CardNumber = "378282246310005",
CardExpires = DateTime.Now,
Filled = DateTime.Now
};
SalesOrderDto salesOrderDto = new SalesOrderDto(salesOrder);
Assert.Equal(salesOrder.SalesOrderId, salesOrderDto.SalesOrderId);
Assert.Equal(salesOrder.OrderDate, salesOrderDto.OrderDate);
Assert.Equal(salesOrder.CustomerId, salesOrderDto.CustomerId);
Assert.Equal(salesOrder.Total, salesOrderDto.Total);
Assert.Null(salesOrderDto.CardNumber);
Assert.Null(salesOrderDto.CardExpires);
// Assert.Null(salesOrderDto.CardAuthorized);
Assert.Equal(salesOrder.Filled, salesOrderDto.Filled);
}
public ActionResult <SalesOrderDto> PostSalesOrder([FromBody] SalesOrderDto salesOrderDto)
{
SalesOrder salesOrder = salesOrdersService.CreateSalesOrder(salesOrderDto);
return(new SalesOrderDto(salesOrder));
}
public virtual ActionResult UpdateQtyDetails(EditQtyProductDto dto, string qtyType)
{
bool isSuccess = false;
string alertMessage = string.Empty;
decimal?qtyBefore = dto.EditQuantity;
int? createdBy = WebSecurity.GetUserId(User.Identity.Name);
if (ModelState.IsValid)
{
if (!qtyType.IsNull())
{
switch (qtyType.ToLower())
{
case "add":
dto.EditQuantity = dto.EditQuantity + dto.OldQuantity;
break;
case "minus":
dto.EditQuantity = dto.OldQuantity - dto.EditQuantity;
break;
default:
break;
}
ProductDto newDetails = new ProductDto()
{
ProductId = dto.ProductId,
CategoryId = dto.CategoryId,
QuantityUnitId = dto.QuantityUnitId,
ProductCode = dto.ProductCode,
ProductName = dto.ProductName,
ProductDescription = dto.ProductDescription,
ProductSize = dto.ProductSize,
CurrentNum = dto.CurrentNum,
DRNum = dto.DRNum,
CartonNum = dto.CartonNum,
Quantity = dto.EditQuantity
};
if (qtyType.ToLower() == "minus")
{
SalesOrderDto orderDto = new SalesOrderDto()
{
CreatedBy = createdBy,
DateCreated = DateTime.Now,
SalesNo = "PL" + Constants.SalesTemplate,
CustomerId = 0,
SalesOrderId = 0,
IsPrinted = false,
IsCorrected = false
};
var salesOrderId = _orderService.SaveSalesOrder(orderDto);
if (salesOrderId == 0)
{
alertMessage = string.Format(Messages.ErrorOccuredDuringProcessingThis, "saving in sales order");
}
else
{
SalesOrderDetailDto orderDetailDto = new SalesOrderDetailDto()
{
SalesOrderId = salesOrderId,
ProductId = newDetails.ProductId,
SalesPrice = 0,
Quantity = (decimal)qtyBefore,
UnitPrice = 0,
DateCreated = DateTime.Now,
CreatedBy = createdBy
};
isSuccess = _orderService.SaveSalesOrderDetail(orderDetailDto);
if (!isSuccess)
{
alertMessage = string.Format(Messages.ErrorOccuredDuringProcessingThis, "saving in sales order details");
}
else
{
isSuccess = _inventoryService.UpdateDetails(newDetails);
if (!isSuccess)
{
alertMessage = string.Format(Messages.ErrorOccuredDuringProcessingThis, "updating in product");
}
else
{
alertMessage = Messages.UpdateSuccess;
}
}
}
}
else
{
OrderDto orders = new OrderDto()
{
OrderId = 0, DateCreated = DateTime.Now, CreatedBy = createdBy
};
var retPurchaseOrderId = _orderService.SaveOrder(orders);
if (retPurchaseOrderId == 0)
{
alertMessage = string.Format(Messages.ErrorOccuredDuringProcessingThis, "saving in purchase order");
}
else
{
OrderDetailDto orderDetails = new OrderDetailDto()
{
OrderDetailId = 0,
OrderId = retPurchaseOrderId,
ProductId = newDetails.ProductId,
Quantity = Convert.ToDecimal(qtyBefore),
SupplierId = dto.SupplierId
};
if (!_orderService.SaveOrderDetail(orderDetails))
{
alertMessage = (string.Format(Messages.ErrorOccuredDuringProcessingThis, "saving in purchase order details"));
}
else
{
isSuccess = _inventoryService.UpdateDetails(newDetails);
if (!isSuccess)
{
alertMessage = string.Format(Messages.ErrorOccuredDuringProcessingThis, "updating in product");
}
else
{
alertMessage = Messages.UpdateSuccess;
}
}
}
}
}
}
var jsonResult = new
{
isSuccess = isSuccess,
alertMessage = alertMessage
};
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
public virtual ActionResult QueueSalesOrder(List <SalesOrderListDto> dto, int CustomerId, long salesOrderId)
{
bool isSuccess = false;
int createdBy = 1;
DateTime dateNow = DateTime.Now;
string alertMsg = string.Empty;
if (!dto.IsNull())
{
var oldSalesOrderDto = _orderService.GetAllSalesOrder().Where(so => so.OrderId == salesOrderId).FirstOrDefault();
if (oldSalesOrderDto.IsNull())
{
alertMsg = "No queue order selected";
}
else
{
SalesOrderDto orderDto = new SalesOrderDto()
{
CreatedBy = createdBy,
DateCreated = dateNow,
SalesNo = oldSalesOrderDto.SalesNo,
CustomerId = oldSalesOrderDto.CustomerId,
SalesOrderId = salesOrderId,
IsPrinted = false,
IsCorrected = false
};
if (_orderService.UpdateSalesOrder(orderDto) <= 0)
{
alertMsg = "Error in updating queue order id";
}
else
{
if (!_orderService.DeleteAllSalesOrderDetail(salesOrderId))
{
alertMsg = "Error in deleting all queue order details";
}
else
{
foreach (var oDetail in dto)
{
SalesOrderDetailDto orderDetailDto = new SalesOrderDetailDto()
{
SalesOrderId = salesOrderId,
ProductId = oDetail.ProductId,
SalesPrice = oDetail.SalesPrice,
Quantity = oDetail.Quantity,
UnitPrice = oDetail.UnitPrice,
DateCreated = dateNow,
CreatedBy = createdBy
};
_orderService.SaveSalesOrderDetail(orderDetailDto);
var productDetails = _inventoryService.GetAll().Where(p => p.ProductId == oDetail.ProductId).FirstOrDefault();
productDetails.Quantity = (productDetails.Quantity - oDetail.Quantity);
_inventoryService.UpdateDetails(productDetails);
CustomerPriceDto customerPriceDto = new CustomerPriceDto()
{
Price = oDetail.UnitPrice,
ProductId = oDetail.ProductId,
CustomerId = CustomerId,
CreatedBy = createdBy,
DateCreated = dateNow
};
SaveCustomerPrice(customerPriceDto);
}
isSuccess = true;
alertMsg = Messages.UpdateSuccess;
}
}
}
}
var jsonResult = new
{
isSuccess = isSuccess,
alertMsg = alertMsg
};
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
public bool ImportSalesOrder(SalesOrderDto salesOrder, ref SalesOrderResponseDto orderResponse)
{
try
{
taSopHdrIvcInsert sopHeader;
List <taSopLineIvcInsert_ItemsTaSopLineIvcInsert> sopLines = new List <taSopLineIvcInsert_ItemsTaSopLineIvcInsert>();
taSopLineIvcInsert_ItemsTaSopLineIvcInsert sopLine;
bool success = false;
string orderNumber = salesOrder.SOPNUMBE;
string customerID = salesOrder.CUSTNMBR;
int errorCode = 0;
string errorMessage = string.Empty;
sopHeader = new taSopHdrIvcInsert
{
SOPTYPE = salesOrder.SOPTYPE,
SOPNUMBE = salesOrder.SOPNUMBE,
DOCID = instance.APIModel.APIConfig.SOPTypeID,
SHIPMTHD = salesOrder.SHIPMTHD,
TAXAMNT = salesOrder.TAXAMNT,
LOCNCODE = salesOrder.LOCNCODE,
DOCDATE = salesOrder.DOCDATE.ToShortDateString(),
TRDISAMT = salesOrder.TRDISAMT,
MRKDNAMT = salesOrder.MRKDNAMT,
CUSTNMBR = salesOrder.CUSTNMBR,
CUSTNAME = salesOrder.CUSTNAME,
CSTPONBR = salesOrder.CSTPONBR,
ShipToName = salesOrder.ShipToName,
ADDRESS1 = salesOrder.ADDRESS1,
ADDRESS2 = salesOrder.ADDRESS2,
ADDRESS3 = salesOrder.ADDRESS3,
CNTCPRSN = salesOrder.CNTCPRSN,
FAXNUMBR = salesOrder.FAXNUMBR,
CITY = salesOrder.CITY,
STATE = salesOrder.STATE,
ZIPCODE = salesOrder.ZIPCODE,
COUNTRY = salesOrder.COUNTRY,
PHNUMBR1 = salesOrder.PHNUMBR1,
PHNUMBR2 = salesOrder.PHNUMBR2,
PHNUMBR3 = salesOrder.PHNUMBR3,
SUBTOTAL = salesOrder.SUBTOTAL,
FREIGHT = salesOrder.FRTAMNT,
MISCAMNT = salesOrder.MISCAMNT,
DOCAMNT = salesOrder.DOCAMNT,
SALSTERR = salesOrder.SALSTERR,
SLPRSNID = salesOrder.SLPRSNID,
UPSZONE = salesOrder.UPSZONE,
USER2ENT = "GPWEBAPI",
BACHNUMB = "WEBORDERS",
USINGHEADERLEVELTAXES = 1,
DEFTAXSCHDS = 1
};
foreach (SalesOrderLineDto line in salesOrder.SalesOrderLines)
{
sopLine = new taSopLineIvcInsert_ItemsTaSopLineIvcInsert
{
SOPTYPE = sopHeader.SOPTYPE,
SOPNUMBE = sopHeader.SOPNUMBE,
CUSTNMBR = sopHeader.CUSTNMBR,
DOCDATE = sopHeader.DOCDATE,
LOCNCODE = line.LOCNCODE,
ITEMNMBR = line.ITEMNMBR,
ITEMDESC = line.ITEMDESC,
UNITPRCE = line.UNITPRCE,
XTNDPRCE = line.XTNDPRCE,
QUANTITY = line.QUANTITY,
COMMNTID = line.COMMNTID,
COMMENT_1 = line.COMMENT_1,
COMMENT_2 = line.COMMENT_2,
COMMENT_3 = line.COMMENT_3,
COMMENT_4 = line.COMMENT_4,
PRCLEVEL = line.PRCLEVEL,
TAXAMNT = line.TAXAMNT,
NONINVEN = line.NONINVEN,
LNITMSEQ = line.LNITMSEQ,
DROPSHIP = line.DROPSHIP,
QTYTBAOR = line.QTYTBAOR,
DOCID = line.DOCID,
SALSTERR = line.SALSTERR,
SLPRSNID = line.SLPRSNID,
ITMTSHID = line.ITMTSHID,
IVITMTXB = line.IVITMTXB,
TAXSCHID = line.TAXSCHID,
PRSTADCD = line.PRSTADCD,
ShipToName = line.ShipToName,
CNTCPRSN = line.CNTCPRSN,
ADDRESS1 = line.ADDRESS1,
ADDRESS2 = line.ADDRESS2,
ADDRESS3 = line.ADDRESS3,
CITY = line.CITY,
STATE = line.STATE,
ZIPCODE = line.ZIPCODE,
COUNTRY = line.COUNTRY,
PHONE1 = line.PHONE1,
PHONE2 = line.PHONE2,
PHONE3 = line.PHONE3,
FAXNUMBR = line.FAXNUMBR,
QTYCANCE = line.QTYCANCE,
QTYFULFI = line.QTYFULFI,
ALLOCATE = line.ALLOCATE,
TOTALQTY = line.TOTALQTY,
CMMTTEXT = line.CMMTTEXT,
//Quantity shortage option:
//1 = Sell balance;
//2 = Override shortage;
//3 = Back Order all;
//4 = Back Order balance;
//5 = Cancel all;
//6 = Cancel balance
QtyShrtOpt = instance.APIModel.APIConfig.QtyShortageOption,
UOFM = line.UOFM
};
sopLines.Add(sopLine);
}
//**********************************************************************
//Assemble document
//**********************************************************************
SOPTransactionType sopTransaction = new SOPTransactionType();
sopTransaction.taSopHdrIvcInsert = sopHeader;
sopTransaction.taSopLineIvcInsert_Items = sopLines.ToArray();
SOPTransactionType[] sopTransactionType = { sopTransaction };
eConnectType eConnect = new eConnectType();
eConnect.SOPTransactionType = sopTransactionType;
MemoryStream memStream = new MemoryStream();
XmlSerializer serializer = new XmlSerializer(eConnect.GetType());
serializer.Serialize(memStream, eConnect);
memStream.Position = 0;
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(memStream);
memStream.Close();
string response = string.Empty;
success = eConn.InsertTransaction(ref response, xmlDocument.OuterXml, instance.APIModel.APIConfig.GPCompanyDB);
if (success == false)
{
errorMessage = "Failed to import order " + orderNumber + " for customer " + customerID + ": " + response;
}
orderResponse.Success = success;
orderResponse.OrderNumber = orderNumber;
orderResponse.ErrorCode = errorCode;
orderResponse.ErrorMessage = errorMessage;
orderResponse.DocumentData = xmlDocument.OuterXml;
return(success);
}
catch (Exception)
{
throw;
}
}
public virtual ActionResult SaveSalesOrder(List <SalesOrderListDto> dto, string SalesNo, int CustomerId)
{
bool isSuccess = false;
int createdBy = 1;
DateTime dateNow = DateTime.Now;
string alertMsg = string.Empty;
long salesOrderId = 0;
if (!dto.IsNull())
{
SalesOrderDto orderDto = new SalesOrderDto()
{
CreatedBy = createdBy,
DateCreated = dateNow,
SalesNo = SalesNo,
CustomerId = CustomerId,
SalesOrderId = 0,
IsPrinted = true,
IsCorrected = false
};
salesOrderId = _orderService.SaveSalesOrder(orderDto);
if (salesOrderId == 0)
{
alertMsg = "Error in inserting Order Id";
}
else
{
foreach (var oDetail in dto)
{
SalesOrderDetailDto orderDetailDto = new SalesOrderDetailDto()
{
SalesOrderId = salesOrderId,
ProductId = oDetail.ProductId,
SalesPrice = oDetail.SalesPrice,
Quantity = oDetail.Quantity,
UnitPrice = oDetail.UnitPrice,
DateCreated = dateNow,
CreatedBy = createdBy
};
_orderService.SaveSalesOrderDetail(orderDetailDto);
var productDetails = _inventoryService.GetAll().Where(p => p.ProductId == oDetail.ProductId).FirstOrDefault();
productDetails.Quantity = (productDetails.Quantity - oDetail.Quantity);
_inventoryService.UpdateDetails(productDetails);
CustomerPriceDto customerPriceDto = new CustomerPriceDto()
{
Price = oDetail.UnitPrice,
ProductId = oDetail.ProductId,
CustomerId = CustomerId,
CreatedBy = createdBy,
DateCreated = dateNow
};
SaveCustomerPrice(customerPriceDto);
}
isSuccess = true;
alertMsg = Messages.InsertSuccess;
}
}
var jsonResult = new
{
isSuccess = isSuccess,
alertMsg = alertMsg,
salesOrderId = salesOrderId,
customerId = CustomerId,
salesNo = SalesNo
};
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
public async Task <SalesOrderOutput> GetSalesOrderForCreate()
{
//VARIABLES
var output = new SalesOrderOutput();
var salesOrderDto = new SalesOrderDto();
var salesInvoiceDto = new SalesInvoiceDto();
var salesOrderLineDto = new SalesOrderLineDto();
var salesOrderLineDtoList = new List <SalesOrderLineDto>();
var salesInvoiceAdditionalCostDto = new SalesInvoiceAdditionalCostDto();
var salesInvoiceAdditionalCostDtoList = new List <SalesInvoiceAdditionalCostDto>();
var salesInvoicePaymentDto = new SalesInvoicePaymentDto();
var salesInvoicePaymentDtoList = new List <SalesInvoicePaymentDto>();
//DEFAULT SELECTED COMBOBOX
var defaultSelectedCombobox = new ComboboxItemDto("0", "Please select ...")
{
IsSelected = true
};
//CUSTOMER LOOKUP
var customers = _lookup_customerRepository
.GetAll()
.Select(c => new ComboboxItemDto(c.Id.ToString(), c.Name + " (" + c.Company + ")"))
.ToList();
customers.Add(defaultSelectedCombobox);
output.Customers = customers;
//PRODUCTION STATUS LOOKUP
var productionStatuses = _lookup_productionStatusRepository
.GetAll()
.Select(s => new ComboboxItemDto(s.Id.ToString(), s.Name))
.ToList();
output.ProductionStatuses = productionStatuses;
//EMPTY SALES ORDER
salesOrderDto.Id = null;
salesOrderDto.Number = "";
salesOrderDto.Date = DateTime.Now;
salesOrderDto.Deadline = DateTime.Now;
output.SalesOrder = salesOrderDto;
//EMPTY SALES ORDER LINE
salesOrderLineDto.Id = 0;
salesOrderLineDto.Name = "";
salesOrderLineDto.Description = "";
salesOrderLineDto.MarkForDelete = false;
salesOrderLineDtoList.Add(salesOrderLineDto);
output.SalesOrderLines = salesOrderLineDtoList;
//EMPTY SALES INVOICE ADDTIONAL COST
salesInvoiceAdditionalCostDto.Id = 0;
salesInvoiceAdditionalCostDto.Name = "";
salesInvoiceAdditionalCostDto.Description = "";
salesInvoiceAdditionalCostDto.MarkForDelete = false;
salesInvoiceAdditionalCostDtoList.Add(salesInvoiceAdditionalCostDto);
output.SalesInvoiceAdditionalCosts = salesInvoiceAdditionalCostDtoList;
//EMPTY SALES INVOICE PAYMENT
salesInvoicePaymentDto.Id = 0;
salesInvoicePaymentDto.Date = DateTime.Now;
salesInvoicePaymentDto.MarkForDelete = false;
salesInvoicePaymentDtoList.Add(salesInvoicePaymentDto);
output.SalesInvoicePayments = salesInvoicePaymentDtoList;
//PAYMENT METHOD LOOKUP
//var paymentMethod = _lookup_paymentMethodRepository
// .GetAll()
// .Select(c => new ComboboxItemDto(c.Id.ToString(), c.Name ))
// .ToList();
//paymentMethod.Add(defaultSelectedCombobox);
// ViewData["PaymentMethod"] = paymentMethod;
//var paymentMethod = _paymentMethodRepo.GetAll().OrderBy(p => p.Name);
//ViewData["PaymentMethod"] = new SelectList(paymentMethod, "ID", "Name");
//RETURN
return(output);
}
public void Put(Guid id, SalesOrderDto value)
{
throw new NotImplementedException();
}
public IActionResult AddOrModify([FromForm] SalesOrderDto model)
{
return(Json(""));
}
public void Post(SalesOrderDto model)
{
throw new NotImplementedException();
}
