public DataModel.Response.InsertResponse Create(DataModel.Model.ExperienceModel experience)
{
try
{
IExperienceRepository experienceRepository = RepositoryClassFactory.GetInstance().GetExperienceRepository();
IList <Experience> _experiences = experienceRepository.FindByOrganization(experience.Organization);
if (_experiences != null && _experiences.Count > 0)
{
return(new InsertResponse
{
ErrorCode = (int)ErrorCode.Error,
Message = string.Format(Resources.Resource.msg_insert_exists, "Organization", experience.Organization)
});
}
var _experience = MapperUtil.CreateMapper().Mapper.Map <ExperienceModel, Experience>(experience);
object id = experienceRepository.Insert(_experience);
return(new InsertResponse
{
InsertID = id.ToString(),
ErrorCode = (int)ErrorCode.None,
Message = Resources.Resource.msg_create_success
});
}
catch (Exception ex)
{
return(new InsertResponse
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public ReportService(ICompanyRepository CompanyRepository,IEmployeeRepository employeeRespository, IExperienceRepository experienceRepository,ITerminateRepository terminateRepository)
{
this.companyRepository = CompanyRepository;
this.employeeRespository = employeeRespository;
this.experienceRepository = experienceRepository;
this.terminateRepository = terminateRepository;
}
private void resetForm()
{
repos = null;
Employers = null;
selectedEmployer = null;
selectedJobTitle = null;
}
//test
public ExperienceController(IProductRepository productRepository, IExperienceRepository experienceRepository, ICategoryRepository categoryRepository, IHostingEnvironment hostingEnvironment)
{
_productRepository = productRepository;
_experienceRepository = experienceRepository;
_categoryRepository = categoryRepository;
_hostingEnvironment = hostingEnvironment;
}
public CreateJobAgeCommandHandler(IExperienceRepository repository, IUnitOfWork unitOfWork, IMapper mapper, IAuthenticatedUserService authenticatedUser)
{
_repository = repository;
_unitOfWork = unitOfWork;
_mapper = mapper;
_authenticatedUser = authenticatedUser;
}
public EventRepository(IOptions <Settings> settings, ICategoryRepository categoryRepository, IExperienceRepository experienceRepository, IUserRepository userRepository)
{
_context = new MongoDbContext(settings);
_categoryRepository = categoryRepository;
_experienceRepository = experienceRepository;
_userRepository = userRepository;
}
public PictureController(IOptions <FileUploadOptions> fileOptions, IPictureRepository pictureRepository, IExperienceRepository experienceRepository, ILogger logger, IMapper mapper)
{
_fileOptions = fileOptions.Value;
_pictureRepository = pictureRepository;
_experienceRepository = experienceRepository;
_logger = logger;
_mapper = mapper;
}
public EditJobViewModel(IExperienceRepository repository, Guid jobId)
{
repos = repository;
SetUpRelayCommands();
LoadJob(jobId);
}
public ExperienceService(IExperienceRepository repository,
IBadgeRepository badgeRepository,
IMapper mapper)
{
_repository = repository;
_badgeRepository = badgeRepository;
_mapper = mapper;
}
// Public Methods
public DeleteJobTitleViewModel(IExperienceRepository repository)
{
repos = repository;
loadEmployers();
setUpRelayCommands();
}
public MyProfileController(IMapper mapper, IOwnerRepository ownerRepository, IAddressRepository addressRepository, IContactRepository contactRepository, IExperienceRepository experienceRepository)
{
_mapper = mapper;
_ownerRepository = ownerRepository;
_addressRepository = addressRepository;
_contactRepository = contactRepository;
_experienceRepository = experienceRepository;
}
private void Reset()
{
repos = null;
formState = UIState.View;
selectedEmployer = null;
initialExperienceItem = null;
updatedExperienceItem = null;
}
public AuthService(IResumeRepository resumeRepository, IProjectRepository projectRepository, ISkillRepository skillRepository, IExperienceRepository experienceRepository, IEducationRepository educationRepository)
{
_resumeRepository = resumeRepository;
_projectRepository = projectRepository;
_skillRepository = skillRepository;
_experienceRepository = experienceRepository;
_educationRepository = educationRepository;
}
public ExperienceService(
ILoggingService loggingService,
IExperienceRepository experienceRepository,
IUserRepository userRepository)
{
_loggingService = loggingService;
_experienceRepository = experienceRepository;
_userRepository = userRepository;
}
// Public Methods
public EditJobTitleViewModel(IExperienceRepository repository)
{
repos = repository;
Employers = new ObservableCollection <IExperienceEntity>();
loadEmployers();
setUpRelayCommands();
}
public ExperienceService(IInsuranceRepository insuranceRepository, IExperienceRepository experienceRepository, IEmployeeRepository employeeRepository,ICompanyRepository companyRepository,IPositionRepository positionRepository, IUnitOfWork unitOfWork)
{
this.experienceRepository = experienceRepository;
this.employeeRepository = employeeRepository;
this.companyRepository = companyRepository;
this.positionRepository = positionRepository;
this.insuranceRepository = insuranceRepository;
this.unitOfWork = unitOfWork;
}
public UserService(IEducationRepository educationRepository, IModelFactory modelFactory, IFileRepository fileRepository, ISkillRepository skillRepository,
IProjectRepository projectRepository, IExperienceRepository experienceRepository)
{
_educationRepository = educationRepository;
_modelFactory = modelFactory;
_fileRepository = fileRepository;
_skillRepository = skillRepository;
_projectRepository = projectRepository;
_experienceRepository = experienceRepository;
}
public UserService(IEducationRepository educationRepository, IModelFactory modelFactory, IFileRepository fileRepository, ISkillRepository skillRepository,
IProjectRepository projectRepository, IExperienceRepository experienceRepository)
{
_educationRepository = educationRepository;
_modelFactory = modelFactory;
_fileRepository = fileRepository;
_skillRepository = skillRepository;
_projectRepository = projectRepository;
_experienceRepository = experienceRepository;
}
public ExperiencesController(IExperienceRepository experienceRepository,
IDocumentRepository documentRepository,
IUploadedFileRepository uploadedFileRepository,
ITranslator translator)
{
_experienceRepository = experienceRepository;
_documentRepository = documentRepository;
_uploadedFileRepository = uploadedFileRepository;
_translator = translator;
}
public UserController(IOptions <Settings> settings, IUserRepository userRepository, IEventRepository eventRepository, ICategoryRepository categoryRepository, IExperienceRepository experienceRepository, IMapper mapper, IOptions <AppSettings> appSettings)
{
_context = new MongoDbContext(settings);
_userRepository = userRepository;
_eventRepository = eventRepository;
_categoryRepository = categoryRepository;
_experienceRepository = experienceRepository;
_mapper = mapper;
_appSettings = appSettings.Value;
}
public ReportController(ILogger logger,
IExperienceReportRepository experienceReportRepository,
IReviewReportRepository reviewReportRepository,
IExperienceRepository experienceRepository,
IReviewRepository reviewRepository)
{
_logger = logger;
_experienceReportRepository = experienceReportRepository;
_reviewReportRepository = reviewReportRepository;
_experienceRepository = experienceRepository;
_reviewRepository = reviewRepository;
}
public ResumeViewRepository(ITalentRepository talent,
IEducationRepository education,
IExperienceRepository experience,
IProfileRepository profile,
ProjectRepository project)
{
this.Talent = talent;
this.Education = education;
this.Experience = experience;
this.Profile = profile;
this.Project = project;
}
/*************************
**************************
***** PUBLIC METHODS *****
**************************
*************************/
public ResumeCreatorViewModel(
IResumeCreationService rcs,
ILoggingService ls,
IGeneralInfoRepository giRepository,
IExperienceRepository experienceRepository,
IExpertiseRepository expertiseRepository,
IEducationRepository educationRepository,
IPublicationsRepository publicationsRepository,
IKernel kernel)
{
try
{
this.rcs = rcs;
this.giRepos = giRepository;
this.experienceRepos = experienceRepository;
this.expertiseRepos = expertiseRepository;
this.edRepos = educationRepository;
this.pubRepos = publicationsRepository;
this.ls = ls;
this._kernel = kernel;
SetUpRelayCommands();
var gie = giRepos.Get(Guid.Empty);
FullName = gie.FullName;
Email = gie.Email;
Phone = gie.Phone;
AddLine1 = gie.Add1;
AddLine2 = gie.Add2;
InExpertises = new ObservableCollection <IExpertiseEntity>();
OutExpertises = AllExpertises = new ObservableCollection <IExpertiseEntity>(expertiseRepos.GetAll());
RefreshJobs();
InEducations = new ObservableCollection <IEducationEntity>();
OutEducations = AllEducations = new ObservableCollection <IEducationEntity>(edRepos.GetAll());
InPublications = new ObservableCollection <IPublicationEntity>();
OutPublications = AllPublications = new ObservableCollection <IPublicationEntity>(pubRepos.GetAll());
UpdateDocumentPreview();
}
catch (Exception e)
{
ls.Log(e, "Exception");
}
}
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 CurriculumVitaeService(ILoggingService loggingService, IUserRepository userRepository,
IProfileRepository profileRepository, IExperienceRepository experienceRepository,
ICourseRepository courseRepository, ISkillRepository skillRepository, IAwardRepository awardRepository,
IInterestRepository interestRepository, IProjectRepository projectRepository,
ICurriculumVitaeRepository curriculumVitaeRepository)
{
_loggingService = loggingService;
_userRepository = userRepository;
_profileRepository = profileRepository;
_experienceRepository = experienceRepository;
_courseRepository = courseRepository;
_skillRepository = skillRepository;
_awardRepository = awardRepository;
_interestRepository = interestRepository;
_projectRepository = projectRepository;
_curriculumVitaeRepository = curriculumVitaeRepository;
}
public DataModel.Response.BaseResponse Delete(string id)
{
try
{
IExperienceRepository experienceRepository = RepositoryClassFactory.GetInstance().GetExperienceRepository();
experienceRepository.Delete(id);
return(new BaseResponse
{
ErrorCode = (int)ErrorCode.None,
Message = Resources.Resource.msg_delete_success
});
}
catch (Exception ex)
{
return(new BaseResponse
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public DataModel.Response.BaseResponse Update(DataModel.Model.ExperienceModel experience)
{
try
{
IExperienceRepository experienceRepository = RepositoryClassFactory.GetInstance().GetExperienceRepository();
var _experience = MapperUtil.CreateMapper().Mapper.Map <ExperienceModel, Experience>(experience);
experienceRepository.Update(_experience);
return(new BaseResponse
{
ErrorCode = (int)ErrorCode.None,
Message = Resources.Resource.msg_update_success
});
}
catch (Exception ex)
{
return(new BaseResponse
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public DataModel.Response.FindAllItemReponse <DataModel.Model.ExperienceModel> GetAlls()
{
try
{
IExperienceRepository experienceRepository = RepositoryClassFactory.GetInstance().GetExperienceRepository();
IList <Experience> experiences = experienceRepository.FindAll();
var _experiences = experiences.Select(n => MapperUtil.CreateMapper().Mapper.Map <Experience, ExperienceModel>(n)).ToList();
return(new FindAllItemReponse <ExperienceModel>
{
Items = _experiences,
ErrorCode = (int)ErrorCode.None,
Message = string.Empty
});
}
catch (Exception ex)
{
return(new FindAllItemReponse <ExperienceModel>
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public FindAllItemReponse <ExperienceModel> FindByscholarshipID(string scholarship)
{
try
{
IExperienceRepository experienceRepository = RepositoryClassFactory.GetInstance().GetExperienceRepository();
IList <Experience> experiences = experienceRepository.FindByYouthScholarshipID(scholarship);
var _experiences = experiences.Select(n => MapperUtil.CreateMapper().Mapper.Map <Experience, ExperienceModel>(n)).ToList();
return(new FindAllItemReponse <ExperienceModel>
{
Items = _experiences,
ErrorCode = (int)ErrorCode.None,
Message = string.Empty
});
}
catch (Exception ex)
{
return(new FindAllItemReponse <ExperienceModel>
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public DataModel.Response.FindItemReponse <DataModel.Model.ExperienceModel> FindByID(string id)
{
try
{
IExperienceRepository experienceRepository = RepositoryClassFactory.GetInstance().GetExperienceRepository();
Experience experience = experienceRepository.FindByID(id);
var _experience = MapperUtil.CreateMapper().Mapper.Map <Experience, ExperienceModel>(experience);
return(new FindItemReponse <ExperienceModel>
{
Item = _experience,
ErrorCode = (int)ErrorCode.None,
Message = string.Empty
});
}
catch (Exception ex)
{
return(new FindItemReponse <ExperienceModel>
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public ExperienceController(IExperienceRepository expRepository, IOptions <Settings> settings)
{
_context = new MongoDbContext(settings);
_expRepository = expRepository;
}
public UsersController(IUserRepository userRepository, IExperienceRepository experienceRepository, UserManager <CustomUser> userManager)
{
_userRepository = userRepository;
_experienceRepository = experienceRepository;
_userManager = userManager;
}
public GetAllQueryHandler(IExperienceRepository repository)
{
_repository = repository;
}