public ActionResult EditMaintainRecord(WebMaintainRecord webMaintainRecord, List <string> delIDList)
        {
            MaintainRecordBLL maintainRecordBLL = new MaintainRecordBLL();
            var cResult = maintainRecordBLL.UpdateMaintainRecord(webMaintainRecord, delIDList);

            return(JsonContentHelper.GetJsonContent(cResult));
        }
示例#2
0
        public CResult <string> InsertMaintainRecord(WebMaintainRecord model)
        {
            LogHelper.Info(MethodBase.GetCurrentMethod().ToString());
            LogHelper.Info("model", model);

            if (string.IsNullOrEmpty(model.ProjectID))
            {
                return(new CResult <string>("", ErrorCode.ParameterError));
            }

            using (var context = new DeviceMgmtEntities())
            {
                if (context.Project.Any(t => t.IsValid && t.ID == model.ProjectID) == false)
                {
                    return(new CResult <string>("", ErrorCode.ProjectNotExist));
                }

                if (context.Device.Any(t => t.ID == model.DeviceID) == false)
                {
                    return(new CResult <string>("", ErrorCode.DeviceNotExist));
                }

                var entity = new MaintainRecord();
                entity.CreateDate   = DateTime.Now;
                entity.CreateUserID = model.CreateUserID;
                entity.ID           = Guid.NewGuid().ToString();
                entity.MaintainDate = model.MaintainDate;
                entity.IsValid      = true;
                entity.Note         = model.Note;
                entity.ProjectID    = model.ProjectID;
                entity.Operator     = model.Operator;
                entity.DeviceID     = model.DeviceID;

                context.MaintainRecord.Add(entity);

                foreach (var item in model.MaintainItems)
                {
                    var relation = new MaintainRecordMaintainItemRel()
                    {
                        MaintainRecordID = entity.ID,
                        MaintainItemID   = item.ID
                    };

                    context.MaintainRecordMaintainItemRel.Add(relation);
                }

                if (context.SaveChanges() > 0)
                {
                    return(new CResult <string>(entity.ID));
                }
                else
                {
                    return(new CResult <string>("", ErrorCode.SaveDbChangesFailed));
                }
            }
        }
        public ActionResult AddMainTainRecord(WebMaintainRecord webMaintainRecord, List <string> delIDList)
        {
            MaintainRecordBLL maintainRecordBLL = new MaintainRecordBLL();

            webMaintainRecord.CreateUserID = this.GetCurrentUserID();
            webMaintainRecord.ProjectID    = this.GetCurrentProjectID();
            var cResult = maintainRecordBLL.InsertMaintainRecord(webMaintainRecord);

            return(JsonContentHelper.GetJsonContent(cResult));
        }
        public ActionResult AddMainTainRecord(string deviceID, string deviceName, string returnUrl)
        {
            int totalCount;
            var items = new MaintainItemBLL().GetMaintainItemListByDeviceID(deviceID);

            ViewBag.AllMaintainItems = items.Data;

            ViewBag.ReturnUrl     = returnUrl;
            ViewBag.DeviceName    = deviceName;
            ViewBag.DeviceID      = deviceID;
            ViewBag.OperateAction = "Add";
            ViewBag.IsAddRecord   = "True";
            ViewBag.LeftName      = "设备信息";
            WebMaintainRecord webMaintainRecord = new WebMaintainRecord();

            webMaintainRecord.MaintainDate = DateTime.Now.Date;
            return(View("MaintainRecord/AddMainTainRecord", webMaintainRecord));
        }
