Esempio n. 1
0
        public void DTO2DB_PurchaseOrder(DTO.PurchaseOrderDto dtoItem, ref PurchaseOrder dbItem)
        {
            if (dtoItem.PurchaseOrderDetailDTOs != null)
            {
                //delete item in db that exist in dto but not exist in db
                foreach (var item in dbItem.PurchaseOrderDetail.ToArray())
                {
                    if (!dtoItem.PurchaseOrderDetailDTOs.Select(s => s.PurchaseOrderDetailID).Contains(item.PurchaseOrderDetailID))
                    {
                        //delete purchase order workorder item
                        foreach (var wItem in item.PurchaseOrderWorkOrderDetail.ToArray())
                        {
                            item.PurchaseOrderWorkOrderDetail.Remove(wItem);
                        }

                        //delete purchase order receiving plan item
                        foreach (var wItem in item.PurchaseOrderDetailReceivingPlan.ToArray())
                        {
                            item.PurchaseOrderDetailReceivingPlan.Remove(wItem);
                        }

                        //delete purchase order detail
                        dbItem.PurchaseOrderDetail.Remove(item);
                    }
                    else
                    {
                        var x = dtoItem.PurchaseOrderDetailDTOs.Where(o => o.PurchaseOrderDetailID == item.PurchaseOrderDetailID).FirstOrDefault().PurchaseOrderWorkOrderDetailDTOs;
                        var y = dtoItem.PurchaseOrderDetailDTOs.Where(o => o.PurchaseOrderDetailID == item.PurchaseOrderDetailID).FirstOrDefault().PurchaseOrderDetailReceivingPlanDtos;

                        //delete purchase order workorder detail
                        foreach (var wItem in item.PurchaseOrderWorkOrderDetail.ToArray())
                        {
                            if (!x.Select(s => s.PurchaseOrdertWorkOrderDetailID).Contains(wItem.PurchaseOrderWorkOrderDetailID))
                            {
                                item.PurchaseOrderWorkOrderDetail.Remove(wItem);
                            }
                        }

                        //delete purchase order receiving plan detail
                        foreach (var wItem in item.PurchaseOrderDetailReceivingPlan.ToArray())
                        {
                            if (!y.Select(s => s.PurchaseOrderDetailReceivingPlanID).Contains(wItem.PurchaseOrderDetailReceivingPlanID))
                            {
                                item.PurchaseOrderDetailReceivingPlan.Remove(wItem);
                            }
                        }
                    }
                }
                //read from dto to db
                PurchaseOrderDetail              dbPurchaseDetail;
                PurchaseOrderWorkOrderDetail     dbPurchaseWorkOrderDetail;
                PurchaseOrderDetailReceivingPlan dbPurchaseOrderDetailReceivingPlan;
                foreach (var item in dtoItem.PurchaseOrderDetailDTOs)
                {
                    if (item.PurchaseOrderDetailID > 0)
                    {
                        dbPurchaseDetail = dbItem.PurchaseOrderDetail.Where(o => o.PurchaseOrderDetailID == item.PurchaseOrderDetailID).FirstOrDefault();

                        //read from purchase order workorder detail dto to db
                        if (dbPurchaseDetail != null && item.PurchaseOrderWorkOrderDetailDTOs != null)
                        {
                            foreach (var wItem in item.PurchaseOrderWorkOrderDetailDTOs)
                            {
                                if (wItem.PurchaseOrdertWorkOrderDetailID > 0)
                                {
                                    dbPurchaseWorkOrderDetail = dbPurchaseDetail.PurchaseOrderWorkOrderDetail.Where(o => o.PurchaseOrderWorkOrderDetailID == wItem.PurchaseOrdertWorkOrderDetailID).FirstOrDefault();
                                }
                                else
                                {
                                    dbPurchaseWorkOrderDetail = new PurchaseOrderWorkOrderDetail();
                                    dbPurchaseDetail.PurchaseOrderWorkOrderDetail.Add(dbPurchaseWorkOrderDetail);
                                }
                                if (dbPurchaseWorkOrderDetail != null)
                                {
                                    AutoMapper.Mapper.Map <DTO.PurchaseOrderWorkOrderDetailDto, PurchaseOrderWorkOrderDetail>(wItem, dbPurchaseWorkOrderDetail);
                                }
                            }
                        }

                        //read from purchase order detail receiving plan dto to db
                        if (dbPurchaseDetail != null && item.PurchaseOrderDetailReceivingPlanDtos != null)
                        {
                            foreach (var wItem in item.PurchaseOrderDetailReceivingPlanDtos)
                            {
                                if (wItem.PurchaseOrderDetailReceivingPlanID > 0)
                                {
                                    dbPurchaseOrderDetailReceivingPlan = dbPurchaseDetail.PurchaseOrderDetailReceivingPlan.Where(o => o.PurchaseOrderDetailReceivingPlanID == wItem.PurchaseOrderDetailReceivingPlanID).FirstOrDefault();
                                }
                                else
                                {
                                    dbPurchaseOrderDetailReceivingPlan = new PurchaseOrderDetailReceivingPlan();
                                    dbPurchaseDetail.PurchaseOrderDetailReceivingPlan.Add(dbPurchaseOrderDetailReceivingPlan);
                                }
                                if (dbPurchaseOrderDetailReceivingPlan != null)
                                {
                                    AutoMapper.Mapper.Map <DTO.PurchaseOrderDetailReceivingPlanDto, PurchaseOrderDetailReceivingPlan>(wItem, dbPurchaseOrderDetailReceivingPlan);
                                    dbPurchaseOrderDetailReceivingPlan.PlannedETA = wItem.PlannedETA.ConvertStringToDateTime().Value;
                                }
                            }
                        }
                    }
                    else
                    {
                        dbPurchaseDetail = new PurchaseOrderDetail();
                        dbItem.PurchaseOrderDetail.Add(dbPurchaseDetail);

                        //read from purchase order workorder detail dto to db
                        if (item.PurchaseOrderWorkOrderDetailDTOs != null)
                        {
                            foreach (var mItem in item.PurchaseOrderWorkOrderDetailDTOs)
                            {
                                dbPurchaseWorkOrderDetail = new PurchaseOrderWorkOrderDetail();
                                dbPurchaseDetail.PurchaseOrderWorkOrderDetail.Add(dbPurchaseWorkOrderDetail);
                                AutoMapper.Mapper.Map <DTO.PurchaseOrderWorkOrderDetailDto, PurchaseOrderWorkOrderDetail>(mItem, dbPurchaseWorkOrderDetail);
                            }
                        }

                        //read from purchase order receiving plan dto to db
                        if (item.PurchaseOrderDetailReceivingPlanDtos != null)
                        {
                            foreach (var mItem in item.PurchaseOrderDetailReceivingPlanDtos)
                            {
                                dbPurchaseOrderDetailReceivingPlan = new PurchaseOrderDetailReceivingPlan();
                                dbPurchaseDetail.PurchaseOrderDetailReceivingPlan.Add(dbPurchaseOrderDetailReceivingPlan);
                                AutoMapper.Mapper.Map <DTO.PurchaseOrderDetailReceivingPlanDto, PurchaseOrderDetailReceivingPlan>(mItem, dbPurchaseOrderDetailReceivingPlan);
                                dbPurchaseOrderDetailReceivingPlan.PlannedETA = mItem.PlannedETA.ConvertStringToDateTime().Value;
                            }
                        }
                    }
                    //read purchase request detail dto to db
                    if (dbPurchaseDetail != null)
                    {
                        AutoMapper.Mapper.Map <DTO.PurchaseOrderDetailDto, PurchaseOrderDetail>(item, dbPurchaseDetail);
                        dbPurchaseDetail.ETA = item.ETA.ConvertStringToDateTime();
                        dbPurchaseDetail.PurchaseRequestDetailID = item.PurchaseRequestDetailID;
                    }
                }
            }
            AutoMapper.Mapper.Map <DTO.PurchaseOrderDto, PurchaseOrder>(dtoItem, dbItem);
            dbItem.VAT = (decimal?)dtoItem.VAT;
            dbItem.PurchaseOrderDate = dtoItem.PurchaseOrderDate.ConvertStringToDateTime();
            dbItem.UpdatedDate       = DateTime.Now;
            dbItem.ETA = dtoItem.ETA.ConvertStringToDateTime();
        }
