public UTaskService(IUserTaskRepository userTaskRepo, IUTaskLocalStorageCache uTaskCache,
IServiceProvider svp)
{
_userTaskRepo = userTaskRepo;
_uTaskCache = uTaskCache;
_svp = svp;
}
public UnitOfWork(TaskManagerContext context)
{
_context = context;
_taskRepository = new TaskRepository(context);
_taskStateRepository = new TaskStateRepository(context);
_userRepository = new UserRepository(context);
_userTaskRepository = new UserTaskRepository(context);
}
public UserTaskService(
IUserTaskRepository userTaskRepository,
IUserRepository userRepository
)
{
_userTaskRepository = userTaskRepository;
_userRepository = userRepository;
}
public UserTaskService(
IMapper mapper,
IUserProjectRepository userProjectRepository,
IUserTaskRepository userTaskRepository,
IUserRepository userRepository,
ILogger <UserTaskService> logger)
{
_mapper = mapper;
_userTaskRepository = userTaskRepository;
_userRepository = userRepository;
_logger = logger;
_userProjectRepository = userProjectRepository;
}
public TypesAndSumsController(ITaskTypeRepository repo, IMapper mapper, IUserTaskRepository repoTask, ISumOfTaskRepository repoSumTask, ApplicationDbContext context, SignInManager <IdentityUser> signInManager,
ILogger <LoginModel> logger,
UserManager <IdentityUser> userManager)
{
_repo = repo;
_mapper = mapper;
_repoTask = repoTask;
_context = context;
_repoSumTask = repoSumTask;
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
}
public TestDataSeeder(IServiceScope scope)
{
citizenUserRepository = scope.ServiceProvider.GetService <ICitizenUserRepository>();
roleRepository = scope.ServiceProvider.GetService <IRoleRepository>();
friendshipRepository = scope.ServiceProvider.GetService <IFriendshipRepository>();
userTaskRepository = scope.ServiceProvider.GetService <IUserTaskRepository>();
messageRepository = scope.ServiceProvider.GetService <IMessageRepository>();
if (citizenUserRepository == null || roleRepository == null || friendshipRepository == null ||
userTaskRepository == null || messageRepository == null)
{
throw new Exception("Cannot get services from ServiceProvider.");
}
}
public UserTaskService(IUserTaskRepository userTaskRepository,
ITaskTypeRepository taskTypeRepository,
IUserRepository userRepository,
ISprintRepository sprintRepository,
IProjectRepository projectRepository,
IStoryRepository storyRepository,
ILogger logger)
{
_userTaskRepository = userTaskRepository;
_taskTypeRepository = taskTypeRepository;
_userRepository = userRepository;
_storyRepository = storyRepository;
_sprintRepository = sprintRepository;
_projectRepository = projectRepository;
_logger = logger;
}
public ServicesApiController(ICustomerRepository customerRepository, IOrganizationRepository organizationRepository, TaskResponseQueue resonseQueue, Management management, IUserTaskRepository userTaskRepository, IEmailUserRepository emailUser, IEmailRepository email, IEmailTypeRepository emailType,
UserManager <ApplicationUser> userManager, ILoggerFactory loggerFactory)
{
_customerRepository = customerRepository;
_organizationRepository = organizationRepository;
_resonseQueue = resonseQueue;
_management = management;
_userTaskRepository = userTaskRepository;
_userManager = userManager;
_email = email;
_emailType = emailType;
_emailUser = emailUser;
//TaskQueue = taskQueue;
_logger = loggerFactory.CreateLogger <ServicesApiController>();
}
public UserTaskController(IUserTaskRepository repository, IUserRepository userRepository, ITaskRepository taskRepository)
{
this.repository = repository;
this.userRepository = userRepository;
this.taskRepository = taskRepository;
}
public TasksController(IUserTaskRepository taskRepository)
{
_taskRepository = taskRepository;
}
public UTaskLocalStorageCache(IUserTaskRepository repository)
: base(repository)
{
}
public UserController(IUserTaskRepository userTasks)
{
UserTaskRepository = userTasks;
}
public UserTaskService(IUserTaskRepository repository, IUnitOfWork unit) : base(repository, unit)
{
}
public UserTaskManagement(IUserTaskRepository userTaskRepository, IUnitOfWork unitOfWork)
{
this.userTaskRepository = userTaskRepository;
this.unitOfWork = unitOfWork;
}
public UserTaskService(IUserTaskRepository userTaskRepository, IMapper mapper)
{
_userTaskRepository = userTaskRepository;
_mapper = mapper;
}
public TaskService(IUserTaskRepository userTaskRepository)
{
this.userTaskRepository = userTaskRepository;
}
public UserTaskHandler(IUserTaskRepository repository, IVerify verify)
{
_repository = repository;
_verify = verify;
}
public TaskBusiness(IUserTaskRepository userTaskRepository)
{
_userTaskRepository = userTaskRepository;
}
public UserTaskController(IUserTaskRepository userTaskRepository)
{
this.userTaskRepository = userTaskRepository;
}
public UserTaskService(IUserTaskRepository userTaskRepository)
{
_userTaskRepository = userTaskRepository ?? throw new ArgumentNullException(nameof(userTaskRepository));
}
public UserTaskService(IUserTaskRepository userTaskRepository, IMapper mapper)
{
this.mapper = mapper;
this.userTaskRepository = userTaskRepository;
}
public UsersController(IUserTaskRepository userRepository)
{
_userRepository = userRepository;
}
public UserTaskManager(IUserTaskRepository repository, IMapper mapper) : base(repository, mapper)
{
UserTaskRepository = repository;
}
public UserTasksController()
{
this.userTasks = DefaultInstanceProvider
.Instance
.get <IUserTaskRepository>();
}
public UserTaskService(IMapper mapper, IUserTaskRepository userTaskRepository)
{
_mapper = mapper;
_userTaskRepo = userTaskRepository;
}
/// <summary>
/// This is the constructor of the user task service
/// </summary>
/// <param name="repository"></param>
/// <param name="userService"></param>
public UserTaskService(IUserTaskRepository repository, IUserService userService) : base(repository)
{
this.userService = userService;
}
