コード例 #1
0
 public long UpdateImportClassificationRequirement(ImportClassificationRequirementObject importClassificationRequirement, List <ImportClassificationRequirementObject> importClassificationRequirements)
 {
     try
     {
         return(_importClassificationRequirementManager.UpdateImportClassificationRequirement(importClassificationRequirement, importClassificationRequirements));
     }
     catch (Exception ex)
     {
         ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
         return(0);
     }
 }
コード例 #2
0
        public long UpdateImportClassificationRequirement(ImportClassificationRequirementObject iClassReq, List <ImportClassificationRequirementObject> newReqs)
        {
            try
            {
                if (iClassReq == null || !newReqs.Any())
                {
                    return(-2);
                }

                using (var db = new ImportPermitEntities())
                {
                    var oldReqs = db.ImportClassificationRequirements.Where(r => r.ClassificationId == iClassReq.ClassificationId && r.ImportStageId == iClassReq.ImportStageId).ToList();
                    if (!oldReqs.Any())
                    {
                        return(-2);
                    }
                    var newRequirements = new List <ImportClassificationRequirementObject>();
                    if (newReqs != null)
                    {
                        newRequirements = newReqs;
                    }

                    if (newRequirements.Any())
                    {
                        if (oldReqs.Any())
                        {
                            var oldMatch = oldReqs[0];
                            var newMatch = newRequirements[0];
                            if (oldMatch.ClassificationId != newMatch.ClassificationId || oldMatch.ImportStageId != newMatch.ImportStageId)
                            {
                                oldReqs.ForEach(k =>
                                {
                                    db.ImportClassificationRequirements.Remove(k);
                                    db.SaveChanges();
                                    oldReqs.Remove(k);
                                });
                            }
                        }
                        newRequirements.ForEach(k =>
                        {
                            if (!oldReqs.Exists(n => n.DocumentTypeId == k.DocumentTypeId))
                            {
                                if (db.ImportClassificationRequirements.Count(m => m.ClassificationId == iClassReq.Id && m.DocumentTypeId == k.DocumentTypeId) < 1)
                                {
                                    var iClassReqReqEntity = ModelMapper.Map <ImportClassificationRequirementObject, ImportClassificationRequirement>(k);
                                    if (iClassReqReqEntity != null && iClassReqReqEntity.DocumentTypeId > 0 && iClassReqReqEntity.Id > 0)
                                    {
                                        db.ImportClassificationRequirements.Add(iClassReqReqEntity);
                                        db.SaveChanges();
                                    }
                                }
                            }
                        });

                        if (oldReqs.Any())
                        {
                            oldReqs.ForEach(c =>
                            {
                                if (!newRequirements.Exists(n => n.DocumentTypeId == c.DocumentTypeId))
                                {
                                    db.ImportClassificationRequirements.Remove(c);
                                    db.SaveChanges();
                                }
                            });
                        }
                    }
                    return(iClassReq.Id);
                }
            }
            catch (Exception ex)
            {
                ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
                return(0);
            }
        }