Esempio n. 2
0
        public override bool UpdateData(int userId, int id, ref object dtoItem, out Notification notification)
        {
            notification = new Library.DTO.Notification()
            {
                Type = Library.DTO.NotificationType.Success
            };
            DTO.PurchaseOrderDto dtoPurchaseOrder = ((Newtonsoft.Json.Linq.JObject)dtoItem).ToObject <DTO.PurchaseOrderDto>();
            try
            {
                //get companyID
                Module.Framework.DAL.DataFactory fw_factory = new Framework.DAL.DataFactory();
                int?companyID = fw_factory.GetCompanyID(userId);
                using (PurchaseOrderMngEntities context = CreateContext())
                {
                    PurchaseOrder dbItem = null;
                    if (id == 0)
                    {
                        dbItem = new PurchaseOrder();
                        context.PurchaseOrder.Add(dbItem);
                    }
                    else
                    {
                        dbItem = context.PurchaseOrder.Where(o => o.PurchaseOrderID == id).FirstOrDefault();
                    }
                    if (dbItem == null)
                    {
                        notification.Message = "data not found!";
                        return(false);
                    }
                    else
                    {
                        //upload file
                        Module.Framework.DAL.DataFactory fwFactory = new Module.Framework.DAL.DataFactory();
                        string tempFolder = FrameworkSetting.Setting.AbsoluteUserTempFolder + userId.ToString() + @"\";
                        if (dtoPurchaseOrder.File_HasChange.HasValue && dtoPurchaseOrder.File_HasChange.Value)
                        {
                            dtoPurchaseOrder.AttachedFile = fwFactory.CreateFilePointer(tempFolder, dtoPurchaseOrder.File_NewFile, dtoPurchaseOrder.AttachedFile, dtoPurchaseOrder.FriendlyName);
                        }

                        //
                        //convert dto to db
                        converter.DTO2DB_PurchaseOrder(dtoPurchaseOrder, ref dbItem);
                        dbItem.CompanyID   = companyID;
                        dbItem.UpdatedBy   = userId;
                        dbItem.UpdatedDate = DateTime.Now;

                        if (id == 0)
                        {
                            //dbItem.PurchaseOrderUD = context.PurchaseOrderMng_function_GeneratePurchaseOrderUD(dtoPurchaseOrder.FactoryRawMaterialUD, dtoPurchaseOrder.PurchaseOrderDate, dtoPurchaseOrder.FactoryRawMaterialID).FirstOrDefault();
                            dbItem.CreatedBy   = userId;
                            dbItem.CreatedDate = DateTime.Now;
                            if (dtoPurchaseOrder.PurchaseOrderStatusID != 4)
                            {
                                dbItem.PurchaseOrderStatusID = 1;
                            }
                        }

                        // loop dto item detail
                        foreach (var item in dtoPurchaseOrder.PurchaseOrderDetailDTOs)
                        {
                            if (item.IsChangePrice == true)
                            {
                                PurchaseOrderDetailPriceHistory dbItemPriceHistory = new PurchaseOrderDetailPriceHistory();
                                context.PurchaseOrderDetailPriceHistory.Add(dbItemPriceHistory);
                                dbItemPriceHistory.PurchaseOrderDetailID = (int)item.PurchaseOrderDetailID;
                                dbItemPriceHistory.UnitPrice             = (decimal)item.UnitPrice;
                                dbItemPriceHistory.ApprovedBy            = userId;
                                dbItemPriceHistory.ApprovedDate          = DateTime.Now;
                            }
                        }
                        //remove orphan

                        context.PurchaseOrderDetail.Local.Where(o => o.PurchaseOrder == null).ToList().ForEach(o => context.PurchaseOrderDetail.Remove(o));
                        context.PurchaseOrderWorkOrderDetail.Local.Where(o => o.PurchaseOrderDetail == null).ToList().ForEach(o => context.PurchaseOrderWorkOrderDetail.Remove(o));
                        context.PurchaseOrderDetailReceivingPlan.Local.Where(o => o.PurchaseOrderDetail == null).ToList().ForEach(o => context.PurchaseOrderDetailReceivingPlan.Remove(o));
                        context.PurchaseOrderDetailPriceHistory.Local.Where(o => o.PurchaseOrderDetail == null).ToList().ForEach(o => context.PurchaseOrderDetailPriceHistory.Remove(o));
                        //save data
                        context.SaveChanges();

                        // Generate PurchaseOrderUD.
                        if (id == 0)
                        {
                            context.PurchaseOrderMng_function_GeneratePurchaseOrderUD(dbItem.Season, dbItem.FactoryRawMaterialID, dbItem.PurchaseOrderID);
                        }
                        else
                        {
                            // Auto update unit price in receiving note
                            UpdateUnitPriceReceivingNoteDetail(dbItem.PurchaseOrderID, out notification);
                        }

                        //get return data
                        dtoItem = GetData(userId, dbItem.PurchaseOrderID, out notification).Data;

                        if (id == 0)
                        {
                            string emailSubject = string.Format("[Tilsoft] - Purchasing Order - {0} - {1}", dbItem.PurchaseOrderUD, dtoPurchaseOrder.FactoryRawMaterialShortNM);
                            string emailBody    = string.Format("Please approve PO: {0} - {1} - {2}", dbItem.PurchaseOrderUD, dtoPurchaseOrder.FactoryRawMaterialShortNM, "http://app.tilsoft.bg/PurchaseOrderMng/Edit/" + dbItem.PurchaseOrderID);
                            SendNotification(emailSubject, emailBody);
                        }

                        return(true);
                    }
                }
            }
            catch (Exception ex)
            {
                notification.Type    = Library.DTO.NotificationType.Error;
                notification.Message = ex.Message;
                notification.DetailMessage.Add(ex.Message);
                if (ex.GetBaseException() != null)
                {
                    notification.DetailMessage.Add(ex.GetBaseException().Message);
                }
                return(false);
            }
        }