public async Task CreateAsync_WithInValidModel_ReturnsFalse()
{
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var user = new User
{
UserName = "******"
};
await context.Users.AddAsync(user);
context.SaveChanges();
var serviceModel = new CompanyServiceModel
{
User = new UserServiceModel
{
UserName = user.UserName
}
};
var companyService = new CompanyService(new EfRepository <User>(context),
new EfRepository <Company>(context));
var result = await companyService.CreateAsync(serviceModel);
Assert.False(result);
var dbModels = await context.Companies.AnyAsync();
Assert.False(dbModels);
}
public async Task <bool> CreateAsync(CompanyServiceModel model)
{
if (!IsEntityStateValid(model))
{
return(false);
}
if (model.User == null)
{
return(false);
}
var user = usersRepository.All().FirstOrDefault(u => u.UserName == model.User.UserName);
if (user == null)
{
return(false);
}
var company = Mapper.Map <Company>(model);
company.User = user;
await this.companyRepository.AddAsync(company);
await this.companyRepository.SaveChangesAsync();
return(true);
}
public async Task UpdateAsync_WithNonExistentCompany_ReturnsFalse()
{
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var company = new Company
{
CompanyName = "TestCompanyName123456",
User = new User()
{
UserName = "******"
}
};
var companyService = new CompanyService(new EfRepository <User>(context),
new EfRepository <Company>(context));
var serviceModel = new CompanyServiceModel
{
Id = company.Id,
};
var result = await companyService.UpdateAsync(serviceModel);
Assert.False(result);
}
/// <summary>
/// Finds a company by name
/// </summary>
/// <param name="name">Company name</param>
/// <returns>CompanyServiceModel which is a DTO which contains the needed info for this operations</returns>
public CompanyServiceModel FindByName(string name)
{
var company = data.Companies.Where(c => c.Name == name).FirstOrDefault();
var csm = new CompanyServiceModel()
{
Name = company.Name,
Description = company.Description,
CompanyCode = company.CompanyCode
};
return(csm);
}
/// <summary>
/// Finds a Company by id
/// </summary>
/// <param name="id">Company id</param>
/// <returns>Company service model which contains the needed info</returns>
public CompanyServiceModel FindById(int?id)
{
var company = data.Companies.Where(c => c.Id == id).FirstOrDefault();
var csm = new CompanyServiceModel()
{
Id = company.Id,
Name = company.Name,
Description = company.Description,
CompanyCode = company.CompanyCode
};
return(csm);
}
public async Task <bool> CreateCompany(CompanyServiceModel model)
{
try
{
_unitOfWork.BeginTransaction();
var createModel = _mapper.Map <Company>(model);
await _unitOfWork.GetRepository <Company>().AddItemAsync(createModel);
await _unitOfWork.CommitAsync();
return(true);
}
catch
{
await _unitOfWork.RollbackAsync();
throw;
}
}
public void SaveCompanyDetails(CompanyServiceModel CompanyDetails)
{
var company = new CompanyModel()
{
Id = CompanyDetails.Id,
Address1 = CompanyDetails.Address1,
Address2 = CompanyDetails.Address2,
ContactName = CompanyDetails.ContactName,
Email = CompanyDetails.Email,
Lat = CompanyDetails.Lat,
Lng = CompanyDetails.Lng,
Phone1 = CompanyDetails.Phone1,
Phone2 = CompanyDetails.Phone2,
Title = CompanyDetails.Title,
Website = CompanyDetails.Website,
ZipCode = CompanyDetails.ZipCode
};
_ICompanyRepository.SaveCompanyDetails(company);
}
public async Task CreateAsync_WithNonExistentUser_ReturnsFalse()
{
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var serviceModel = new CompanyServiceModel
{
CompanyName = "CompanyName"
};
var companyService = new CompanyService(new EfRepository <User>(context),
new EfRepository <Company>(context));
var result = await companyService.CreateAsync(serviceModel);
Assert.False(result);
var dbModels = await context.Companies.AnyAsync();
Assert.False(dbModels);
}
public async Task UpdateAsync_WithValidModel_WorksCorrectly()
{
// Arrange
const string expectedResult = "TestCompanyName";
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var company = new Company
{
CompanyName = "TestCompanyName123456",
User = new User()
{
UserName = "******"
}
};
await context.Companies.AddAsync(company);
context.SaveChanges();
var companyService = new CompanyService(new EfRepository <User>(context),
new EfRepository <Company>(context));
var serviceModel = new CompanyServiceModel
{
Id = company.Id,
CompanyName = expectedResult
};
var result = await companyService.UpdateAsync(serviceModel);
Assert.True(result);
var actualResult = (await context.Companies.SingleAsync(c => c.Id == company.Id)).CompanyName;
Assert.Equal(expectedResult, actualResult);
}
public async Task CreateAsync_WithValidModel_WorksCorrectly()
{
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var user = new User
{
UserName = "******"
};
await context.Users.AddAsync(user);
context.SaveChanges();
var serviceModel = new CompanyServiceModel
{
CompanyName = "TestCompanyName",
User = new UserServiceModel
{
UserName = user.UserName
}
};
var companyService = new CompanyService(new EfRepository <User>(context),
new EfRepository <Company>(context));
var result = await companyService.CreateAsync(serviceModel);
Assert.True(result);
var dbModel = context.Companies.SingleOrDefault();
Assert.NotNull(dbModel);
Assert.Equal(user.Id, dbModel.UserId);
}
public async Task <bool> UpdateAsync(CompanyServiceModel model)
{
if (!this.IsEntityStateValid(model))
{
return(false);
}
var company = await this.companyRepository.All().SingleOrDefaultAsync(c => c.Id == model.Id);
if (company == null)
{
return(false);
}
company.CompanyName = model.CompanyName;
company.CompanySize = model.CompanySize;
company.CategoryId = model.CategoryId;
company.WebsiteUrl = model.WebsiteUrl;
this.companyRepository.Update(company);
await this.companyRepository.SaveChangesAsync();
return(true);
}
public JsonResult SaveDetails(CompanyViewModel company)
{
CompanyServiceModel CompanyModel;
CompanyModel = new CompanyServiceModel()
{
Id = company.Id,
Address1 = company.Address1,
Address2 = company.Address2,
ContactName = company.ContactName,
Email = company.Email,
Lat = company.Lat,
Lng = company.Lng,
Phone1 = company.Phone1,
Phone2 = company.Phone2,
Title = company.Title,
Website = company.Website,
ZipCode = company.ZipCode
};
_ICompanyService.SaveCompanyDetails(CompanyModel);
bool success = true;
return(Json(success, JsonRequestBehavior.AllowGet));
}
