public NoteDTO Add(NoteDTO noteToAdd)
{
var newNote = DTOService.ToEntity <NoteDTO, Note>(noteToAdd);
uow.NoteRepo.Insert(newNote);
uow.Commit();
return(DTOService.ToDTO <Note, NoteDTO>(newNote));
}
public IEnumerable <EventDTO> GetByCandidateId(int candidateId)
{
var domainEvents = new List <Event>();
var filters = new List <Expression <Func <Event, bool> > >();
filters.Add(x => x.CandidateId == candidateId);
return(uow.EventRepo.Get(filters).Select(x => DTOService.ToDTO <Event, EventDTO>(x)));
}
public virtual DTO Add(DTO entity)
{
var entityToAdd = DTOService.ToEntity <DTO, DomainEntity>(entity);
currentRepo.Insert(entityToAdd);
uow.Commit();
return(DTOService.ToDTO <DomainEntity, DTO>(entityToAdd));
}
public NoteDTO Update(NoteDTO noteToChange)
{
var changedNote = DTOService.ToEntity <NoteDTO, Note>(noteToChange);
uow.NoteRepo.Update(changedNote);
uow.Commit();
return(DTOService.ToDTO <Note, NoteDTO>(changedNote));
}
public virtual DTO Update(DTO entity)
{
var changedDomainEntity = DTOService.ToEntity <DTO, DomainEntity>(entity);
currentRepo.Update(changedDomainEntity);
uow.Commit();
return(DTOService.ToDTO <DomainEntity, DTO>(changedDomainEntity));
}
public override FileDTO Add(FileDTO entity)
{
var file = DTOService.ToEntity <FileDTO, File>(entity);
currentRepo.Insert(file);
uow.Commit();
return(DTOService.ToDTO <File, FileDTO>(file));
}
public CandidateDTO Update(CandidateDTO entity)
{
Candidate _candidate = uow.CandidateRepo.GetByID(entity.Id);
_candidate.Update(entity, uow);
uow.CandidateRepo.Update(_candidate);
uow.Commit();
return(DTOService.ToDTO <Candidate, CandidateDTO>(_candidate));
}
public EventDTO Add(EventDTO eventToAdd)
{
Event newEvent = new Event();
newEvent.Update(eventToAdd);
uow.EventRepo.Insert(newEvent);
uow.Commit();
return(DTOService.ToDTO <Event, EventDTO>(newEvent));
}
public EventDTO Update(EventDTO eventToChange)
{
Event domainEvent = uow.EventRepo.GetByID(eventToChange.Id);
domainEvent.Update(eventToChange);
uow.EventRepo.Update(domainEvent);
uow.Commit();
return(DTOService.ToDTO <Event, EventDTO>(domainEvent));
}
public UserDTO Add(UserDTO userToAdd)
{
User _user = new User();
_user.Update(userToAdd, uow);
uow.UserRepo.Insert(_user);
uow.Commit();
return(DTOService.ToDTO <User, UserDTO>(_user));
}
public IEnumerable <NoteDTO> GetByUserId(int userId)
{
var filter = new List <Expression <Func <Note, bool> > >();
filter.Add(x => x.UserId == userId);
var notes = uow.NoteRepo.Get(filter);
return(notes.Select(x => DTOService.ToDTO <Note, NoteDTO>(x)));
}
public CandidateDTO Add(CandidateDTO candidateToAdd)
{
Candidate _candidate = new Candidate();
_candidate.Update(candidateToAdd, uow);
uow.CandidateRepo.Insert(_candidate);
uow.Commit();
return(DTOService.ToDTO <Candidate, CandidateDTO>(_candidate));
}
public UserDTO Update(UserDTO entity)
{
User _user = uow.UserRepo.GetByID(entity.Id);
_user.Update(entity, uow);
uow.UserRepo.Update(_user);
uow.Commit();
return(DTOService.ToDTO <User, UserDTO>(_user));
}
public VacancyDTO Update(VacancyDTO vacancy)
{
var vacancyToUpdate = uow.VacancyRepo.GetByID(vacancy.Id);
vacancyToUpdate.Update(vacancy, uow);
CreateChildVacanciesIfNeeded(vacancyToUpdate, vacancy);
uow.VacancyRepo.Update(vacancyToUpdate);
uow.Commit();
return(DTOService.ToDTO <Vacancy, VacancyDTO>(vacancyToUpdate));
}
public VacancyDTO Add(VacancyDTO vacancy)
{
var vacancyToAdd = new Vacancy();
vacancyToAdd.Update(vacancy, uow);
CreateChildVacanciesIfNeeded(vacancyToAdd, vacancy);
uow.VacancyRepo.Insert(vacancyToAdd);
uow.Commit();
return(DTOService.ToDTO <Vacancy, VacancyDTO>(vacancyToAdd));
}
/// <summary>
/// Perfoms accessing to user of specified login and password async
/// </summary>
/// <param name="login">Application user login</param>
/// <param name="password">User password (hashed)</param>
/// <returns>Corresponting user dto object</returns>
/// <exception cref="System.Exception">Is thrown, when there is no user with such a login and password</exception>
public async Task <UserDTO> AuthentificateAsync(string login, string password)
{
var user = await uow.UserRepo.GetAsync(login, password);
if (user == null)
{
throw new Exception("Wrong login or password");
//TODO: Extract message to external source
//TODO: new exception type
}
return(DTOService.ToDTO <User, UserDTO>(user));
}
public Tuple <IEnumerable <VacancyDTO>, int> Get(
int?userId,
int?industryId,
string title,
int?state,
int?typeOfEmployment,
IEnumerable <int> levelIds,
IEnumerable <int> locationIds,
int current,
int size
)
{
var filters = new List <Expression <Func <Vacancy, bool> > >();
if (userId.HasValue)
{
filters.Add(x => x.Responsible.Id == userId);
}
if (industryId.HasValue)
{
filters.Add(x => x.IndustryId == industryId);
}
if (!String.IsNullOrEmpty(title))
{
filters.Add(x => x.Title.ToLower().Contains(title.ToLower()));
}
if (state.HasValue)
{
filters.Add(x => (int)x.State == state);
}
if (typeOfEmployment.HasValue)
{
filters.Add(x => (int)x.TypeOfEmployment == typeOfEmployment);
}
if (levelIds.Any())
{
filters.Add(x => x.Levels.Any(l => levelIds.Contains(l.Id)));
}
if (locationIds.Any())
{
filters.Add(x => x.Cities.Any(loc => locationIds.Contains(loc.Id)));
}
var vacancies = uow.VacancyRepo.Get(filters);
var total = vacancies.Count();
return(new Tuple <IEnumerable <VacancyDTO>, int>(
vacancies.Skip(current * size).Take(size).Select(vacancy => DTOService.ToDTO <Vacancy, VacancyDTO>(vacancy)),
total));
}
public IEnumerable <EventDTO> Get(IEnumerable <int> userIds, DateTime startDate, DateTime?endDate)
{
var domainEvents = new List <Event>();
var clearedStartDate = new DateTime(startDate.Year, startDate.Month, startDate.Day, 0, 0, 0);
var clearedEndDate = endDate.HasValue ? new DateTime(endDate.Value.Year, endDate.Value.Month, endDate.Value.Day, 23, 59, 59) : endDate;
if (IsNeededEventsForAMonth(clearedStartDate, clearedEndDate))
{
domainEvents = EventsForAMonthForAUsers(userIds, clearedStartDate);
}
else
{
domainEvents = EventsForAUsersForADateBetween(userIds, clearedStartDate, clearedEndDate);
}
var eventsDto = domainEvents.Select(x => DTOService.ToDTO <Event, EventDTO>(x));
return(eventsDto);
}
public object Get(object searchParameters)
{
var users = uow.UserRepo.Get();
return(users.Select(x => DTOService.ToDTO <User, UserDTO>(x)));
}
public UserDTO Get(int id)
{
var entity = uow.UserRepo.GetByID(id);
return(DTOService.ToDTO <User, UserDTO>(entity));
}
public Tuple <IEnumerable <CandidateDTO>, int> Get(
string firstName,
string lastName,
bool?relocationAgreement,
bool?isMale,
int?minAge,
int?maxAge,
DateTime?startExperience,
int?minSalary,
int?maxSalary,
int?currencyId,
int?industryId,
string position,
string technology,
IEnumerable <LanguageSkillDTO> languageSkills,
IEnumerable <int> citiesIds,
int current, int size)
{
var filters = new List <Expression <Func <Candidate, bool> > >();
if (!String.IsNullOrEmpty(firstName))
{
filters.Add(x => x.FirstName.ToLower().StartsWith(firstName.ToLower()));
}
if (!String.IsNullOrEmpty(lastName))
{
filters.Add(x => x.LastName.ToLower().StartsWith(lastName.ToLower()));
}
if (relocationAgreement.HasValue)
{
filters.Add(x => x.RelocationAgreement == relocationAgreement.Value);
}
if (isMale.HasValue)
{
filters.Add(x => x.IsMale.Value == isMale.Value);
}
if (minAge.HasValue)
{
if (maxAge.HasValue)
{
filters.Add(x => x.BirthDate.Value <= DbFunctions.AddYears(DateTime.Now, -minAge.Value) && x.BirthDate.Value >= DbFunctions.AddYears(DateTime.Now, -maxAge.Value));
}
}
if (startExperience.HasValue)
{
filters.Add(x => x.StartExperience <= startExperience.Value);
}
if (minSalary.HasValue)
{
if (maxSalary.HasValue)
{
filters.Add(x => x.SalaryDesired >= minSalary.Value && x.SalaryDesired <= maxSalary.Value);
}
}
if (currencyId.HasValue)
{
filters.Add(x => x.CurrencyId == currencyId.Value);
}
if (industryId.HasValue)
{
filters.Add(x => x.IndustryId == industryId);
}
if (!String.IsNullOrEmpty(position))
{
filters.Add(cand => cand.PositionDesired.ToLower().StartsWith(position.ToLower()));
}
if (!String.IsNullOrEmpty(technology))
{
filters.Add(x => x.Skills.Any(s => s.Title.StartsWith(technology) || x.Tags.Any(t => t.Title.StartsWith(technology))));
}
if (citiesIds.Any())
{
filters.Add(x => citiesIds.Any(y => y == x.CityId));
}
if (languageSkills.Any())
{
foreach (var ls in languageSkills)
{
if (ls.LanguageLevel.HasValue)
{
filters.Add(x => x.LanguageSkills.Any(l => l.LanguageId == ls.LanguageId && l.LanguageLevel.Value >= ls.LanguageLevel.Value));
}
else
{
filters.Add(x => x.LanguageSkills.Any(l => l.LanguageId == ls.LanguageId));
}
}
}
var candidates = uow.CandidateRepo.Get(filters);
var total = candidates.Count();
return(new Tuple <IEnumerable <CandidateDTO>, int>(
candidates.Skip(current * size).Take(size).Select(candidate => DTOService.ToDTO <Candidate, CandidateDTO>(candidate)),
total));
}
public VacancyDTO Get(int id)
{
var entity = uow.VacancyRepo.GetByID(id);
return(DTOService.ToDTO <Vacancy, VacancyDTO>(entity));
}
public virtual IEnumerable <DTO> Get()
{
var entities = currentRepo.Get();
return(entities.Select(en => DTOService.ToDTO <DomainEntity, DTO>(en)));
}
public virtual DTO Get(int id)
{
var entity = currentRepo.GetByID(id);
return(DTOService.ToDTO <DomainEntity, DTO>(entity));
}
public EventDTO Get(int id)
{
var entity = uow.EventRepo.GetByID(id);
return(DTOService.ToDTO <Event, EventDTO>(entity));
}
public NoteDTO Get(int id)
{
var entity = uow.NoteRepo.GetByID(id);
return(DTOService.ToDTO <Note, NoteDTO>(entity));
}
public CandidateDTO Get(int id)
{
var entity = uow.CandidateRepo.GetByID(id);
return(DTOService.ToDTO <Candidate, CandidateDTO>(entity));
}
