public ActionResult DeleteConfirmed(int id)
        {
            CaseParties caseParties = db.CaseParties.Find(id);

            db.CaseParties.Remove(caseParties);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
 public ActionResult Edit([Bind(Include = "CaseId,PartyId,RoleId")] CaseParties caseParties)
 {
     if (ModelState.IsValid)
     {
         db.Entry(caseParties).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.CaseId  = new SelectList(db.Cases, "Id", "Type", caseParties.CaseId);
     ViewBag.RoleId  = new SelectList(db.CaseRoles, "Id", "Title", caseParties.RoleId);
     ViewBag.PartyId = new SelectList(db.Parties, "Id", "FirstName", caseParties.PartyId);
     return(View(caseParties));
 }
        // GET: CaseParties/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            CaseParties caseParties = db.CaseParties.Find(id);

            if (caseParties == null)
            {
                return(HttpNotFound());
            }
            return(View(caseParties));
        }
        // GET: CaseParties/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            CaseParties caseParties = db.CaseParties.Find(id);

            if (caseParties == null)
            {
                return(HttpNotFound());
            }
            ViewBag.CaseId  = new SelectList(db.Cases, "Id", "Type", caseParties.CaseId);
            ViewBag.RoleId  = new SelectList(db.CaseRoles, "Id", "Title", caseParties.RoleId);
            ViewBag.PartyId = new SelectList(db.Parties, "Id", "FirstName", caseParties.PartyId);
            return(View(caseParties));
        }
Exemplo n.º 5
0
        public CaseBaseValidator(
            CasePartyValidator casePartyValidator,
            CaseDescriptionValidator caseDescriptionValidator,
            ILookupService LookupService,
            ICircuitService CircuitService,
            ICaseConfiguration CaseConfiguration)
        {
            this.LookupService     = LookupService;
            this.CircuitService    = CircuitService;
            this.CaseConfiguration = CaseConfiguration;
            #region CaseBasicData Validator
            RuleFor(Case => Case.Business_Case_Id)
            .NotEmpty()
            .WithErrorCode(ErrorCode.EmptyProsCaseID.ToString());
            RuleFor(Case => Case.Court_ID)
            .NotEmpty()
            .WithErrorCode(ErrorCode.EmptyCourtID.ToString())
            .DependentRules(() =>
            {
                RuleFor(Case => Case.Court_ID)
                .Must(CheckCourtIDExist)
                .WithErrorCode(ErrorCode.InvalidCourtID.ToString());
            });
            RuleFor(Case => Case.CrimeID)
            .NotEmpty()
            .WithErrorCode(ErrorCode.EmptyCrimeID.ToString())
            .DependentRules(() =>
            {
                RuleFor(Case => Case.CrimeID)
                .Must(CheckCrimeIDExist)
                .WithErrorCode(ErrorCode.InvalidCrimeID.ToString());
            });
            RuleFor(Case => Case.ProcedureTypeID)
            .NotEmpty()
            .WithErrorCode(ErrorCode.EmptyProcedureTypeID.ToString())
            .DependentRules(() =>
            {
                RuleFor(Case => Case.ProcedureTypeID)
                .Must(CheckProcedureType)
                .WithErrorCode(ErrorCode.InvalidProcedureTypeID.ToString());
            });
            RuleFor(Case => Case.CaseTypeID)
            .NotEmpty()
            .WithErrorCode(ErrorCode.EmptyCaseTypeID.ToString())
            .DependentRules(() =>
            {
                RuleFor(Case => Case.CaseTypeID)
                .Must(CheckCaseTypeID)
                .WithErrorCode(ErrorCode.InvalidCaseTypeID.ToString());
            });
            RuleFor(Case => Case.First_Case_No)
            .NotEmpty()
            .WithErrorCode(ErrorCode.EmptyFirstCaseNo.ToString());
            RuleFor(Case => Case.First_Case_Police_Station_ID)
            .NotEmpty()
            .WithErrorCode(ErrorCode.EmptyFirstPoliceStationID.ToString())
            .DependentRules(() =>
            {
                RuleFor(Case => Case.First_Case_Police_Station_ID)
                .Must(CheckPoliceStationIDExist)
                .WithErrorCode(ErrorCode.InvalidFirstPoliceStationID.ToString());
            });
            RuleFor(Case => Case.First_Case_Year)
            .NotEmpty()
            .WithErrorCode(ErrorCode.EmptyFirstCaseYearID.ToString());
            #endregion

            #region CaseDescriptionValidation
            RuleFor(Case => Case.CaseDescription)
            .NotNull()
            .WithErrorCode(ErrorCode.NullCaseDescription.ToString())
            .DependentRules(() =>
            {
                RuleFor(Case => Case.CaseDescription).SetValidator(caseDescriptionValidator);
            });

            #endregion

            #region CaseParties
            RuleFor(Case => Case.CaseParties)
            .NotEmpty()
            .WithErrorCode(ErrorCode.EmptyCaseParties.ToString())
            .DependentRules(() =>
            {
                RuleFor(Case => Case.CaseParties)
                .SetCollectionValidator(casePartyValidator);


                //Check For If Defendant and Victim Exist
                RuleFor(Case => Case.CaseParties)
                .Must(CaseParties => CaseParties.Exists(CaseParty => (CaseParty.PartyType == (int)PartyTypes.Victim || CaseParty.PartyType == (int)PartyTypes.VictimAndDefendant)))
                .WithErrorCode(ErrorCode.VictimDoesntExist.ToString());

                RuleFor(Case => Case.CaseParties)
                .Must(CaseParties => CaseParties.Exists(CaseParty => (CaseParty.PartyType == (int)PartyTypes.Defendant || CaseParty.PartyType == (int)PartyTypes.VictimAndDefendant)))
                .WithErrorCode(ErrorCode.DefendantDoesntExist.ToString());

                RuleFor(Case => Case.CaseParties)
                .Must(CaseParties => CaseParties.Count > 1)
                .When(Case => Case.CaseParties.Exists(CaseParty => CaseParty.PartyType == (int)PartyTypes.VictimAndDefendant))
                .WithErrorCode(ErrorCode.OnlyOneVictimDefendantExist.ToString());
            });

            #endregion
        }