public PersonsDiseaseQuery(IPersonRepository personRepository, IDiseaseRepository diseaseRepository, IPersonalDiseasesRepository pdRepository)
{
Name = "PersonsDiseaseQuery";
Field <PersonsType>(
"person",
arguments: new QueryArguments(new QueryArgument <IntGraphType> {
Name = "Id"
}),
resolve: context => personRepository.GetById(context.GetArgument <int>("Id"))
);
Field <ListGraphType <PersonsType> >(
"persons", "Returns list of persons",
resolve: context => personRepository.GetAll()
);
Field <DiseasesType>(
"disease",
arguments: new QueryArguments(new QueryArgument <IntGraphType> {
Name = "Id"
}),
resolve: context => diseaseRepository.GetById(context.GetArgument <int>("Id"))
);
Field <ListGraphType <DiseasesType> >(
"diseases", "returns list of disease",
resolve: context => diseaseRepository.GetAll()
);
Field <ListGraphType <PersonalDiseasesType> >(
"personsDiseases", "returns list of all persons with diseases",
resolve: context => pdRepository.GetAll()
);
}
public ConfirmImportUserInteractor(
IDiseaseRepository diseaseRepository,
IAcuteDiseaseRepository acuteDiseaseRepository)
{
this.diseaseRepository = diseaseRepository;
this.acuteDiseaseRepository = acuteDiseaseRepository;
}
public DiseaseBusiness(IMapper mapper,
IDiseaseRepository diseaseRepository,
IDiseaseGroupRepository diseaseGroupRepository)
{
_mapper = mapper;
_diseaseRepository = diseaseRepository;
_diseaseGroupRepository = diseaseGroupRepository;
}
public RequestImportUserInteractor(
IUserRepository userRepository,
IDocumentRepository documentRepository,
IDiseaseRepository diseaseRepository,
IAcuteDiseaseRepository acuteDiseaseRepository)
{
this.userRepository = userRepository;
this.documentRepository = documentRepository;
this.diseaseRepository = diseaseRepository;
this.acuteDiseaseRepository = acuteDiseaseRepository;
}
public DiseasesType(IDiseaseRepository diseaseRepository)
{
Field(x => x.Id, type: typeof(IdGraphType)).Description("Disease Id");
Field(x => x.Description).Description("Description of a disease");
Field(x => x.DiseaseName).Description("Name of the Disease");
FieldAsync <ListGraphType <PersonalDiseasesType>, IReadOnlyCollection <PersonalDisease> >(
"personsWithDisease", "returns list of persons with this disease",
resolve: context =>
{
return(diseaseRepository.GetPersonsByDiseaseId(context.Source.Id));
});
}
public MedicalRecordBusiness(IMapper mapper,
IMedicalRecordRepository medicalRecordRepository,
IPatientRepository patientRepository,
IMedicalRecordStatusRepository medicalRecordStatusRepository,
IDiseaseRepository diseaseRepository,
ITreatmentDiseaseRepository treatmentDiseaseRepository)
{
_mapper = mapper;
_medicalRecordRepository = medicalRecordRepository;
_patientRepository = patientRepository;
_medicalRecordStatusRepository = medicalRecordStatusRepository;
_diseaseRepository = diseaseRepository;
_treatmentDiseaseRepository = treatmentDiseaseRepository;
}
public GetAllSharedDataInteractor(
IShareRepository shareRepository,
IUserRepository userRepository,
IDocumentRepository documentRepository,
IActivityRepository activityRepository,
IDiseaseRepository diseaseRepository,
IAcuteDiseaseRepository acuteDiseaseRepository)
{
this.shareRepository = shareRepository;
this.userRepository = userRepository;
this.documentRepository = documentRepository;
this.activityRepository = activityRepository;
this.diseaseRepository = diseaseRepository;
this.acuteDiseaseRepository = acuteDiseaseRepository;
}
public TreatmentBusiness(IMapper mapper,
ITreatmentRepository treatmentRepository,
IEmployeeRepository employeeRepository,
IPatientRepository patientRepository,
IMedicalRecordRepository medicalRecordRepository,
ITreatmentDiseaseRepository treatmentDiseaseRepository,
IDiseaseRepository diseaseRepository)
{
_mapper = mapper;
_treatmentRepository = treatmentRepository;
_employeeRepository = employeeRepository;
_patientRepository = patientRepository;
_medicalRecordRepository = medicalRecordRepository;
_treatmentDiseaseRepository = treatmentDiseaseRepository;
_diseaseRepository = diseaseRepository;
}
public PersonalDiseasesType(IDiseaseRepository diseaseRepository, IPersonRepository personRepository, IPersonalDiseasesRepository pdRepository)
{
Field(x => x.Id, type: typeof(IdGraphType)).Description("Personal Disease Id");
Field(x => x.PersonId, type: typeof(IdGraphType)).Description("Person Id");
Field(x => x.DiseaseId, type: typeof(IdGraphType)).Description("Disease Id");
Field(x => x.DateOfGetting).Description("Date of Getting It");
FieldAsync <DiseasesType, Disease>("disease", resolve: ctx =>
{
return(diseaseRepository.GetById(ctx.Source.DiseaseId));
});
FieldAsync <PersonsType, Person>("person", resolve: ctx =>
{
return(personRepository.GetById(ctx.Source.PersonId));
});
}
public DiseaseValidator(IDiseaseRepository diseaseRepository)
{
_diseaseRepository = diseaseRepository;
RuleSet("Base", () =>
{
RuleFor(disease => disease.Name).NotNull().NotEmpty();
RuleFor(disease => disease.Code).NotNull().NotEmpty();
});
RuleSet("Create", () =>
{
Custom(CreateCodeValidate);
});
RuleSet("Update", () =>
{
Custom(UpdateCodeValidate);
});
}
public WarningValidator(IDiseaseRepository diseaseRepository, IWarningRepository warningRepository)
{
_diseaseRepository = diseaseRepository;
_warningRepository = warningRepository;
RuleSet("Base", () =>
{
RuleFor(warning => warning.Name).NotNull().NotEmpty();
RuleFor(warning => warning.Code).NotNull().NotEmpty();
RuleFor(warning => warning.DiseaseId).Must(diseaseId => diseaseId.IsNotZero()).WithMessage("Tienes que elegir una enfermedad");
Custom(ReferencesValidate);
});
RuleSet("Create", () =>
{
Custom(CreateCodeValidate);
});
RuleSet("Update", () =>
{
Custom(UpdateCodeValidate);
});
}
public DiseaseController(IDiseaseRepository r)
{
repo = r;
}
public DiseasController(IUserRepository userRepository, IDiseaseRepository diseaseRepository)
{
_userRepository = userRepository;
_diseaseRepository = diseaseRepository;
}
public WarningFactory(IDiseaseRepository diseaseRepository)
{
_diseaseRepository = diseaseRepository;
}
public GetDiseaseQueryHandler(IDiseaseRepository diseaseRepository, IMapper mapper)
{
_diseaseRepository = diseaseRepository;
_mapper = mapper;
}
public UnitOfWork(
IDiseaseRepository diseaseRepository)
{
DiseaseRepository = diseaseRepository;
}
/// <summary>
/// 初始化四诊信息服务
/// </summary>
/// <param name="uow">工作单元</param>
/// <param name="diseaseRepository">四诊信息仓储</param>
public DiseaseService(IUnitOfWork uow, IDiseaseRepository diseaseRepository)
: base(uow, diseaseRepository)
{
_diseaseRepository = diseaseRepository;
}
public DiseaseController(IDiseaseRepository diseaseRepository)
{
_diseaseRepository = diseaseRepository;
}
public DiseaseService(IDiseaseRepository diseaseRepository)
{
_diseaseRepository = diseaseRepository;
}
public DiseaseApplicationService(IDiseaseRepository repository, IUnitOfWork uow)
: base(uow)
{
_repository = repository;
}
public PersonsDiseaseMutation(IPersonRepository personRepository, IDiseaseRepository diseaseRepository, IPersonalDiseasesRepository pdRepository)
{
Name = "PersonsDiseaseMutation";
#region Person
FieldAsync <PersonsType>(
"createPerson",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <PersonsInputType> > {
Name = "person"
}
),
resolve: async context =>
{
var personInput = context.GetArgument <Person>("person");
await personRepository.Add(personInput);
return($"Person has been created succesfully.");
}
);
FieldAsync <PersonsType>(
"updatePerson",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <PersonsInputType> > {
Name = "person"
},
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "personId"
}
),
resolve: async context =>
{
var personInput = context.GetArgument <Person>("person");
var personId = context.GetArgument <int>("personId");
var personInfoRetrived = await personRepository.GetById(personId);
if (personInfoRetrived == null)
{
context.Errors.Add(new ExecutionError("Couldn't find Person info."));
return(null);
}
personInfoRetrived.Name = personInput.Name;
personInfoRetrived.DateOfBirth = personInput.DateOfBirth;
personInfoRetrived.Address = personInput.Address;
personInfoRetrived.Gender = personInput.Gender;
await personRepository.Update(personInfoRetrived);
return($"Person ID {personId} with Name {personInfoRetrived.Name} has been updated succesfully.");
}
);
FieldAsync <StringGraphType>(
"deletePerson",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "personId"
}),
resolve: async context =>
{
var personId = context.GetArgument <int>("personId");
var personInfoRetrived = await personRepository.GetById(personId);
if (personInfoRetrived == null)
{
context.Errors.Add(new ExecutionError("Couldn't find Person info."));
return(null);
}
await personRepository.Delete(personId);
return($"Person ID {personId} with Name {personInfoRetrived.Name} has been deleted succesfully.");
}
);
#endregion
#region Disease
FieldAsync <DiseasesType>(
"createDisease",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <DiseasesInputType> > {
Name = "disease"
}
),
resolve: async context =>
{
var diseaseInput = context.GetArgument <Disease>("disease");
await diseaseRepository.Add(diseaseInput);
return($"Disease has been created succesfully.");
}
);
FieldAsync <DiseasesType>(
"updateDisease",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <DiseasesInputType> > {
Name = "disease"
},
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "diseaseId"
}
),
resolve: async context =>
{
var diseaseInput = context.GetArgument <Disease>("disease");
var diseaseId = context.GetArgument <int>("diseaseId");
var diseaseInfoRetrived = await diseaseRepository.GetById(diseaseId);
if (diseaseInfoRetrived == null)
{
context.Errors.Add(new ExecutionError("Couldn't find Disease info."));
return(null);
}
diseaseInfoRetrived.DiseaseName = diseaseInput.DiseaseName;
diseaseInfoRetrived.Description = diseaseInput.Description;
await diseaseRepository.Update(diseaseInfoRetrived);
return($"Disease ID {diseaseId} has been updated succesfully.");
}
);
FieldAsync <StringGraphType>(
"deleteDisease",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "diseaseId"
}),
resolve: async context =>
{
var diseaseId = context.GetArgument <int>("diseaseId");
var diseaseInfoRetrived = await diseaseRepository.GetById(diseaseId);
if (diseaseInfoRetrived == null)
{
context.Errors.Add(new ExecutionError("Couldn't find Disease info."));
return(null);
}
await diseaseRepository.Delete(diseaseId);
return($"Disease ID {diseaseId} with Name {diseaseInfoRetrived.DiseaseName} has been deleted succesfully.");
}
);
#endregion
#region Personal Diseases
FieldAsync <PersonalDiseasesType>(
"addPersonalDisease",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <PersonalDiseasesInputType> > {
Name = "personalDisease"
}),
resolve: async context =>
{
var personalDisease = context.GetArgument <PersonalDisease>("personalDisease");
await pdRepository.Add(personalDisease);
return($"Personal disease has been created succesfully.");
}
);
FieldAsync <PersonalDiseasesType>(
"updatePersonalDisease",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <DiseasesInputType> > {
Name = "personalDisease"
},
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "personalDiseaseId"
}
),
resolve: async context =>
{
var pdInput = context.GetArgument <PersonalDisease>("personalDisease");
var pdId = context.GetArgument <int>("personalDiseaseId");
var pdInfoRetrived = await pdRepository.GetById(pdId);
if (pdInfoRetrived == null)
{
context.Errors.Add(new ExecutionError("Couldn't find Personal Disease info."));
return(null);
}
pdInfoRetrived.DiseaseId = pdInput.DiseaseId;
pdInfoRetrived.PersonId = pdInput.PersonId;
pdInfoRetrived.DateOfGetting = pdInput.DateOfGetting;
await pdRepository.Update(pdInfoRetrived);
return($"Personal Disease ID {pdId} has been updated succesfully.");
}
);
FieldAsync <StringGraphType>(
"deletePersonalDisease",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "personalDisease"
}),
resolve: async context =>
{
var pdId = context.GetArgument <int>("personalDisease");
var pdInfoRetrived = await pdRepository.GetById(pdId);
if (pdInfoRetrived == null)
{
context.Errors.Add(new ExecutionError("Couldn't find Personal Disease info."));
return(null);
}
await pdRepository.Delete(pdId);
return($"Personal Disease ID {pdId} has been deleted succesfully.");
}
);
#endregion
}
public DiseaseService(IDiseaseRepository diseaseRepository, AppDbContext context)
{
_diseaseRepository = diseaseRepository;
_context = context;
}
public DiseaseService(IUnitOfWork unitOfWork)
{
_diseaseRepository = unitOfWork.DiseaseRepository;
}
public MedicineRepository(ICSVStream <Medicine> stream, ISequencer <long> sequencer, IIngredientRepository ingredientRepository, IDiseaseRepository diseaseRepository) : base(ENTITY_NAME, stream, sequencer, new LongIdGeneratorStrategy <Medicine>())
{
_ingredientRepository = ingredientRepository;
_diseaseRepository = diseaseRepository;
}
//public DiseaseManager():base(new DiseaseRepository())
//{
// _repository=new DiseaseRepository();
//}
public DiseaseManager(IDiseaseRepository repository) : base(repository)
{
_repository = repository;
}
public DiseaseService(IDiseaseRepository diseaseRepository, IMapper mapper)
{
_diseaseRepository = diseaseRepository;
_mapper = mapper;
}
public List <Disease> GetDisease()
{
IDiseaseRepository _diseaseDetailRepo = RepositoryFactory.Create <IDiseaseRepository>(ContextTypes.EntityFramework);
return(_diseaseDetailRepo.GetAll().OrderBy(x => x.DiseaseType).ToList());
}
public CreateDiseaseCommandHandler(IDiseaseRepository diseaseRepository, IMapper mapper)
{
_diseaseRepository = diseaseRepository;
_mapper = mapper;
}
public DiseaseController(IDiseaseRepository service)
{
_service = service;
}
public DiseaseService()
{
this.diseaseRepository = new DiseaseRepository(this.dbContext);
}
