public Company GetCompanyById(int companyId) // READ
{
using var db = new VacancyDbContext();
var companyToFind = db.companies.Include(x => x.Vacancies).First(x => x.CompanyId == companyId);
return(companyToFind);
}
public async Task <IEnumerable <User> > FindUsersAsync(string filterLogin, string filterName, bool?isAdmin)
{
using (var db = new VacancyDbContext(DbConfig))
{
var query = db.UserSet.AsQueryable();
if (!string.IsNullOrEmpty(filterLogin))
{
var filter = filterLogin.ToUpper();
query = query.Where(x => x.Login.ToUpper().Contains(filter));
}
if (!string.IsNullOrEmpty(filterName))
{
var filter = filterName.ToUpper();
query = query.Where(x => x.FullName.ToUpper().Contains(filter));
}
if (isAdmin.HasValue)
{
query = query.Where(x => x.IsAdmin == isAdmin.Value);
}
var result = await query.ToListAsync();
return(result.Select(_mapper.Map <User>));
}
}
public List <Company> GetAllCompanies() // READ
{
using var db = new VacancyDbContext();
var listOfAllCompanies = db.companies.Include(x => x.Vacancies).ToList();
return(listOfAllCompanies);
}
public List <Vacancy> GetLastThreeVacancies() // READ
{
using var db = new VacancyDbContext();
var listOfAllVacancies = db.vacancies.Include(x => x.Company).OrderByDescending(x => x.DateOfCreation).Take(3).ToList(); // wordt IOrderEnumerable door OrderBy
return(listOfAllVacancies);
}
public List <Vacancy> GetAllVacanciesByCity(string city) // READ
{
using var db = new VacancyDbContext();
var listOfAllVacanciesByCity = db.vacancies.Include(x => x.Company).Where(x => x.Company.City == city).ToList();
return(listOfAllVacanciesByCity);
}
public List <Vacancy> GetVacanciesByCompanyId(int companyId) // READ
{
using var db = new VacancyDbContext();
var listOfVacanciesByCompany = db.vacancies.Where(x => x.CompanyId == companyId).ToList();
return(listOfVacanciesByCompany);
}
public Vacancy GetVacancyById(int vacancyId) // READ
{
using var db = new VacancyDbContext();
var vacancyToFind = db.vacancies.Include(x => x.Company).First(x => x.VacancyId == vacancyId);
return(vacancyToFind);
}
public void DeleteVacancyById(int vacancyId) // DELETE
{
using var db = new VacancyDbContext();
var vacancyToDelete = db.vacancies.First(x => x.VacancyId == vacancyId);
db.vacancies.Remove(vacancyToDelete);
db.SaveChanges();
}
public void DeleteCompanyById(int companyId) // DELETE
{
using var db = new VacancyDbContext();
var companyToDelete = db.companies.First(x => x.CompanyId == companyId);
db.Remove(companyToDelete);
db.SaveChanges();
}
public async Task <User> FindByIdAsync(int id)
{
using (var db = new VacancyDbContext(DbConfig))
{
var userDo = await db.UserSet.FirstOrDefaultAsync(x => x.Id == id);
return(userDo == null ? null : _mapper.Map <User>(userDo));
}
}
public async Task <Vacancy> FindById(int id)
{
using (var db = new VacancyDbContext(DbConfig))
{
var vacancyDo = await db.VacancySet.FirstOrDefaultAsync(x => x.Id == id);
return(vacancyDo == null ? null : _mapper.Map <Vacancy>(vacancyDo));
}
}
public async Task <User> FindByLoginAsync(string login)
{
using (var db = new VacancyDbContext(DbConfig))
{
var userDo = await db.UserSet.FirstOrDefaultAsync(x => x.Login == login);
return(userDo == null ? null : _mapper.Map <User>(userDo));
}
}
public async Task <IEnumerable <string> > FindExistingSyncIds(string[] syncIds)
{
using (var db = new VacancyDbContext(DbConfig))
{
return(await db.VacancySet
.Where(x => syncIds.Contains(x.SyncId))
.Select(x => x.SyncId)
.ToListAsync());
}
}
public void UpdateVacancyById(int vacancyId, Vacancy vacancyEditValues) // UPDATE
{
using var db = new VacancyDbContext();
var vacancyToUpdate = db.vacancies.Include(x => x.Company).First(x => x.VacancyId == vacancyId); // bij null geeft dit een InvalidOperationException (opvangen in controller)
vacancyToUpdate.Description = vacancyEditValues.Description;
vacancyToUpdate.DateOfCreation = vacancyEditValues.DateOfCreation;
vacancyToUpdate.CompanyId = vacancyEditValues.CompanyId;
db.vacancies.Update(vacancyToUpdate);
db.SaveChanges();
}
public async Task DeleteAsync(int id)
{
using (var db = new VacancyDbContext(DbConfig))
{
var entry = db.Entry(new UserDo {
Id = id
});
entry.State = EntityState.Deleted;
await db.SaveChangesAsync();
}
}
public async Task <IEnumerable <Vacancy> > FindVacanciesAsync(string text)
{
using (var db = new VacancyDbContext(DbConfig))
{
var filter = text?.ToUpper() ?? string.Empty;
var vacansies = await db.VacancySet
.Where(x => x.Name.ToUpper().Contains(filter) || x.Description.ToUpper().Contains(filter))
.ToListAsync();
return(vacansies.Select(_mapper.Map <Vacancy>));
}
}
public async Task <int> RegisterAsync(User user)
{
using (var db = new VacancyDbContext(DbConfig))
{
var userDo = _mapper.Map <UserDo>(user);
await db.UserSet.AddAsync(userDo);
await db.SaveChangesAsync();
return(userDo.Id);
}
}
public void UpdateCompanyById(int companyId, Company companyEditValues) // UPDATE
{
using var db = new VacancyDbContext();
var companyToUpdate = db.companies.First(x => x.CompanyId == companyId); // InvalidOperatorException if null
companyToUpdate.Name = companyEditValues.Name;
companyToUpdate.Street = companyEditValues.Street;
companyToUpdate.HouseNumber = companyEditValues.HouseNumber;
companyToUpdate.Postal = companyEditValues.Postal;
companyToUpdate.City = companyEditValues.City;
db.companies.Update(companyToUpdate);
db.SaveChanges();
}
public async Task <int[]> AddRangeAsync(IEnumerable <Vacancy> vacancies)
{
using (var db = new VacancyDbContext(DbConfig))
{
var vacancyDos = vacancies
.Select(v => _mapper.Map <VacancyDo>(v))
.ToArray(); // to preserve order
await db.VacancySet.AddRangeAsync(vacancyDos);
await db.SaveChangesAsync();
return(vacancyDos.Select(v => v.Id).ToArray());
}
}
public async Task DeleteAsync(int id)
{
using (var db = new VacancyDbContext(DbConfig))
{
var vacancyDo = await db.VacancySet.FirstOrDefaultAsync(x => x.Id == id);
if (vacancyDo == null)
{
throw new EntityNotFoundException(ErrorText.NotFound, id);
}
db.Remove(vacancyDo);
await db.SaveChangesAsync();
}
}
public async Task UpdateAsync(User user)
{
using (var db = new VacancyDbContext(DbConfig))
{
var userDo = await db.UserSet.FirstOrDefaultAsync(x => x.Id == user.Id);
if (userDo == null)
{
throw new EntityNotFoundException(ErrorText.NotFound, user.Id);
}
_mapper.Map(user, userDo);
db.UserSet.Update(userDo);
await db.SaveChangesAsync();
}
}
public ValuesController(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();
Configuration = builder.Build();
var optionsBuilder = new DbContextOptionsBuilder <VacancyDbContext>();
var options = optionsBuilder
.UseSqlServer(Configuration.GetConnectionString("VacancyDbContext"))
.Options;
_vacancyDbContext = new VacancyDbContext(options);
}
public void CreateVacancy(Vacancy newVacancy) // CREATE
{
using var db = new VacancyDbContext();
db.vacancies.Add(newVacancy);
db.SaveChanges();
}
public VacancyDbController(VacancyDbContext context)
{
_context = context;
}
public void CreateCompany(Company newCompany) // CREATE
{
using var db = new VacancyDbContext();
db.companies.Add(newCompany);
db.SaveChanges();
}
