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); }