public async Task <Guid> CreateNewChecklistDetailsElementAsync(ChecklistElementDetailModel checklistElementDetails)
        {
            try
            {
                var val = await _repository.CreateNewChecklistDetailsElementAsync(checklistElementDetails);

                return(val);
            }
            catch (OzoneException ex)
            {
                throw new OzoneException(ex.Message, ex.InnerException);
            }
        }
        public async Task <bool> CreateNewChecklistElementDetailAsync(ChecklistElementDetailModel checklistElementDetail, Guid elementGuid)
        {
            try
            {
                var status = await _repository.CreateNewChecklistElementDetailAsync(checklistElementDetail, elementGuid);

                return(status);
            }
            catch (OzoneException ex)
            {
                throw new OzoneException(ex.Message, ex.InnerException);
            }
        }
        public async Task <bool> UpdateChecklistElementDatailsAsync(ChecklistElementDetailModel elementDetailsModel)
        {
            try
            {
                var status = await _repository.UpdateChecklistElementDatailsAsync(elementDetailsModel);

                return(status);
            }
            catch (OzoneException ex)
            {
                throw new OzoneException(ex.Message, ex.InnerException);
            }
        }
Beispiel #4
0
        private async Task <ChecklistElementDetailModel> GetElementDetailsByIdAsync(Guid elementDetailsGuid)
        {
            try
            {
                checklistElementDetailModel = await _db.ChecklistElementDetailsTable.FirstOrDefaultAsync(c => c.GuidId == elementDetailsGuid);

                return(checklistElementDetailModel);
            }
            catch (OzoneException ex)
            {
                throw new OzoneException("Error in Getting Element details from Database", ex);
            }
        }
Beispiel #5
0
        // Checklist Element Details Section

        //public async Task CreateNewChecklistElementDetailAsync(ChecklistElementDetailModel checklistElementDetail, int elementId)
        //{
        //    checklistElementDetail.ElementId = elementId;
        //    await _db.ChecklistElementDetailsTable.AddAsync(checklistElementDetail);
        //    await _db.SaveChangesAsync();
        //}

        public async Task <bool> CreateNewChecklistElementDetailAsync(ChecklistElementDetailModel checklistElementDetail, Guid elementGuid)
        {
            try
            {
                checklistElementDetail.GuidId = elementGuid;
                await _db.ChecklistElementDetailsTable.AddAsync(checklistElementDetail);

                var status = await _db.SaveChangesAsync() > 0;

                return(status);
            }
            catch (OzoneException ex)
            {
                throw new OzoneException("Error in Creating New Checklist Element Detail", ex);
            }
        }
Beispiel #6
0
        public async Task <bool> UpdateChecklistElementDatailsAsync(ChecklistElementDetailModel elementDetailsModel)
        {
            try
            {
                await GetElementDetailsByIdAsync(elementDetailsModel.GuidId);

                var nextMaint = elementDetailsModel.EndEventDate;
                if (nextMaint != null)
                {
                    nextMaint = nextMaint.Value.AddDays(7);
                }

                //
                checklistElementDetailModel.Status = elementDetailsModel.Status;
                //required
                checklistElementDetailModel.FaultType = elementDetailsModel.FaultType;
                //required
                checklistElementDetailModel.FaultOther  = elementDetailsModel.FaultOther;
                checklistElementDetailModel.ActionType  = elementDetailsModel.ActionType;
                checklistElementDetailModel.ActionOther = elementDetailsModel.ActionOther;
                //required
                checklistElementDetailModel.StartEventDate = elementDetailsModel.StartEventDate;
                checklistElementDetailModel.EndEventDate   = elementDetailsModel.EndEventDate;
                //required
                checklistElementDetailModel.StartEventHour = elementDetailsModel.StartEventHour;
                checklistElementDetailModel.EndEventHour   = elementDetailsModel.EndEventHour;
                checklistElementDetailModel.LastMINT       = elementDetailsModel.EndEventDate;
                checklistElementDetailModel.NextMINT       = nextMaint;
                //required
                checklistElementDetailModel.FaultDescription    = elementDetailsModel.FaultDescription;
                checklistElementDetailModel.ResponseDescription = elementDetailsModel.ResponseDescription;
                checklistElementDetailModel.Note = " ";
                checklistElementDetailModel.EmployeesInvolved = elementDetailsModel.EmployeesInvolved;
                //required
                checklistElementDetailModel.PublicVisible = elementDetailsModel.PublicVisible;
                checklistElementDetailModel.FaultRank     = "5";
                checklistElementDetailModel.FinalStatus   = elementDetailsModel.FinalStatus;
                checklistElementDetailModel.ElementId     = elementDetailsModel.ElementId;


                return(await _db.SaveChangesAsync() > 0);
            }
            catch (OzoneException ex)
            {
                throw new OzoneException("Error in Updating data in Database", ex);
            }
        }
Beispiel #7
0
        //public async Task<ChecklistElementDetailModel> GetSingleElementDetailsByIdAsync(int elementId)
        //{
        //    //  var maxId = _db.ChecklistElementDetailsTable.Where(c => c.ElementId == elementId).Max(i => i.Id);

        //    checklistElementDetailModel = await _db.ChecklistElementDetailsTable.FirstOrDefaultAsync(c => c.FinalStatus == false);
        //    if (checklistElementDetailModel == null)
        //    {
        //        checklistElementDetailModel = await _db.ChecklistElementDetailsTable.OrderByDescending(c => c.Id).FirstOrDefaultAsync();
        //    }
        //    return (checklistElementDetailModel);
        //}

        public async Task <ChecklistElementDetailModel> GetSingleElementDetailsAsync()
        {
            try
            {
                checklistElementDetailModel = await _db.ChecklistElementDetailsTable.FirstOrDefaultAsync(c => c.FinalStatus == false);

                if (checklistElementDetailModel == null)
                {
                    checklistElementDetailModel = await _db.ChecklistElementDetailsTable.OrderByDescending(c => c.GuidId).FirstOrDefaultAsync();
                }
                return(checklistElementDetailModel);
            }
            catch (OzoneException ex)
            {
                throw new OzoneException("Error in Getting Element Details from Database", ex);
            }
        }
Beispiel #8
0
        public async Task <Guid> CreateNewChecklistDetailsElementAsync(ChecklistElementDetailModel checklistElementDetails)
        {
            try
            {
                Guid guid = Guid.NewGuid();

                checklistElementDetails.GuidId = guid;

                await _db.ChecklistElementDetailsTable.AddAsync(checklistElementDetails);

                await _db.SaveChangesAsync();

                var newElementDetailId = checklistElementDetails.GuidId;

                return(newElementDetailId);
            }
            catch (OzoneException ex)
            {
                throw new OzoneException("Error in Data Insertion into Database", ex);
            }
        }