public OrderMaster Put(OrderMaster item)
{
try
{
var identity = User.Identity as ClaimsIdentity;
int compid = 0, userid = 0;
foreach (Claim claim in identity.Claims)
{
if (claim.Type == "compid")
{
compid = int.Parse(claim.Value);
}
if (claim.Type == "userid")
{
userid = int.Parse(claim.Value);
}
}
logger.Info("User ID : {0} , Company Id : {1}", compid, userid);
return(context.PutOrderMaster(item));
}
catch (Exception ex)
{
return(null);
}
}
public async Task <IActionResult> Edit(int id)
{
AppResult result = new AppResult();
try
{
OrderMaster model = await _context.OrderMasters.Where(a => a.Id == id).Include(a => a.OrderDetails).FirstOrDefaultAsync();
OrderMastViewModel modelvm = new OrderMastViewModel
{
Id = model.Id,
CustomerName = model.CustomerName,
OrderDate = model.OrderDate,
OrderDetlViewModel = model.OrderDetails.Select(a => new OrderDetlViewModel
{
Id = a.Id,
MastId = a.MastId,
ProductName = a.ProductName,
Qty = a.Qty,
Rate = a.Rate
}).ToList()
};
return(PartialView(modelvm));
}
catch (Exception ex)
{
result = new AppResult {
ResultType = ResultType.Failed, Message = "Exception occur with the system. please contact to vendor."
};
return(Json(result));
}
}
/// <summary>
/// 添加用户
/// </summary>
/// <param name="name">用户名称</param>
/// <param name="description">用户描述</param>
/// <param name="state">状态</param>
/// <returns>True-操作成功|False-操作失败</returns>
public bool AddOrderMaster(OrderMaster orderMaster)
{
if (!ExistOrderMaster(orderMaster.OrderNo))
{
//Model.Message userinfo = new Model.Message
//{
// Color = (Message.ColorEnum)color,
// Type = (Extention.TypeEnum)type,
// TopicName = topicName,
// EventData = eventData
// //Name = name,
// //Description = description,
// //State = state
//};
using (_session = _sessionfactory.Session)
{
_session.Save(orderMaster);
_session.Flush();
}
return true;
}
else
{
return false;
}
}
protected override void New()
{
if (requestType == OrderRequestType.InsertNewOrder)
{
OrderMaster om = (OrderMaster)request.TransactionEntityList[0];
om.OrderStatus = OrderStatus.CREATED;
om.CreatedUser = Context.UserName;
orderMan.InsertOrder(om);
if (request.MessageDataExtension.ContainsKey(MessageDataExtensionKeys.CREATE_INVOICE))
{
if (request.MessageDataExtension[MessageDataExtensionKeys.CREATE_INVOICE].Equals(bool.TrueString.ToLower()))
{
ExportQb();
}
else
{
QuickBooksInvoiceLog log = qim.CreateInvoiceLog(om, QbIntegrationLogStatus.WAITING);
qim.InsertIntegrationLog(log);
}
}
response.TransactionResult = om;
}
else
{
long newId = new OrderManager(Context).GetNewOrderId();
this.response.TransactionResult = newId;
}
}
/// <summary>
/// Get OrderBy Number
/// </summary>
/// <param name="OrderNumber"></param>
/// <returns></returns>
public OrderMaster getOrderbyNumber(string OrderNumber, int TenantId)
{
OrderMaster orderMasters = new OrderMaster();
MySqlCommand cmd = new MySqlCommand();
try
{
conn = Db.Connection;
cmd.Connection = conn;
MySqlCommand cmd1 = new MySqlCommand("SP_getOrderByNumber", conn);
cmd1.Parameters.AddWithValue("@objOrderNumber", OrderNumber);
cmd1.Parameters.AddWithValue("@Tenant_Id", TenantId);
cmd1.CommandType = CommandType.StoredProcedure;
MySqlDataAdapter sd = new MySqlDataAdapter(cmd1);
DataTable dt = new DataTable();
sd.Fill(dt);
if (dt != null && dt.Rows.Count > 0)
{
orderMasters.OrderMasterID = Convert.ToInt32(dt.Rows[0]["OrderMasterID"]);
orderMasters.OrderNumber = Convert.ToString(dt.Rows[0]["OrderNumber"]);
}
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
//Console.WriteLine("Error " + ex.Number + " has occurred: " + ex.Message);
}
return(orderMasters);
}
public ActionResult add([FromBody] OrderContactItem args)
{
ReturnMessage rm = new ReturnMessage();
try
{
int memberId = int.Parse(User.Claims.FirstOrDefault(p => p.Type == "jti").Value);
DateTime now = DateTime.Now;
args.dtContact = now;
args.createTime = now;
args.creator = memberId;
args.status = "正常";
DataManager.orderContactItemDAO.add(args);
rm.code = MessageCode.SUCCESS;
rm.data = "add success.";
OrderMaster master = DataManager.orderDao.getOrderMaster(args.orderId);
if (master.payStatus != "已收到貨款")
{
master.payStatus = "貨款確認中";
DataManager.orderDao.updateOrderMaster(master);
}
}
catch (Exception e)
{
rm.code = MessageCode.ERROR;
rm.data = e;
}
return(Ok(rm));
}
public async Task <bool> InsertOrderMaster(string name)
{
var key = "CHProject:Demo:" + DateTime.Now.ToString("yyyy-MM-dd") + ":" + name;
OrderMaster entity = new OrderMaster()
{
Name = name
};
entity.SetId();
entity.OrderDetails = new List <OrderDetail>();
var orderDetail = new OrderDetail()
{
OrderId = entity.Id, GoodsName = "测试", GoodsNo = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
};
orderDetail.SetId();
entity.OrderDetails.Add(orderDetail);
var flag = await _orderMasterRepository.InsertOrderMaster(entity);
if (flag)
{
if (!RedisCommontHelper.CreateInstance().ContainsKey(key))
{
RedisCommontHelper.CreateInstance().Set <OrderMaster>(key, entity);
}
}
return(flag);
}
public void ChangeOrderStatus(OrderMaster OrderInfo)
{
try
{
if (OrderInfo != null)
{
OrderMaster Order = objDbEntities.OrderMasters.Where(o => o.OrderId == OrderInfo.OrderId).FirstOrDefault();
Order.OrderStatusId = OrderInfo.OrderStatusId;
objDbEntities.SaveChanges();
if (OrderInfo.OrderStatusId == 3) //Subtract Product Quantity by 1 When Seller Change Status OrderAccepted
{
ProductMaster Product = objDbEntities.ProductMasters.Where(p => p.ProductId == OrderInfo.ProductId).FirstOrDefault();
Product.Quantity = Product.Quantity - 1;
//ModelState.Remove("Quantity");
objDbEntities.Configuration.ValidateOnSaveEnabled = false;
objDbEntities.SaveChanges();
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <VerifyRecordResult> UpdateAsync(OrderMasterAdapterModel paraObject)
{
try
{
OrderMaster itemData = Mapper.Map <OrderMaster>(paraObject);
CleanTrackingHelper.Clean <OrderMaster>(context);
OrderMaster item = await context.OrderMaster
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == paraObject.Id);
if (item == null)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.無法修改紀錄));
}
else
{
CleanTrackingHelper.Clean <OrderMaster>(context);
context.Entry(itemData).State = EntityState.Modified;
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <OrderMaster>(context);
return(VerifyRecordResultFactory.Build(true));
}
}
catch (Exception ex)
{
Logger.LogError(ex, "修改記錄發生例外異常");
return(VerifyRecordResultFactory.Build(false, "修改記錄發生例外異常", ex));
}
}
public async Task <VerifyRecordResult> DeleteAsync(int id)
{
try
{
CleanTrackingHelper.Clean <OrderMaster>(context);
OrderMaster item = await context.OrderMaster
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == id);
if (item == null)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.無法刪除紀錄));
}
else
{
CleanTrackingHelper.Clean <OrderMaster>(context);
context.Entry(item).State = EntityState.Deleted;
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <OrderMaster>(context);
return(VerifyRecordResultFactory.Build(true));
}
}
catch (Exception ex)
{
Logger.LogError(ex, "刪除記錄發生例外異常");
return(VerifyRecordResultFactory.Build(false, "刪除記錄發生例外異常", ex));
}
}
public async Task <ActionResult <OrderMaster> > PostOrderMaster(OrderMaster orderMaster)
{
_context.tOrderMaster.Add(orderMaster);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetOrderMaster", new { id = orderMaster.OrderMasterId }, orderMaster));
}
public async Task <ActionResult <long> > Post([FromBody] OrderMaster po)
{
try
{
var claimsIdentity = this.User.Identity as ClaimsIdentity;
int userId = Convert.ToInt32(claimsIdentity.FindFirst(ClaimTypes.Name)?.Value);
//var pos = await this._orderService.GetAllOrderMastersAsync(po.CompanyId, userId);
//var existpo = pos.Where(x => x.PONo == po.PONo).FirstOrDefault();
//if(existpo != null && existpo.PONo == po.PONo)
//{
// return BadRequest("PO already exist");
//}
var result = await this._orderService.AddOrderMasterAsync(po);
EmailService emailService = new EmailService(_appSettings);
var company = await this._companyService.GetCompanyAsync(po.CompanyId);
var customer = await this._customerService.GetCustomerAsync(po.CustomerId);
emailService.SendAcknoledgePOEmail(company.EMail, customer.EmailAddress, po.PONo);
return(result);
}
catch (Exception ex)
{
return(StatusCode(500, ex.ToString()));
}
}
public async Task <IActionResult> PutClose(int id, [FromBody] OrderMaster po)
{
try
{
var claimsIdentity = this.User.Identity as ClaimsIdentity;
int userId = Convert.ToInt32(claimsIdentity.FindFirst(ClaimTypes.Name)?.Value);
if (id != po.Id)
{
return(BadRequest());
}
po.Id = id;
await this._orderService.CloseOrderMasterAsync(po);
EmailService emailService = new EmailService(_appSettings);
var company = await this._companyService.GetCompanyAsync(po.CompanyId);
var customer = await this._customerService.GetCustomerAsync(po.CustomerId);
emailService.SendClosePOEmail(company.EMail, customer.EmailAddress, po.PONo);
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(500, ex.ToString()));
}
}
/// <summary>构造函数
///
/// </summary>
/// <param name="orderMaster">orderMaster</param>
/// <param name="lstOrderMaster">lstOrderMaster</param>
/// <param name="lstOrderDetail">lstOrderDetail</param>
public FrmMasterDetailDemoDialog(OrderMaster orderMaster,
List <OrderMaster> lstOrderMaster,
List <OrderDetail> lstOrderDetail)
{
InitializeComponent();
#region 明细表列表绑定字段
this.olvColumn5.AspectGetter = delegate(object x) { return(((OrderDetail)x).DetailId); };
this.olvColumn6.AspectGetter = delegate(object x) { return(((OrderDetail)x).OrderId); };
this.olvColumn7.AspectGetter = delegate(object x) { return(((OrderDetail)x).Customer); };
this.olvColumn8.AspectGetter = delegate(object x) { return(((OrderDetail)x).ProductName); };
this.olvColumn9.AspectGetter = delegate(object x) { return(((OrderDetail)x).Amount); };
this.olvColumn10.AspectGetter = delegate(object x) { return(((OrderDetail)x).SumMoney); };
this.olvColumn11.AspectGetter = delegate(object x) { return(GetDetailStatus(((OrderDetail)x).Status)); };
#endregion
this.m_orderMasterDAL = new OrderMasterDAL();
this.m_orderDetailDAL = new OrderDetailDAL();
this.m_orderMaster = orderMaster;
this.m_lstOrderMaster = lstOrderMaster;
this.m_lstOrderDetail = lstOrderDetail;
//修改
if (orderMaster != null)
{
m_orderMaster = orderMaster;
DisplayData(m_orderMaster);
if (m_lstOrderDetail != null && m_lstOrderDetail.Count > 0)
{
objListViewDetail.SetObjects(m_lstOrderDetail);
objListViewDetail.Refresh();
objListViewDetail.SelectedIndex = 0;
}
}
Command_Click(orderMaster == null ? cmdNew : cmdEdit, null);
}
public void InsertOrder(OrderMaster orderMaster)
{
orderMaster.CreateDate = DateTime.Now;
SpCall spCall = new SpCall("DAT.ORDER_MASTER_INSERT");
spCall.SetBigInt("@ID", orderMaster.Id);
spCall.SetBigInt("@CUSTOMER_ID", orderMaster.Customer.Id);
spCall.SetDateTime("@ORDER_DATE", orderMaster.OrderDate);
spCall.SetDateTime("@DELIVERY_DATE", orderMaster.DeliveryDate);
spCall.SetVarchar("@PAYMENT_TYPE", orderMaster.PaymentType);
spCall.SetVarchar("@NOTES", orderMaster.Notes);
spCall.SetVarchar("@ORDER_STATUS", orderMaster.OrderStatus);
spCall.SetDateTime("@CREATE_DATE", orderMaster.CreateDate);
spCall.SetVarchar("@CREATE_USER", orderMaster.CreatedUser);
spCall.SetBigInt("@SHIP_ADDRESS", orderMaster.ShippingAddressId);
orderMaster.UpdatedUser = orderMaster.CreatedUser;
orderMaster.UpdateDate = orderMaster.CreateDate;
db.ExecuteNonQuery(spCall);
DataTable dt = PrepareOrderItemsTable(orderMaster.OrderItems);
db.ExecuteBulkInsert(dt);
}
public async Task <OrderMasterDto> Handle(Command request, CancellationToken cancellationToken)
{
var orderMaster = new OrderMaster
{
Reseller = request.Reseller,
Supplier = request.Supplier,
Catalog = request.Catalog,
Qty = request.Qty,
Size = request.Size,
Color = request.Color,
ShippingAddress = request.ShippingAddress,
BillingAddress = request.BillingAddress,
Status = request.Status,
Transactions = request.Transactions
};
_context.OrderMasters.Add(orderMaster);
var success = await _context.SaveChangesAsync() > 0;
if (success)
{
var toReturn = _mapper.Map <OrderMaster, OrderMasterDto>(orderMaster);
return(toReturn);
}
throw new Exception("Problem saving changes");
}
public List <OrderMaster> ListMergeOrders(string invoiceGroup)
{
List <OrderMaster> result = new List <OrderMaster>();
string status = "CR";
SpCall spCall = new SpCall("DAT.ORDER_MASTER_MERGE_LIST");
spCall.SetVarchar("@STATUS", status);
spCall.SetVarchar("@INVOICE_GROUP", invoiceGroup);
DataSet ds = db.ExecuteDataSet(spCall);
if (ds.Tables[0].Rows.Count > 0)
{
ds.Tables[0].AsEnumerable().ToList().ForEach(omRow =>
{
OrderMaster om = ReadOrderMaster(omRow);
om.OrderItems = new List <OrderItem>();
ds.Tables[1].AsEnumerable().Where(itemRow =>
itemRow.Field <long>("ORDER_ID") == om.Id).ToList().ForEach(itemRow =>
om.OrderItems.Add(InitOrderItem(itemRow)));
ds.Tables[2].AsEnumerable().Where(logRow => logRow.Field <long>("ORDER_ID") == om.Id).ToList().ForEach(
logRow => om.InvoiceLog = qm.InitLog(logRow));
result.Add(om);
});
}
return(result);
}
private async Task 建立訂單紀錄Async(Random random, List <Product> products)
{
for (int i = 0; i < 3; i++)
{
OrderMaster order = new OrderMaster()
{
Name = $"Order{i}",
OrderDate = DateTime.Now.AddDays(random.Next(30)),
RequiredDate = DateTime.Now.AddDays(random.Next(30)),
ShippedDate = DateTime.Now.AddDays(random.Next(30)),
};
context.Add(order);
await context.SaveChangesAsync();
var total = random.Next(1, 6);
for (int j = 0; j < total; j++)
{
OrderItem orderItem = new OrderItem()
{
Name = $"OrderItem{j}",
OrderMasterId = order.Id,
ProductId = products[j].Id,
Quantity = 3,
ListPrice = 168,
};
context.Add(orderItem);
}
await context.SaveChangesAsync();
}
CleanTrackingHelper.Clean <Product>(context);
CleanTrackingHelper.Clean <OrderMaster>(context);
CleanTrackingHelper.Clean <OrderItem>(context);
}
public List <OrderMaster> List(DateTime begin, DateTime end, long customerId, string status, string dateField)
{
List <OrderMaster> result = new List <OrderMaster>();
SpCall spCall = new SpCall("DAT.ORDER_MASTER_LIST");
spCall.SetDateTime("@BEGIN_DATE", begin);
spCall.SetDateTime("@END_DATE", end);
spCall.SetBigInt("@CUSTOMER_ID", customerId);
spCall.SetVarchar("@STATUS", status);
spCall.SetVarchar("@DATE_FIELD", dateField);
DataSet ds = db.ExecuteDataSet(spCall);
if (ds.Tables[0].Rows.Count > 0)
{
ds.Tables[0].AsEnumerable().ToList().ForEach(omRow =>
{
OrderMaster om = ReadOrderMaster(omRow);
om.OrderItems = new List <OrderItem>();
ds.Tables[1].AsEnumerable().Where(itemRow =>
itemRow.Field <long>("ORDER_ID") == om.Id).ToList().ForEach(itemRow =>
om.OrderItems.Add(InitOrderItem(itemRow)));
ds.Tables[2].AsEnumerable().Where(logRow => logRow.Field <long>("ORDER_ID") == om.Id).ToList().ForEach(
logRow => om.InvoiceLog = qm.InitLog(logRow));
result.Add(om);
});
}
return(result);
}
public async Task <IActionResult> PutOrderMaster([FromRoute] int id, [FromBody] OrderMaster orderMaster)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != orderMaster.OrderId)
{
return(BadRequest());
}
_context.Entry(orderMaster).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderMasterExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public List <OrderMaster> GetOrders(List <long> ids)
{
SpCall spCall = new SpCall("DAT.ORDER_MASTER_SELECT_MULTI_BY_ID");
spCall.SetStructured <long>("@ID_LIST", "COR.ID_LIST", "ID", ids);
DataSet ds = db.ExecuteDataSet(spCall);
if (ds.Tables[0].Rows.Count == 0)
{
throw new Exception("No orders could be found not found");
}
List <OrderMaster> result = new List <OrderMaster>();
ds.Tables[0].AsEnumerable().ToList().ForEach(row =>
{
long orderId = row.Field <long>("ID");
OrderMaster orderMaster = ReadOrderMaster(row);
orderMaster.OrderItems = ReadOrderItems(ds.Tables[1].AsEnumerable().Where(r => r.Field <long>("ORDER_ID") == orderId).ToList());
orderMaster.InvoiceLog = ReadInvoice(ds.Tables[2].AsEnumerable().First(r => r.Field <long>("ORDER_ID") == orderId));
result.Add(orderMaster);
});
return(result);
}
/// <summary>编辑
///
/// </summary>
private void DoEdit()
{
string strMsg = CheckSelect(EntityOperationType.修改);
if (strMsg != string.Empty)
{
MessageBox.Show(strMsg);
return;
}
OrderMaster model = objListViewMaster.SelectedObjects[0] as OrderMaster;
if (model != null)
{
FrmOrderMasterMasterDetailDialog frmDialog = new FrmOrderMasterMasterDetailDialog(model, m_lstOrderMaster, m_lstOrderDetail, m_dsDetailGridSource);
if (frmDialog.ShowDialog() == DialogResult.OK)
{
m_lstOrderMaster = frmDialog.ListOrderMaster;
m_lstOrderDetail = frmDialog.ListOrderDetail;
if (m_lstOrderMaster != null)
{
objListViewMaster.SetObjects(m_lstOrderMaster);
objListViewMaster.Refresh();
}
if (m_lstOrderDetail != null)
{
objListViewDetail.SetObjects(m_lstOrderDetail);
objListViewDetail.Refresh();
}
}
}
}
public JsonResult UpdateOrderStatus(int id)
{
try
{
Chatpata_dabbaEntities1 Entity = new Chatpata_dabbaEntities1();
OrderMaster OM = new OrderMaster();
var details = Entity.OrderMasters.Where(q => q.OrderId == id).FirstOrDefault();
details.Status = "Accept";
Entity.Entry(details).State = System.Data.Entity.EntityState.Modified;
Entity.SaveChanges();
if (details.StartDate.Day <= DateTime.Now.Day && details.EndDate.Day >= DateTime.Now.Day)
{
DailyOrder dor = new DailyOrder();
dor.CustId = details.CustomerId;
dor.OrderId = id;
dor.Date = DateTime.Now;
dor.Status = "Pending";
dor.Code = 0;
Entity.DailyOrders.Add(dor);
Entity.SaveChanges();
}
return(Json("Accept", JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json("Error", JsonRequestBehavior.AllowGet));
}
}
public ActionResult Save(OrderMaster order)
{
bool status = false;
DateTime dateOrg;
var isValidDate = DateTime.TryParseExact(order.OrderDate.ToString(), "mm-dd-yyyy", null, DateTimeStyles.None, out dateOrg);
if (isValidDate)
{
order.OrderDate = dateOrg;
}
var isValidModel = TryUpdateModel(order);
if (isValidModel)
{
using (MasterDetailsEntities db = new MasterDetailsEntities())
{
db.OrderMasters.Add(order);
db.SaveChanges();
status = true;
}
}
return(new JsonResult {
Data = new { status = status }
});
}
public ActionResult DOEntry()
{
Chatpata_dabbaEntities1 Entity = new Chatpata_dabbaEntities1();
OrderMaster OM = new OrderMaster();
DailyOrder DO = new DailyOrder();
var currentdate = Convert.ToDateTime(DateTime.Now.ToShortDateString());
var orderdetails = Entity.OrderMasters.Where(q => q.StartDate <= currentdate && q.EndDate >= currentdate && (q.Status.Equals("Accept") || q.Status.Equals("Delivered"))).OrderBy(q => q.CustomerMaster.FirstName).ToList();
// var cname = orderdetails.OrderBy(q => q.MenuId).ToList();
if (orderdetails != null)
{
foreach (var order in orderdetails.ToList())
{
DO.CustId = Convert.ToInt32(order.CustomerId);
DO.OrderId = Convert.ToInt32(order.OrderId);
DO.Date = DateTime.Now;
DO.Status = "Pending";
DO.Code = 0;
Entity.DailyOrders.Add(DO);
Entity.SaveChanges();
}
}
return(RedirectToAction("ViewDailyOrder"));
}
public async Task <IActionResult> PutOrderMaster(int id, OrderMaster orderMaster)
{
if (id != orderMaster.INVNUM)
{
return(BadRequest());
}
_context.Entry(orderMaster).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderMasterExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void OrderLogic_Add_ShouldAddNewOrderInInventory()
{
var orderMaster = new OrderMaster
{
//Id = Guid.Empty,
OrderAt = DateTime.UtcNow,
OrderBy = "Person 1",
OrderDetails = new List <OrderDetail>()
{
new OrderDetail
{
Id = Guid.NewGuid(),
Quantity = 2,
ItemId = Guid.NewGuid()
},
new OrderDetail
{
Id = Guid.NewGuid(),
Quantity = 10,
ItemId = Guid.NewGuid()
}
}
};
orderLogic.Add(orderMaster);
var hasOrderPlaced = InventoryContext.OrderMaster.Any(o => o.Id != Guid.Empty);
Assert.True(hasOrderPlaced);
}
public IHttpActionResult SaveOrderMaster(OrderMaster orderMaster)
{
try
{
orderMaster.CreatedDate = DateTime.Now;
orderMaster.ModifiedDate = DateTime.Now;
int count = orderMaster.OrderDetails.Count;
var OrderDetails = orderMaster.OrderDetails.ToArray();
for (int i = 0; i < count; i++)
{
OrderDetails[i].CreatedDate = DateTime.Now;
OrderDetails[i].ModifiedDate = DateTime.Now;
}
db.OrderMasters.Add(orderMaster);
db.SaveChanges();
return(Ok(true));
}
catch (Exception ex)
{
var errMsg = ex.Message;
return(Content(HttpStatusCode.InternalServerError, false));
}
}
public void OrderLogic_Add_ShouldThrowExceptionIfOrderQuantityIsZero()
{
var orderMasterId = Guid.NewGuid();
var orderMaster = new OrderMaster
{
Id = orderMasterId,
OrderAt = DateTime.UtcNow,
OrderBy = "Person 1",
OrderDetails = new List <OrderDetail>()
{
new OrderDetail
{
Id = Guid.NewGuid(),
Quantity = 2,
ItemId = Guid.NewGuid()
},
new OrderDetail
{
Id = Guid.NewGuid(),
Quantity = 0,
ItemId = Guid.NewGuid()
}
}
};
Assert.Throws <Exception>(() => orderLogic.Add(orderMaster));
}
public JsonResult save(OrderMaster order)
{
bool status = false;
DateTime dateOrg;
var isValidDate = DateTime.TryParseExact(order.OrderDateString, "mm-dd-yyyy", null, System.Globalization.DateTimeStyles.None, out dateOrg);
if (isValidDate)
{
order.OrderDate = dateOrg;
}
var isValidModel = TryUpdateModel(order);
if (isValidModel)
{
using (MyDatabaseEntities dc = new MyDatabaseEntities())
{
dc.OrderMasters.Add(order);
dc.SaveChanges();
status = true;
}
}
return(new JsonResult {
Data = new { status = status }
});
}
/// <summary>保存主表
///
/// </summary>
private void DoSave()
{
switch (m_masterStatus)
{
case EntityOperationType.新增:
OrderMaster model = EntityOperateManager.AddEntity <OrderMaster>(this.grpMaster);
int intReturn = m_orderMasterDAL.Add(model);
if (intReturn > 0)
{
m_orderMaster = model;
model.OrderId = intReturn;
m_lstOrderMaster.Add(model);
ListOrderMaster = m_lstOrderMaster;
//清空明细列表
m_lstOrderDetail.Clear();
objListViewDetail.SetObjects(m_lstOrderDetail);
objListViewDetail.Refresh();
}
break;
case EntityOperationType.修改:
m_orderMaster = EntityOperateManager.EditEntity(this.grpMaster, m_orderMaster);
bool blnReturn = m_orderMasterDAL.Update(m_orderMaster);
if (blnReturn)
{
ListOrderMaster = m_lstOrderMaster;
}
break;
}
SetMode(EntityOperationType.只读);
}
