public DashboardManager(IDashboardRepository dashboardRepository, IReportDashboardRelRepository repDashRel, IReportRepository reportRepository, IUserDashboardRelRepository userDashRelRepository)
{
_dashboardRepository = dashboardRepository;
_reportDashboardRel = repDashRel;
_reportRepository = reportRepository;
_userDashRelRepository = userDashRelRepository;
}
public static PregnancyDetails GetPregnancy(IDashboardRepository repo, string patientDfn, string pregIen)
{
PregnancyDetails returnVal = null;
// *** Get pregnancy ***
PregnancyListResult pregResult = repo.Pregnancy.GetPregnancies(patientDfn, pregIen);
// *** Check result ***
if (pregResult.Success)
{
if (pregResult.Pregnancies != null)
{
if (pregResult.Pregnancies.Count == 1)
{
returnVal = pregResult.Pregnancies[0];
}
}
}
// *** Also, get lmp, fetus count ***
if (returnVal != null)
{
PregnancyDetails tempPreg = GetPregnancyObservationData(repo, patientDfn, pregIen);
returnVal.Lmp = tempPreg.Lmp;
returnVal.LmpDateType = tempPreg.LmpDateType;
returnVal.FetusBabyCount = tempPreg.FetusBabyCount;
// *** Will return EDD Basis and Is Final ***
returnVal.EddBasis = tempPreg.EddBasis;
returnVal.EddIsFinal = tempPreg.EddIsFinal;
}
return(returnVal);
}
public DashboardController(
IDashboardRepository repository,
IMapper mapper)
{
_repository = repository;
_mapper = mapper;
}
/// <summary>
/// Initializes a new instance of the <see cref="DashboardRepositoryTests"/> class.
/// </summary>
public DashboardRepositoryTests()
{
this.httpClientHelper = new Mock<IHttpClientHelper>();
DataAccess.Dependencies.Register();
DIContainer.Instance.RegisterInstance<IHttpClientHelper>(this.httpClientHelper.Object);
this.dashboardRepository = DIContainer.Instance.Resolve<IDashboardRepository>();
}
public UserGraphType(
IRoleRepository roleRepository,
IDashboardRepository dashboardRepository,
IHttpContextAccessor httpContextAccessor)
{
_roleRepository = roleRepository;
_dashboardRepository = dashboardRepository;
_httpContextAccessor = httpContextAccessor;
Field(x => x.UserId, type: typeof(IdGraphType)).Description("Unique identifier from the authentication provider.");
Field(x => x.DateCreated, type: typeof(DateTimeGraphType)).Description("The date the record was created in the system.");
// Field<ListGraphType<RoleGraphType>>("roles",
// description: "",
// resolve: context =>
// {
// var results = context.Source.RoleIds.Select(x => _roleRepository.GetRoleByIdAsync(x).Result)
// .ToList();
// return results;
// });
Field <ListGraphType <AccrualGraphType> >("accruals",
description: "",
resolve: context =>
{
// int userId = _httpContextAccessor.HttpContext.User.UserId();
var results = _dashboardRepository.GetAllAccrualsForUser(context.Source.UserId);
return(results);
});
}
public DashboardController(IDashboardRepository dashboardRepository, IClienteRepository clienteRepository, IUsuarioRepository usuarioRepository, ITableroRepository tableroRepository)
{
this.dashboardRepository = dashboardRepository;
this.clienteRepository = clienteRepository;
this.usuarioRepository = usuarioRepository;
this.tableroRepository = tableroRepository;
}
//#Bonsai Snippets - Declarations
public override void SetRepositories()
{
_Service = new DashboardService <DashboardViewModel>((U, C, A) =>
ExecuteQueryWithReturnTypeAndNetworkAccessAsync <DashboardViewModel>(U, C, A));
_Repository = new DashboardRepository <DashboardViewModel>(_MasterRepo, _Service);
//#Bonsai Snippets - ServicedRepos
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Todos = new TodoRepository(context);
Categories = new CategoryRepository(context);
Dashboards = new DashboardRepository(context);
}
public DashboardManager(IDashboardRepository dashboardRepository, IPermissionManager permissionManager,
IShiftRepository shiftRepository)
{
_dashboardRepository = dashboardRepository;
_permissionManager = permissionManager;
_shiftRepository = shiftRepository;
}
public static PregnancyOutcomeType GetPregnancyOutcome(IDashboardRepository repo, string patientDfn, string pregIen)
{
PregnancyOutcomeType returnVal = PregnancyOutcomeType.Unknown;
ObservationListResult obsResult = repo.Observations.GetObservations(patientDfn, pregIen, "", "", "", "", "Outcome", 0, 0);
if (obsResult.Success)
{
if (obsResult.Observations != null)
{
foreach (Observation obs in obsResult.Observations)
{
if (obs.Code == ObservationsFactory.OutcomeTypeCode)
{
PregnancyOutcomeType outType = PregnancyOutcomeType.Unknown;
if (Enum.TryParse <PregnancyOutcomeType>(obs.Value, true, out outType))
{
returnVal = outType;
}
}
}
}
}
return(returnVal);
}
public DashboardService(IDashboardRepository dashboardrepository, LogHandler.Logger logManager, IDeviceService deviceService, IEntityService entityService)
{
_dashboardrepository = dashboardrepository;
_logger = logManager;
_deviceService = deviceService;
_entityService = entityService;
}
//private IDashboardRepository DashboardRepository { get; set; }
//public PregnancyUtilities(IDashboardRepository repo)
//{
// this.DashboardRepository = repo;
//}
public static PregnancyDetails GetWorkingPregnancy(IDashboardRepository repo, string dfn, string pregIen)
{
PregnancyDetails returnVal = null;
// *** First try the pregnancy ien passed in ***
if (!string.IsNullOrWhiteSpace(pregIen))
{
PregnancyListResult pregResult = repo.Pregnancy.GetPregnancies(dfn, pregIen);
if (pregResult.Success)
{
if (pregResult.Pregnancies != null)
{
if (pregResult.Pregnancies.Count > 0)
{
returnVal = pregResult.Pregnancies[0];
}
}
}
}
// *** Then try to get the current/most-recent ***
if (returnVal == null)
{
PregnancyResult pregResult = repo.Pregnancy.GetCurrentOrMostRecentPregnancy(dfn);
if (pregResult.Success)
{
returnVal = pregResult.Pregnancy;
}
}
return(returnVal);
}
public DashboardService(ILocationRepository locationRepository, IDashboardRepository dashboardrepository, LogHandler.Logger logManager, IGeneratorService generatorService)
{
_locationRepository = locationRepository;
_dashboardrepository = dashboardrepository;
_logger = logManager;
_generatorService = generatorService;
}
public DashboardController(IDashboardRepository repository)
{
if (!WebUtils.CheckRightsForAdminSettingsPage(true))
throw new HttpResponseException(HttpStatusCode.Unauthorized);
this.repository = repository;
}
public static PregnancyChecklistItemsResult GetSortedPregnancyChecklist(IDashboardRepository repo, string patientDfn, PregnancyDetails pregnancy, DsioChecklistCompletionStatus status)
{
PregnancyChecklistItemsResult result = new PregnancyChecklistItemsResult();
PregnancyChecklistItemsResult chkResult = repo.Checklist.GetPregnancyItems(patientDfn, pregnancy.Ien, "", status);
result.SetResult(chkResult.Success, chkResult.Message);
if (result.Success)
{
PregnancyChecklistItemList tempList = new PregnancyChecklistItemList();
tempList.AddRange(chkResult.Items);
tempList.AddPregnancyDates(pregnancy.EDD, pregnancy.EndDate);
tempList.Sort(delegate(PregnancyChecklistItem x, PregnancyChecklistItem y)
{
return(x.DueDate.CompareTo(y.DueDate));
});
result.Items = tempList;
}
return(result);
}
public DashboardBuilder(IDashboardRepository dashboardrepository, IWidgetRepository widgetrepository,
IParameterRepository parameterrepository)
{
_dashboardrepository = dashboardrepository;
_widgetrepository = widgetrepository;
_parameterrepository = parameterrepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="DashboardService"/> class.
/// </summary>
/// <param name="DashboardRepository">The dashboard repository.</param>
public DashboardService(IDashboardRepository DashboardRepository, IAccountService accountService, IFileService FileService, IDownloadRepository DownloadRepository)
{
this.m_DashboardRepository = DashboardRepository;
this.m_AccountService = accountService;
this.m_FileService = FileService;
this.m_DownloadRepository = DownloadRepository;
}
public DashboardController(IDashboardRepository dashboardRepository
, IHostingEnvironment hostingEnvironment
)
{
_idashboardRepository = dashboardRepository;
_hostingEnvironment = hostingEnvironment;
}
public DashboardBusiness(IUnitOfWork uow, ILogger <DashboardBusiness> logger, ICacheService cacheService,
IMapper mapper)
{
_cacheService = cacheService;
_repository = uow.Repository <IDashboardRepository>();
_logger = logger;
_mapper = mapper;
}
public DashBoardController(IDashboardRepository dashboard_repository, IMetricRepository metricRepository, ITagRepository tagRepository, IChartRepository chartRepository, IElementRepository elementRepository)
{
_dashboardRepository = dashboard_repository;
_iMetricRepository = metricRepository;
_iTagRepository = tagRepository;
_iChartRepository = chartRepository;
_iElementRepository = elementRepository;
}
public UsersController(IDashboardRepository repo,
IMapper mapper,
UserManager <User> userManager)
{
_repo = repo;
_mapper = mapper;
_userManager = userManager;
}
public DashboardManager(IHttpContextAccessor contextAccessor,
IDashboardRepository dashboardRepository,
IUnitOfWork unitOfWork)
{
_userId = contextAccessor.HttpContext.User.GetUserId();
_repository = dashboardRepository;
_unitOfWork = unitOfWork;
}
public DashboardController(IDashboardRepository dashboardRepository, IMenuItemRepository menuItemRepository, IMenuRepository menuRepository, IItemTagRepository itemTagRepository, ICategoryRepository categoryRepository, IServiceProvider serviceProvider) : base(serviceProvider)
{
_dashboardRepository = dashboardRepository;
_categoryRepository = categoryRepository;
_itemTagRepository = itemTagRepository;
_menuRepository = menuRepository;
_menuItemRepository = menuItemRepository;
}
public DashboardController(IDashboardBuilder dashboardbuilder, IDashboardRepository dashboardrepository,
SecurityResolver sr, SessionData sd)
{
_sr = sr;
_sd = sd;
_dashboardbuilder = dashboardbuilder;
_dashboardrepository = dashboardrepository;
}
public DashboardController(IDashboardRepository repository)
{
if (!WebUtils.CheckRightsForAdminSettingsPage(true))
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
this.repository = repository;
}
public DashboardService(IDashboardRepository dashboardRepository)
{
this._dashboardRepository = dashboardRepository;
if (!string.IsNullOrEmpty(CurrentUser.DbName))
{
this._dbName = CurrentUser.DbName;
this._userId = CurrentUser.UserId;
}
}
public DashboardHandler(IConfiguration configuration)
{
var factory = new ProcessorFactoryResolver <IDashboardRepository>(configuration);
dashboard = factory.CreateProcessor();
var masterFactory = new ProcessorFactoryResolver <IMasterDataRepository>(configuration);
masterRepository = masterFactory.CreateProcessor();
}
public DashboardService(IEntityRepository entityRepository, IDashboardRepository dashboardrepository, IDeviceService deviceService, LogHandler.Logger logManager, IUserDashboardWidgetRepository userDashboardWidgetRepository, IMasterWidgetRepository masterWidgetRepository)
{
_entityRepository = entityRepository;
_dashboardrepository = dashboardrepository;
_deviceService = deviceService;
_logger = logManager;
_userDashboardWidgetRepository = userDashboardWidgetRepository;
_masterWidgetRepository = masterWidgetRepository;
}
public static BrokerOperationResult UpdateNextDates(IDashboardRepository repo, string patientDfn, string pregnancyIen)
{
BrokerOperationResult result = new BrokerOperationResult();
// *** First get the pregnancy ***
PregnancyListResult pregResult = repo.Pregnancy.GetPregnancies(patientDfn, pregnancyIen);
result.SetResult(pregResult.Success, pregResult.Message);
if (pregResult.Success)
{
if (pregResult.Pregnancies != null)
{
if (pregResult.Pregnancies.Count > 0)
{
// *** Get the checklist items ***
PregnancyChecklistItemsResult getResult = GetSortedPregnancyChecklist(repo, patientDfn, pregResult.Pregnancies[0], DsioChecklistCompletionStatus.NotComplete);
result.SetResult(getResult.Success, getResult.Message);
if (result.Success)
{
if (getResult.Items != null)
{
if (getResult.Items.Count > 0)
{
// *** Find the next due ***
DateTime nextChecklistDue = getResult.Items[0].DueDate;
// *** Save next checklist observation ***
result = repo.Observations.UpdateNextChecklistDue(patientDfn, nextChecklistDue);
if (result.Success)
{
// *** Find next contact due ***
DateTime nextContactDue = DateTime.MinValue;
foreach (PregnancyChecklistItem item in getResult.Items)
{
if (item.ItemType == DsioChecklistItemType.MccCall)
{
nextContactDue = item.DueDate;
break;
}
}
result = repo.Observations.UpdateNextContactDue(patientDfn, nextContactDue);
}
}
}
}
}
}
}
return(result);
}
public OracleRepository(string connectionString)
{
OracleInsightDbProvider.RegisterProvider();
db = new OracleConnectionStringBuilder(connectionString);
searchRepository = new SearchRepository(db);
historyRepository = new AccessHistoryRepository(db);
dashboardRepository = new DashboardRepository(db);
}
public static BrokerOperationResult CompleteEducationItem(IDashboardRepository repo, string patientDfn, string educationItemIen, string checklistItemIen)
{
BrokerOperationResult returnResult = new BrokerOperationResult();
// *** Two-step process:
// *** (1) Create completed patient education item
// *** (2) Complete the checklist item
PatientEducationItem patItem = new PatientEducationItem()
{
PatientDfn = patientDfn,
EducationItemIen = educationItemIen,
CompletedOn = DateTime.Now
};
IenResult saveResult = repo.Education.SavePatientItem(patItem);
returnResult.SetResult(saveResult.Success, saveResult.Message);
if (saveResult.Success)
{
PregnancyChecklistItemsResult result = repo.Checklist.GetPregnancyItems(patientDfn, "", checklistItemIen);
returnResult.SetResult(result.Success, result.Message);
if (result.Success)
{
if (result.Items != null)
{
if (result.Items.Count > 0)
{
PregnancyChecklistItem checkItem = result.Items[0];
checkItem.CompletionStatus = DsioChecklistCompletionStatus.Complete;
checkItem.CompletionLink = saveResult.Ien;
IenResult ienResult = repo.Checklist.SavePregnancyItem(checkItem);
returnResult.SetResult(ienResult.Success, ienResult.Message);
if (returnResult.Success)
{
returnResult = UpdateNextDates(repo, patientDfn, checkItem.PregnancyIen);
if (returnResult.Success)
{
returnResult.Message = "Education item completed";
}
}
}
}
}
}
return(returnResult);
}
public static Dictionary <string, string> GetPregnanciesSelection(IDashboardRepository repo, string dfn)
{
Dictionary <string, string> returnVal = new Dictionary <string, string>();
List <PregnancyDetails> pregList = PregnancyUtilities.GetPregnancies(repo, dfn);
returnVal = PregnancyUtilities.GetPregnanciesSelection(pregList, false);
return(returnVal);
}
public DashboardHandler(IConfiguration configuration, IEMailHandler _emailHandler, IHostingEnvironment env)
{
var factory = new ProcessorFactoryResolver <IDashboardRepository>(configuration);
dashboardRepository = factory.CreateProcessor();
var mfactory = new ProcessorFactoryResolver <IMasterDataRepository>(configuration);
masterDataRepository = mfactory.CreateProcessor();
emailHandler = _emailHandler;
environment = env;
}
public AdministrationController(IUserRepository userRepository, IMemberRepository memberRepository,
IAttendanceRepository attendanceRepository, IEventRepository eventRepository,
IDashboardRepository dashboardRepository, IGroupRepository groupRepository)
{
_userRepository = userRepository;
_memberRepository = memberRepository;
_attendanceRepository = attendanceRepository;
_eventRepository = eventRepository;
_dashboardRepository = dashboardRepository;
_groupRepository = groupRepository;
}
public DashboardManager(
ILogger <DashboardManager> logger,
IDashboardRepository repository, AssetTagManager tagManager, MetadataManager metadataManager,
ExchangeManager exchangeManager, CurrencyConfiguration currencyConfig)
{
_logger = logger;
_repository = repository;
_tagManager = tagManager;
_metadataManager = metadataManager;
_exchangeManager = exchangeManager;
_currencyConfig = currencyConfig;
}
public DashboardController(IMenuItemService menuItemService, IDashboardService dashboardService,
IMenuItemRepository menuItemRepository,
IDashboardRepository dashboardRepository,
//IDashboardUserRepository dashboardUserRepository,
IApplicationUserRepository ApplicationUserRepository,
ICrudRepository<SharedWith> sharedWithRepository,
ICrudRepository<DashboardType> dashboardTypeRepository,
IUnitOfWork<DashboardContext> dashboardUnitOfWork, ICurrentUser currentUser)
{
//db = new SJiraContext();
this._menuItemService = menuItemService;
this._menuItemRepository = menuItemRepository;
this._dashboardRepository = dashboardRepository;
this._dashboardService = dashboardService;
//this._dashboardUserRepository = dashboardUserRepository;
this._ApplicationUserRepository = ApplicationUserRepository;
this._sharedWithRepository = sharedWithRepository;
this._dashboardTypeRepository = dashboardTypeRepository;
this._dashboardUnitOfWork = dashboardUnitOfWork;
this._currentUser = currentUser;
}
/// <summary>
/// Initializes a new instance of the <see cref="DashboardManager"/> class.
/// </summary>
/// <param name="repository">The Dashboard repository instance.</param>
public DashboardManager(IDashboardRepository repository)
{
this.dashboardRepository = repository;
}
public HomeController(IDashboardRepository dashboardRepository)
{
this.dashboardRepository = dashboardRepository;
}
public DashboardService(IDashboardRepository
repository, IUnitOfWork unitOfWork)
{
this._repository = repository;
this._unitOfWork = unitOfWork;
}
public DashboardController(IDashboardRepository repository)
{
this.repository = repository;
}
/// <summary>
/// Initializes the controller with dependency injection.
/// </summary>
/// <param name="dashParam">Implementation of IDashboardRepository.</param>
/// <param name="authParam">Implementation of IAuthorizationRepository.</param>
public DashboardController(IDashboardRepository dashParam, IAuthorizationRepository authParam, ISiteSettingRepository siteParam)
{
repo = dashParam;
authRepo = authParam;
site = siteParam;
}
public DashboardService(IDashboardRepository dashboardRepository, IUnitOfWork unitOfWork)
{
this.dashboardRepository = dashboardRepository;
this.unitOfWork = unitOfWork;
}
public DashboardController(IGenericRepository genRepo, IDashboardRepository dashRepo)
{
_genRepo = genRepo;
_dashRepo = dashRepo;
}
public DashboardService(IDashboardRepository DashboardRepository)
{
_DashboardRepository = DashboardRepository;
}
