public ProjectController(IProjectRepository projectRepository,
IProjectActivityRepository projectActivityRepository,
IProjectMemberRepository projectMemberRepository,
IProjectBillingRepository projectBillingRepository,
ITaskRepository taskRepository,
ITaskEffortRepository taskEffortRepository,
IProjectTechnologyMapRepository projectTechnologyMapRepository,
IProjectMileStoneRepository projectMileStoneRepository,
IProjectDocumentRepository projectDocumentRepository,
ITimeSheetLineItemRepository timeSheetLineItemRepository,
IUserRepository userRepository,
IEmployeeRepository employeeRepository,
ITechnologyRepository technologyRepository,
ICRMContactRepository crmContactRepository,
IUnitOfWork unitOfWork)
{
_projectRepository = projectRepository;
_projectActivityRepository = projectActivityRepository;
_projectBillingRepository = projectBillingRepository;
_projectMemberRepository = projectMemberRepository;
_taskRepository = taskRepository;
_taskEffortRepository = taskEffortRepository;
_projectTechnologyMapRepository = projectTechnologyMapRepository;
_projectMileStoneRepository = projectMileStoneRepository;
_timeSheetLineItemRepository = timeSheetLineItemRepository;
_projectDocumentRepository = projectDocumentRepository;
_userRepository = userRepository;
_employeeRepository = employeeRepository;
_technologyRepository = technologyRepository;
_crmContactRepository = crmContactRepository;
_unitOfWork = unitOfWork;
}
public async Task <UpdateResult> AddTechnology(EntityTechnology entityTechnology, string id,
ITechnologyRepository technologyRepository)
{
var entity = await FindByIdAsync(id);
var technology = await technologyRepository.FindByIdAsync(entityTechnology.TechnologyId);
if (technology == null)
{
throw new ArgumentException("Invalid technology id");
}
var technologies = entity.Technologies;
if (technologies != null && technologies.Length > 0)
{
if (technologies.Any(t => t.TechnologyId == entityTechnology.TechnologyId))
{
throw new ArgumentException("This technology is already in your entity");
}
Array.Resize(ref technologies, technologies.Length + 1);
technologies[technologies.GetUpperBound(0)] = entityTechnology;
}
else
{
technologies = new EntityTechnology[1];
technologies[0] = entityTechnology;
}
return(await UpdateOneAsync(id, "technologies", technologies));
}
public async Task <IActionResult> PatchTechnology(
[FromServices] ITechnologyRepository technologyRepository,
[FromServices] IQueue queue,
string id,
[FromBody] JsonPatchDocument <Technology> technologyPatch)
{
var user = HttpContext.User;
if (!user.IsInRole("root"))
{
return(Unauthorized());
}
var technology = await technologyRepository.FindByIdAsync(id);
if (technology == null)
{
return(BadRequest());
}
technologyPatch.ApplyTo(technology);
if (!_validation.Validate(technology))
{
return(BadRequest());
}
await technologyRepository.ReplaceOneAsync(id, technology);
var author = user.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Name).Value;
queue.PublishAsync("history", JsonConvert.SerializeObject(
new HistoryMessage()
{
Id = id, Data = JsonConvert.SerializeObject(technology), Type = "technology", Author = author
}
));
return(NoContent());
}
public async Task <IActionResult> GetAllTechnologies(
[FromServices] ITechnologyRepository technologyRepository,
[FromServices] IEntityRepository entityRepository,
[FromServices] ITechnologyService technologyService
)
{
var result = await technologyRepository.FindAllAsync();
if (result.Any())
{
var entities = await entityRepository.FindAllAsync();
var technologiesToReturn = new List <Technology>();
var referenceEntityId = configuration.GetSection("ReferenceEntityId");
foreach (var technology in result)
{
var technologyToAdd = new Technology();
technologyToAdd.Map(technology);
technologyToAdd.EntitiesStatus = new List <EntityStatus>();
foreach (var entity in entities)
{
technologyToAdd = technologyService.SetEntityStatus(technologyToAdd, entity, referenceEntityId.Value);
}
technologiesToReturn.Add(technologyToAdd);
}
return(Ok(technologiesToReturn));
}
return(NoContent());
}
public CandidatesController(ICandidateDesignationRepository candidateDesignationRepository,
ICandidateRepository candidateRepository,
ICandidateActivityRepository candidateActivityRepository,
IInterviewRoundRepository interviewRoundRepository,
IInterviewRoundActivityRepository interviewRoundActivityRepository,
ICandidateTechnologyMapRepository candidateTechnologyMapRepository,
IUserRepository userRepository,
IJobOpeningRepository jobOpeningRepository,
IRoundRepository roundRepository,
ICandidateDocumentRepository candidateDocumentRepository,
ITechnologyRepository technologyRepository,
ICandidateService candidateService,
ISettingsService settingsService,
EmailComposerService emailComposerService,
IUnitOfWork unitOfWork)
{
_candidateDesignationRepository = candidateDesignationRepository;
_candidateRepository = candidateRepository;
_candidateActivityRepository = candidateActivityRepository;
_interviewRoundRepository = interviewRoundRepository;
_interviewRoundActivityRepository = interviewRoundActivityRepository;
_userRepository = userRepository;
_jobOpeningRepository = jobOpeningRepository;
_roundRepository = roundRepository;
_candidateDocumentRepository = candidateDocumentRepository;
_candidateService = candidateService;
_candidateTechnologyMapRepository = candidateTechnologyMapRepository;
_technologyRepository = technologyRepository;
_emailComposerService = emailComposerService;
_unitOfWork = unitOfWork;
_settingsService = settingsService;
}
public RequirementsController(IRequirementRepository requirementRepository,
IRequirementActivityRepository requirementActivityRepository,
IRequirementDocumentRepository requirementDocumentRepository,
IRequirementTechnologyMapRepository requirementTechnologyMapRepository,
IRequirementCategoryRepository requirementCategoryRepository,
ITechnologyRepository technologyRepository,
IUserRepository userRepository,
ICRMContactRepository crmContactRepository,
ICRMLeadSourceRepository crmLeadSourceRepository,
IRequirementService requirementService,
EmailComposerService emailComposerService,
IUnitOfWork unitOfWork)
{
_requirementRepository = requirementRepository;
_requirementActivityRepository = requirementActivityRepository;
_requirementDocumentRepository = requirementDocumentRepository;
_requirementTechnologyMapRepository = requirementTechnologyMapRepository;
_requirementCategoryRepository = requirementCategoryRepository;
_requirementService = requirementService;
_technologyRepository = technologyRepository;
_userRepository = userRepository;
_crmContactRepository = crmContactRepository;
_crmLeadSourceRepository = crmLeadSourceRepository;
_unitOfWork = unitOfWork;
_emailComposerService = emailComposerService;
}
public AppController(IConfigurationRoot config, IProjectsRepository projectsRepository, ITechnologyRepository technologyRepository, ILogger <AppController> logger)
{
_config = config;
_logger = logger;
_projectsRepository = projectsRepository;
_technologyRepository = technologyRepository;
}
public async Task <IActionResult> GetEntityTechnologies(
[FromServices] IEntityRepository entityRepository,
[FromServices] ITechnologyRepository technologyRepository,
[FromServices] IEntityService entityService,
string id)
{
var result = await entityRepository.FindTechnologies(technologyRepository, id);
if (result != null && EnumerableExtensions.Any(result))
{
var referenceEntityId = configuration.GetSection("ReferenceEntityId");
if (referenceEntityId != null && !String.IsNullOrEmpty(referenceEntityId.Value))
{
var referenceEntityTechnologies =
await entityRepository.FindTechnologies(technologyRepository, referenceEntityId.Value);
if (referenceEntityTechnologies != null && EnumerableExtensions.Any(referenceEntityTechnologies))
{
result = entityService.PopulateEntityTechnologiesGroupStatus(result,
referenceEntityTechnologies);
}
}
return(Ok(result));
}
return(NoContent());
}
public ProfileAppService(ISkillRepository skillRepository, IDeveloperRepository developerRepository,
IStackRepository stackRepository, ITechnologyRepository technologyRepository)
{
this.skillRepository = skillRepository;
this.developerRepository = developerRepository;
this.stackRepository = stackRepository;
this.technologyRepository = technologyRepository;
}
public BootcampTechnologyController(IBootcampTechnologyRepository bootcampTechRepo,
ITechnologyRepository techRepo,
IBootcampRepository bootcampRepo)
{
_bootcampTechRepo = bootcampTechRepo;
_techRepo = techRepo;
_bootcampRepo = bootcampRepo;
}
public BootcampsController(IBootcampRepository bootcampRepo,
ILocationRepository locationRepo,
ITechnologyRepository techRepo)
{
_bootcampRepo = bootcampRepo;
_locationRepo = locationRepo;
_techRepo = techRepo;
}
public BootcampsController(IBootcampRepository bootcampRepo,
ILocationRepository locationRepo,
ITechnologyRepository techRepo)
{
_bootcampRepo = bootcampRepo;
_locationRepo = locationRepo;
_techRepo = techRepo;
}
public BootcampTechnologyController(IBootcampTechnologyRepository bootcampTechRepo,
ITechnologyRepository techRepo,
IBootcampRepository bootcampRepo)
{
_bootcampTechRepo = bootcampTechRepo;
_techRepo = techRepo;
_bootcampRepo = bootcampRepo;
}
public async Task <ActionResult> GetTechnologiesNotInEntity(
[FromServices] ITechnologyRepository technologyRepository,
[FromServices] IEntityRepository entityRepository,
string entityId)
{
var technologies = await technologyRepository.FindTechnologiesNotInEntity(entityRepository, entityId);
return(Ok(technologies));
}
public void Setup()
{
_waitListHelper = Substitute.For <IWaitListHelper>();
_volunteerRepository = Substitute.For <IVolunteerRepository>();
_jobRoleRepository = Substitute.For <IJobRoleRepository>();
_notificationService = Substitute.For <INotificationService>();
_technologyRepository = Substitute.For <ITechnologyRepository>();
_experienceLevelRepository = Substitute.For <IExperienceLevelRepository>();
}
public ProjectService(IProjectRepository projectRepository, IProjectTechnologiesRepository projectTechnologiesRepository, ITechnologyRepository technologyRepository, IProjectInternRepository projectInternRepository, IMentorProjectRepository mentorProjectRepository, IMentorRepository mentorRepository)
{
this.projectRepository = projectRepository;
this.projectTechnologiesRepository = projectTechnologiesRepository;
this.technologyRepository = technologyRepository;
this.projectInternRepository = projectInternRepository;
this.mentorProjectRepository = mentorProjectRepository;
this.mentorRepository = mentorRepository;
}
public async Task <EntityTechnology> PopulateEntityTechnologies(string entityId, string technologyId,
ITechnologyRepository technologyRepository)
{
var newEntityTechnology = await FindTechnologyByIdAsync(entityId, technologyId);
newEntityTechnology.Technology = await technologyRepository.FindByIdAsync(technologyId);
return(newEntityTechnology);
}
public void Setup()
{
_waitListHelper = Substitute.For<IWaitListHelper>();
_volunteerRepository = Substitute.For<IVolunteerRepository>();
_jobRoleRepository = Substitute.For<IJobRoleRepository>();
_notificationService = Substitute.For<INotificationService>();
_technologyRepository = Substitute.For<ITechnologyRepository>();
_experienceLevelRepository = Substitute.For<IExperienceLevelRepository>();
}
public async Task <IActionResult> GetTechnologyById([FromServices] ITechnologyRepository technologyRepository, string id)
{
var result = await technologyRepository.FindByIdAsync(id);
if (result != null)
{
return(Ok(result));
}
return(NoContent());
}
public IndexModel(IGeneralInfoRepository generalInfoRepository, ISkillRepository skillRepository, ICompanyRepository companyRepository, IReferenceRepository referenceRepository, ITechnologyRepository technologyRepository, IAptitudeRepository aptitudeRepository, IEmailService emailService, ICaptchaValidationService captchaValidationService)
{
this._generalInfoRepository = generalInfoRepository;
this._skillRepository = skillRepository;
this._companyRepository = companyRepository;
this._referenceRepository = referenceRepository;
this._technologyRepository = technologyRepository;
this._aptitudeRepository = aptitudeRepository;
this._emailService = emailService;
this._captchaValidationService = captchaValidationService;
}
public async Task <IActionResult> CreateTechnology(
[FromServices] ITechnologyRepository technologyRepository,
[FromServices] IQueue queue,
TechnologyInput input)
{
var user = HttpContext.User;
if (!user.IsInRole("root"))
{
return(Unauthorized());
}
if (!_validation.Validate(input))
{
return(BadRequest());
}
try
{
var technology = new Technology()
{
Version = input.Version,
Name = input.Name,
Key = input.Key,
Category = input.Category,
Description = input.Description,
Reporter = input.Reporter,
Scope = input.Scope,
UpdateDate = input.UpdateDate
};
await technologyRepository.SaveAsync(technology);
var author = user.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Name).Value;
queue.PublishAsync("history", JsonConvert.SerializeObject(
new HistoryMessage()
{
Id = technology.Id, Data = JsonConvert.SerializeObject(technology), Type = "technology", Author = author
}
));
return(CreatedAtAction(nameof(GetTechnologyById), new { id = technology.Id }, technology));
}
catch (ArgumentException ex)
{
return(BadRequest(new { message = ex.Message }));
}
catch (MongoWriteException exception)
{
if (exception.WriteError.Category == ServerErrorCategory.DuplicateKey)
{
return(Conflict(new { message = $"Duplicate entry for technology {input.Name}" }));
}
return(BadRequest());
}
}
public ProfileController(IAccessRuleRepository accessRuleRepository,
IUserRepository userRepository,
IUserSkillRepository userSkillRepository,
IUserCertificationRepository userCertificationRepository,
IUserDocumentRepository userDocumentRepository,
IUserHobbyRepository userHobbyRepository,
ILinkedAccountRepository linkedAccountRepository,
IRoleMemberRepository roleMemberRepository,
IAssetRepository assetRepository,
ILeaveEntitlementRepository leaveEntitlementRepository,
IProjectMemberRepository projectMemberRepository,
IUserTechnologyMapRepository userTechnologyMapRepository,
IEmergencyContactRepository emergencyContactRepository,
IEmployeeDependentRepository employeeDependentRepository,
IUserAwardRepository userAwardRepository,
ITokenRepository tokenRepository,
IAwardRepository awardRepository,
ITechnologyRepository technologyRepository,
ISkillRepository skillRepository,
IHobbyRepository hobbyRepository,
ICertificationRepository certificationRepository,
ISystemSnapshotRepository systemSnapshotRepository,
ISettingsService settingsService,
IEmployeeRepository employeeRepository,
IUnitOfWork unitOfWork)
{
_accessRuleRepository = accessRuleRepository;
_userRepository = userRepository;
_userSkillRepository = userSkillRepository;
_userCertificationRepository = userCertificationRepository;
_userDocumentRepository = userDocumentRepository;
_userHobbyRepository = userHobbyRepository;
_roleMemberRepository = roleMemberRepository;
_leaveEntitlementRepository = leaveEntitlementRepository;
_assetRepository = assetRepository;
_projectMemberRepository = projectMemberRepository;
_userTechnologyMapRepository = userTechnologyMapRepository;
_emergencyContactRepository = emergencyContactRepository;
_employeeDependentRepository = employeeDependentRepository;
_tokenRepository = tokenRepository;
_awardRepository = awardRepository;
_systemSnapshotRepository = systemSnapshotRepository;
_userAwardRepository = userAwardRepository;
_technologyRepository = technologyRepository;
_skillRepository = skillRepository;
_hobbyRepository = hobbyRepository;
_certificationRepository = certificationRepository;
_employeeRepository = employeeRepository;
_linkedAccountRepository = linkedAccountRepository;
_settingsService = settingsService;
_unitOfWork = unitOfWork;
}
public TechnologyService(
ITechnologyRepository technologyRepository,
ITechnologyRepositoryAdmin technologyRepositoryAdmin,
IMapper mapper)
{
Guard.ConstructorArgumentIsNotNull(technologyRepository, nameof(technologyRepository));
Guard.ConstructorArgumentIsNotNull(technologyRepositoryAdmin, nameof(technologyRepositoryAdmin));
Guard.ConstructorArgumentIsNotNull(mapper, nameof(mapper));
_technologyRepository = technologyRepository;
_technologyRepositoryAdmin = technologyRepositoryAdmin;
_mapper = mapper;
}
public VolunteerController(IWaitListHelper waitListHelper,
IVolunteerRepository volunteerRepository,
IJobRoleRepository jobRoleRepository,
INotificationService notificationService,
ITechnologyRepository technologyRepository,
IExperienceLevelRepository xpLevelRepository)
{
_waitListHelper = waitListHelper;
_xpLevelRepository = xpLevelRepository;
_technologyRepository = technologyRepository;
_jobRoleRepository = jobRoleRepository;
_volunteerRepository = volunteerRepository;
_notificationService = notificationService;
}
public HomeController(IContactFormRepository contactFromRepo,
IBootcampRepository bootcampRepo,
ITechnologyRepository technologyRepo,
ILocationRepository locationRepo,
IBootcampLocationsRepository bootcampLocationsRepo,
IBootcampTechnologyRepository bootcampTechnologyRepo)
{
_contactFormRepo = contactFromRepo;
_bootcampRepo = bootcampRepo;
_technologyRepo = technologyRepo;
_locationRepo = locationRepo;
_bootcampLocationsRepo = bootcampLocationsRepo;
_bootcampTechnologyRepo = bootcampTechnologyRepo;
}
public HomeController(IContactFormRepository contactFromRepo,
IBootcampRepository bootcampRepo,
ITechnologyRepository technologyRepo,
ILocationRepository locationRepo,
IBootcampLocationsRepository bootcampLocationsRepo,
IBootcampTechnologyRepository bootcampTechnologyRepo)
{
_contactFormRepo = contactFromRepo;
_bootcampRepo = bootcampRepo;
_technologyRepo = technologyRepo;
_locationRepo = locationRepo;
_bootcampLocationsRepo = bootcampLocationsRepo;
_bootcampTechnologyRepo = bootcampTechnologyRepo;
}
public VolunteerController(IWaitListHelper waitListHelper,
IVolunteerRepository volunteerRepository,
IJobRoleRepository jobRoleRepository,
INotificationService notificationService,
ITechnologyRepository technologyRepository,
IExperienceLevelRepository xpLevelRepository)
{
_waitListHelper = waitListHelper;
_xpLevelRepository = xpLevelRepository;
_technologyRepository = technologyRepository;
_jobRoleRepository = jobRoleRepository;
_volunteerRepository = volunteerRepository;
_notificationService = notificationService;
}
public UnitOfWork(
ApplicationDbContext context,
IVacancyRepository vacancyRepository,
IVacancyCityRepository vacancyCityRepository,
ICVRepository cvRepository,
ISkillRepository skillRepository,
ICompanyRepository companyRepository,
ICompanyCityRepository companyCityRepository,
IJobExperienceRepository jobExperienceRepository,
IKnowledgeLevelRepository knowledgeLevelRepository,
IDegreeRepository degreeRepository,
ISpecialityRepository specialityRepository,
IEducationRepository educationRepository,
IUserRepository userRepository,
IQualificationRepository qualificationRepository,
ISkillRequirementRepository skillRequirementRepository,
ISkillTypeRepository skillTypeRepository,
IUserCompanyRepository userCompanyRepository,
IExperienceRepository experienceRepository,
ICityRepository cityRepository,
ICountryRepository countryRepository,
ITechnologyRepository technologyRepository,
IVacancyCVFlowRepository vacancyCVFlowRepository)
{
_context = context;
_skillTypeRepository = skillTypeRepository;
_skillRepository = skillRepository;
_companyRepository = companyRepository;
_userRepository = userRepository;
_vacancyRepository = vacancyRepository;
_vacancyCityRepository = vacancyCityRepository;
_cvRepository = cvRepository;
_companyCityRepository = companyCityRepository;
_qualificationRepository = qualificationRepository;
_skillRequirementRepository = skillRequirementRepository;
_jobExperienceRepository = jobExperienceRepository;
_degreeRepository = degreeRepository;
_specialityRepository = specialityRepository;
_educationRepository = educationRepository;
_knowledgeLevelRepository = knowledgeLevelRepository;
_userCompanyRepository = userCompanyRepository;
_experienceRepository = experienceRepository;
_cityRepository = cityRepository;
_countryRepository = countryRepository;
_technologyRepository = technologyRepository;
_vacancyCVFlowRepository = vacancyCVFlowRepository;
}
public async Task <IActionResult> AddTechnology(
[FromServices] IEntityRepository entityRepository,
[FromServices] IQueue queue,
[FromServices] ITechnologyRepository technologyRepository,
[FromBody] EntityTechnology entityTechnology,
string id)
{
try
{
var user = HttpContext.User;
if (!_validation.Validate(entityTechnology))
{
return(BadRequest());
}
await entityRepository.AddTechnology(entityTechnology, id, technologyRepository);
var author = user.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Name).Value;
queue.PublishAsync("history", JsonConvert.SerializeObject(
new HistoryMessage()
{
Id = entityTechnology.Id,
Data = JsonConvert.SerializeObject(
entityTechnology,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}
),
Type = "entity-technology",
Author = author
}
));
return(NoContent());
}
catch (ArgumentException ex)
{
return(BadRequest(new { message = ex.Message }));
}
catch (MongoWriteException exception)
{
if (exception.WriteError.Category == ServerErrorCategory.DuplicateKey)
{
return(Conflict(new { message = "This technology is already in your entity" }));
}
return(BadRequest());
}
}
public static void InitializeInstances(ref IGeneralInfoRepository generalInfoRepository,
ref IAptitudeRepository aptitudeRepository,
ref ICompanyRepository companyRepository,
ref IReferenceRepository referenceRepository,
ref ISkillRepository skillRepository,
ref ITechnologyRepository technologyRepository,
ref IEmailService _emailService,
ref ICaptchaValidationService _captchaValidationService)
{
string storageConnectionKey = Util.GetConfigVariable(STORAGECONNECTIONKEY, null);
generalInfoRepository = new TableGeneralInfoRepository(new TableStorageConfig()
{
ConnectionString = storageConnectionKey
});
aptitudeRepository = new TableAptitudeRepository(new TableStorageConfig()
{
ConnectionString = storageConnectionKey
});
companyRepository = new TableCompanyRepository(new TableStorageConfig()
{
ConnectionString = storageConnectionKey
});
referenceRepository = new TableReferenceRepository(new TableStorageConfig()
{
ConnectionString = storageConnectionKey
});
skillRepository = new TableSkillRepository(new TableStorageConfig()
{
ConnectionString = storageConnectionKey
});
technologyRepository = new TableTechologyRepository(new TableStorageConfig()
{
ConnectionString = storageConnectionKey
});
// generalInfoRepository = new JSONGeneralInfoRepository(new JSONDatabaseConfig() { ConnectionString = storageConnectionKey });
//aptitudeRepository = new JSONAptitudeRepository(new JSONDatabaseConfig() { ConnectionString = storageConnectionKey });
//companyRepository = new JSONCompanyRepository(new JSONDatabaseConfig() { ConnectionString = storageConnectionKey });
//referenceRepository = new JSONReferenceRepository(new JSONDatabaseConfig() { ConnectionString = storageConnectionKey });
//skillRepository = new JSONSkillRepository(new JSONDatabaseConfig() { ConnectionString = storageConnectionKey });
//technologyRepository = new JSONTechnologyRepository(new JSONDatabaseConfig() { ConnectionString = storageConnectionKey });
_emailService = new SendGridEmailService(Util.Deserialize <EmailSettings>(Util.GetConfigVariable("emailSettings", null)));
_captchaValidationService = new CaptchaValidationService(Util.Deserialize <CaptchaSettings>(Util.GetConfigVariable("captchaSettings", null)));
}
public BootcampController(IBootcampRepository bootcampRepo,
ITechnologyRepository technologyRepo,
ILocationRepository locationRepo,
IBootcampLocationsRepository bootcampLocationsRepo,
IBootcampTechnologyRepository bootcampTechnologyRepo,
ILinkRepository linkRepo,
IBootcampSessionRepository sessionRepo,
ISiteRepository siteRepo)
{
_bootcampRepo = bootcampRepo;
_technologyRepo = technologyRepo;
_locationRepo = locationRepo;
_bootcampLocationsRepo = bootcampLocationsRepo;
_bootcampTechnologyRepo = bootcampTechnologyRepo;
_linkRepo = linkRepo;
_sessionRepo = sessionRepo;
_siteRepo = siteRepo;
}
public PortalController(ICandidateRepository candidateRepository,
IJobOpeningRepository jobOpeningRepository,
IInterviewRoundRepository interviewRoundRepository,
IRoundRepository roundRepository,
ICandidateTechnologyMapRepository candidateTechnologyMapRepository,
ITechnologyRepository technologyRepository,
ICandidateDesignationRepository candidateDesignationRepository,
IUnitOfWork unitOfWork)
{
_candidateRepository = candidateRepository;
_jobOpeningRepository = jobOpeningRepository;
_roundRepository = roundRepository;
_interviewRoundRepository = interviewRoundRepository;
_candidateTechnologyMapRepository = candidateTechnologyMapRepository;
_technologyRepository = technologyRepository;
_candidateDesignationRepository = candidateDesignationRepository;
_unitOfWork = unitOfWork;
}
public BootcampController(IBootcampRepository bootcampRepo,
ITechnologyRepository technologyRepo,
ILocationRepository locationRepo,
IBootcampLocationsRepository bootcampLocationsRepo,
IBootcampTechnologyRepository bootcampTechnologyRepo,
ILinkRepository linkRepo,
IBootcampSessionRepository sessionRepo,
ISiteRepository siteRepo)
{
_bootcampRepo = bootcampRepo;
_technologyRepo = technologyRepo;
_locationRepo = locationRepo;
_bootcampLocationsRepo = bootcampLocationsRepo;
_bootcampTechnologyRepo = bootcampTechnologyRepo;
_linkRepo = linkRepo;
_sessionRepo = sessionRepo;
_siteRepo = siteRepo;
}
public async Task <IEnumerable <EntityTechnology> > FindTechnologies(
ITechnologyRepository technologyRepository, string entityId)
{
var entity = await FindByIdAsync(entityId);
if (entity.Technologies != null && entity.Technologies.Length > 0)
{
List <EntityTechnology> technologyList = entity.Technologies.ToList();
for (var i = 0; i < technologyList.Count; i++)
{
technologyList[i] =
await PopulateEntityTechnologies(entityId, technologyList[i].TechnologyId, technologyRepository);
}
return(technologyList);
}
return(null);
}
public ProjectsController(INotificationService notificationService,
IProjectRepository projectRepository,
IProjectActivityRepository projectActivityRepository,
IProjectMemberRepository projectMemberRepository,
IProjectBillingRepository projectBillingRepository,
IProjectBillingCorrectionRepository projectBillingCorrectionRepository,
ITaskRepository taskRepository,
ITaskEffortRepository taskEffortRepository,
IProjectTechnologyMapRepository projectTechnologyMapRepository,
IProjectMileStoneRepository projectMileStoneRepository,
IProjectDocumentRepository projectDocumentRepository,
ILeaveRepository leaveRepository,
ITimeSheetLineItemRepository timeSheetLineItemRepository,
IUserRepository userRepository,
IEmployeeRepository employeeRepository,
ITimeSheetRepository timeSheetRepository,
ITechnologyRepository technologyRepository,
ICRMContactRepository crmContactRepository,
IUnitOfWork unitOfWork)
{
_notificationService = notificationService;
_projectRepository = projectRepository;
_projectActivityRepository = projectActivityRepository;
_projectBillingRepository = projectBillingRepository;
_projectMemberRepository = projectMemberRepository;
_projectBillingCorrectionRepository = projectBillingCorrectionRepository;
_taskRepository = taskRepository;
_taskEffortRepository = taskEffortRepository;
_projectTechnologyMapRepository = projectTechnologyMapRepository;
_projectMileStoneRepository = projectMileStoneRepository;
_leaveRepository = leaveRepository;
_timeSheetLineItemRepository = timeSheetLineItemRepository;
_projectDocumentRepository = projectDocumentRepository;
_userRepository = userRepository;
_employeeRepository = employeeRepository;
_timeSheetRepository = timeSheetRepository;
_technologyRepository = technologyRepository;
_crmContactRepository = crmContactRepository;
_unitOfWork = unitOfWork;
}
public CRMLeadsController(ICRMLeadRepository crmLeadRepository,
ICRMLeadStatusRepository crmLeadStatusRepository,
ICRMLeadSourceRepository crmLeadSourceRepository,
ICRMLeadCategoryRepository crmLeadCategoryRepository,
ICRMLeadActivityRepository crmLeadActivityRepository,
ICRMLeadTechnologyMapRepository crmLeadTechnologyMapRepository,
IUserRepository userRepository,
ITechnologyRepository technologyRepository,
IUnitOfWork unitOfWork,
ICRMLeadService crmLeadService)
{
_crmLeadRepository = crmLeadRepository;
_crmLeadSourceRepository = crmLeadSourceRepository;
_crmLeadStatusRepository = crmLeadStatusRepository;
_crmLeadCategoryRepository = crmLeadCategoryRepository;
_crmLeadActivityRepository = crmLeadActivityRepository;
_crmLeadTechnologyMapRepository = crmLeadTechnologyMapRepository;
_userRepository = userRepository;
_technologyRepository = technologyRepository;
_unitOfWork = unitOfWork;
_crmLeadService = crmLeadService;
}