public ExternalProviderSaga(IBus bus, IEventStore eventStore, ISchedulingRepository schedulingRepository, AccessTokenService accessTokenService) : base(bus, eventStore)
{
_bus = bus;
_eventStore = eventStore;
_schedulingRepository = schedulingRepository;
_accessTokenService = accessTokenService;
}
public DeleteToDoByPatientIdDataResponse DeleteToDoByPatientId(DeleteToDoByPatientIdDataRequest request)
{
DeleteToDoByPatientIdDataResponse response = new DeleteToDoByPatientIdDataResponse();
try
{
ISchedulingRepository repo = Factory.GetRepository(request, RepositoryType.ToDo);
GetToDosDataRequest getToDosDataRequest = new GetToDosDataRequest
{
PatientId = request.PatientId,
Context = request.Context,
ContractNumber = request.ContractNumber,
UserId = request.UserId,
Version = request.Version
};
GetToDosDataResponse toDosResponse = repo.FindToDos(getToDosDataRequest);
List <ToDoData> patientToDos = (List <ToDoData>)toDosResponse.ToDos; //repo.FindToDos(getToDosDataRequest);
List <string> deletedIds = null;
if (patientToDos != null)
{
deletedIds = new List <string>();
patientToDos.ForEach(u =>
{
request.Id = u.Id;
repo.Delete(request);
deletedIds.Add(request.Id);
});
response.DeletedIds = deletedIds;
}
response.Success = true;
return(response);
}
catch (Exception ex) { throw ex; }
}
public void Initialize()
{
Base.SeedDatabase();
_repository = new SchedulingRepository();
_mockEmployee = new Mock <Employee>();
_mockRoom = new Mock <Room>();
}
public ISchedulingRepository GetRepository(IDataDomainRequest request, RepositoryType type)
{
try
{
ISchedulingRepository repo = null;
switch (type)
{
case RepositoryType.ToDo:
{
repo = new StubMongoToDoRepository(request.ContractNumber);
break;
}
case RepositoryType.Schedule:
{
repo = new StubMongoScheduleRepository(request.ContractNumber);
break;
}
}
repo.UserId = request.UserId;
return(repo);
}
catch (Exception ex)
{
throw ex;
}
}
public EmployeeWorkHoursService(IEmployeeWorkHoursRepository employeeWorkHoursRepository,
ISchedulingRepository schedulingRepository, IEmployeeRepository employeeRepository) : base(employeeWorkHoursRepository)
{
_employeeWorkHoursRepository = employeeWorkHoursRepository;
_schedulingRepository = schedulingRepository;
_employeeRepository = employeeRepository;
}
public RemoveProgramInToDosDataResponse RemoveProgramInToDos(RemoveProgramInToDosDataRequest request)
{
RemoveProgramInToDosDataResponse response = new RemoveProgramInToDosDataResponse();
try
{
ISchedulingRepository repo = Factory.GetRepository(request, RepositoryType.ToDo);
if (request.ProgramId != null)
{
List <ToDoData> todos = repo.FindToDosWithAProgramId(request.ProgramId) as List <ToDoData>;
if (todos != null && todos.Count > 0)
{
todos.ForEach(u =>
{
request.ToDoId = u.Id;
if (u.ProgramIds != null && u.ProgramIds.Remove(request.ProgramId))
{
repo.RemoveProgram(request, u.ProgramIds);
}
});
}
}
return(response);
}
catch (Exception ex) { throw ex; }
}
public SchedulingCreateHandler(IMapper mapper, ISchedulingRepository repository, IProvidedServiceRepository providedServiceRepository, IEmployeeRepository employeeRepository)
{
_mapper = mapper;
_repository = repository;
_providedServiceRepository = providedServiceRepository;
_employeeRepository = employeeRepository;
}
public SchedulingService(ISchedulingRepository schedulingRepository, IBlockRepository blockRepository, ITicketRepository ticketRepository, IUnitOfWork unitOfWork)
{
_schedulingRepository = schedulingRepository;
_blockRepository = blockRepository;
_ticketRepository = ticketRepository;
_unitOfWork = unitOfWork;
}
public void Initialize()
{
BaseSqlTest.SeedDatabase();
_repository = new SchedulingSqlRepository();
_employee = ObjectMother.GetEmployee();
_room = ObjectMother.GetRoom();
}
public HoraryAppService(IMapper mapper,
IHoraryRepository horaryRepository,
IHoraryExtraRepository horaryExtraRepository,
ISchedulingRepository schedulingRepository)
{
_horaryRepository = horaryRepository;
_horaryExtraRepository = horaryExtraRepository;
_schedulingRepository = schedulingRepository;
_mapper = mapper;
}
public SchedulingService(ISchedulingRepository schedulingRepository, IClientRepository clientRepository,
IEmployeeRepository employeeRepository, ICompanyService companyService, IServiceRepository serviceRepository,
IEmployeeService employeeService) : base(schedulingRepository)
{
_schedulingRepository = schedulingRepository;
_clientRepository = clientRepository;
_employeeRepository = employeeRepository;
_companyService = companyService;
_serviceRepository = serviceRepository;
_employeeService = employeeService;
}
public DentistService(IUnitOfWork unitOfWork,
INotifier notifier,
UserManager <IdentityUser> userManager,
IDentistRepository dentistRepository,
IEmailService emailService, ISchedulingRepository schedulingRepository)
: base(unitOfWork, notifier, userManager)
{
_userManager = userManager;
_dentistRepository = dentistRepository;
_emailService = emailService;
_schedulingRepository = schedulingRepository;
}
public DTO.PutInsertToDoDataResponse InsertToDo(DTO.PutInsertToDoDataRequest request)
{
PutInsertToDoDataResponse respone = new PutInsertToDoDataResponse();
ISchedulingRepository repo = Factory.GetRepository(request, RepositoryType.ToDo);
string toDoId = (string)repo.Insert(request);
if (!string.IsNullOrEmpty(toDoId))
{
ToDoData data = (ToDoData)repo.FindByID(toDoId);
respone.ToDoData = data;
}
return(respone);
}
public DTO.PutUpdateToDoDataResponse UpdateToDo(DTO.PutUpdateToDoDataRequest request)
{
PutUpdateToDoDataResponse response = new PutUpdateToDoDataResponse();
ISchedulingRepository repo = Factory.GetRepository(request, RepositoryType.ToDo);
bool success = (bool)repo.Update(request);
if (success)
{
ToDoData data = (ToDoData)repo.FindByID(request.ToDoData.Id, true);
response.ToDoData = data;
}
return(response);
}
public SchedulingService(
ISchedulingRepository schedulingRepository
, IProgramRepository programRepository
, ICustomerRepository customerRepository
, ICdcRepository cdcRepository
, ILog loggingInstance, LoggingCommandHandlerDecorator <LogCommand> loghandler
)
{
_schedulingRepository = schedulingRepository ?? throw new ArgumentNullException($"schedulingRepository repository instance is null");
_programRepository = programRepository ?? throw new ArgumentNullException($"programRepository repository instance is null");
_customerRepository = customerRepository ?? throw new ArgumentNullException($"customerRepository repository instance is null");
_cdcRepository = cdcRepository ?? throw new ArgumentNullException($"cdcRepository repository instance is null");
_loggingInstance = loggingInstance ?? throw new ArgumentNullException($"logging instance is null");
_logHandler = loghandler ?? throw new ArgumentNullException($"logging commandhandlerDecorator instance is null");
}
public GetToDosDataResponse GetToDos(GetToDosDataRequest request)
{
try
{
var result = new GetToDosDataResponse();
ISchedulingRepository repo = Factory.GetRepository(request, RepositoryType.ToDo);
repo.UserId = request.UserId;
result = (GetToDosDataResponse)repo.FindToDos(request);
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public List <HttpObjectResponse <ToDoData> > InsertBatchPatientToDos(InsertBatchPatientToDosDataRequest request)
{
List <HttpObjectResponse <ToDoData> > list = null;
try
{
if (request.PatientToDosData != null && request.PatientToDosData.Count > 0)
{
list = new List <HttpObjectResponse <ToDoData> >();
ISchedulingRepository repo = Factory.GetRepository(request, RepositoryType.ToDo);
BulkInsertResult result = (BulkInsertResult)repo.InsertAll(request.PatientToDosData.Cast <object>().ToList());
if (result != null)
{
if (result.ProcessedIds != null && result.ProcessedIds.Count > 0)
{
// Get the ToDos that were newly inserted.
List <ToDoData> insertedToDos = repo.Select(result.ProcessedIds) as List <ToDoData>;
if (insertedToDos != null && insertedToDos.Count > 0)
{
#region DataAudit
List <string> insertedPatientToDoIds = insertedToDos.Select(p => p.Id).ToList();
AuditHelper.LogDataAudit(request.UserId, MongoCollectionName.ToDo.ToString(), insertedPatientToDoIds, Common.DataAuditType.Insert, request.ContractNumber);
#endregion
insertedToDos.ForEach(r =>
{
list.Add(new HttpObjectResponse <ToDoData> {
Code = HttpStatusCode.Created, Body = (ToDoData) new ToDoData {
Id = r.Id, ExternalRecordId = r.ExternalRecordId, PatientId = r.PatientId
}
});
});
}
}
result.ErrorMessages.ForEach(e =>
{
list.Add(new HttpObjectResponse <ToDoData> {
Code = HttpStatusCode.InternalServerError, Message = e
});
});
}
}
}
catch (Exception ex) { throw ex; }
return(list);
}
public PatientService(IUnitOfWork unitOfWork,
INotifier notifier,
UserManager <IdentityUser> userManager,
IPatientRepository patientRepository,
IEmailService emailService,
IHealthInsuranceService healthInsuranceService,
IHealthInsuranceRepository healthInsuranceRepository,
ISchedulingRepository schedulingRepository)
: base(unitOfWork, notifier, userManager)
{
_userManager = userManager;
_patientRepository = patientRepository;
_emailService = emailService;
_healthInsuranceService = healthInsuranceService;
_healthInsuranceRepository = healthInsuranceRepository;
_schedulingRepository = schedulingRepository;
}
public SchedulingService(IUnitOfWork unitOfWork,
INotifier notifier,
UserManager <IdentityUser> userManager,
ISchedulingRepository schedulingRepository,
IDentistService dentistService,
IPatientService patientService,
IDentistRepository dentistRepository,
IPatientRepository patientRepository,
IAttendantRepository attendantRepository)
: base(unitOfWork, notifier, userManager)
{
_schedulingRepository = schedulingRepository;
_dentistService = dentistService;
_patientService = patientService;
_dentistRepository = dentistRepository;
_patientRepository = patientRepository;
_attendantRepository = attendantRepository;
}
public PutUpdateToDoDataResponse UpdateToDo(PutUpdateToDoDataRequest request)
{
PutUpdateToDoDataResponse response = new PutUpdateToDoDataResponse();
try
{
ISchedulingRepository repo = Factory.GetRepository(request, RepositoryType.ToDo);
bool success = (bool)repo.Update(request);
if (success)
{
ToDoData data = (ToDoData)repo.FindByID(request.ToDoData.Id, true);
response.ToDoData = data;
}
}
catch (Exception ex)
{
throw ex;
}
return(response);;
}
public UndoDeletePatientToDosDataResponse UndoDeleteToDos(UndoDeletePatientToDosDataRequest request)
{
UndoDeletePatientToDosDataResponse response = new UndoDeletePatientToDosDataResponse();
try
{
ISchedulingRepository repo = Factory.GetRepository(request, RepositoryType.ToDo);
if (request.Ids != null && request.Ids.Count > 0)
{
request.Ids.ForEach(u =>
{
request.ToDoId = u;
repo.UndoDelete(request);
});
}
response.Success = true;
return(response);
}
catch (Exception ex) { throw ex; }
}
public PutInsertToDoDataResponse InsertToDo(PutInsertToDoDataRequest request)
{
PutInsertToDoDataResponse respone = new PutInsertToDoDataResponse();
try
{
ISchedulingRepository repo = Factory.GetRepository(request, RepositoryType.ToDo);
string toDoId = (string)repo.Insert(request);
if (!string.IsNullOrEmpty(toDoId))
{
ToDoData data = (ToDoData)repo.FindByID(toDoId);
respone.ToDoData = data;
}
}
catch (Exception ex)
{
throw ex;
}
return(respone);
}
public SchedulingController(ISchedulingRepository repo, IMeetingRoomRepository meetingRepo)
{
SchedulingRepository = repo;
MeetingRoomRepository = meetingRepo;
}
public SchedulingAppService(IMapper mapper, ISchedulingRepository schedulingRepository)
{
_schedulingRepository = schedulingRepository;
_mapper = mapper;
}
public TimeSlotController(ISchedulingRepository schedulingRepository)
{
_schedulingRepository = schedulingRepository;
}
public SchedulingSaga(IBus bus, IEventStore eventStore, ISchedulingRepository schedulingRepository) : base(bus, eventStore)
{
_schedulingRepository = schedulingRepository;
}
public SchedulingService(ISchedulingRepository repository)
{
_repository = repository;
}
public SchedulingBoardController(ISchedulingRepository schedulingRepository)
{
_schedulingRepository = schedulingRepository;
}
public SchedulingService(IUnitOfWork unitOfWork, ISchedulingRepository schedulingRepository)
{
_schedulingRepository = schedulingRepository;
_unitOfWork = unitOfWork;
}
public SchedulingService(ISchedulingRepository schedulingRepository, IAddressRepository addressRepository)
{
_schedulingRepository = schedulingRepository;
_addressRepository = addressRepository;
}
