public HomeController(IManagerRepository manager, IManagerRoleRepository managerRole, IMenuRepository menu, IRolePermissionRepository rolePermission)
{
_manager = manager;
_managerRole = managerRole;
_menu = menu;
_rolePermission = rolePermission;
}
public Seed(UserManager <User> userManager,
RoleManager <Role> roleManager,
IUnitOfWork unitOfWork,
ISeasonRepository seasonRepository,
IStadiumRepository stadiumRepository,
IClubRepository clubRepository,
ISquadRepository squadRepository,
IKitRepository kitRepository,
IManagerRepository managerRepository,
IPlayerRepository playerRepository)
{
_userManager = userManager;
_roleManager = roleManager;
_unitOfWork = unitOfWork;
_seasonRepository = seasonRepository;
_stadiumRepository = stadiumRepository;
_clubRepository = clubRepository;
_squadRepository = squadRepository;
_kitRepository = kitRepository;
_managerRepository = managerRepository;
_playerRepository = playerRepository;
_jsonSerializerSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore
};
}
//Inject the repositories
public VacationRequestService(IVacationRequestRepository repo, IMessageRepository messrepository, IUnitOfWork uow, IManagerRepository manrepository)
{
_repository = repo;
_messrepository = messrepository;
_uow = uow;
_manrepository = manrepository;
}
public void HireManager(int manId, bool free = false)
{
IManagerRepository managerRepository = ResourceService.Managers;
var man = managerRepository.GetManagerData(manId);
var genId = manId;
Hire(genId);
Services.GenerationService.Generators.SetAutomatic(genId, true);
ManagerInfo manager = GameServices.Instance.ManagerService.GetManager(manId);
if (!free)
{
Player.RemoveCompanyCash(manager.Cost);
Player.CheckNonNegativeCompanyCash();
}
if (manager.CashOnHand < 1)
{
manager.ResetNextKickBackTime();
}
if (!Convert.ToBoolean(PlayerPrefs.GetInt("FirstManagerHire_" + genId, 0)))
{
FacebookEventUtils.LogFirstHireManagerEvent(genId);
PlayerPrefs.SetInt("FirstManagerHire_" + genId, 1);
}
}
public OrderController(IOrderRepository orders, IManagerRepository managers)
{
this._orderRepository = orders;
this._managerRepository = managers;
this._managerSelectList = new ManagerSelectList(_managerRepository);
InitiateManagers();
}
public EquipmentDistributionService(IEquipmentDistribution equipmentDistribution, IEquipmentRepository equipmentRepository, IAgentRepository agentRepository, IManagerRepository managerRepository)
{
_equipmentDistributionRepository = equipmentDistribution;
_equipmentRepository = equipmentRepository;
_agentRepository = agentRepository;
_managerRepository = managerRepository;
}
public NotificationRepository(ICSVStream <Notification> stream, ISequencer <long> sequencer, IPatientRepository patientRepository, IDoctorRepository doctorRepository, IManagerRepository managerRepository, ISecretaryRepository secretaryRepository) : base(ENTITY_NAME, stream, sequencer, new LongIdGeneratorStrategy <Notification>())
{
_patientRepository = patientRepository;
_doctorRepository = doctorRepository;
_managerRepository = managerRepository;
_secretaryRepository = secretaryRepository;
}
public void SetUp()
{
_wordRepository = Substitute.For <IWordRepository>();
_managerRepository = Substitute.For <IManagerRepository>();
_modificationService = new ModificationService(_managerRepository, _wordRepository);
}
public ProjectService(
IUnitOfWork unitOfWork,
IMapper mapper,
IProjectRepository projectRepository,
IRoomRepository roomRepository,
IUserRepository userRepository,
ITagRepository tagRepository,
IManagerRepository managerRepository,
ITeamMemberRepository teamMemberRepository,
ITaskRepository taskRepository,
IFollowRepository followRepository,
MapperConfiguration mapperConfig,
INotificationRepository notificationRepository)
{
_unitOfWork = unitOfWork;
_mapper = mapper;
_projectRepository = projectRepository;
_roomRepository = roomRepository;
_managerRepository = managerRepository;
_teamMemberRepository = teamMemberRepository;
_tagRepository = tagRepository;
_userRepository = userRepository;
_taskRepository = taskRepository;
_followRepository = followRepository;
_notificationRepository = notificationRepository;
_mapperConfig = mapperConfig;
}
public LoginService(RepositoryFactory repositoryFactory)
{
_doctorFileRepository = repositoryFactory.GetDoctorRepository();
_managerFileRepository = repositoryFactory.GetManagerRepository();
_patientFileRepository = repositoryFactory.GetPatientRepository();
_secretaryFileRepository = repositoryFactory.GetSecretaryRepository();
}
public ManagerService(IManagerRepository repository, IManagerRoleRepository roleRepository, IMapper mapper, IManagerLogRepository managerLogRepository)
{
_repository = repository;
_roleRepository = roleRepository;
_mapper = mapper;
_managerLogRepository = managerLogRepository;
}
public AppointmentService(IAppointmentRepository appointmentRepository, IManagerBuildingRepository managerBuildingRepository,
IManagerTimeSlotRepository managerTimeSlotRepository, IManagerRepository managerRepository)
{
_appointmentRepository = appointmentRepository;
_managerBuildingRepository = managerBuildingRepository;
_managerTimeSlotRepository = managerTimeSlotRepository;
_managerRepository = managerRepository;
}
public ManagerController(IRepositoryEF <ManagerEntities> repositoryEF, IManagerRepository repository, IUnitOfWork unitOfWork, IMapper mapper, IRoleRepository roleRepository)
{
this._repositoryEF = repositoryEF;
this._repository = repository;
this._unitOfWork = unitOfWork;
this._mapper = mapper;
this._roleRepository = roleRepository;
}
public FeedbackRepository(ICSVStream <Feedback> stream, ISequencer <long> sequencer, IQuestionRepository questionRepository, IPatientRepository patientRepository, IDoctorRepository doctorRepository, IManagerRepository managerRepository, ISecretaryRepository secretaryRepository) : base(ENTITY_NAME, stream, sequencer, new LongIdGeneratorStrategy <Feedback>())
{
_questionRepository = questionRepository;
_patientRepository = patientRepository;
_doctorRepository = doctorRepository;
_managerRepository = managerRepository;
_secretaryRepository = secretaryRepository;
}
public ManagerDbReaderWriter(SalesContext context)
{
Context = context;
var mapper = AutoMapper.CreateConfiguration().CreateMapper();
Managers = new ManagerRepository(Context, mapper);
}
public ManagerController(IRequsitionManager _requsition, IEmployeeManager employee, IManagerRepository manager,
IVehicleRepository vehicle)
{
this._employeeManager = employee;
this._requsitionManager = _requsition;
this.managerRepository = manager;
this.vehicleRepository = vehicle;
}
public HireManagerHandler(
IValidator <HireManager> validator,
IEventBus eventBus,
IMapper mapper,
IManagerRepository managerRepository)
: base(validator, eventBus, mapper)
{
_managerRepository = managerRepository;
}
public ManagerController(IBusinessCardRepository businessCardRepository, ICompanyRepository companyRepository, IManagerRepository managerRepository, ILogger <ManagerController> logger, RoleManager <IdentityRole> roleManager, UserManager <ApplicationUser> userManager)
{
_managerRepository = managerRepository;
_logger = logger;
_roleManager = roleManager;
_userManager = userManager;
_companyRepository = companyRepository;
_businessCardRepository = businessCardRepository;
}
public ChartController()
{
_dalContext = new DALContext();
_customerRepository = _dalContext.Customers;
_inputFileRepository = _dalContext.InputFiles;
_managerRepository = _dalContext.Managers;
_productRepository = _dalContext.Products;
_saleItemRepository = _dalContext.SaleItems;
}
public AssignManagerToAccountHandler(
IValidator <AssignManagerToAccount> validator,
IEventBus eventBus,
IMapper mapper,
IUserRepository userRepository,
IManagerRepository managerRepository)
: base(validator, eventBus, mapper, userRepository)
{
_managerRepository = managerRepository;
}
public ManagerAppService(
IIdentityUserRepository userRepository,
IManagerRepository repository,
IRepository <DistrictEntity, string> districtRepository)
: base()
{
Repository = repository;
DistrictRepository = districtRepository;
UserRepository = userRepository;
}
public SaleUnitOfWork(SalesInfoContext context, ReaderWriterLockSlim locker)
{
_context = context;
_locker = locker;
_clients = new ClientRepository(_context);
_managers = new ManagerRepository(_context);
_products = new ProductRepository(_context);
_sales = new SaleRepository(_context);
}
public ManagerDbReaderWriter(SalesInformationEntities context, ReaderWriterLockSlim locker)
{
Context = context;
Locker = locker;
var mapper = Support.Adapter.AutoMapper.CreateConfiguration().CreateMapper();
Managers = new ManagerRepository(Context, mapper);
}
public void SetUp()
{
_anagramSolver = Substitute.For <IAnagramSolver>();
_wordRepository = Substitute.For <IWordRepository>();
_managerRepository = Substitute.For <IManagerRepository>();
ExpectedList = new List <string>();
_requestService = new RequestService(_anagramSolver, _wordRepository, _managerRepository);
}
public ProjectManagerController(IUserManagerRepository userManagerRepository,
IUserTeamLeaderRepository userTeamLeaderRepository,
IUserDeveloperRepository userDeveloperRepository,
IManagerRepository managerRepository)
{
this.userManagerRepository = userManagerRepository;
this.userTeamLeaderRepository = userTeamLeaderRepository;
this.userDeveloperRepository = userDeveloperRepository;
this.managerRepository = managerRepository;
}
public BondoraTesting()
{
IServiceCollection services = new ServiceCollection();
services.AddMemoryCache();
var serviceProvider = services.BuildServiceProvider();
var memoryCache = serviceProvider.GetService <IMemoryCache>();
CacheMemoryService memory = new CacheMemoryService(memoryCache);
manager = new ManagerRepository(memory);
}
public ClientEventRecipientsFacade(
IAdminRepository admins,
IManagerRepository managers,
IClientRepository clients,
IEventEmailRecipient recipients)
{
_admins = admins;
_managers = managers;
_clients = clients;
_recipients = recipients;
}
public ReceiveAlertCommandHandler(
IAlertRepository alertRepository,
ITeamRepository teamRepository,
IManagerRepository managerRepository,
IFollowupAdapter followupAdapter)
{
_alertRepository = alertRepository;
_teamRepository = teamRepository;
_managerRepository = managerRepository;
_followupAdapter = followupAdapter;
}
public ClientEventRecipientsFacade(
IAdminRepository admins,
IManagerRepository managers,
IClientRepository clients,
IEventEmailRecipient recipients)
{
_admins = admins;
_managers = managers;
_clients = clients;
_recipients = recipients;
}
protected void Awake()
{
Object.DontDestroyOnLoad(gameObject);
gameController = this;
ConfigurationRepository = new ConfigurationRepository();
ManagerRepository = new ManagerRepository();
GladiatorRepository = new GladiatorRepository();
GameState = new GameState();
}
public ManagerService(IConfigurationRepository configurationRepository, IManagerRepository managerRepository)
{
this.configurationRepository = configurationRepository ??
throw new ArgumentNullException(nameof(configurationRepository));
this.managerRepository = managerRepository ??
throw new ArgumentNullException(nameof(managerRepository));
this.TokenSigningKey = this.configurationRepository.GetSettingAsync("Token", "SigningKey")
.Result
.Value;
}
public AwbEventRecipientsFacade(
IAdminRepository admins,
IManagerRepository managers,
IBrokerRepository brokers,
IAwbRepository awbs,
IEventEmailRecipient recipients)
{
_admins = admins;
_managers = managers;
_brokers = brokers;
_awbs = awbs;
_recipients = recipients;
}
public AwbEventRecipientsFacade(
IAdminRepository admins,
IManagerRepository managers,
IBrokerRepository brokers,
IAwbRepository awbs,
IEventEmailRecipient recipients)
{
_admins = admins;
_managers = managers;
_brokers = brokers;
_awbs = awbs;
_recipients = recipients;
}
public UserService(IUserRepository users,
IAdminRepository admins,
IManagerRepository managers,
ICarrierRepository carriers,
ISenderRepository senders,
IForwarderRepository forwarders,
IBrokerRepository brokers)
{
_users = users;
_admins = admins;
_managers = managers;
_carriers = carriers;
_senders = senders;
_forwarders = forwarders;
_brokers = brokers;
}
public IdentityService(
IUserRepository users,
IAdminRepository admins,
IManagerRepository managers,
ICarrierRepository carriers,
ISenderRepository senders,
IClientRepository clients,
IForwarderRepository forwarders,
IBrokerRepository brokers)
{
if(HttpContext.Current == null)
throw new NotSupportedException("UserHolder works only when the HttpContext.Current is presented");
_users = users;
_admins = admins;
_managers = managers;
_carriers = carriers;
_senders = senders;
_clients = clients;
_forwarders = forwarders;
_brokers = brokers;
}
public ApplicationEventRecipientsFacade(
IAwbRepository awbs,
IApplicationRepository applications,
IAdminRepository admins,
IManagerRepository managers,
ISenderRepository senders,
IClientRepository clients,
ICarrierRepository carriers,
IForwarderRepository forwarders,
IBrokerRepository brokers,
IEventEmailRecipient recipients)
{
_awbs = awbs;
_applications = applications;
_admins = admins;
_managers = managers;
_senders = senders;
_clients = clients;
_carriers = carriers;
_forwarders = forwarders;
_brokers = brokers;
_recipients = recipients;
}
public ManagerController()
{
_dalContext = new DALContext();
_managerRepository = _dalContext.Managers;
}
public ManagerController(IManagerRepository manager_repository)
{
this.manager_repository = manager_repository;
}
public ManagersController(IManagerRepository manageRepository)
{
_manageRepository = manageRepository;
}
public EmployeeController(IEmployeeRepository employee_repository, IManagerRepository manager_repository)
{
this.employee_repository = employee_repository;
this.manager_repository = manager_repository;
}
