public PersonsController(
IUnitOfWork unitOfWork,
ILotRepository lotRepository,
IPersonRepository personRepository,
IApplicationRepository applicationRepository,
IApplicationStageRepository applicationStageRepository,
ICaseTypeRepository caseTypeRepository,
INomRepository nomRepository,
IFileRepository fileRepository,
IPersonDocumentRepository personDocumentRepository,
ILotEventDispatcher lotEventDispatcher,
UserContext userContext)
{
this.unitOfWork = unitOfWork;
this.lotRepository = lotRepository;
this.personRepository = personRepository;
this.applicationRepository = applicationRepository;
this.applicationStageRepository = applicationStageRepository;
this.caseTypeRepository = caseTypeRepository;
this.nomRepository = nomRepository;
this.fileRepository = fileRepository;
this.personDocumentRepository = personDocumentRepository;
this.lotEventDispatcher = lotEventDispatcher;
this.userContext = userContext;
}
public ApplicationsController(
IUnitOfWork unitOfWork,
ILotRepository lotRepository,
IPersonRepository personRepository,
IOrganizationRepository organizationRepository,
IAircraftRepository aircraftRepository,
IAirportRepository airportRepository,
IEquipmentRepository equipmentRepository,
IDocRepository docRepository,
IApplicationRepository applicationRepository,
INomRepository nomRepository,
IFileRepository fileRepository,
IExaminationSystemRepository examinationSystemRepository,
ILotEventDispatcher lotEventDispatcher,
UserContext userContext)
{
this.unitOfWork = unitOfWork;
this.lotRepository = lotRepository;
this.personRepository = personRepository;
this.organizationRepository = organizationRepository;
this.aircraftRepository = aircraftRepository;
this.airportRepository = airportRepository;
this.equipmentRepository = equipmentRepository;
this.docRepository = docRepository;
this.applicationRepository = applicationRepository;
this.nomRepository = nomRepository;
this.examinationSystemRepository = examinationSystemRepository;
this.fileRepository = fileRepository;
this.lotEventDispatcher = lotEventDispatcher;
this.userContext = userContext;
}
public AircraftsController(
IUnitOfWork unitOfWork,
ILotRepository lotRepository,
IInventoryRepository inventoryRepository,
IAircraftRepository aircraftRepository,
IAircraftRegistrationRepository aircraftRegistrationRepository,
IAircraftRegMarkRepository aircraftRegMarkRepository,
ISModeCodeRepository sModeCodeRepository,
IFileRepository fileRepository,
IApplicationRepository applicationRepository,
ICaseTypeRepository caseTypeRepository,
ILotEventDispatcher lotEventDispatcher,
UserContext userContext)
{
this.unitOfWork = unitOfWork;
this.lotRepository = lotRepository;
this.inventoryRepository = inventoryRepository;
this.aircraftRepository = aircraftRepository;
this.aircraftRegistrationRepository = aircraftRegistrationRepository;
this.aircraftRegMarkRepository = aircraftRegMarkRepository;
this.sModeCodeRepository = sModeCodeRepository;
this.fileRepository = fileRepository;
this.applicationRepository = applicationRepository;
this.caseTypeRepository = caseTypeRepository;
this.lotEventDispatcher = lotEventDispatcher;
this.userContext = userContext;
}
public void NewCorrespondentSpec()
{
IUnitOfWork unitOfWork1 = null;
ICorrespondentRepository correspondentRepository1 = null;
UserContext userContext1 = null;
IUnitOfWork unitOfWork2 = null;
ICorrespondentRepository correspondentRepository2 = null;
UserContext userContext2 = null;
"A new correspondent setup".ContextFixture(() =>
{
var lf1 = container.BeginLifetimeScope();
unitOfWork1 = lf1.Resolve<IUnitOfWork>();
correspondentRepository1 = lf1.Resolve<ICorrespondentRepository>();
userContext1 = new UserContext(1);
var lf2 = container.BeginLifetimeScope();
unitOfWork2 = lf2.Resolve<IUnitOfWork>();
correspondentRepository2 = lf2.Resolve<ICorrespondentRepository>();
userContext2 = new UserContext(1);
return DisposableTuple.Create(lf1, lf2);
});
"can be created as bg citizen".Assert(() =>
{
var corr1 = correspondentRepository1.CreateBgCitizen(2, 1, true, "Иван", "Иванов", "1212120909", userContext1);
unitOfWork1.Save();
var corr2 = correspondentRepository2.GetCorrespondent(corr1.CorrespondentId);
Assert.NotNull(corr2);
});
"can be created as legal entity".Assert(() =>
{
var corr1 = correspondentRepository1.CreateLegalEntity(2, 3, true, "Фирма Х", "10203040503", userContext1);
unitOfWork1.Save();
var corr2 = correspondentRepository2.GetCorrespondent(corr1.CorrespondentId);
Assert.NotNull(corr2);
});
"can be created as foreigner".Assert(() =>
{
var corr1 = correspondentRepository1.CreateForeigner(2, 2, true, "John", "Doe", null, "Downtown", DateTime.Now, userContext1);
unitOfWork1.Save();
var corr2 = correspondentRepository2.GetCorrespondent(corr1.CorrespondentId);
Assert.NotNull(corr2);
});
"can be created as foreign legal entity".Assert(() =>
{
var corr1 = correspondentRepository1.CreateFLegalEntity(2, 4, true, "Company X", null, "Ltd.", "001", "Other data", userContext1);
unitOfWork1.Save();
var corr2 = correspondentRepository2.GetCorrespondent(corr1.CorrespondentId);
Assert.NotNull(corr2);
});
}
protected override void Initialize(System.Web.Http.Controllers.HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
try
{
this.userContext = this.Request.GetUserContext();
}
catch { }
}
public ExaminationSystemController(
IUnitOfWork unitOfWork,
ILotRepository lotRepository,
IExaminationSystemRepository examinationSystemRepository,
UserContext userContext)
{
this.unitOfWork = unitOfWork;
this.lotRepository = lotRepository;
this.examinationSystemRepository = examinationSystemRepository;
this.userContext = userContext;
}
public SModeCodesController(
IUnitOfWork unitOfWork,
ILotRepository lotRepository,
INomRepository nomRepository,
ISModeCodeRepository sModeCodeRepository,
ICaseTypeRepository caseTypeRepository,
ILotEventDispatcher lotEventDispatcher,
UserContext userContext)
{
this.unitOfWork = unitOfWork;
this.lotRepository = lotRepository;
this.nomRepository = nomRepository;
this.sModeCodeRepository = sModeCodeRepository;
this.caseTypeRepository = caseTypeRepository;
this.lotEventDispatcher = lotEventDispatcher;
this.userContext = userContext;
}
public AplicationsCaseController(
IUnitOfWork unitOfWork,
ILotRepository lotRepository,
IDocRepository docRepository,
IApplicationRepository applicationRepository,
IFileRepository fileRepository,
ICaseTypeRepository caseTypeRepository,
ILotEventDispatcher lotEventDispatcher,
UserContext userContext)
{
this.unitOfWork = unitOfWork;
this.lotRepository = lotRepository;
this.docRepository = docRepository;
this.applicationRepository = applicationRepository;
this.lotEventDispatcher = lotEventDispatcher;
this.fileRepository = fileRepository;
this.caseTypeRepository = caseTypeRepository;
this.userContext = userContext;
}
public EquipmentsController(
IUnitOfWork unitOfWork,
ILotRepository lotRepository,
IInventoryRepository inventoryRepository,
IEquipmentRepository equipmentRepository,
IApplicationRepository applicationRepository,
ICaseTypeRepository caseTypeRepository,
ILotEventDispatcher lotEventDispatcher,
UserContext userContext)
{
this.unitOfWork = unitOfWork;
this.lotRepository = lotRepository;
this.inventoryRepository = inventoryRepository;
this.equipmentRepository = equipmentRepository;
this.applicationRepository = applicationRepository;
this.caseTypeRepository = caseTypeRepository;
this.lotEventDispatcher = lotEventDispatcher;
this.userContext = userContext;
}
public OrganizationsController(
IUnitOfWork unitOfWork,
ILotRepository lotRepository,
IInventoryRepository inventoryRepository,
IOrganizationRepository organizationRepository,
IApplicationRepository applicationRepository,
ICaseTypeRepository caseTypeRepository,
INomRepository nomRepository,
ILotEventDispatcher lotEventDispatcher,
UserContext userContext)
{
this.unitOfWork = unitOfWork;
this.lotRepository = lotRepository;
this.inventoryRepository = inventoryRepository;
this.organizationRepository = organizationRepository;
this.applicationRepository = applicationRepository;
this.caseTypeRepository = caseTypeRepository;
this.nomRepository = nomRepository;
this.lotEventDispatcher = lotEventDispatcher;
this.userContext = userContext;
}
public IHttpActionResult GetDocsForChange(
int id,
int limit = 10,
int offset = 0,
DateTime? fromDate = null,
DateTime? toDate = null,
string regUri = null,
string docName = null,
int? docTypeId = null,
int? docStatusId = null,
string corrs = null,
string units = null
)
{
this.userContext = this.Request.GetUserContext();
UnitUser unitUser = this.unitOfWork.DbContext.Set<UnitUser>().FirstOrDefault(e => e.UserId == this.userContext.UserId);
ClassificationPermission readPermission = this.unitOfWork.DbContext.Set<ClassificationPermission>().SingleOrDefault(e => e.Alias == "Read");
int totalCount = 0;
List<Doc> docs = new List<Doc>();
List<int> docRelations = this.docRepository.fnGetSubordinateDocs(id);
docs = this.docRepository.GetDocsForChange(
fromDate,
toDate,
regUri,
docName,
docTypeId,
docStatusId,
corrs,
units,
docRelations,
limit,
offset,
readPermission,
unitUser,
out totalCount);
List<DocListItemDO> returnValue = docs.Select(e => new DocListItemDO(e, unitUser)).ToList();
StringBuilder sb = new StringBuilder();
if (totalCount >= 10000)
{
sb.Append("Има повече от 10000 резултата, моля, въведете допълнителни филтри.");
}
return Ok(new
{
documents = returnValue,
documentCount = totalCount,
msg = sb.ToString()
});
}
public IHttpActionResult GetDocs(
int limit = 10,
int offset = 0,
string filter = null,
DateTime? fromDate = null,
DateTime? toDate = null,
string regUri = null,
string docName = null,
int? docTypeId = null,
int? docStatusId = null,
bool? hideRead = null,
bool? isCase = null,
string corrs = null,
string units = null,
string ds = null
)
{
this.userContext = this.Request.GetUserContext();
UnitUser unitUser = this.unitOfWork.DbContext.Set<UnitUser>().FirstOrDefault(e => e.UserId == this.userContext.UserId);
ClassificationPermission readPermission = this.unitOfWork.DbContext.Set<ClassificationPermission>().SingleOrDefault(e => e.Alias == "Read");
DocSourceType docSourceType = this.unitOfWork.DbContext.Set<DocSourceType>().SingleOrDefault(e => e.Alias == "Internet");
DocCasePartType docCasePartType = this.unitOfWork.DbContext.Set<DocCasePartType>().SingleOrDefault(e => e.Alias == "Control");
List<DocStatus> docStatuses = this.unitOfWork.DbContext.Set<DocStatus>().Where(e => e.IsActive).ToList();
List<DocUnitRole> docUnitRoles = this.unitOfWork.DbContext.Set<DocUnitRole>()
.Where(e => e.Alias.ToLower() == "incharge" || e.Alias.ToLower() == "controlling" || e.Alias.ToLower() == "to")
.ToList();
int totalCount = 0;
DocView docView = DocView.Normal;
List<Doc> docs = new List<Doc>();
switch (filter)
{
case null:
case "current":
//текущи преписки
docs = this.docRepository.GetCurrentCaseDocs(
fromDate,
toDate,
regUri,
docName,
docTypeId,
docStatusId,
hideRead,
isCase,
corrs,
units,
ds,
limit,
offset,
docCasePartType,
docStatuses,
readPermission,
unitUser,
out totalCount);
break;
case "finished":
//приключени преписки
docs = this.docRepository.GetFinishedCaseDocs(
fromDate,
toDate,
regUri,
docName,
docTypeId,
docStatusId,
hideRead,
isCase,
corrs,
units,
ds,
limit,
offset,
docCasePartType,
docStatuses,
readPermission,
unitUser,
out totalCount);
break;
case "manage":
//за управление
docs = this.docRepository.GetDocsForManagement(
fromDate,
toDate,
regUri,
docName,
docTypeId,
docStatusId,
hideRead,
isCase,
corrs,
units,
ds,
limit,
offset,
docCasePartType,
docStatuses,
readPermission,
unitUser,
out totalCount);
docView = DocView.ForManagement;
break;
case "control":
//за контрол и изпълнение
docs = this.docRepository.GetDocsForControl(
fromDate,
toDate,
regUri,
docName,
docTypeId,
docStatusId,
hideRead,
isCase,
corrs,
units,
ds,
limit,
offset,
docCasePartType,
docStatuses,
readPermission,
docUnitRoles,
unitUser,
out totalCount);
docView = DocView.ForControl;
break;
case "draft":
//чернови
docs = this.docRepository.GetDraftDocs(
fromDate,
toDate,
regUri,
docName,
docTypeId,
docStatusId,
hideRead,
isCase,
corrs,
units,
ds,
limit,
offset,
docCasePartType,
docStatuses,
readPermission,
unitUser,
out totalCount);
break;
case "unfinished":
//неприключени
docs = this.docRepository.GetUnfinishedDocs(
fromDate,
toDate,
regUri,
docName,
docTypeId,
docStatusId,
hideRead,
isCase,
corrs,
units,
ds,
limit,
offset,
docCasePartType,
docStatuses,
readPermission,
unitUser,
out totalCount);
break;
case "portal":
//от портал
docs = this.docRepository.GetPortalDocs(
fromDate,
toDate,
regUri,
docName,
docTypeId,
docStatusId,
hideRead,
isCase,
corrs,
units,
ds,
limit,
offset,
docCasePartType,
docStatuses,
readPermission,
docSourceType,
unitUser,
out totalCount);
break;
case "new":
//нова поща
throw new NotImplementedException();
case "allControl":
//всички контролни
docs = this.docRepository.GetControlDocs(
fromDate,
toDate,
regUri,
docName,
docTypeId,
docStatusId,
hideRead,
isCase,
corrs,
units,
ds,
limit,
offset,
docCasePartType,
readPermission,
unitUser,
out totalCount);
break;
case "all":
default:
//всички
docs = this.docRepository.GetDocs(
fromDate,
toDate,
regUri,
docName,
docTypeId,
docStatusId,
hideRead,
isCase,
corrs,
units,
ds,
limit,
offset,
docCasePartType,
readPermission,
unitUser,
out totalCount);
break;
};
List<int> loadedDocIds = docs.Select(e => e.DocId).ToList();
var docHasReads = this.unitOfWork.DbContext.Set<DocHasRead>()
.Where(e => e.UnitId == unitUser.UnitId && loadedDocIds.Contains(e.DocId)).ToList();
List<DocListItemDO> returnValue = docs.Select(e => new DocListItemDO(e, unitUser)).ToList();
foreach (var item in returnValue)
{
List<DocRelation> resolutionDocRelations =
this.unitOfWork.DbContext.Set<DocRelation>()
.Include(e => e.Doc.DocDirection)
.Include(e => e.Doc.DocCasePartType)
.Include(e => e.Doc.DocType)
.Include(e => e.Doc.DocEntryType)
.Where(e => e.ParentDocId == item.DocId &&
(e.Doc.DocStatus.Alias == "Processed" || e.Doc.DocStatus.Alias == "Finished") &&
(e.Doc.DocEntryType.Alias == "Resolution" || e.Doc.DocEntryType.Alias == "Task"))
.ToList();
if (resolutionDocRelations.Any())
{
var resolutionDocIds = resolutionDocRelations.Select(r => r.DocId).ToArray();
this.unitOfWork.DbContext.Set<DocUnit>()
.Include(e => e.Unit.UnitRelations.Select(er => er.ParentUnit))
.Include(e => e.DocUnitRole)
.Where(e => resolutionDocIds.Contains(e.DocId))
.ToList();
item.ResolutionDocRelations.AddRange(resolutionDocRelations.Select(r => new DocRelationDO(r)));
}
if (docView == DocView.ForControl || docView == DocView.ForManagement)
{
int? rootId = this.unitOfWork.DbContext.Set<DocRelation>()
.FirstOrDefault(e => e.DocId == item.DocId)
.RootDocId;
if (rootId.HasValue)
{
DocRelation rootDocRelation = this.unitOfWork.DbContext.Set<DocRelation>()
.Include(e => e.Doc.DocDirection)
.Include(e => e.Doc.DocCasePartType)
.Include(e => e.Doc.DocType)
.Include(e => e.Doc.DocEntryType)
.FirstOrDefault(e => e.DocId == rootId.Value);
item.CaseDocRelation = new DocRelationDO(rootDocRelation);
var docCorrespondents = this.unitOfWork.DbContext.Set<DocCorrespondent>()
.Include(e => e.Correspondent.CorrespondentType)
.Where(e => e.DocId == rootId.Value)
.ToList();
item.DocCorrespondents.AddRange(docCorrespondents.Select(e => new DocCorrespondentDO(e)).ToList());
}
}
else
{
var docCorrespondents = this.unitOfWork.DbContext.Set<DocCorrespondent>()
.Include(e => e.Correspondent.CorrespondentType)
.Where(e => e.DocId == item.DocId)
.ToList();
item.DocCorrespondents.AddRange(docCorrespondents.Select(e => new DocCorrespondentDO(e)).ToList());
}
}
StringBuilder sb = new StringBuilder();
if (totalCount >= 10000)
{
sb.Append("Има повече от 10000 резултата, моля, въведете допълнителни филтри.");
}
List<int> docIds = Helper.GetIdListFromString(ds);
if (docIds.Any())
{
int min = docIds.Min(),
max = docIds.Max();
DocListItemDO minDoc = new DocListItemDO(this.docRepository.Find(min));
DocListItemDO maxDoc = new DocListItemDO(this.docRepository.Find(max));
if (minDoc != null && maxDoc != null)
{
sb.AppendFormat("Документите са регистрирани с номера от <strong>{0}</strong> до <strong>{1}</strong>", minDoc.RegUri, maxDoc.RegUri);
}
else
{
sb.Append("Проблем с регистрирането на документите");
}
}
return Ok(new
{
docView = docView.ToString(),
documents = returnValue,
documentCount = totalCount,
msg = sb.ToString()
});
}
private void ReloadStatePerPerson(
int lotId,
List<GvaExSystExaminee> allPersonExams,
Dictionary<string, GvaExSystQualification> allQualifications,
List<CaseDO> cases,
UserContext userContext)
{
Lot lot = this.lotRepository.GetLotIndex(lotId);
PartVersion<PersonExamSystDataDO> examSystDataPartVersion = lot.Index.GetPart<PersonExamSystDataDO>("personExamSystData");
var qualificationCodes = allPersonExams.Select(e => e.Exam.QualificationCode).Distinct();
List<GvaExSystQualification> allPersonQualifications = new List<GvaExSystQualification>();
foreach(var qualificationCode in qualificationCodes)
{
allPersonQualifications.Add(allQualifications[qualificationCode]);
}
List<PersonExamSystStateDO> newStates = new List<PersonExamSystStateDO>();
foreach (GvaExSystQualification qualification in allPersonQualifications)
{
var certPaths = qualification.CertPaths.GroupBy(p => p.Code);
foreach (var certPath in certPaths)
{
List<string> requiredExamCodes = certPath.Select(p => p.ExamCode).Distinct().ToList();
List<GvaExSystExaminee> availableExams = allPersonExams
.Where(e => requiredExamCodes.Contains(e.ExamCode))
.ToList();
PersonExamSystStateDO lastState = null;
if (examSystDataPartVersion != null)
{
lastState = examSystDataPartVersion.Content.States
.Where(s => s.QualificationCode == qualification.Code)
.OrderByDescending(s => s.FromDate)
.FirstOrDefault();
if (lastState != null)
{
if (lastState.State == "Finished" || lastState.State == "Canceled")
{
availableExams = availableExams
.Where(t => t.EndTime.Subtract(lastState.FromDate).TotalHours >= 24)
.ToList();
}
else
{
availableExams = availableExams
.Where(t => t.EndTime.Subtract(lastState.FromDate).TotalHours >= 0)
.ToList();
}
}
if (availableExams.Count() == 0)
{
continue;
}
var firstExam = availableExams.OrderBy(t => t.EndTime).First();
if (lastState != null && lastState.State == "Started")
{
var newStateFisrtExam = availableExams.Where(e => e.EndTime > lastState.ToDate.Value)
.OrderBy(e => e.EndTime)
.FirstOrDefault();
if (newStateFisrtExam != null)
{
newStates.Add(new PersonExamSystStateDO()
{
FromDate = newStateFisrtExam.EndTime,
ToDate = newStateFisrtExam.EndTime.AddMonths(18),
QualificationCode = qualification.Code,
QualificationName = qualification.Name,
StateMethod = QualificationStateMethod.Automatically.ToString(),
State = QualificationState.Started.ToString()
});
break;
}
var firstFailedExam = availableExams.OrderBy(t => t.EndTime).Where(e => e.ResultStatus == "failed").LastOrDefault();
if (availableExams.Where(t => t.CertCampCode != null).Select(t => t.CertCampCode).Distinct().Count() > 6)
{
newStates.Add(new PersonExamSystStateDO()
{
FromDate = firstFailedExam != null ? firstFailedExam.EndTime : lastState.FromDate,
ToDate = lastState.ToDate,
QualificationCode = qualification.Code,
QualificationName = qualification.Name,
Notes = "Достигнат е пределно допустим брой сесиии",
StateMethod = QualificationStateMethod.Automatically.ToString(),
State = QualificationState.Canceled.ToString()
});
break;
}
if (availableExams.GroupBy(c => c.ExamCode).Any(t => t.Count() >= 4 && t.All(c => c.ResultStatus == "failed")))
{
newStates.Add(new PersonExamSystStateDO()
{
FromDate = firstFailedExam != null ? firstFailedExam.EndTime : lastState.FromDate,
ToDate = lastState.ToDate,
QualificationCode = qualification.Code,
QualificationName = qualification.Name,
Notes = "Достигнат е пределно допустим брой на невзети изпити за тест",
StateMethod = QualificationStateMethod.Automatically.ToString(),
State = QualificationState.Canceled.ToString()
});
break;
}
}
}
if (availableExams.Count() == 0)
{
continue;
}
bool allExamsArePassed = true;
foreach (string requiredExamCode in requiredExamCodes)
{
if (availableExams.Where(t => t.ResultStatus == "passed" && t.ExamCode == requiredExamCode).Count() == 0)
{
allExamsArePassed = false;
break;
}
}
if (allExamsArePassed)
{
newStates.Add(new PersonExamSystStateDO()
{
FromDate = availableExams.OrderBy(t => t.EndTime).Last().EndTime,
QualificationCode = qualification.Code,
QualificationName = qualification.Name,
StateMethod = QualificationStateMethod.Automatically.ToString(),
State = QualificationState.Finished.ToString()
});
break;
}
if (availableExams.Count() > 0 && (lastState == null || lastState.State != "Started"))
{
var exam = availableExams.OrderBy(t => t.EndTime).First();
newStates.Add(new PersonExamSystStateDO()
{
FromDate = exam.EndTime,
ToDate = exam.EndTime.AddMonths(18),
QualificationCode = qualification.Code,
QualificationName = qualification.Name,
StateMethod = QualificationStateMethod.Automatically.ToString(),
State = QualificationState.Started.ToString()
});
break;
}
}
}
if (newStates.Count() > 0)
{
if (examSystDataPartVersion == null)
{
examSystDataPartVersion = lot.CreatePart("personExamSystData", new PersonExamSystDataDO() { States = newStates}, userContext);
this.fileRepository.AddFileReferences(examSystDataPartVersion.Part, cases);
}
else
{
examSystDataPartVersion.Content.States.AddRange(newStates);
lot.UpdatePart("personExamSystData", examSystDataPartVersion.Content, userContext);
}
lot.Commit(userContext, lotEventDispatcher);
this.unitOfWork.Save();
this.lotRepository.ExecSpSetLotPartTokens(examSystDataPartVersion.PartId);
}
}
public void ReloadStates(UserContext userContext)
{
var allPersonsWithQualificationsToReload =
this.unitOfWork.DbContext.Set<GvaExSystExaminee>()
.Include(e => e.Exam)
.ToList()
.GroupBy(q => q.LotId);
Dictionary<string, GvaExSystQualification> allQualifications = this.unitOfWork.DbContext.Set<GvaExSystQualification>()
.Include(c => c.CertPaths)
.ToDictionary(q => q.Code, q => q);
var cases = this.caseTypeRepository.GetCaseTypesForSet("person")
.Select(ct => new CaseDO()
{
CaseType = new NomValue()
{
NomValueId = ct.GvaCaseTypeId,
Name = ct.Name,
Alias = ct.Alias
},
IsAdded = true
})
.ToList();
foreach (var person in allPersonsWithQualificationsToReload)
{
this.ReloadStatePerPerson(person.Key, person.ToList(), allQualifications, cases, userContext);
}
}
public void SavedCorrespondentSpec()
{
int crCorrespondentId = 0;
int crCorrespondentIdWithContacts = 0;
IUnitOfWork unitOfWork1 = null;
ICorrespondentRepository correspondentRepository1 = null;
UserContext userContext1 = null;
IUnitOfWork unitOfWork2 = null;
ICorrespondentRepository correspondentRepository2 = null;
UserContext userContext2 = null;
"An existing correspondent and nomenclatures".ContextFixture(() =>
{
using (var lf = container.BeginLifetimeScope())
{
var unitOfWork = lf.Resolve<IUnitOfWork>();
var correspondentRepository = lf.Resolve<ICorrespondentRepository>();
var userContext = new UserContext(1);
var corr1 = correspondentRepository.CreateLegalEntity(2, 3, true, "Фирма Х", "102030405", userContext);
var corr2 = correspondentRepository.CreateLegalEntity(2, 3, true, "Фирма Y", "201058583", userContext);
corr2.CreateCorrespondentContact("Vasil Petrov", "0110130441", "", true, userContext);
unitOfWork.Save();
crCorrespondentId = corr1.CorrespondentId;
crCorrespondentIdWithContacts = corr2.CorrespondentId;
}
var lf1 = container.BeginLifetimeScope();
unitOfWork1 = lf1.Resolve<IUnitOfWork>();
correspondentRepository1 = lf1.Resolve<ICorrespondentRepository>();
userContext1 = new UserContext(1);
var lf2 = container.BeginLifetimeScope();
unitOfWork2 = lf2.Resolve<IUnitOfWork>();
correspondentRepository2 = lf2.Resolve<ICorrespondentRepository>();
userContext2 = new UserContext(1);
return DisposableTuple.Create(lf1, lf2);
});
"can be found and edited".Assert(() =>
{
var correspondents = correspondentRepository1.GetCorrespondents(null, null, 10, 0);
Assert.NotEmpty(correspondents);
var corr1 = correspondentRepository1.GetCorrespondent(crCorrespondentId);
Assert.NotNull(corr1);
corr1.LegalEntityBulstat = "102034343";
unitOfWork1.Save();
var corr2 = correspondentRepository2.GetCorrespondent(corr1.CorrespondentId);
Assert.Equal("102034343", corr2.LegalEntityBulstat);
});
"can be added correspondent contact".Assert(() =>
{
var corr1 = correspondentRepository1.GetCorrespondent(crCorrespondentId);
corr1.CreateCorrespondentContact("Petar Petrov", "0110130441", "", true, userContext1);
unitOfWork1.Save();
var corr2 = correspondentRepository2.GetCorrespondent(crCorrespondentId);
Assert.NotEmpty(corr2.CorrespondentContacts);
});
"can be removed correspondent contact".Assert(() =>
{
var corr1 = correspondentRepository1.GetCorrespondent(crCorrespondentIdWithContacts);
Assert.NotEmpty(corr1.CorrespondentContacts);
corr1.DeleteCorrespondentContact(corr1.CorrespondentContacts.First(), userContext1);
unitOfWork1.Save();
var corr2 = correspondentRepository2.GetCorrespondent(crCorrespondentIdWithContacts);
Assert.Empty(corr2.CorrespondentContacts);
});
"cannot be modified concurrently".Assert(() =>
{
var corr1 = correspondentRepository1.GetCorrespondent(crCorrespondentId);
corr1.LegalEntityBulstat = "102034343";
var corr2 = correspondentRepository2.GetCorrespondent(crCorrespondentId);
corr2.CreateCorrespondentContact("Petar Petrov", "0110130441", "", true, userContext2);
unitOfWork2.Save();
Assert.Throws<DbUpdateConcurrencyException>(() => unitOfWork1.Save());
});
"can be deleted".Assert(() =>
{
var corr1 = correspondentRepository1.GetCorrespondent(crCorrespondentId);
correspondentRepository1.DeteleCorrespondent(crCorrespondentId, corr1.Version);
unitOfWork1.Save();
var corr2 = correspondentRepository2.GetCorrespondent(crCorrespondentId);
Assert.Null(corr2);
});
}
public void Process(int pendingIncomingDocId)
{
try
{
using (var transaction = this.unitOfWork.BeginTransaction())
{
//Init user variables
User systemUser = this.unitOfWork.DbContext.Set<User>().Single(e => e.Username == "system");
UnitUser systemUnitUser = this.unitOfWork.DbContext.Set<UnitUser>().Include(e => e.Unit).Single(e => e.UserId == systemUser.UserId);
UserContext systemUserContext = new UserContext(systemUser.UserId);
IncomingDoc incomingDoc = this.unitOfWork.DbContext.Set<IncomingDoc>()
.Include(e => e.IncomingDocFiles)
.Where(e => e.IncomingDocId == pendingIncomingDocId)
.Single();
IncomingDocFile incomingDocFile = incomingDoc.IncomingDocFiles.First();
string xmlContent = incomingDocFile.DocFileContent;
object rioApplication = rioDocumentParser.XmlDeserializeApplication(xmlContent);
ApplicationDataDo applicationDataDo = rioObjectExtractor.Extract<ApplicationDataDo>(rioApplication);
IList<AttachedDocDo> attachedDocuments = rioObjectExtractor.Extract<IList<AttachedDocDo>>(rioApplication);
MarkAttachedFilesAsUsed(attachedDocuments);
List<ElectronicDocumentDiscrepancyTypeNomenclature> discrepancies = GetValidationDiscrepancies(xmlContent, applicationDataDo, attachedDocuments);
bool isDocAcknowledged = discrepancies.Count == 0;
incomingDoc.IncomingDocStatusId = this.unitOfWork.DbContext.Set<IncomingDocStatus>()
.Where(e => e.Alias == (isDocAcknowledged ? "Registered" : "NotRegistered"))
.Single()
.IncomingDocStatusId;
List<Correspondent> docCorrespondents = this.GetDocumentCorrespondents(applicationDataDo.ElectronicServiceApplicant, applicationDataDo.ElectronicServiceApplicantContactData);
foreach (var correspondent in docCorrespondents.Where(c => c.CorrespondentId == 0))
{
this.unitOfWork.DbContext.Set<Correspondent>().Add(correspondent);
this.unitOfWork.Save();
}
//TODO: Implement
//var validationErrors = rioValidator.ValidateRioApplication(null, xmlContent)
List<string> validationErrors = new List<string>();
Doc rootDoc = null;
if (applicationDataDo.DocumentURI != null)
{
string regIndex = applicationDataDo.DocumentURI.RegisterIndex.PadLeft(4, '0');
int regNumber = int.Parse(applicationDataDo.DocumentURI.SequenceNumber);
DateTime regdDate = applicationDataDo.DocumentURI.ReceiptOrSigningDate.Value;
rootDoc = this.docRepository.GetDocByRegUri(regIndex, regNumber, regdDate);
}
string electronicServiceFileTypeUri = String.Format("{0}-{1}", applicationDataDo.DocumentTypeURI.RegisterIndex, applicationDataDo.DocumentTypeURI.BatchNumber);
int docTypeId = this.unitOfWork.DbContext.Set<DocType>().Single(e => e.ElectronicServiceFileTypeUri == electronicServiceFileTypeUri).DocTypeId;
//Initial Doc
Doc initialDoc = CreateInitialDoc(isDocAcknowledged, validationErrors, docTypeId, rootDoc == null, systemUser);
this.unitOfWork.DbContext.Set<Doc>().Add(initialDoc);
foreach (var correspondent in docCorrespondents)
{
DocCorrespondent docCorrespondent = new DocCorrespondent();
docCorrespondent.Doc = initialDoc;
docCorrespondent.Correspondent = correspondent;
this.unitOfWork.DbContext.Set<DocCorrespondent>().Add(docCorrespondent);
}
DocIncomingDoc initialDocIncomingDoc = new DocIncomingDoc();
initialDocIncomingDoc.Doc = initialDoc;
initialDocIncomingDoc.IncomingDoc = incomingDoc;
initialDocIncomingDoc.IsDocInitial = true;
initialDocIncomingDoc.CreateDate = DateTime.Now;
this.unitOfWork.DbContext.Set<DocIncomingDoc>().Add(initialDocIncomingDoc);
this.unitOfWork.Save();
DocRelation initialDocRelation = CreateInitialDocRelation(initialDoc, rootDoc);
this.unitOfWork.DbContext.Set<DocRelation>().Add(initialDocRelation);
this.unitOfWork.Save();
this.docRepository.RegisterDoc(initialDoc, systemUnitUser, systemUserContext);
AddDocUnit(initialDoc, systemUnitUser.Unit, systemUser);
var parentDocClassifications = AddDocClassification(initialDoc, systemUser);
this.unitOfWork.Save();
this.docRepository.ExecSpSetDocTokens(docId: initialDoc.DocId);
this.docRepository.ExecSpSetDocUnitTokens(docId: initialDoc.DocId);
initialDoc.SetReceiptOrder(this.docRepository.GetNextReceiptOrder(initialDoc.DocId), systemUserContext);
Guid fileKey = WriteToBlob(Utf8Utils.GetBytes(incomingDocFile.DocFileContent));
DocFileKind publicDocFileKind = this.unitOfWork.DbContext.Set<DocFileKind>().Single(e => e.Alias == "PublicAttachedFile");
var docFileType = this.unitOfWork.DbContext.Set<DocFileType>().SingleOrDefault(e => e.Alias == applicationDataDo.DocFileTypeAlias);
DocFile initialDocFile = CreateInitialDocFile(initialDoc, fileKey, docFileType.DocFileTypeId, publicDocFileKind.DocFileKindId, applicationDataDo.ApplicationSigningTime);
this.unitOfWork.DbContext.Set<DocFile>().Add(initialDocFile);
//Add attached application files as DocFiles
if (attachedDocuments != null && attachedDocuments.Count > 0)
{
foreach (var attachedAppFile in attachedDocuments)
{
byte[] fileContent = null;
if (attachedAppFile.UseAbbcdn)
{
fileContent = AbbcdnStorage.DownloadFile(Guid.Parse(attachedAppFile.UniqueIdentifier)).ContentBytes;
}
else
{
fileContent = attachedAppFile.BytesContent;
}
Guid key = WriteToBlob(fileContent);
DocFile attachedAppDocFile = CreateEApplicationAttachDocFile(attachedAppFile, initialDoc, publicDocFileKind.DocFileKindId, key);
this.unitOfWork.DbContext.Set<DocFile>().Add(attachedAppDocFile);
}
}
this.unitOfWork.Save();
//ReceiptDoc
Doc receiptDoc = CreateReceiptDoc(isDocAcknowledged, systemUser);
this.unitOfWork.DbContext.Set<Doc>().Add(receiptDoc);
DocIncomingDoc receiptDocIncomingDoc = new DocIncomingDoc();
receiptDocIncomingDoc.Doc = receiptDoc;
receiptDocIncomingDoc.IncomingDoc = incomingDoc;
receiptDocIncomingDoc.IsDocInitial = false;
receiptDocIncomingDoc.CreateDate = DateTime.Now;
this.unitOfWork.DbContext.Set<DocIncomingDoc>().Add(receiptDocIncomingDoc);
this.unitOfWork.Save();
DocRelation receiptDocRelation = CreateReceiptDocRelation(initialDoc, receiptDoc, rootDoc);
this.unitOfWork.DbContext.Set<DocRelation>().Add(receiptDocRelation);
this.unitOfWork.Save();
this.docRepository.RegisterDoc(receiptDoc, systemUnitUser, systemUserContext);
AddDocUnit(receiptDoc, systemUnitUser.Unit, systemUser);
AddDocClassification(receiptDoc, systemUser);
foreach (var item in parentDocClassifications.Where(i => i.IsInherited))
{
receiptDoc.CreateDocClassification(item.ClassificationId, item.IsInherited, systemUserContext);
}
this.unitOfWork.Save();
this.docRepository.ExecSpSetDocTokens(docId: receiptDoc.DocId);
this.docRepository.ExecSpSetDocUnitTokens(docId: receiptDoc.DocId);
receiptDoc.SetReceiptOrder(this.docRepository.GetNextReceiptOrder(receiptDoc.DocId), systemUserContext);
Guid receiptFileKey = CreateReceiptDocFileContent(initialDoc, receiptDoc, rootDoc, discrepancies, applicationDataDo);
DocFile receiptDocFile = CreateReceiptDocFile(publicDocFileKind.DocFileKindId, receiptDoc, receiptFileKey, isDocAcknowledged);
this.unitOfWork.DbContext.Set<DocFile>().Add(receiptDocFile);
// TODO
//if (applicationDataDo.SendConfirmationEmail)
//{
AddReceiveConfirmationEmailRecord(isDocAcknowledged, systemUser, docCorrespondents, rootDoc ?? initialDoc, discrepancies);
//}
this.unitOfWork.Save();
AddBeginningServiceStage(docTypeId, initialDoc);
AddCheckRegularityServiceStage(docTypeId, initialDoc);
this.unitOfWork.Save();
transaction.Commit();
}
}
catch (Exception ex)
{
logger.Error("IncommingDocProcessor Exception: " + Helper.GetDetailedExceptionInfo(ex));
using (var factory = unitOfWorkFactory())
{
this.unitOfWork = factory.Value;
var incomingDoc = this.unitOfWork.DbContext.Set<IncomingDoc>().SingleOrDefault(e => e.IncomingDocId == pendingIncomingDocId);
incomingDoc.IncomingDocStatusId = this.unitOfWork.DbContext.Set<IncomingDocStatus>().Single(e => e.Alias == "Incorrect").IncomingDocStatusId;
this.unitOfWork.Save();
}
}
}
public LotRepository(IUnitOfWork unitOfWork, UserContext userContext)
{
this.unitOfWork = unitOfWork;
this.userContext = userContext;
}
public IHttpActionResult GetDocsForSelect(
int limit = 10,
int offset = 0,
string filter = null,
DateTime? fromDate = null,
DateTime? toDate = null,
string regUri = null,
string docName = null,
int? docTypeId = null,
int? docStatusId = null,
bool? hideRead = null,
string corrs = null,
string units = null,
string ds = null,
int? isChosen = null
)
{
this.userContext = this.Request.GetUserContext();
UnitUser unitUser = this.unitOfWork.DbContext.Set<UnitUser>().FirstOrDefault(e => e.UserId == this.userContext.UserId);
ClassificationPermission readPermission = this.unitOfWork.DbContext.Set<ClassificationPermission>().SingleOrDefault(e => e.Alias == "Read");
DocSourceType docSourceType = this.unitOfWork.DbContext.Set<DocSourceType>().SingleOrDefault(e => e.Alias == "Internet");
DocCasePartType docCasePartType = this.unitOfWork.DbContext.Set<DocCasePartType>().SingleOrDefault(e => e.Alias == "Control");
List<DocStatus> docStatuses = this.unitOfWork.DbContext.Set<DocStatus>().Where(e => e.IsActive).ToList();
List<DocUnitRole> docUnitRoles = this.unitOfWork.DbContext.Set<DocUnitRole>()
.Where(e => e.Alias.ToLower() == "incharge" || e.Alias.ToLower() == "controlling" || e.Alias.ToLower() == "to")
.ToList();
int totalCount = 0;
List<Doc> docs = new List<Doc>();
//? if possible implement to search for docs that are not connected to lots
//if (isChosen == 1) //true
//{
// List<AopApp> allAopApps = this.unitOfWork.DbContext.Set<AopApp>().ToList();
// List<int> aopAppDocIds =
// allAopApps.Where(e => e.STDocId.HasValue).Select(e => e.STDocId.Value)
// .Union(allAopApps.Where(e => e.STChecklistId.HasValue).Select(e => e.STChecklistId.Value))
// .Union(allAopApps.Where(e => e.STNoteId.HasValue).Select(e => e.STNoteId.Value))
// .Union(allAopApps.Where(e => e.NDDocId.HasValue).Select(e => e.NDDocId.Value))
// .Union(allAopApps.Where(e => e.NDChecklistId.HasValue).Select(e => e.NDChecklistId.Value))
// .Union(allAopApps.Where(e => e.NDReportId.HasValue).Select(e => e.NDReportId.Value))
// .ToList();
// for (int i = 0; i < returnValue.Count; i++)
// {
// if (returnValue[i].DocId.HasValue &&
// aopAppDocIds.Contains(returnValue[i].DocId.Value))
// {
// returnValue.RemoveAt(i);
// }
// }
//}
docs = this.docRepository.GetDocs(
fromDate,
toDate,
regUri,
docName,
docTypeId,
docStatusId,
hideRead,
null,
corrs,
units,
ds,
limit,
offset,
docCasePartType,
readPermission,
unitUser,
out totalCount);
List<int> loadedDocIds = docs.Select(e => e.DocId).ToList();
var docHasReads = this.unitOfWork.DbContext.Set<DocHasRead>()
.Where(e => e.UnitId == unitUser.UnitId && loadedDocIds.Contains(e.DocId)).ToList();
List<DocListItemDO> returnValue = docs.Select(e => new DocListItemDO(e, unitUser)).ToList();
foreach (var item in returnValue)
{
var docCorrespondents = this.unitOfWork.DbContext.Set<DocCorrespondent>()
.Include(e => e.Correspondent.CorrespondentType)
.Where(e => e.DocId == item.DocId)
.ToList();
item.DocCorrespondents.AddRange(docCorrespondents.Select(e => new DocCorrespondentDO(e)).ToList());
}
StringBuilder sb = new StringBuilder();
if (totalCount >= 10000)
{
sb.Append("Има повече от 10000 резултата, моля, въведете допълнителни филтри.");
}
return Ok(new
{
documents = returnValue,
documentCount = totalCount,
msg = sb.ToString()
});
}
public void MigrateLicenceDocuments(
ConcurrentQueue<int> personIds,
Dictionary<int, int> personIdToLotId,
Dictionary<int, IEnumerable<JObject>> personsLicences,
CookieCollection cookies,
//cancellation
CancellationTokenSource cts,
CancellationToken ct)
{
try
{
this.oracleConn.Open();
}
catch (Exception)
{
cts.Cancel();
throw;
}
ct.ThrowIfCancellationRequested();
using (var dependencies = this.dependencyFactory())
{
this.unitOfWork = dependencies.Value.Item1;
this.lotRepository = dependencies.Value.Item2;
var printRepository = dependencies.Value.Item3;
this.lotEventDispatcher = dependencies.Value.Item4;
this.userContext = dependencies.Value.Item5;
string connectionString = ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString;
int personId = -1;
try
{
while (personIds.TryDequeue(out personId))
{
if (personIdToLotId.ContainsKey(personId))
{
var lot = lotRepository.GetLotIndex(personIdToLotId[personId], fullAccess: true);
JObject licence = null;
ConcurrentQueue<JObject> personLicences = new ConcurrentQueue<JObject>(personsLicences[personId]);
while (personLicences.TryDequeue(out licence))
{
string queryString = licence.Get<string>("query_string");
int oldId = licence.Get<int>("old_id");
int editionPartIndex = lot.Index.GetParts<dynamic>("licenceEditions")
.Where(e => e.Content.__oldId == oldId)
.Single().Part.Index;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(queryString);
request.CookieContainer = new CookieContainer();
request.CookieContainer.Add(cookies);
using (HttpWebResponse httpResponse = (HttpWebResponse)request.GetResponse())
using (var responseStream = httpResponse.GetResponseStream())
using (var stream = printRepository.ConvertWordStreamToPdfStream(responseStream))
{
var licenceEditionDocBlobKey = printRepository.SaveStreamToBlob(stream, connectionString);
this.UpdateLicenceEdition(licenceEditionDocBlobKey, editionPartIndex, lot);
}
}
Console.WriteLine("Migrated printed licences of personId: {0}", personId);
}
}
}
catch (Exception)
{
Console.WriteLine("Error in migration of printed licences of personId: {0}", personId);
cts.Cancel();
throw;
}
}
}
public IntegrationController(
IDocRepository docRepository,
IUnitOfWork unitOfWork,
ILotRepository lotRepository,
IPersonRepository personRepository,
IApplicationRepository applicationRepository,
ICaseTypeRepository caseTypeRepository,
IIntegrationRepository integrationRepository,
INomRepository nomRepository,
ICorrespondentRepository correspondentRepository,
IRioDocumentParser rioDocumentParser,
UserContext userContext)
{
this.docRepository = docRepository;
this.unitOfWork = unitOfWork;
this.lotRepository = lotRepository;
this.personRepository = personRepository;
this.applicationRepository = applicationRepository;
this.integrationRepository = integrationRepository;
this.caseTypeRepository = caseTypeRepository;
this.nomRepository = nomRepository;
this.correspondentRepository = correspondentRepository;
this.rioDocumentParser = rioDocumentParser;
this.userContext = userContext;
}
public void UpdateLotCaseTypes(string set, GvaCaseType caseType, Lot lot, UserContext userContext)
{
Part updatedPart = null;
if (set == "Person")
{
PersonDataDO personData = lot.Index.GetPart<PersonDataDO>("personData").Content;
personData.CaseTypes.Add(caseType.GvaCaseTypeId);
this.caseTypeRepository.AddCaseTypes(lot, personData.CaseTypes);
updatedPart = lot.UpdatePart("personData", personData, userContext).Part;
}
else if (set == "Organization")
{
NomValue caseTypeNom = new NomValue()
{
NomValueId = caseType.GvaCaseTypeId,
Name = caseType.Name,
Alias = caseType.Alias
};
OrganizationDataDO organizationData = lot.Index.GetPart<OrganizationDataDO>("organizationData").Content;
organizationData.CaseTypes.Add(caseTypeNom);
this.caseTypeRepository.AddCaseTypes(lot, organizationData.CaseTypes.Select(ct => ct.NomValueId));
updatedPart = lot.UpdatePart("organizationData", organizationData, userContext).Part;
}
lot.Commit(userContext, this.lotEventDispatcher);
this.unitOfWork.Save();
this.lotRepository.ExecSpSetLotPartTokens(updatedPart.PartId);
}
