public async Task <ActionResult> CreateChecklist([FromBody] LogChecklist checklist)
        {
            checklist.Version = 1;
            checklist.Status  = "Draft";

            var index = new LogChecklistIndex()
            {
                CreatedBy   = user,
                CreatedTime = DateTime.Now,
            };

            _repo.Add(index);
            checklist.Idchecklist = index.Idchecklist;
            _repo.Add(checklist);

            var history = LogHistory(checklist, "Create new Checklist Version", 1);

            _repo.Add(history);


            if (await _repo.SaveAll())
            {
                return(CreatedAtAction("GetbyId", new { id = checklist.Idchecklist, ver = checklist.Version }, checklist));
            }

            return(BadRequest("Failed to Create Checklist"));
        }
Пример #2
0
        public async Task <ActionResult> ReorderSteps(LogChecklist checklist)
        {
            foreach (var s in checklist.LogChecklistSteps)
            {
                _repo.ReorderSteps(s);
            }

            await _repo.SaveAll();

            return(NoContent());
        }
 public LogChecklistHistory LogHistory(LogChecklist checklist, string action, short ver)
 {
     return(new LogChecklistHistory
     {
         Idchecklist = checklist.Idchecklist,
         Version = ver,
         Status = checklist.Status,
         FileTime = DateTime.Now,
         FileAction = action,
         FileBy = user
     });
 }
        public async Task <ActionResult> CreateDraft(int id, short ver, LogChecklist checklist)
        {
            if (id < 0 || ver < 0)
            {
                return(BadRequest("Id or version was not supplied"));
            }
            if (checklist.Status != "Approved")
            {
                return(BadRequest("Invalid Status"));
            }
            if (await _repo.CheckForDraft(id) != null)
            {
                return(BadRequest("Draft already exists"));
            }

            var   steps  = new List <LogChecklistSteps>();
            short newVer = ver += 1;

            foreach (var step in checklist.LogChecklistSteps)
            {
                var copy = new LogChecklistSteps
                {
                    Idchecklist = id,
                    Version     = newVer,
                    Step        = step.Step,
                    StepText    = step.StepText,
                    Title       = step.Title
                };

                steps.Add(copy);
            }

            var newChecklist = new LogChecklist
            {
                Idchecklist       = id,
                Version           = newVer,
                Status            = "Draft",
                Title             = checklist.Title,
                ProdLine          = checklist.ProdLine,
                Rel               = checklist.Rel,
                Scope             = checklist.Scope,
                Type              = checklist.Type,
                LogChecklistSteps = steps
            };

            _repo.Add(newChecklist);
            _repo.Add(LogHistory(newChecklist, "Create new Checklist Version", newChecklist.Version));
            await _repo.SaveAll();

            return(CreatedAtAction("GetbyId", new { id = newChecklist.Idchecklist, ver = newChecklist.Version }, newChecklist));
        }
        public async Task <LogChecklist> GetChecklist(int id, int ver)
        {
            var checklist = new LogChecklist();

            if (ver > 0)
            {
                checklist = await _ctx.LogChecklist
                            .Include(x => x.LogChecklistSteps)
                            .Include(x => x.LogChecklistHistory)
                            .Where(x => x.Idchecklist == id && x.Version == ver).FirstOrDefaultAsync();
            }
            else
            {
                checklist = await _ctx.LogChecklist
                            .Include(x => x.LogChecklistSteps)
                            .Include(x => x.LogChecklistHistory)
                            .Where(x => x.Idchecklist == id && x.Version >= ver).OrderByDescending(v => v.Version).FirstOrDefaultAsync();
            }
            checklist.LogChecklistSteps = checklist.LogChecklistSteps.OrderBy(x => x.Step).ToList();
            return(checklist);
        }
 public void EditChecklist(LogChecklist checklist)
 {
     _ctx.Entry(checklist).State = EntityState.Modified;
 }