/// <summary>
/// Creates article controller
/// </summary>
/// <param name="blogPostRepository">blogpost repository to use, leave null to use default mocked implementation</param>
/// <param name="shouldBlogPostRepositoryAlwayReturnPost">if using default blogpost repository, if set to true then repository will always return BlogPost regardless of input. If however it is false posts titles are 0 to 19 and published date is current day</param>
/// <param name="lookupRepository">repository to look things up, leave null for default mocked implementation</param>
/// <param name="configurationReader">configuration reader to use, leave null for default mocked implementation</param>
/// <param name="waneTransform">wane transform, leave null for default mocked implementaion</param>
/// <param name="logger">Logger, leave null for default implementation</param>
/// <param name="principal">principal used for security, leave null for default implementation</param>
/// <returns></returns>
public static BlogPostController CreateBlogPostController(IBlogPostRepository blogPostRepository = null, bool shouldBlogPostRepositoryAlwayReturnPost = true,
ILookupRepository lookupRepository = null, IConfigurationReader configurationReader = null, IWaneTransform waneTransform = null, IJumbleblocksLogger logger = null,
IJumbleblocksPrincipal principal = null)
{
if (blogPostRepository == null)
blogPostRepository = CreateMockedBlogPostRepository(shouldBlogPostRepositoryAlwayReturnPost).Object;
if (lookupRepository == null)
lookupRepository = CreateMockedLookupRepository().Object;
if (configurationReader == null)
configurationReader = CreateMockedConfigurationReader().Object;
if (waneTransform == null)
waneTransform = CreateMockedWaneTransform().Object;
if (logger == null)
logger = new Mock<IJumbleblocksLogger>().Object;
if (principal == null)
principal = CreateMockedPrincipalAndAddBlogUserToLookUp(Mock.Get<ILookupRepository>(lookupRepository)).Object;
var controller = new BlogPostController(blogPostRepository, lookupRepository, configurationReader, waneTransform, logger);
controller.SetMockedControllerContext();
controller.SetPrincipal(principal);
return controller;
}
public MembersController(IDivineRepositories repositories,
IDivineLogger logger, IGeocoder geocoder,
IHttpContextAccessor _httpContextAccessor)
: base(repositories,logger, _httpContextAccessor)
{
membersRepo = repositories.MemberRepo;
lookupRepo = repositories.LookupRepo;
this.geocoder = geocoder;
}
public BlogPostDeleter(IBlogPostRepository blogPostRepository, ILookupRepository lookupRepository)
{
if (blogPostRepository == null)
throw new ArgumentNullException("blogPostRepository");
if (lookupRepository == null)
throw new ArgumentNullException("lookupRepository");
BlogPostRepository = blogPostRepository;
LookupRepository = lookupRepository;
}
public DivineRepositories(IRepository<Attendance> attendance,
ILookupRepository lookup,
IRepository<Member> member,
IRepository<DivineMessage> message
)
{
AttendanceRepo = attendance;
LookupRepo = lookup;
MemberRepo = member;
MessageRepo = message;
}
// private DivineBotDialog divineDialog;
public MessageController(IDivineRepositories repositories,
ICommunicationService msgService, IMemoryCache cache,
IDivineLogger logger, IHttpContextAccessor _httpContextAccessor
/* DivineBotDialog divineBotDialog*/)
: base(repositories, logger, _httpContextAccessor)
{
this.msgRepo = repositories.MessageRepo;
this.msgService = msgService;
this.membersRepo = repositories.MemberRepo;
this.lookupRepo = repositories.LookupRepo;
this.cache = cache;
this.attendanceRepo = repositories.AttendanceRepo;
//this.divineDialog = divineBotDialog;
this.repositories = repositories;
}
//
//
public WorkAssignmentService(
IWorkAssignmentRepository waRepo,
IWorkerRepository wRepo,
IWorkOrderRepository woRepo,
ILookupRepository lRepo,
IWorkerSigninRepository wsiRepo,
IUnitOfWork unitOfWork,
IMapper map
) : base(waRepo, unitOfWork)
{
this.waRepo = waRepo;
this.unitOfWork = unitOfWork;
this.wRepo = wRepo;
_woRepo = woRepo;
this.lRepo = lRepo;
this.wsiRepo = wsiRepo;
this.map = map;
this.logPrefix = "WorkAssignment";
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="repo"></param>
/// <param name="waServ">Work Assignment service</param>
/// <param name="uow">Unit of Work</param>
public WorkOrderService(IWorkOrderRepository repo,
IWorkAssignmentService waServ,
ITransportProvidersService tpServ,
IWorkerRequestService wrServ,
IWorkerService wServ,
ILookupRepository lRepo,
IUnitOfWork uow,
IMapper map,
IConfigService cfg) : base(repo, uow)
{
this.waServ = waServ;
this.wrServ = wrServ;
this.wServ = wServ;
this.map = map;
this.lRepo = lRepo;
this.cfg = cfg;
this.tpServ = tpServ;
this.logPrefix = "WorkOrder";
}
public MatchDetailService(ILogger <MatchDetailService> logger, IEmailService emailService, IPlayerStatsRepository playerStatsRepository, ISummonerInfoRepository summonerInfoRepository,
ISeasonInfoRepository seasonInfoRepository, IMatchDetailRepository matchDetailRepository, IMatchMvpRepository matchMvpRepository,
IChampionStatsRepository championStatsRepository, IScheduleService scheduleService, ITeamPlayerRepository teamPlayerRepository, ITeamRosterRepository teamRosterRepository,
IAchievementRepository achievementRepository, ILookupRepository lookupRepository)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_emailService = emailService ?? throw new ArgumentNullException(nameof(emailService));
_playerStatsRepository = playerStatsRepository ?? throw new ArgumentNullException(nameof(playerStatsRepository));
_summonerInfoRepository = summonerInfoRepository ?? throw new ArgumentNullException(nameof(summonerInfoRepository));
_seasonInfoRepository = seasonInfoRepository ?? throw new ArgumentNullException(nameof(seasonInfoRepository));
_matchDetailRepository = matchDetailRepository ?? throw new ArgumentNullException(nameof(matchDetailRepository));
_matchMvpRepository = matchMvpRepository ?? throw new ArgumentNullException(nameof(matchMvpRepository));
_championStatsRepository = championStatsRepository ?? throw new ArgumentNullException(nameof(championStatsRepository));
_scheduleService = scheduleService ?? throw new ArgumentNullException(nameof(scheduleService));
_teamPlayerRepository = teamPlayerRepository ?? throw new ArgumentNullException(nameof(teamPlayerRepository));
_teamRosterRepository = teamRosterRepository ?? throw new ArgumentNullException(nameof(teamRosterRepository));
_achievementRepository = achievementRepository ?? throw new ArgumentNullException(nameof(achievementRepository));
_lookupRepository = lookupRepository ?? throw new ArgumentNullException(nameof(lookupRepository));
}
public EventsController(
ILookupRepository lookupRepo,
IEventRepository eventRepo,
ACDBContext ctx)
{
_lookupRepo = lookupRepo;
_eventRepo = eventRepo;
_ctx = ctx;
ViewBag.PossibleEventDocumentationTypes = _lookupRepo.GetEventDocumentationTypes();
ViewBag.PossibleEventTypes = _lookupRepo.GetEventTypes();
ViewBag.PossibleWebIncidentTypes = _lookupRepo.GetWebIncidentTypes();
ViewBag.PossibleApprovalStatus = _lookupRepo.GetApprovalStatuses();
ViewBag.PossibleActiveStatus = _lookupRepo.GetActiveStatuses();
ViewBag.PossibleMovementClasses = _lookupRepo.GetMovementClasses();
ViewBag.PossibleRemovalStatus = _lookupRepo.GetRemovalStatus();
ViewBag.PossiblePrimaryStatus = _lookupRepo.GetPrimaryStatuses();
ViewBag.PossibleNewsSources = _lookupRepo.GetNewsSources();
ViewBag.PossibleReligions = _lookupRepo.GetReligions();
}
public AdminService(ICompanyRepository companyRepository, IAdminViewModelFactory adminViewModelFactory, IDigitalFileRepository digitalFileRepository,
ILookupRepository lookupRepository, IDepartmentRepository departmentRepository, IEmployeeOnBoardRepository employeeOnBoardRepository,
IJobTitleRepository jobTitleRepository, ISessionStateService session, IAccountRepository accountRepository,
IIndustryRepository industryRepository, IUsersRepository usersRepository, IDigitalFileService digitalFileService,
IGenerateDocumentService generateDocumentService)
{
this.companyRepository = companyRepository;
this.adminViewModelFactory = adminViewModelFactory;
this.lookupRepository = lookupRepository;
this.departmentRepository = departmentRepository;
this.jobTitleRepository = jobTitleRepository;
this.industryRepository = industryRepository;
this.usersRepository = usersRepository;
this.session = session;
this.accountRepository = accountRepository;
this.digitalFileService = digitalFileService;
this.generateDocumentService = generateDocumentService;
this.employeeOnBoardRepository = employeeOnBoardRepository;
this.digitalFileRepository = digitalFileRepository;
}
public ReportService(IWorkOrderRepository woRepo,
IWorkAssignmentRepository waRepo,
IWorkerRepository wRepo,
IWorkerSigninRepository wsiRepo,
IWorkerRequestRepository wrRepo,
ILookupRepository lookRepo,
ILookupCache lookCache,
IEmployerRepository eRepo,
IActivitySigninRepository asRepo)
{
this.woRepo = woRepo;
this.waRepo = waRepo;
this.wRepo = wRepo;
this.wsiRepo = wsiRepo;
this.wrRepo = wrRepo;
this.lookRepo = lookRepo;
this.lookCache = lookCache;
this.eRepo = eRepo;
this.asRepo = asRepo;
}
public WorkAssignmentService(
IWorkAssignmentRepository waRepo,
IWorkerRepository wRepo,
IWorkOrderRepository woRepo,
ILookupRepository lRepo,
IWorkerSigninRepository wsiRepo,
IUnitOfWork unitOfWork,
IMapper map,
ITenantService tenantService
) : base(waRepo, unitOfWork)
{
this.waRepo = waRepo;
this.unitOfWork = unitOfWork;
this.wRepo = wRepo;
_woRepo = woRepo;
this.lRepo = lRepo;
this.wsiRepo = wsiRepo;
this.map = map;
this.logPrefix = "WorkAssignment";
_clientTimeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(tenantService.GetCurrentTenant().Timezone);
}
public PayrollServices(IPayrollRepository payrollRepository, ILookupRepository lookupRepository, IEmployeeRepository employeeRepository,
IPayrollViewModelFactory payrollViewModelFactory, ILevelGradeRepository levelGradeRepository, ICompanyRepository companyRepository,
IEmployeeDeductionRepository employeeDeductionRepository, IRewardRepository rewardRepository, ILoanRepository loanRepository,
IEmployeeOnBoardRepository employeeOnBoardRepository, IUsersRepository usersRepository, ILevelRepository levelRepository,
IGradeRepository gradeRepository, IBenefitRepository benefitRepository, IDigitalFileRepository digitalFileRepository, ISessionStateService session)
{
this.lookupRepository = lookupRepository;
this.payrollRepository = payrollRepository;
this.payrollViewModelFactory = payrollViewModelFactory;
this.levelGradeRepository = levelGradeRepository;
this.employeeRepository = employeeRepository;
this.employeeDeductionRepository = employeeDeductionRepository;
this.companyRepository = companyRepository;
this.rewardRepository = rewardRepository;
this.loanRepository = loanRepository;
this.usersRepository = usersRepository;
this.levelRepository = levelRepository;
this.gradeRepository = gradeRepository;
this.benefitRepository = benefitRepository;
this.employeeOnBoardRepository = employeeOnBoardRepository;
this.digitalFileRepository = digitalFileRepository;
this.session = session;
}
public static void search(viewOptions o, ref IQueryable <WorkAssignment> q, ILookupRepository lRepo)
{
bool isDateTime = false;
DateTime parsedTime;
if (isDateTime = DateTime.TryParse(o.sSearch, out parsedTime))
{
filterOnDatePart(o.sSearch, parsedTime, ref q);
}
else
{
q = q
.Join(lRepo.GetAllQ(), wa => wa.skillID, sk => sk.ID, (wa, sk) => new { wa, sk })
.Where(p => p.wa.workOrder.paperOrderNum.ToString().Contains(o.sSearch) ||
p.wa.description.Contains(o.sSearch) ||
p.sk.text_EN.Contains(o.sSearch) ||
p.sk.text_ES.Contains(o.sSearch) ||
p.wa.workOrder.contactName.Contains(o.sSearch) ||
p.wa.workOrder.Employer.name.Contains(o.sSearch) ||
//p.dateupdated.ToString().ContainsOIC(param.sSearch) ||
p.wa.updatedby.Contains(o.sSearch)).Select(p => p.wa);
}
}
/// <summary>
/// Business logic object for WorkOrder record management. Contains logic specific
/// to processing work orders, and not necessarily related to a web application.
/// </summary>
/// <param name="repo"></param>
/// <param name="waServ">Work Assignment service</param>
/// <param name="tpServ"></param>
/// <param name="wrServ"></param>
/// <param name="wServ"></param>
/// <param name="lRepo"></param>
/// <param name="uow">Unit of Work</param>
/// <param name="map"></param>
/// <param name="cfg"></param>
/// <param name="tenantService"></param>
public WorkOrderService(IWorkOrderRepository repo,
IWorkAssignmentService waServ,
ITransportProvidersService tpServ,
IWorkerRequestService wrServ,
IWorkerService wServ,
ILookupRepository lRepo,
IUnitOfWork uow,
IMapper map,
IConfigService cfg,
ITenantService tenantService
) : base(repo, uow)
{
this.repo = repo;
this.waServ = waServ;
this.wrServ = wrServ;
this.wServ = wServ;
this.map = map;
this.lRepo = lRepo;
this.cfg = cfg;
this.tpServ = tpServ;
this.logPrefix = "WorkOrder";
_clientTimeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(tenantService.GetCurrentTenant().Timezone);
}
public BlogPostController(IBlogPostRepository blogPostSummaryRepository, ILookupRepository lookupRepository, IConfigurationReader configurationReader, IWaneTransform waneTransformer, IJumbleblocksLogger logger)
{
if (blogPostSummaryRepository == null)
throw new ArgumentNullException("blogPostSummaryRepository");
if (lookupRepository == null)
throw new ArgumentNullException("lookupRepository");
if (configurationReader == null)
throw new ArgumentNullException("configurationReader");
if (waneTransformer == null)
throw new ArgumentNullException("waneTransformer");
if (logger == null)
throw new ArgumentNullException("logger");
BlogPostRepository = blogPostSummaryRepository;
LookupRepository = lookupRepository;
ConfigurationReader = configurationReader;
WaneTransformer = waneTransformer;
Logger = logger;
}
public static async Task SetupChampionCache(ILookupRepository lookupRepo)
{
var retry = 0;
var maxRetry = 4;
while (retry < maxRetry)
{
try
{
if (!ChampionDictionary.Any())
{
var champions = (await lookupRepo.GetLookupEntitiesByCategory("Champion")).ToList();
foreach (var championLookup in champions.OrderBy(x => x.Enum))
{
var enumValue = championLookup.Enum;
var trueValue = championLookup;
ChampionDictionary.Add(enumValue.ToLowerInvariant(), trueValue);
}
if (!ChampionDictionary.Any())
{
throw new NotImplementedException(nameof(GlobalVariables.ChampionDictionary));
}
}
break;
}
catch (Exception)
{
retry++;
if (retry >= maxRetry)
{
//somethings wrong I can feel it
}
}
}
}
public AddressesController(IAddressRepository addressRepository,
IAddressChapterRelRepository addresschapterrelRepository,
IAddressPersonRelRepository addresspersonrelRepository,
IAddressEventRelRepository addresseventrelRepository,
IAddressContactRelRepository addresscontactrelRepository,
IAddressSubscriptionsRelRepository addresssubscriptionsrelRepository,
ILookupRepository lookupRepo,
IPersonRepository personRepo,
IBeholderPersonRepository beholderPersonRepo)
{
_lookupRepo = lookupRepo;
_addressRepository = addressRepository;
_addresspersonrelRepository = addresspersonrelRepository;
_addresschapterrelRepository = addresschapterrelRepository;
_addresseventrelRepository = addresseventrelRepository;
_addresscontactrelRepository = addresscontactrelRepository;
_addresssubscriptionsrelRepository = addresssubscriptionsrelRepository;
_beholderPersonRepo = beholderPersonRepo;
_personRepo = personRepo;
ViewBag.PossibleStates = _lookupRepo.GetStates();
ViewBag.PossibleAddressTypes = _lookupRepo.GetAddressTypes();
ViewBag.PossiblePrimaryStatus = _lookupRepo.GetPrimaryStatuses();
}
public static void typeOfWork(viewOptions o, ref IQueryable <WorkAssignment> q, ILookupRepository lRepo)
{
q = q.Join(lRepo.GetAllQ(),
wa => wa.skillID,
sk => sk.ID,
(wa, sk) => new { wa, sk })
.Where(jj => jj.sk.typeOfWorkID == o.typeofwork_grouping)
.Select(jj => jj.wa);
}
public ProductRepository(ILookupRepository lookupRepository)
{
this.lookupRepository = lookupRepository;
}
public GatewayLookupService(ILookupRepository lookupService, IApiUserRepository apiUserService)
{
_lookupService = lookupService;
_mpApiUserService = apiUserService;
}
/// <summary>
/// Initializes a new instance of the <see cref="LookupService"/> class.
/// </summary>
/// <param name="productCategoryRepository">The product category repository.</param>
public LookupService(ILookupRepository <TEntity> lookupRepository)
{
_lookupRepository = lookupRepository;
}
public LookupComponent(ILookupRepository LookupRepository, ICourtRepository CourtRepository)
{
this.LookupRepository = LookupRepository;
this.CourtRepository = CourtRepository;
}
public LookupService(ILookupRepository LookupRepository)
{
_LookupRepositoy = LookupRepository;
}
public static IEnumerable <WorkAssignment> filterOnSkill(
viewOptions o,
IQueryable <WorkAssignment> q,
ILookupRepository l,
Worker worker)
{
// "Machete --A series of good intentions, marinated in panic."
//
// Kludge panic. horrible flattening job of relational data.
// Skills have hierarchy (painter, skilled painter, master painter)
// kludge assumes hierarchy tree will never lead to more than 6 skill IDs to
// match against. Hacked this late one night.
int?skill1 = null;
int?skill2 = null;
int?skill3 = null;
int?skill4 = null;
int?skill5 = null;
int?skill6 = null;
IEnumerable <WorkAssignment> filteredWA = q.AsEnumerable();
Stack <int> primeskills = new Stack <int>();
Stack <int> skills = new Stack <int>();
//Worker worker = wcache.FirstOrDefault(w => w.dwccardnum == o.dwccardnum);
if (worker != null)
{
if (worker.skill1 != null)
{
primeskills.Push((int)worker.skill1);
}
if (worker.skill2 != null)
{
primeskills.Push((int)worker.skill2);
}
if (worker.skill3 != null)
{
primeskills.Push((int)worker.skill3);
}
foreach (var skillid in primeskills)
{
skills.Push(skillid);
Lookup skill = l.GetById(skillid);
foreach (var subskill in l.GetManyQ(a => a.category == skill.category &&
a.subcategory == skill.subcategory &&
a.level < skill.level))
{
skills.Push(subskill.ID);
}
}
if (skills.Count() != 0)
{
skill1 = skills.Pop();
}
if (skills.Count() != 0)
{
skill2 = skills.Pop();
}
if (skills.Count() != 0)
{
skill3 = skills.Pop();
}
if (skills.Count() != 0)
{
skill4 = skills.Pop();
}
if (skills.Count() != 0)
{
skill5 = skills.Pop();
}
if (skills.Count() != 0)
{
skill6 = skills.Pop();
}
filteredWA = filteredWA.Join(l.GetAllQ(), //LINQ
wa => wa.skillID,
sk => sk.ID,
(wa, sk) => new { wa, sk }
)
.Where(jj => jj.wa.englishLevelID <= worker.englishlevelID &&
jj.sk.typeOfWorkID.Equals(worker.typeOfWorkID) && (
jj.wa.skillID.Equals(skill1) ||
jj.wa.skillID.Equals(skill2) ||
jj.wa.skillID.Equals(skill3) ||
jj.wa.skillID.Equals(skill4) ||
jj.wa.skillID.Equals(skill5) ||
jj.wa.skillID.Equals(skill6) ||
jj.sk.speciality == false)
)
.Select(jj => jj.wa).AsEnumerable();
}
return(filteredWA);
}
private LookupKernel(ILookupRepository dbContext)
{
_lookupRepository = dbContext;
}
public LookupService()
{
menuReposity = new MenuRepository(DbContextSelector.getInstance().getDbFactory(DbContextSelector.DbName.Workflow));
lookupReposity = new LookupRepository(DbContextSelector.getInstance().getDbFactory(DbContextSelector.DbName.Workflow));
lookupChildReposity = new LookupRepository(DbContextSelector.getInstance().getDbFactory(DbContextSelector.DbName.Workflow));
}
public AdminController()
{
lookupRepository = new LookupRepository();
vehicleRepository = new VehicleRepository();
}
public abstract void LoadCategoryInfo(ILookupRepository lRep);
public SeedData(DivineContext context, ILookupRepository lookupRepo)
{
dbContext = context;
this.lookupRepo = lookupRepo;
}
public static void waGrouping(viewOptions o, ref IQueryable <WorkAssignment> q, ILookupRepository lRepo)
{
switch (o.wa_grouping)
{
case "open": q = q.Where(p => p.workerAssignedID == null &&
p.workOrder.statusID == WorkOrder.iActive);
break;
case "assigned": q = q.Where(p => p.workerAssignedID != null &&
p.workOrder.statusID == WorkOrder.iActive); break;
case "requested":
q = q.Where(p => p.workerAssignedID == null &&
p.workOrder.workerRequestsDDD.Any() == true &&
p.workOrder.statusID == WorkOrder.iActive);
break;
case "skilled": q = q.Join(lRepo.GetAllQ(),
wa => wa.skillID,
sk => sk.ID,
(wa, sk) => new { wa, sk })
.Where(jj => jj.sk.speciality == true &&
jj.wa.workerAssignedDDD == null &&
jj.wa.workOrder.statusID == WorkOrder.iActive)
.Select(jj => jj.wa);
break;
case "completed":
q = q.Where(wa => wa.workOrder.statusID == WorkOrder.iCompleted);
break;
}
}
public LookupBAL(ILookupRepository lookupRepository)
{
_lookupRepository = lookupRepository;
}
public SharepointPromoteKeyValueLookupResult()
{
_repository = new SharepointLookupRepository();
}
/// <summary>
/// Initializes a new instance of the <see cref="LookupService"/> class.
/// </summary>
/// <param name="repository">The loopup reposutory.</param>
public LookupService(ILookupRepository repository)
{
this.repository = repository;
}
public LookupServices(ILookupRepository lookupRepository, IGeneralFactory generalFactory)
{
this.generalFactory = generalFactory;
this.lookupRepository = lookupRepository;
}
public RatingLinkModel()
{
_lookupRepository = DependencyResolver.Current.GetService <ILookupRepository>();
}
public EventCancellationModelFactory(ILookupRepository lookupRepository, IOrganizationRoleUserRepository organizationRoleUserRepository, IHostRepository hostRepository)
{
_lookupRepository = lookupRepository;
_organizationRoleUserRepository = organizationRoleUserRepository;
_hostRepository = hostRepository;
}
public LookupController(ILookupRepository repository)
{
this.repository = repository;
}
public LookupApiController(ILookupRepository statesRepo, ILoggerFactory loggerFactory)
{
_LookupRepository = statesRepo;
_Logger = loggerFactory.CreateLogger(nameof(LookupApiController));
}
public FormsService(ILookupRepository lookupRepository)
{
_lookupRepository = lookupRepository;
}
