public IActionResult EditResult(CaseSessionResult model)
{
SetViewbagResult(model.CaseSessionId);
if (!ModelState.IsValid)
{
return(View(nameof(Edit), model));
}
string _isvalid = IsValidResult(model);
if (_isvalid != string.Empty)
{
SetErrorMessage(_isvalid);
return(View(nameof(EditResult), model));
}
var currentId = model.Id;
if (service.CaseSessionResult_SaveData(model))
{
SetAuditContext(service, SourceTypeSelectVM.CaseSessionResult, model.Id, currentId == 0);
this.SaveLogOperation(currentId == 0, model.Id);
SetSuccessMessage(MessageConstant.Values.SaveOK);
return(RedirectToAction(nameof(EditResult), new { id = model.Id }));
}
else
{
SetErrorMessage(MessageConstant.Values.SaveFailed);
}
return(View(nameof(EditResult), model));
}
public void IsExistMainResultFalseTest()
{
using (serviceProvider.CreateScope())
{
var service = serviceProvider.GetService <ICaseSessionService>();
var userContext = serviceProvider.GetService <IUserContext>();
var repo = serviceProvider.GetService <IRepository>();
var saved = new CaseSessionResult()
{
CaseId = 1,
CourtId = 1,
CaseSessionId = 1,
SessionResultId = 1,
SessionResultBaseId = 1,
Description = "Test",
IsActive = true,
IsMain = false
};
repo.Add <CaseSessionResult>(saved);
var result = service.IsExistMainResult(1, 2);
Assert.IsFalse(result);
}
}
/// <summary>
/// Валидация преди запис на резултат
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private string IsValidResult(CaseSessionResult model)
{
if (model.SessionResultId < 0)
{
return("Няма избран резултат");
}
var selectListItems = nomService.GetDDL_SessionResultBase(model.SessionResultId);
if (selectListItems.Count > 1)
{
if (model.SessionResultBaseId < 1)
{
return("Няма избрано основание");
}
}
if (model.IsMain)
{
if (service.IsExistMainResult(model.CaseSessionId, model.Id))
{
return("Вече има избран основен резултат");
}
}
return(string.Empty);
}
private SessionType FillSessionType(CaseSession session, CaseSessionResult sessionResult, ICollection <CaseLawUnit> caseLawUnitsAll, List <CaseMigration> migrations)
{
var caseLawUnits = caseLawUnitsAll.Where(x => (x.DateTo ?? session.DateFrom) >= session.DateFrom)
.Where(x => x.CaseSessionId == session.Id)
.Where(x => x.JudgeRoleId == NomenclatureConstants.JudgeRole.JudgeReporter)
.ToList();
var acts = session.CaseSessionActs.Select(x => FillActType(x, session, migrations)).ToArray();
(var newId, var action) = AppendUpdateIntegrationKeyAction(SourceTypeSelectVM.CaseSession, session.Id, session.DateExpired != null);
if (string.IsNullOrEmpty(newId))
{
return(null);
}
return(new SessionType()
{
session_action = ServiceMethodToAction(action),
Act = acts,
session_date = (session.DateTo ?? session.DateFrom).Date,
session_id = newId,
session_kind = GetNomValueInt(EpepConstants.Nomenclatures.SessionTypes, session.SessionTypeId),
session_text = session.Description,
session_time = session.DateTo ?? session.DateFrom,
session_result = GetNomValueInt(EpepConstants.Nomenclatures.SessionResults, sessionResult.Id), /* nom_session_result */
Surround = FillSurroundProcessedArray(session.CaseSessionDocs.ToList()),
Judge = FillJudgeTypeArray(caseLawUnits),
//extensions =
});
}
public void DeadLineDeclaredForResolve(CaseSessionResult sessionResult)
{
var deadline = DeadLineDeclaredForResolveStart(sessionResult);
SaveDeadLine(deadline);
var deadlines = DeadLineDeclaredForResolveExpire(sessionResult);
foreach (var deadlineExp in deadlines)
{
repo.Update(deadlineExp);
}
}
public void DeadLineCompanyCaseCompleteOnResult(CaseSessionResult sessionResult)
{
var companyCase = repo.AllReadonly <CaseSession>()
.Where(x => x.Id == sessionResult.CaseSessionId)
.Select(x => x.Case)
.FirstOrDefault();
if (companyCase == null)
{
return;
}
var deadlinesComplete = DeadLineCompanyCaseComplete(companyCase);
foreach (var deadline in deadlinesComplete)
{
SaveDeadLine(deadline);
}
}
public CaseDeadline DeadLineOpenSessionResultCompleteInit(CaseSessionResult sessionResult)
{
CaseSession session = repo.AllReadonly <CaseSession>().Where(x => x.Id == sessionResult.CaseSessionId).FirstOrDefault();
var deadline = repo.AllReadonly <CaseDeadline>()
.Where(x => x.SourceType == SourceTypeSelectVM.CaseSession &&
x.SourceId == session.Id &&
x.DeadlineTypeId == NomenclatureConstants.DeadlineType.OpenSessionResult &&
x.DateComplete == null)
.FirstOrDefault();
if (deadline == null)
{
return(null);
}
deadline.DateComplete = DateTime.Now;
deadline.CaseSessionResultId = sessionResult.Id;
return(deadline);
}
public List <CaseDeadline> DeadLineDeclaredForResolveExpire(CaseSessionResult sessionResult)
{
CaseSession session = repo.AllReadonly <CaseSession>().Where(x => x.Id == sessionResult.CaseSessionId).FirstOrDefault();
var result = new List <CaseDeadline>();
if (sessionHaveResult(session, NomenclatureConstants.CaseSessionResult.StopedMoveWithSubstantialReason))
{
var deadlines = repo.AllReadonly <CaseDeadline>()
.Where(x => x.SourceType == SourceTypeSelectVM.CaseSession &&
x.SourceId <= session.Id &&
x.CaseId == session.CaseId &&
x.DeadlineTypeId == NomenclatureConstants.DeadlineType.DeclaredForResolve &&
x.DateComplete == null &&
x.DateExpired == null)
.ToList();
foreach (var deadline in deadlines)
{
setExpired(deadline);
deadline.ResultExpiredId = sessionResult.Id;
result.Add(deadline);
}
}
if (!sessionHaveResult(session, NomenclatureConstants.CaseSessionResult.AnnouncedForResolution))
{
var deadlines = repo.AllReadonly <CaseDeadline>()
.Where(x => x.SourceType == SourceTypeSelectVM.CaseSession &&
x.SourceId == session.Id &&
x.CaseId == session.CaseId &&
x.DeadlineTypeId == NomenclatureConstants.DeadlineType.DeclaredForResolve &&
x.DateComplete == null &&
x.DateExpired == null)
.ToList();
foreach (var deadline in deadlines)
{
setExpired(deadline);
deadline.ResultExpiredId = sessionResult.Id;
if (!result.Any(x => x.Id == deadline.Id))
{
result.Add(deadline);
}
}
}
return(result);
}
private SessionType FillSessionType(CaseSession session, CaseSessionResult sessionResult, ICollection <CaseLawUnit> caseLawUnitsAll, List <CaseMigration> migrations)
{
var caseLawUnits = caseLawUnitsAll.Where(x => (x.DateTo ?? session.DateFrom) >= session.DateFrom)
.Where(x => x.CaseSessionId == session.Id)
.Where(x => x.JudgeRoleId == NomenclatureConstants.JudgeRole.JudgeReporter)
.ToList();
var acts = session.CaseSessionActs
.Where(x => x.DateExpired == null &&
x.ActDeclaredDate != null &&
x.ActTypeId != NomenclatureConstants.ActType.ExecListPrivatePerson &&
x.ActTypeId != NomenclatureConstants.ActType.ObezpechitelnaZapoved
)
.Select(x => FillActType(x, session, migrations)).ToArray();
//acts = acts.Where(x => x.act_reason.Length > 0 || x.act_debtor_status > 0 || !string.IsNullOrEmpty(x.act_text)).ToArray();
(var newId, var action) = AppendUpdateIntegrationKeyAction(SourceTypeSelectVM.CaseSession, session.Id, session.DateExpired != null);
if (string.IsNullOrEmpty(newId))
{
return(null);
}
int sessionResultIspn = 11004;
try
{
sessionResultIspn = GetNomValueInt(EpepConstants.Nomenclatures.SessionResults, sessionResult.Id); /* nom_session_result */
} catch
{
}
return(new SessionType()
{
session_action = ServiceMethodToAction(action),
Act = acts,
session_date = (session.DateTo ?? session.DateFrom).Date,
session_id = newId,
session_kind = GetNomValueInt(EpepConstants.Nomenclatures.SessionTypes, session.SessionTypeId),
session_text = session.Description ?? "",
session_time = session.DateTo ?? session.DateFrom,
session_result = sessionResultIspn,
Surround = FillSurroundProcessedArray(session.CaseSessionDocs.ToList()),
Judge = FillJudgeTypeArray(caseLawUnits),
//extensions =
});
}
/// <summary>
/// Добавяне на резултат
/// </summary>
/// <param name="caseSessionId"></param>
/// <returns></returns>
public IActionResult AddResult(int caseSessionId)
{
if (!CheckAccess(service, SourceTypeSelectVM.CaseSessionResult, null, AuditConstants.Operations.Append, caseSessionId))
{
return(Redirect_Denied());
}
var caseSession = service.CaseSessionVMById(caseSessionId);
var model = new CaseSessionResult()
{
CaseId = caseSession.CaseId,
CourtId = caseSession.CourtId,
CaseSessionId = caseSessionId,
IsActive = true,
IsMain = !service.IsExistMainResult(caseSessionId)
};
SetViewbagResult(caseSessionId);
return(View(nameof(EditResult), model));
}
public void DeadLineeOpenSessionResultComplete(CaseSessionResult sessionResult)
{
var deadline = DeadLineOpenSessionResultCompleteInit(sessionResult);
SaveDeadLine(deadline);
}
public void DeadLineOnSessionResult(CaseSessionResult sessionResult)
{
DeadLineDeclaredForResolve(sessionResult);
DeadLineeOpenSessionResultComplete(sessionResult);
DeadLineCompanyCaseCompleteOnResult(sessionResult);
}
public CaseDeadline DeadLineDeclaredForResolveStart(CaseSessionResult sessionResult)
{
CaseSession session = repo.AllReadonly <CaseSession>().Where(x => x.Id == sessionResult.CaseSessionId).FirstOrDefault();
if (session == null)
{
return(null);
}
var deadline = repo.AllReadonly <CaseDeadline>()
.Where(x => x.SourceType == SourceTypeSelectVM.CaseSession &&
x.SourceId == session.Id &&
x.CaseSessionResultId == sessionResult.Id &&
x.DeadlineTypeId == NomenclatureConstants.DeadlineType.DeclaredForResolve)
.FirstOrDefault();
var aCase = session.Case;
if (aCase == null)
{
aCase = repo.AllReadonly <Case>().Where(x => x.Id == session.CaseId).FirstOrDefault();
}
var deadlineType = repo.AllReadonly <DeadlineType>().Where(x => x.Id == NomenclatureConstants.DeadlineType.DeclaredForResolve).FirstOrDefault();
bool isSet = false;
if (deadline != null)
{
if (sessionResult.SessionResultId == NomenclatureConstants.CaseSessionResult.AnnouncedForResolution ||
sessionResult.DateExpired != null)
{
if (deadline.DateExpired != null)
{
setUnExpired(deadline);
isSet = true;
}
if (deadline.StartDate != session.DateTo && session.DateTo != null)
{
deadline.StartDate = session.DateTo ?? deadline.StartDate;
setDateEnd(deadline, deadlineType);
isSet = true;
}
}
else
{
setExpired(deadline);
isSet = true;
}
}
else
{
if (sessionResult.SessionResultId == NomenclatureConstants.CaseSessionResult.AnnouncedForResolution)
{
deadline = new CaseDeadline();
deadline.CaseId = session.CaseId;
deadline.SourceType = SourceTypeSelectVM.CaseSession;
deadline.SourceId = session.Id;
deadline.DeadlineTypeId = NomenclatureConstants.DeadlineType.DeclaredForResolve;
deadline.DeadlineGroupId = deadlineType.DeadlineGroupId;
deadline.CaseSessionResultId = sessionResult.Id;
deadline.StartDate = session.DateTo ?? DateTime.Now;
setDateEnd(deadline, deadlineType);
isSet = true;
}
}
if (deadline != null && isSet)
{
return(deadline);
}
else
{
return(null);
}
}