示例#5
0
        public CResult <WebMaintainRecord> GetMaintainRecordByID(string maintainRecordID)
        {
            LogHelper.Info(MethodBase.GetCurrentMethod().ToString());
            LogHelper.Info("maintainRecordID", maintainRecordID);

            if (string.IsNullOrEmpty(maintainRecordID))
            {
                return(new CResult <WebMaintainRecord>(null, ErrorCode.ParameterError));
            }

            using (var context = new DeviceMgmtEntities())
            {
                var entity = context.MaintainRecord.FirstOrDefault(t => t.ID == maintainRecordID && t.IsValid);
                if (entity == null)
                {
                    return(new CResult <WebMaintainRecord>(null, ErrorCode.DataNoExist));
                }

                var model = new WebMaintainRecord()
                {
                    ID             = entity.ID,
                    Note           = entity.Note,
                    DeviceID       = entity.DeviceID,
                    DeviceName     = entity.Device.Name,
                    Operator       = entity.Operator,
                    MaintainDate   = entity.MaintainDate,
                    CreateDate     = entity.CreateDate,
                    CreateUserID   = entity.CreateUserID,
                    CreateUserName = entity.User.Name,
                    ProjectID      = entity.ProjectID
                };

                var attachments = context.Attachment.Where(a => a.RelationID == entity.ID).ToList();
                foreach (var attachment in attachments)
                {
                    model.Attachments.Add(new WebAttachment()
                    {
                        DisplayName = attachment.DisplayName,
                        FilePath    = attachment.FilePath,
                        ID          = attachment.ID,
                        Note        = attachment.Note
                    });
                }

                var items = (from rel in context.MaintainRecordMaintainItemRel
                             join item in context.MaintainItem on rel.MaintainItemID equals item.ID
                             where rel.MaintainRecordID == entity.ID
                             select new WebMaintainItem()
                {
                    ID = item.ID,
                    Name = item.Name
                }).ToList();

                model.MaintainItems = items;


                LogHelper.Info("result", model);

                return(new CResult <WebMaintainRecord>(model));
            }
        }
示例#6
0
        public CResult <string> UpdateMaintainRecord(WebMaintainRecord model, List <string> deleteFiles)
        {
            LogHelper.Info(MethodBase.GetCurrentMethod().ToString());
            LogHelper.Info("model", model);
            LogHelper.Info("deleteFiles", deleteFiles);

            if (string.IsNullOrEmpty(model.ID))
            {
                return(new CResult <string>("", ErrorCode.ParameterError));
            }

            using (var context = new DeviceMgmtEntities())
            {
                var entity = context.MaintainRecord.FirstOrDefault(t => t.ID == model.ID && t.IsValid);
                if (entity == null)
                {
                    return(new CResult <string>("", ErrorCode.DataNoExist));
                }

                entity.Note                 = model.Note;
                entity.Operator             = model.Operator;
                entity.MaintainDate         = model.MaintainDate;
                context.Entry(entity).State = EntityState.Modified;
                if (deleteFiles != null && deleteFiles.Count() > 0)
                {
                    var needDelete = context.Attachment.Where(t => deleteFiles.Contains(t.ID)).ToList();
                    foreach (var item in needDelete)
                    {
                        context.Attachment.Remove(item);
                        FileHelper.DelFile(item.FilePath);
                    }
                }

                var oldRelations = context.MaintainRecordMaintainItemRel.Where(t => t.MaintainRecordID == entity.ID);

                var oldRelationItemIDs = oldRelations.Select(t => t.MaintainItemID);
                var newRelationItemIDs = model.MaintainItems.Select(t => t.ID).ToList();

                var needDeletes = oldRelations.Where(t => newRelationItemIDs.Contains(t.MaintainItemID) == false).ToList();
                var needAdd     = model.MaintainItems.Where(t => oldRelationItemIDs.Contains(t.ID) == false).ToList();

                foreach (var item in needDeletes)
                {
                    context.MaintainRecordMaintainItemRel.Remove(item);
                }

                foreach (var item in needAdd)
                {
                    var relation = new MaintainRecordMaintainItemRel()
                    {
                        MaintainRecordID = entity.ID,
                        MaintainItemID   = item.ID
                    };

                    context.MaintainRecordMaintainItemRel.Add(relation);
                }

                if (context.SaveChanges() > 0)
                {
                    return(new CResult <string>(""));
                }
                else
                {
                    return(new CResult <string>("", ErrorCode.SaveDbChangesFailed));
                }
            }
        }