Ejemplo n.º 1
0
        void SetViewBag(int lawUnitId, CheckListViewVM model)
        {
            var lawUnit = commonService.GetById <LawUnit>(lawUnitId);

            model.Label     = "Специалности за " + lawUnit.FullName;
            ViewBag.backUrl = Url.Action("Index", "LawUnit", new { lawUnitType = lawUnit.LawUnitTypeId });
        }
Ejemplo n.º 2
0
        public IActionResult AddCaseSessionDoc(CheckListViewVM model)
        {
            if (service.CaseSessionDoc_SaveDataAdd(model))
            {
                CheckAccess(service, SourceTypeSelectVM.CaseSessionDoc, null, AuditConstants.Operations.ChoiceByList, model.ObjectId);
                CheckListViewVM checkListView = service.CheckListViewVM_Fill(model.ObjectId);
                if (checkListView.checkListVMs.Count < 1)
                {
                    SetSuccessMessage(MessageConstant.Values.SaveOK + " Няма документи за добавяне.");
                    return(RedirectToAction("Preview", "CaseSession", new { id = model.ObjectId }));
                }
                else
                {
                    SetSuccessMessage(MessageConstant.Values.SaveOK);
                }
            }
            else
            {
                SetErrorMessage(MessageConstant.Values.SaveFailed);
            }

            ViewBag.backUrl     = Url.Action("Preview", "CaseSession", new { id = model.ObjectId });
            ViewBag.breadcrumbs = commonService.Breadcrumbs_GetForCaseSession(model.ObjectId);
            return(RedirectToAction("AddCaseSessionDoc", "CaseSessionDoc", new { CeaseSessionId = model.ObjectId }));
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Запис на Страни в Обжалвания към съдебен акт
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool CaseSessionActComplainPerson_SaveData(CheckListViewVM model)
        {
            try
            {
                var caseSessionActComplainPeople = repo.AllReadonly <CaseSessionActComplainPerson>().Where(x => x.CaseSessionActComplainId == model.ObjectId).ToList();
                repo.DeleteRange(caseSessionActComplainPeople);
                var caseSessionActComplain = repo.GetById <CaseSessionActComplain>(model.ObjectId);

                foreach (var checkList in model.checkListVMs.Where(x => x.Checked))
                {
                    var person = new CaseSessionActComplainPerson()
                    {
                        CourtId = caseSessionActComplain.CourtId,
                        CaseId  = caseSessionActComplain.CaseId,
                        CaseSessionActComplainId = model.ObjectId,
                        CasePersonId             = int.Parse(checkList.Value),
                        DateWrt = DateTime.Now,
                        UserId  = userContext.UserId
                    };

                    repo.Add <CaseSessionActComplainPerson>(person);
                }
                repo.SaveChanges();

                return(true);
            }
            catch (Exception ex)
            {
                logger.LogError(ex, $"Грешка при запис на Страни в Обжалвания към съдебен акт Id={ model.ObjectId }");
                return(false);
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Зарежда индикаторите по делото заедно с информацията дали е чекнат индикатора или не
        /// </summary>
        /// <param name="caseId"></param>
        /// <param name="caseSessionId"></param>
        /// <returns></returns>
        public CheckListViewVM CaseClassification_SelectForCheck(int caseId, int?caseSessionId)
        {
            CheckListViewVM checkListViewVM = new CheckListViewVM
            {
                CourtId      = caseId,
                ObjectId     = caseSessionId ?? 0,
                Label        = "Индикатори",
                checkListVMs = FillCheckListVMs(caseId, caseSessionId)
            };

            return(checkListViewVM);
        }
        /// <summary>
        /// Извличане на данни за Съпровождащ документ представен в заседание за чеклист
        /// </summary>
        /// <param name="CaseSessionFromId"></param>
        /// <param name="CaseSessionToId"></param>
        /// <returns></returns>
        public CheckListViewVM CaseSessionFastDocument_SelectForSessionCheck(int CaseSessionFromId, int CaseSessionToId)
        {
            CheckListViewVM checkListViewVM = new CheckListViewVM
            {
                CourtId      = CaseSessionFromId,
                ObjectId     = CaseSessionToId,
                Label        = "Изберете документ",
                checkListVMs = FillCheckListVMs_SelectForCheck(CaseSessionFromId, CaseSessionToId)
            };

            return(checkListViewVM);
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Избор на съдии към дежурство
        /// </summary>
        /// <param name="courtId"></param>
        /// <param name="dutyId"></param>
        /// <returns></returns>
        public CheckListViewVM CheckListViewVM_Fill(int courtId, int dutyId)
        {
            var             courtDuty       = repo.GetById <CourtDuty>(dutyId);
            CheckListViewVM checkListViewVM = new CheckListViewVM
            {
                CourtId      = courtId,
                ObjectId     = dutyId,
                Label        = "Изберете съдии към дежурство " + courtDuty.Label,
                checkListVMs = FillCheckListVMs(courtId, dutyId)
            };

            return(checkListViewVM);
        }
        /// <summary>
        /// Пълнене на лист от Съпровождащи документи, прикачени към заседание
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        private List <CaseSessionDoc> FillListSave(CheckListViewVM model)
        {
            List <CaseSessionDoc> sessionDocs = new List <CaseSessionDoc>();

            foreach (var check in model.checkListVMs)
            {
                if (check.Checked)
                {
                    sessionDocs.Add(FillData(model.ObjectId, int.Parse(check.Value)));
                }
            }

            return(sessionDocs);
        }
        /// <summary>
        /// Извличане на данни за чеклис за Съпровождащи документи, прикачени към заседание
        /// </summary>
        /// <param name="CaseSessionId"></param>
        /// <returns></returns>
        public CheckListViewVM CheckListViewVM_Fill(int CaseSessionId)
        {
            var session = repo.GetById <CaseSession>(CaseSessionId);

            CheckListViewVM checkListViewVM = new CheckListViewVM
            {
                CourtId      = session.CaseId,
                ObjectId     = session.Id,
                Label        = "Изберете документи ",
                checkListVMs = FillCheckListVMs(session.CaseId, session.Id, session.DateFrom)
            };

            return(checkListViewVM);
        }
Ejemplo n.º 9
0
        public IActionResult LawUnits(CheckListViewVM model)
        {
            if (service.CourtDutyLawUnit_SaveData(model))
            {
                SetSuccessMessage(MessageConstant.Values.SaveOK);
            }
            else
            {
                SetErrorMessage(MessageConstant.Values.SaveFailed);
            }

            ViewBag.backUrl = Url.Action("Index", "CourtDuty");
            return(View("CheckListViewVM", model));
        }
Ejemplo n.º 10
0
        public IActionResult CaseClassification(CheckListViewVM model)
        {
            if (service.CaseClassification_SaveData(model))
            {
                SetSuccessMessage(MessageConstant.Values.SaveOK);
            }
            else
            {
                SetErrorMessage(MessageConstant.Values.SaveFailed);
            }

            SetViewBag(model.CourtId, model.ObjectId);
            return(View("CheckListViewVM", service.CaseClassification_SelectForCheck(model.CourtId, model.ObjectId)));
        }
        /// <summary>
        /// Попълване на обекта нужен за вюто с чек боксовете
        /// </summary>
        /// <param name="courtId"></param>
        /// <param name="departmentId"></param>
        /// <returns></returns>
        public CheckListViewVM CheckListViewVM_Fill(int courtId, int departmentId)
        {
            var             courtDepartment = repo.GetById <CourtDepartment>(departmentId);
            var             departmentType  = repo.GetById <DepartmentType>(courtDepartment.DepartmentTypeId);
            CheckListViewVM checkListViewVM = new CheckListViewVM
            {
                CourtId      = courtId,
                ObjectId     = departmentId,
                Label        = "Изберете съдии към " + departmentType.Label + "-" + courtDepartment.Label,
                checkListVMs = FillCheckListVMs(courtId, departmentId)
            };

            return(checkListViewVM);
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Взема Страни в Обжалвания към съдебен акт за чеклист
        /// </summary>
        /// <param name="CaseSessionActComplainId"></param>
        /// <returns></returns>
        public CheckListViewVM CheckListViewVM_FillCasePerson(int CaseSessionActComplainId)
        {
            var caseSessionActComplain = repo.GetById <CaseSessionActComplain>(CaseSessionActComplainId);
            var caseSessionAct         = repo.GetById <CaseSessionAct>(caseSessionActComplain.CaseSessionActId);
            var caseSession            = repo.GetById <CaseSession>(caseSessionAct.CaseSessionId);

            CheckListViewVM checkListViewVM = new CheckListViewVM
            {
                CourtId      = caseSession.CaseId,
                ObjectId     = CaseSessionActComplainId,
                Label        = "Изберете жалбоподатели",
                checkListVMs = FillCheckListVMs(caseSession.CaseId, CaseSessionActComplainId)
            };

            return(checkListViewVM);
        }
Ejemplo n.º 13
0
        public IActionResult SessionLawUnitFromCase(CheckListViewVM model)
        {
            if (service.SessionLawUnitFromCase_SaveData(model))
            {
                CheckAccess(service, SourceTypeSelectVM.CaseSessionLawUnit, null, AuditConstants.Operations.ChoiceByList, model.ObjectId);
                SetSuccessMessage(MessageConstant.Values.SaveOK);
                this.SaveLogOperation(IO.LogOperation.Models.OperationTypes.Patch, model.ObjectId);
            }
            else
            {
                SetErrorMessage(MessageConstant.Values.SaveFailed);
            }

            ViewBag.backUrl = Url.Action("Preview", "CaseSession", new { id = model.ObjectId });
            return(View("CheckListViewVM", model));
        }
Ejemplo n.º 14
0
        public IActionResult AddCaseSessionActComplainPerson(CheckListViewVM model)
        {
            if (service.CaseSessionActComplainPerson_SaveData(model))
            {
                SetSuccessMessage(MessageConstant.Values.SaveOK);
            }
            else
            {
                SetErrorMessage(MessageConstant.Values.SaveFailed);
            }

            CheckAccess(service, SourceTypeSelectVM.CaseSessionActComplainResult, null, AuditConstants.Operations.Update, model.ObjectId);

            ViewBag.backUrl = Url.Action("Edit", "CaseSessionActComplain", new { id = model.ObjectId });
            return(View("CheckListViewVM", model));
        }
Ejemplo n.º 15
0
        /// <summary>
        /// Валидация преди запис на копирани Съпровождащ документ представен в заседание
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        private string IsValidCopyCaseSessionFastDocument(CheckListViewVM model)
        {
            if (model.checkListVMs == null)
            {
                return("Няма избрани документи");
            }

            if (model.checkListVMs != null)
            {
                if (model.checkListVMs.Where(x => x.Checked).Count() < 1)
                {
                    return("Няма избрани документи");
                }
            }

            return(string.Empty);
        }
Ejemplo n.º 16
0
        public IActionResult LawUnitSpeciality(CheckListViewVM model)
        {
            ViewBag.breadcrumbs = commonService.Breadcrumbs_ForSpeciality(model.CourtId).DeleteOrDisableLast();

            if (commonService.LawUnitSpeciality_SaveData(model))
            {
                SetSuccessMessage(MessageConstant.Values.SaveOK);
            }
            else
            {
                SetErrorMessage(MessageConstant.Values.SaveFailed);
            }

            var newModel = commonService.LawUnitSpeciality_SelectForCheck(model.CourtId);

            SetViewBag(model.CourtId, newModel);
            return(View("CheckListViewVM", newModel));
        }
        /// <summary>
        /// Запис на Съпровождащ документ представен в заседание от чеклист
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool CaseSessionFastDocument_SaveSelectForSessionCheck(CheckListViewVM model)
        {
            try
            {
                var caseSession      = repo.GetById <CaseSession>(model.ObjectId);
                var caseSessionFasts = CaseSessionFastDocument_SelectForCopy(model.CourtId);
                var casePersonLists  = casePersonService.CasePerson_Select(caseSession.CaseId, caseSession.Id, true, false, false);

                foreach (var fastDocument in model.checkListVMs.Where(x => x.Checked))
                {
                    var sessionFastDocument = caseSessionFasts.Where(x => x.Id == int.Parse(fastDocument.Value)).FirstOrDefault();
                    var person = casePersonLists.Where(x => x.Uic == sessionFastDocument.CasePerson.Uic).FirstOrDefault();

                    if ((sessionFastDocument != null) && (person != null))
                    {
                        var caseSessionFastDocumentSave = new CaseSessionFastDocument()
                        {
                            CourtId                       = caseSession.CourtId ?? 0,
                            CaseId                        = caseSession.CaseId,
                            CaseSessionId                 = caseSession.Id,
                            CasePersonId                  = person.Id,
                            SessionDocTypeId              = sessionFastDocument.SessionDocTypeId,
                            Description                   = sessionFastDocument.Description,
                            SessionDocStateId             = sessionFastDocument.SessionDocStateId,
                            CaseSessionFastDocumentInitId = ((sessionFastDocument.CaseSessionFastDocumentInitId != null) ? sessionFastDocument.CaseSessionFastDocumentInitId : sessionFastDocument.Id),
                            DateWrt                       = DateTime.Now,
                            UserId                        = userContext.UserId
                        };

                        repo.Add <CaseSessionFastDocument>(caseSessionFastDocumentSave);
                    }
                }

                repo.SaveChanges();
                return(true);
            }
            catch (Exception ex)
            {
                logger.LogError(ex, $"Грешка при копиране на Съпровождащ документ представен в заседание от заседание Id={ model.CourtId } в заседание Id={model.ObjectId}");
                return(false);
            }
        }
Ejemplo n.º 18
0
        /// <summary>
        /// Запис на индикатори към дело
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool CaseClassification_SaveData(CheckListViewVM model)
        {
            try
            {
                DateTime dateTomorrow = DateTime.Now.AddDays(1).Date;
                DateTime fromDate     = DateTime.Now;
                DateTime toDate       = DateTime.Now.AddSeconds(-1);

                var expiryList = repo.All <CaseClassification>()
                                 .Where(x => x.CaseId == model.CourtId && (x.CaseSessionId ?? 0) == model.ObjectId && (x.DateTo ?? dateTomorrow).Date > DateTime.Now.Date)
                                 .ToList();
                foreach (var item in expiryList)
                {
                    item.DateTo = toDate;
                }
                foreach (var classification in model.checkListVMs)
                {
                    if (classification.Checked == false)
                    {
                        continue;
                    }
                    CaseClassification newClassification = new CaseClassification();
                    newClassification.CaseId           = model.CourtId;
                    newClassification.CourtId          = userContext.CourtId;
                    newClassification.ClassificationId = int.Parse(classification.Value);
                    newClassification.CaseSessionId    = null;
                    if (model.ObjectId > 0)
                    {
                        newClassification.CaseSessionId = model.ObjectId;
                    }
                    newClassification.DateFrom = fromDate;
                    repo.Add <CaseClassification>(newClassification);
                }
                repo.SaveChanges();
                return(true);
            }
            catch (Exception ex)
            {
                logger.LogError(ex, $"Грешка при запис на CaseClassification CaseId={ model.CourtId }");
                return(false);
            }
        }
Ejemplo n.º 19
0
        public IActionResult AddCaseSessionDoc(int CeaseSessionId)
        {
            if (!CheckAccess(service, SourceTypeSelectVM.CaseSessionDoc, null, AuditConstants.Operations.ChoiceByList, CeaseSessionId))
            {
                return(Redirect_Denied());
            }
            ViewBag.backUrl     = Url.Action("Preview", "CaseSession", new { id = CeaseSessionId });
            ViewBag.breadcrumbs = commonService.Breadcrumbs_GetForCaseSession(CeaseSessionId);
            SetHelpFile(HelpFileValues.SessionDoc);

            CheckListViewVM checkListView = service.CheckListViewVM_Fill(CeaseSessionId);

            if (checkListView.checkListVMs.Count < 1)
            {
                SetErrorMessage("Няма документи към това дело");
                return(RedirectToAction("Preview", "CaseSession", new { id = CeaseSessionId }));
            }

            return(View("CheckListViewVM", checkListView));
        }
Ejemplo n.º 20
0
        public IActionResult CaseSessionFastDocument_SelectForSessionCheck(CheckListViewVM model)
        {
            string _isvalid = IsValidCopyCaseSessionFastDocument(model);

            if (_isvalid != string.Empty)
            {
                SetErrorMessage(_isvalid);
                return(View("CopyCaseSessionFastDocument", model.ObjectId));
            }

            if (service.CaseSessionFastDocument_SaveSelectForSessionCheck(model))
            {
                CheckAccess(service, SourceTypeSelectVM.CaseSessionPerson, null, AuditConstants.Operations.Update, model.ObjectId);
                SetSuccessMessage(MessageConstant.Values.SaveOK);
            }
            else
            {
                SetErrorMessage(MessageConstant.Values.SaveFailed);
            }

            return(RedirectToAction("Index", "CaseSessionFastDocument", new { CaseSessionId = model.ObjectId }));
        }
Ejemplo n.º 21
0
        /// <summary>
        /// Запис на Съдии към дежурство
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool CourtDutyLawUnit_SaveData(CheckListViewVM model)
        {
            #region Попълване на данните за запис
            List <CourtDutyLawUnit> courtDutyLowUnits = CourtDutyLowUnit_Select(model.ObjectId).ToList();

            // сетване на всички до днешна дата без 1 секунда
            courtDutyLowUnits.ToList().ForEach(x => x.DateTo = DateTime.Now.AddSeconds(-1));

            List <CourtDutyLawUnit> courtDutyLawUnitNews = new List <CourtDutyLawUnit>();

            // въртя списъка с елементи визуализирани на екрана
            foreach (var check in model.checkListVMs)
            {
                // търси елемента от екрана в списъка с записани елементи
                var court = courtDutyLowUnits.Where(x => x.LawUnitId == int.Parse(check.Value)).DefaultIfEmpty(null).FirstOrDefault();

                if (court != null)
                {
                    // ако не го е намерил

                    if (check.Checked)
                    {
                        //ако е маркирано в екрана
                        if ((court.DateTo != null) && (court.DateTo <= DateTime.Now))
                        {
                            court.DateTo = null;
                        }
                    }
                    else
                    {
                        // ако не е маркирано в екрана
                        if (court.DateTo == null)
                        {
                            court.DateTo = DateTime.Now.AddSeconds(-1);
                        }
                    }
                }
                else
                {
                    // ако е намерен в записаните елементи
                    if (check.Checked)
                    {
                        // ако е маркиран
                        CourtDutyLawUnit courtDepartmentLawUnit = new CourtDutyLawUnit
                        {
                            CourtDutyId = model.ObjectId,
                            LawUnitId   = int.Parse(check.Value)
                        };

                        courtDutyLawUnitNews.Add(courtDepartmentLawUnit);
                    }
                }
            }

            courtDutyLowUnits.AddRange(courtDutyLawUnitNews);
            #endregion

            #region Запис на данните

            return(SaveLawUnit(courtDutyLowUnits));

            #endregion
        }
Ejemplo n.º 22
0
 /// <summary>
 /// Запис на избрани Съпровождащи документи, прикачени към заседание от чеклист
 /// </summary>
 /// <param name="model"></param>
 /// <returns></returns>
 public bool CaseSessionDoc_SaveDataAdd(CheckListViewVM model)
 {
     return(SaveCaseSessionDoc(FillListSave(model)));
 }