Exemple #1
0
        public bool DeleteData(int id, int iRequesterID, out Library.DTO.Notification notification)
        {
            notification = new Library.DTO.Notification()
            {
                Type = Library.DTO.NotificationType.Success
            };
            try
            {
                //check permission on invoice
                if (fwFactory.CheckPackingListPermission(iRequesterID, id) == 0)
                {
                    throw new Exception("You do not have access permission on this packing list");
                }
                using (PackingListMngEntities context = CreateContext())
                {
                    PackingList dbItem = context.PackingList.FirstOrDefault(o => o.PackingListID == id);
                    if (dbItem == null)
                    {
                        notification.Message = "Invoice not found!";
                        return(false);
                    }
                    else
                    {
                        List <PackingListDetail> need_delete_details = new List <PackingListDetail>();
                        foreach (PackingListDetail dbDetail in dbItem.PackingListDetail)
                        {
                            need_delete_details.Add(dbDetail);
                        }

                        List <PackingListDetailExtend> need_delete_detailextends = new List <PackingListDetailExtend>();
                        foreach (PackingListDetailExtend dbDetailExtend in dbItem.PackingListDetailExtend)
                        {
                            need_delete_detailextends.Add(dbDetailExtend);
                        }

                        foreach (var item in need_delete_details)
                        {
                            context.PackingListDetail.Remove(item);
                        }
                        foreach (var item in need_delete_detailextends)
                        {
                            context.PackingListDetailExtend.Remove(item);
                        }

                        context.PackingList.Remove(dbItem);
                        context.SaveChanges();

                        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);
            }
        }
        public void DTO2DB_PackingList(DTO.PackingListMng.PackingList dtoItem, ref PackingList dbItem)
        {
            /*
             * MAP & CHECK PackingListDetail
             */
            List <PackingListDetail> ItemNeedDelete_Detail = new List <PackingListDetail>();

            if (dtoItem.PackingListDetails != null)
            {
                //CHECK
                foreach (PackingListDetail dbDetail in dbItem.PackingListDetail.Where(o => !dtoItem.PackingListDetails.Select(s => s.PackingListDetailID).Contains(o.PackingListDetailID)))
                {
                    ItemNeedDelete_Detail.Add(dbDetail);
                }
                foreach (PackingListDetail dbDetail in ItemNeedDelete_Detail)
                {
                    dbItem.PackingListDetail.Remove(dbDetail);
                }
                //MAP
                foreach (DTO.PackingListMng.PackingListDetail dtoDetail in dtoItem.PackingListDetails)
                {
                    PackingListDetail dbDetail;
                    if (dtoDetail.PackingListDetailID < 0)
                    {
                        dbDetail = new PackingListDetail();
                        dbItem.PackingListDetail.Add(dbDetail);
                    }
                    else
                    {
                        dbDetail = dbItem.PackingListDetail.FirstOrDefault(o => o.PackingListDetailID == dtoDetail.PackingListDetailID);
                    }

                    if (dbDetail != null)
                    {
                        AutoMapper.Mapper.Map <DTO.PackingListMng.PackingListDetail, PackingListDetail>(dtoDetail, dbDetail);
                    }
                }
            }

            /*
             * MAP & CHECK PackingListDetail
             */
            List <PackingListSparepartDetail> tobe_delete_sparepart = new List <PackingListSparepartDetail>();

            if (dtoItem.PackingListDetails != null)
            {
                //CHECK
                foreach (PackingListSparepartDetail dbDetail in dbItem.PackingListSparepartDetail.Where(o => !dtoItem.PackingListSparepartDetails.Select(s => s.PackingListSparepartDetailID).Contains(o.PackingListSparepartDetailID)))
                {
                    tobe_delete_sparepart.Add(dbDetail);
                }
                foreach (PackingListSparepartDetail dbDetail in tobe_delete_sparepart)
                {
                    dbItem.PackingListSparepartDetail.Remove(dbDetail);
                }
                //MAP
                foreach (DTO.PackingListMng.PackingListSparepartDetail dtoDetail in dtoItem.PackingListSparepartDetails)
                {
                    PackingListSparepartDetail dbDetail;
                    if (dtoDetail.PackingListSparepartDetailID < 0)
                    {
                        dbDetail = new PackingListSparepartDetail();
                        dbItem.PackingListSparepartDetail.Add(dbDetail);
                    }
                    else
                    {
                        dbDetail = dbItem.PackingListSparepartDetail.FirstOrDefault(o => o.PackingListSparepartDetailID == dtoDetail.PackingListSparepartDetailID);
                    }

                    if (dbDetail != null)
                    {
                        AutoMapper.Mapper.Map <DTO.PackingListMng.PackingListSparepartDetail, PackingListSparepartDetail>(dtoDetail, dbDetail);
                    }
                }
            }

            /*
             * MAP & CHECK PackingListDetailExtend
             */
            List <PackingListDetailExtend> ItemNeedDelete_DetailExt = new List <PackingListDetailExtend>();

            if (dtoItem.PackingListDetailExtends != null)
            {
                //CHECK
                foreach (PackingListDetailExtend dbDetailExt in dbItem.PackingListDetailExtend.Where(o => !dtoItem.PackingListDetailExtends.Select(s => s.PackingListDetailExtendID).Contains(o.PackingListDetailExtendID)))
                {
                    ItemNeedDelete_DetailExt.Add(dbDetailExt);
                }
                foreach (PackingListDetailExtend dbDetailExt in ItemNeedDelete_DetailExt)
                {
                    dbItem.PackingListDetailExtend.Remove(dbDetailExt);
                }
                //MAP
                foreach (DTO.PackingListMng.PackingListDetailExtend dtoDetailExt in dtoItem.PackingListDetailExtends)
                {
                    PackingListDetailExtend dbDetailExt;
                    if (dtoDetailExt.PackingListDetailExtendID < 0)
                    {
                        dbDetailExt = new PackingListDetailExtend();
                        dbItem.PackingListDetailExtend.Add(dbDetailExt);
                    }
                    else
                    {
                        dbDetailExt = dbItem.PackingListDetailExtend.FirstOrDefault(o => o.PackingListDetailExtendID == dtoDetailExt.PackingListDetailExtendID);
                    }

                    if (dbDetailExt != null)
                    {
                        AutoMapper.Mapper.Map <DTO.PackingListMng.PackingListDetailExtend, PackingListDetailExtend>(dtoDetailExt, dbDetailExt);
                    }
                }
            }

            if (!string.IsNullOrEmpty(dtoItem.PackingListDateFormated))
            {
                dtoItem.PackingListDate = dtoItem.PackingListDateFormated.ConvertStringToDateTime();
            }

            AutoMapper.Mapper.Map <DTO.PackingListMng.PackingList, PackingList>(dtoItem, dbItem);
        }
Exemple #3
0
        public bool UpdateData(int id, ref DTO.PackingListMng.PackingList dtoItem, int iRequesterID, out Library.DTO.Notification notification)
        {
            notification = new Library.DTO.Notification()
            {
                Type = Library.DTO.NotificationType.Success
            };
            try
            {
                using (PackingListMngEntities context = CreateContext())
                {
                    PackingList dbItem = null;
                    if (id == 0)
                    {
                        //check permission on invoice
                        if (fwFactory.CheckPurchasingInvoicePermission(iRequesterID, dtoItem.PurchasingInvoiceID.Value) == 0)
                        {
                            throw new Exception("You do not have access permission on this invoice to create packing list");
                        }
                        dbItem = new PackingList();
                        context.PackingList.Add(dbItem);
                    }
                    else
                    {
                        //check permission on invoice
                        if (fwFactory.CheckPackingListPermission(iRequesterID, id) == 0)
                        {
                            throw new Exception("You do not have access permission on this packing list");
                        }
                        dbItem = context.PackingList.FirstOrDefault(o => o.PackingListID == id);
                    }

                    if (dbItem == null)
                    {
                        notification.Message = "Invoice not found!";
                        return(false);
                    }
                    else
                    {
                        // check concurrency
                        if (dbItem.ConcurrencyFlag != null && !dbItem.ConcurrencyFlag.SequenceEqual(Convert.FromBase64String(dtoItem.ConcurrencyFlag_String)))
                        {
                            throw new Exception(DALBase.Helper.TEXT_CONCURRENCY_CONFLICT);
                        }

                        converter.DTO2DB_PackingList(dtoItem, ref dbItem);

                        if (id == 0)
                        {
                            dbItem.CreatedBy   = dtoItem.UpdatedBy;
                            dbItem.CreatedDate = DateTime.Now;
                        }
                        else
                        {
                            dbItem.UpdatedBy   = dtoItem.UpdatedBy;
                            dbItem.UpdatedDate = DateTime.Now;
                        }

                        context.PackingListDetail.Local.Where(o => o.PackingList == null).ToList().ForEach(o => context.PackingListDetail.Remove(o));
                        context.PackingListSparepartDetail.Local.Where(o => o.PackingList == null).ToList().ForEach(o => context.PackingListSparepartDetail.Remove(o));
                        context.PackingListDetailExtend.Local.Where(o => o.PackingList == null).ToList().ForEach(o => context.PackingListDetailExtend.Remove(o));

                        context.SaveChanges();
                        dtoItem = GetData(dbItem.PackingListID, out notification);

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