public GoalController(IConstantRepository ConstantParam, IMinistryRepository MinistryParam, IGoalRepository GoalParam, IMinistryMemberRepository MinistryMemberParam,
IMemberRepository MemberParam)
{
ConstantRepository = ConstantParam;
MinistryRepository = MinistryParam;
GoalRepository = GoalParam;
MinistryMemberRepository = MinistryMemberParam;
MemberRepository = MemberParam;
ViewBag.Supervisor = false;
int memberID = Convert.ToInt16(System.Web.HttpContext.Current.Session["personID"]);
if (MembershipRepositroy.IsUser(memberID))
{
user user = MembershipRepositroy.GetUserByID(memberID);
if ((user.role.Name == "WebMaster") || (user.role.Name == "Pastor") || (user.role.Name == "Admin") || (user.role.Name == "Admin2")) //creator access
{
ViewBag.Supervisor = true;
}
if (user.role.Name == "WebMaster") //creator access
{
ViewBag.WebMaster = true;
}
if (user.role.Name == "Officer") //creator access
{
ViewBag.Supervisor2 = true;
}
}
}
public UpdateService(IUpdateRepository updateRepository, IGoalRepository goalRepository, IUnitOfWork unitOfWork, IFollowUserRepository followUserRepository)
{
this.updateRepository = updateRepository;
this.goalRepository = goalRepository;
this.followUserRepository = followUserRepository;
this.unitOfWork = unitOfWork;
}
public GoalService(IGoalRepository goalRepository, IActivityRepository activityRepository, IFeedEventService feedEventService, IUnitOfWork unit)
{
_goalRepository = goalRepository;
_activityRepository = activityRepository;
_feedEventService = feedEventService;
_unit = unit;
}
public UpdateService(IUpdateRepository updateRepository, IGoalRepository goalRepository, IUnitOfWork unitOfWork, IFollowUserRepository followUserRepository)
{
this.updateRepository = updateRepository;
this.goalRepository = goalRepository;
this.followUserRepository = followUserRepository;
this.unitOfWork = unitOfWork;
}
public GoalLogic(IUnitOfWork unit, IGoalRepository repo, ITargetRepository t, IActivityRepository a)
{
this.Unit = unit;
this.Repo = repo;
this.tRepo = t;
this.actRepo = a;
}
public UpdateService(IUpdateRepository updateRepository, IGoalRepository goalRepository, IUnitOfWork unitOfWork, IFollowUserRepository followUserRepository)
{
_updateRepository = updateRepository;
_goalRepository = goalRepository;
_followUserRepository = followUserRepository;
_unitOfWork = unitOfWork;
}
public TaskService(ITaskRepository repository, IIdentityRepository identityRepository, IGoalRepository goalRepository, IUserContextProvider userContextProvider)
{
_repository = repository;
_identityRepository = identityRepository;
_goalRepository = goalRepository;
_userContextProvider = userContextProvider;
}
public GetPatientGoalDataResponse GetPatientGoal(GetPatientGoalDataRequest request)
{
GetPatientGoalDataResponse result = null;
try
{
result = new GetPatientGoalDataResponse();
IGoalRepository repo = Factory.GetRepository(request, RepositoryType.PatientGoal);
PatientGoalData patientGoalData = repo.FindByID(request.Id) as PatientGoalData;
if (patientGoalData != null)
{
//Get all barriers for a given goal
patientGoalData.BarriersData = getBarriersByPatientGoalId(request, patientGoalData.Id);
//Get all tasks for a given goal
patientGoalData.TasksData = getTasksByPatientGoalId(request, patientGoalData.Id);
//Get all interventions for a given goal
patientGoalData.InterventionsData = getInterventionsByPatientGoalId(request, patientGoalData.Id);
}
result.GoalData = patientGoalData;
result.Version = request.Version;
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public RemoveProgramInPatientGoalsDataResponse RemoveProgramInPatientGoals(RemoveProgramInPatientGoalsDataRequest request)
{
RemoveProgramInPatientGoalsDataResponse response = null;
try
{
response = new RemoveProgramInPatientGoalsDataResponse();
IGoalRepository repo = Factory.GetRepository(request, RepositoryType.PatientGoal);
if (request.ProgramId != null)
{
List <PatientGoalData> goals = repo.FindGoalsWithAProgramId(request.ProgramId) as List <PatientGoalData>;
if (goals != null && goals.Count > 0)
{
goals.ForEach(u =>
{
request.PatientGoalId = u.Id;
if (u.ProgramIds != null && u.ProgramIds.Remove(request.ProgramId))
{
repo.RemoveProgram(request, u.ProgramIds);
}
});
}
}
return(response);
}
catch (Exception ex) { throw ex; }
}
public DeleteBarrierDataResponse DeleteBarrier(DeleteBarrierDataRequest request)
{
try
{
DeleteBarrierDataResponse result = new DeleteBarrierDataResponse();
IGoalRepository repo = Factory.GetRepository(request, RepositoryType.PatientBarrier);
List <PatientBarrierData> pbd = (List <PatientBarrierData>)repo.Find(request.PatientGoalId);
List <string> deletedIds = null;
if (pbd != null && pbd.Count > 0)
{
deletedIds = new List <string>();
pbd.ForEach(b =>
{
request.BarrierId = b.Id;
repo.Delete(request);
deletedIds.Add(request.BarrierId);
});
}
result.DeletedIds = deletedIds;
result.Success = true;
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public GoalsController(IHubContext <GoalsHub> goalsHub, IMapper mapper, IGoalRepository repository, IUnitOfWork unitOfWork)
{
_goalsHub = goalsHub;
_mapper = mapper;
_repository = repository;
_unitOfWork = unitOfWork;
}
public DeleteInterventionDataResponse DeleteIntervention(DeleteInterventionDataRequest request)
{
try
{
DeleteInterventionDataResponse result = new DeleteInterventionDataResponse();
IGoalRepository repo = Factory.GetRepository(request, RepositoryType.PatientIntervention);
List <PatientInterventionData> pid = (List <PatientInterventionData>)repo.Find(request.PatientGoalId);
List <string> deletedIds = null;
if (pid != null && pid.Count > 0)
{
deletedIds = new List <string>();
pid.ForEach(i =>
{
request.InterventionId = i.Id;
repo.Delete(request);
deletedIds.Add(request.InterventionId);
});
}
result.DeletedIds = deletedIds;
result.Success = true;
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public GetPatientTasksDataResponse GetTasks(GetPatientTasksDataRequest request)
{
try
{
var result = new GetPatientTasksDataResponse();
IGoalRepository taskRepo = Factory.GetRepository(request, RepositoryType.PatientTask);
taskRepo.UserId = request.UserId;
IGoalRepository goalRepo = Factory.GetRepository(request, RepositoryType.PatientGoal);
// Get all the goals associated to the patient in the request object.
if (!string.IsNullOrEmpty(request.PatientId))
{
List <PatientGoalViewData> goalViewDataList = goalRepo.Find(request.PatientId) as List <PatientGoalViewData>;
List <string> patientGoalIds = goalViewDataList.Select(a => a.Id).ToList();
if (patientGoalIds != null && patientGoalIds.Count > 0)
{
result.TasksData = (List <PatientTaskData>)taskRepo.Search(request, patientGoalIds);
}
}
else
{
result.TasksData = (List <PatientTaskData>)taskRepo.Search(request, null);
}
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public GoalLogic(IUnitOfWork unit, IGoalRepository repo, ITargetRepository t, IActivityRepository a)
{
this.Unit = unit;
this.Repo = repo;
this.tRepo = t;
this.actRepo = a;
}
public IGoalRepository GetRepository(IDataDomainRequest request, RepositoryType type)
{
try
{
IGoalRepository repo = null;
switch (type)
{
case RepositoryType.PatientGoal:
{
repo = new MongoPatientGoalRepository(request.ContractNumber);
break;
}
case RepositoryType.PatientBarrier:
{
repo = new MongoPatientBarrierRepository(request.ContractNumber);
break;
}
case RepositoryType.PatientTask:
{
repo = new MongoPatientTaskRepository(request.ContractNumber);
break;
}
case RepositoryType.PatientIntervention:
{
repo = new MongoPatientInterventionRepository(request.ContractNumber);
break;
}
case RepositoryType.Goal:
{
repo = new MongoGoalRepository(request.ContractNumber);
break;
}
case RepositoryType.Task:
{
repo = new MongoTaskRepository(request.ContractNumber);
break;
}
case RepositoryType.Intervention:
{
repo = new MongoInterventionRepository(request.ContractNumber);
break;
}
}
repo.UserId = request.UserId;
return(repo);
}
catch (Exception ex)
{
throw ex;
}
}
private List <PatientInterventionData> getInterventionsByPatientGoalId(IDataDomainRequest request, string patientGoalId)
{
IGoalRepository repo = Factory.GetRepository(request, RepositoryType.PatientIntervention);
List <PatientInterventionData> interventionDataList = repo.Find(patientGoalId) as List <PatientInterventionData>;
return(interventionDataList);
}
private List <PatientBarrierData> getBarriersByPatientGoalId(IDataDomainRequest request, string patientGoalId)
{
IGoalRepository repo = Factory.GetRepository(request, RepositoryType.PatientBarrier);
List <PatientBarrierData> barrierDataList = repo.Find(patientGoalId) as List <PatientBarrierData>;
return(barrierDataList);
}
public GoalCommandHandler(IGoalRepository GoalRepository,
IUnitOfWork uow,
IMediatorHandler bus,
INotificationHandler <DomainNotification> notifications) : base(uow, bus, notifications)
{
_goalRepository = GoalRepository;
Bus = bus;
}
public JobService(IJobRepository jobRepository,
IGoalRepository goalRepository,
ILocationRepository locationRepository)
{
_jobRepository = jobRepository;
_goalRepository = goalRepository;
_locationRepository = locationRepository;
}
private List <PatientTaskData> getTasksByPatientGoalId(IDataDomainRequest request, string patientGoalId)
{
IGoalRepository repo = Factory.GetRepository(request, RepositoryType.PatientTask);
List <PatientTaskData> taskDataList = repo.Find(patientGoalId) as List <PatientTaskData>;
return(taskDataList);
}
public GoalService(IUnitOfWork unitOfWork,
IMatchRepository matchRepository,
IGoalRepository goalRepository)
{
_unitOfWork = unitOfWork;
_matchRepository = matchRepository;
_goalRepository = goalRepository;
}
public HomeModule(IGoalRepository goalRepository)
{
_goalRepository = goalRepository;
Get["/"] = _ =>
{
return View["Index"];
};
}
public GoalApplicationService(IMapper mapper,
IGoalRepository goalRepository,
IMediatorHandler bus,
IEventStoreRepository eventStoreRepository)
{
_mapper = mapper;
_goalRepository = goalRepository;
Bus = bus;
_eventStoreRepository = eventStoreRepository;
}
public SavingRepository(IGoalRepository goalRepository, ICatalogRepository catalogRepository, IDbConnection connection)
: base(connection)
{
if (catalogRepository == null)
{
throw new ArgumentNullException("catalogRepository");
}
_goalRepository = goalRepository;
_catalogRepository = catalogRepository;
}
// GET: /<controller>/
public GoalsController(IGoalRepository thisRepo = null)
{
if (thisRepo == null)
{
this.goalRepo = new EFGoalRepository();
}
else
{
this.goalRepo = thisRepo;
}
}
public UserProfileUnitOfWork(IUserProfileContext context,
IUserProfileRepository userProfiles,
IInterestRepository interests,
IGoalRepository goals
) : base(context)
{
this.context = context;
UserProfiles = userProfiles;
Interests = interests;
Goals = goals;
}
public KAOSModel()
{
agentRepository = new AgentRepository();
domainRepository = new DomainRepository();
goalRepository = new GoalRepository();
modelMetadataRepository = new ModelMetadataRepository();
entityRepository = new EntityRepository();
obstacleRepository = new ObstacleRepository();
formalSpecRepository = new FormalSpecRepository();
satisfactionRateRepository = new SatisfactionRateRepository();
Parameters = new Dictionary <string, string> ();
}
public MinistryController(IConstantRepository ConstantParam, IMinistryRepository MinistryParam, IGoalRepository GoalParam, IMeetingRepository MeetingParam,
IAnnouncementRepository AnnouncementParam, ICalendarRepository CalendarParam, IMinistryMemberRepository MinistryMemberParam, IMemberRepository MemberParam,
IChildParentRepository ChildParentParam, IStoryRepository StoryParam, IPictureRepository PictureParam, IListtableRepository ListTableParam, IMinistryGroupRepository MinistryGroupParam,
IDocumentRepository DocumentParam, IVideoRepository VideoParam)
{
ConstantRepository = ConstantParam;
MinistryRepository = MinistryParam;
GoalRepository = GoalParam;
MeetingRepository = MeetingParam;
AnnouncementRepository = AnnouncementParam;
CalendarRepository = CalendarParam;
MinistryMemberRepository = MinistryMemberParam;
MemberRepository = MemberParam;
ChildParentRepository = ChildParentParam;
StoryRepository = StoryParam;
PictureRepository = PictureParam;
ListTableRepository = ListTableParam;
MinistryGroupRepository = MinistryGroupParam;
DocumentRepository = DocumentParam;
VideoRepository = VideoParam;
ViewBag.Supervisor = false;
int memberID = Convert.ToInt16(System.Web.HttpContext.Current.Session["personID"]);
if (memberID > 0)
{
if (MembershipRepositroy.IsUser(memberID))
{
user user = MembershipRepositroy.GetUserByID(memberID);
if ((user.role.Name == "WebMaster") || (user.role.Name == "Pastor") || (user.role.Name == "Admin") || (user.role.Name == "Admin2")) //creator access
{
ViewBag.Supervisor = true;
}
if (user.role.Name == "WebMaster") //creator access
{
ViewBag.WebMaster = true;
}
if ((user.role.Name == "Officer")) //creator access
{
ViewBag.Supervisor2 = true;
}
if ((user.role.Name == "FinanceLead")) //creator access
{
ViewBag.Supervisor3 = true;
}
}
}
}
public CampaignService(ICampaignRepository campaignRepo,
ICampaignDetailsRepository campaignDetailsRepo,
IGoalRepository goalRepo,
ICampaignDocumentRepository campDocRepo)
{
Guard.NotNull(campaignRepo, nameof(campaignRepo));
Guard.NotNull(campaignDetailsRepo, nameof(campaignDetailsRepo));
Guard.NotNull(goalRepo, nameof(goalRepo));
Guard.NotNull(campDocRepo, nameof(campDocRepo));
_campaignRepo = campaignRepo;
_campaignDetailsRepo = campaignDetailsRepo;
_goalRepo = goalRepo;
_campDocRepo = campDocRepo;
}
/// <summary>
/// Initializes a new instance of the <see cref="GoalOrchestrator"/> class.
/// </summary>
/// <param name="assembler">
/// The assembler.
/// </param>
/// <param name="repository">
/// The repository.
/// </param>
/// <param name="errorHelper">
/// The error helper.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// Exception thrown if the assembler or repository are null.
/// </exception>
public GoalOrchestrator(IGoalAssembler assembler, IGoalRepository repository, IErrorHelper errorHelper) : base(errorHelper)
{
if (assembler == null)
{
throw new ArgumentNullException(nameof(assembler));
}
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
this.assembler = assembler;
this.repository = repository;
}
public PutInitializeInterventionResponse InsertNewPatientIntervention(PutInitializeInterventionRequest request)
{
try
{
PutInitializeInterventionResponse result = new PutInitializeInterventionResponse();
IGoalRepository repo = Factory.GetRepository(request, RepositoryType.PatientIntervention);
result.Id = (string)repo.Initialize(request);
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public PutInitializeTaskResponse InsertNewPatientTask(PutInitializeTaskRequest request)
{
try
{
PutInitializeTaskResponse result = new PutInitializeTaskResponse();
IGoalRepository repo = Factory.GetRepository(request, RepositoryType.PatientTask);
result.Task = (PatientTaskData)repo.Initialize(request);
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public MatchService(IUnitOfWork unitOfWork,
ISeasonRepository seasonRepository,
IClubRepository clubRepository,
ISquadRepository squadRepository,
IKitRepository kitRepository,
IMatchRepository matchRepository,
IGoalRepository goalRepository
)
{
_unitOfWork = unitOfWork;
_seasonRepository = seasonRepository;
_clubRepository = clubRepository;
_squadRepository = squadRepository;
_kitRepository = kitRepository;
_matchRepository = matchRepository;
_goalRepository = goalRepository;
}
public GoalService(IGoalRepository goalRepository)
{
_goalRepository = goalRepository;
}
public GoalsController(IAccount account, IGoalRepository goalRepository, IEventBus eventBus)
{
this.account = account;
this.goalRepository = goalRepository;
this.eventBus = eventBus;
}
public ExperimentsController(IExperimentRepository experimentRepository, ICohortRepository cohortRepository, IGoalRepository goalRepository)
{
this.experimentRepository = experimentRepository;
this.cohortRepository = cohortRepository;
this.goalRepository = goalRepository;
}
public GoalsController(IGoalRepository goalRepository)
{
this.goalRepository = goalRepository;
}
public GoalService()
{
_goalRepository = ZC_IT_TimeTracking.DataAccess.Factory.RepositoryFactory.GetInstance().GetGoalRepository();
this.ValidationErrors = _goalRepository.ValidationErrors;
}
public GoalService(IGoalRepository goalRepository, IFollowUserRepository followUserRepository, IUnitOfWork unitOfWork)
{
this.goalRepository = goalRepository;
this.unitOfWork = unitOfWork;
this.followUserrepository = followUserRepository;
}
