public async Task <bool> AddAsync(CompanyDto dto)
{
var entity = CompanyMapper.FromDto(dto);
var result = await _companyRepository.AddAsync(entity);
return(result.Id != 0);
}
public IEnumerable <CompanyDto> GetAllCompanies(Guid tenantid)
{
IEnumerable <Company> companyList = _unitOfWork.CompanyRepository.GetMany(company => company.TenantId == tenantid);
IEnumerable <CompanyDto> companyDtoList = companyList.Select(company => CompanyMapper.EntityMapToDto(company)); // .ToList();
return(companyDtoList);
}
public async Task <IActionResult> GetByID(string id)
{
int.TryParse(id, out int companyId);
var company = companyId > 0 ? await companyDAO.GetCompanyById(companyId) : await companyDAO.GetCompanyByISIN(id);
if (company == null)
{
return(NotFound($"no company found for id: {id}"));
}
var tickers = await tickerDAO.GetTickersByCompanyId(company.Id);
var companyExchanges = await companyExchangeDAO.GetCompanyExchangesByCompanyId(company.Id);
var exchanges = new List <Company.DataAccess.Models.Exchange>();
foreach (var ce in companyExchanges)
{
exchanges.Add(await exchangeDAO.GetExchangeById(ce.ExchangeId));
}
var companyInfo = CompanyMapper.DAOToAPIModel(company, exchanges, tickers);
return(Ok(companyInfo));
}
public ActionResult Pass(String State, String UserID)
{
CompanyDM Result = new CompanyDM();
try
{
if (State == "Pass")
{
Com.QuaPass(UserID, CompanyState.Pass);
var list = CompanyMapper.CompanyInfo(Com.ComPanys(UserID), Url, Com.CompanyCredit(UserID));
Result.UserID = UserID;
Result.CompanyName = list.CompanyName;
Result.UserRealName = list.UserRealName;
Result.UserPhone = list.UserPhone;
Result.CompanyStates = list.CompanyState;
Result.CompanyLicense = list.CompanyLicense;
Result.CompanyQualification = list.CompanyQualification;
Result.CompanyClimbCard = list.CompanyClimbCard;
Result.CompanyWelderCard = list.CompanyWelderCard;
Result.CompanyForkliftCard = list.CompanyForkliftCard;
Result.CompanyElectricianCard = list.CompanyElectricianCard;
Result.CompanySafeCard = list.CompanySafeCard;
Result.CompanyInsuranceCard = list.CompanyInsuranceCard;
Result.EvalAccident = list.EvalAccident;
Result.EvalManagement = list.EvalManagement;
Result.EvalQuality = list.EvalQuality;
Result.EvalReachRate = list.EvalReachRate;
Result.EvalSatisfied = list.EvalSatisfied;
Result.msg = "认证成功";
}
if (State == "NoPass")
{
Com.QuaPass(UserID, CompanyState.NoPass);
var list = CompanyMapper.CompanyInfo(Com.ComPanys(UserID), Url, Com.CompanyCredit(UserID));
Result.CompanyName = list.CompanyName;
Result.UserRealName = list.UserRealName;
Result.UserPhone = list.UserPhone;
Result.CompanyStates = list.CompanyState;
Result.CompanyLicense = list.CompanyLicense;
Result.CompanyQualification = list.CompanyQualification;
Result.CompanyClimbCard = list.CompanyClimbCard;
Result.CompanyWelderCard = list.CompanyWelderCard;
Result.CompanyForkliftCard = list.CompanyForkliftCard;
Result.CompanyElectricianCard = list.CompanyElectricianCard;
Result.CompanySafeCard = list.CompanySafeCard;
Result.CompanyInsuranceCard = list.CompanyInsuranceCard;
Result.EvalAccident = list.EvalAccident;
Result.EvalManagement = list.EvalManagement;
Result.EvalQuality = list.EvalQuality;
Result.EvalReachRate = list.EvalReachRate;
Result.EvalSatisfied = list.EvalSatisfied;
Result.msg = "认证失败";
}
}
catch (Exception ex)
{
Result.msg = ex.Message;
}
return(Json(Result, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> GetAll()
{
//Get all company info
var allCompanies = await companyDAO.GetCompanys();
//Load up Ticker and Exchange data
List <CompanyModel> companyInfo = new List <CompanyModel>();
foreach (Company.DataAccess.Models.Company c in allCompanies)
{
var tickers = await tickerDAO.GetTickersByCompanyId(c.Id);
var companyExchanges = await companyExchangeDAO.GetCompanyExchangesByCompanyId(c.Id);
var exchanges = new List <Company.DataAccess.Models.Exchange>();
foreach (var ce in companyExchanges)
{
exchanges.Add(await exchangeDAO.GetExchangeById(ce.ExchangeId));
}
companyInfo.Add(CompanyMapper.DAOToAPIModel(c, exchanges, tickers));
}
if (companyInfo.Count != 0)
{
return(Ok(companyInfo));
}
return(NotFound("No company exists yet."));
}
public ActionResult Delete(Qualifications Qua, String UserID)
{
CompanyDM Result = new CompanyDM();
Qua.UserID = UserID;
try
{
Com.QuaDelete(Qua);
}
catch (Exception ex)
{
Result.msg = ex.Message;
}
var list = CompanyMapper.CompanyInfo(Com.ComPanys(UserID), Url, Com.CompanyCredit(UserID));
Result.CompanyName = list.CompanyName;
Result.UserRealName = list.UserRealName;
Result.UserPhone = list.UserPhone;
Result.CompanyStates = list.CompanyState;
Result.CompanyLicense = list.CompanyLicense;
Result.CompanyQualification = list.CompanyQualification;
Result.CompanyClimbCard = list.CompanyClimbCard;
Result.CompanyWelderCard = list.CompanyWelderCard;
Result.CompanyForkliftCard = list.CompanyForkliftCard;
Result.CompanyElectricianCard = list.CompanyElectricianCard;
Result.CompanySafeCard = list.CompanySafeCard;
Result.CompanyInsuranceCard = list.CompanyInsuranceCard;
Result.EvalAccident = list.EvalAccident;
Result.EvalManagement = list.EvalManagement;
Result.EvalQuality = list.EvalQuality;
Result.EvalReachRate = list.EvalReachRate;
Result.EvalSatisfied = list.EvalSatisfied;
Result.msg = "删除成功";
return(Json(Result, JsonRequestBehavior.AllowGet));
}
public ActionResult CompanyInfo(String id)
{
CompanyDM Result = new CompanyDM();
var list = CompanyMapper.CompanyInfo(Com.ComPanys(id), Url, Com.CompanyCredit(id));
Result.UserID = list.UserID;
Result.CompanyName = list.CompanyName;
Result.UserRealName = list.UserRealName;
Result.UserPhone = list.UserPhone;
Result.CompanyStates = list.CompanyState;
Result.CompanyLicense = list.CompanyLicense;
Result.CompanyQualification = list.CompanyQualification;
Result.CompanyClimbCard = list.CompanyClimbCard;
Result.CompanyWelderCard = list.CompanyWelderCard;
Result.CompanyForkliftCard = list.CompanyForkliftCard;
Result.CompanyElectricianCard = list.CompanyElectricianCard;
Result.CompanySafeCard = list.CompanySafeCard;
Result.CompanyInsuranceCard = list.CompanyInsuranceCard;
Result.EvalAccident = list.EvalAccident;
Result.EvalManagement = list.EvalManagement;
Result.EvalQuality = list.EvalQuality;
Result.EvalReachRate = list.EvalReachRate;
Result.EvalSatisfied = list.EvalSatisfied;
return(View(Result));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Name,Trade,CompanyEmail,Street,Town,PostalCode,Voivodeship,Country,OwnerID")] Company company)
{
if (id != company.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(CompanyMapper.MapCompanyToView(company, _context));
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CompanyExists(company.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(View(company));
}
public void Edit(CompanyModel companyModel)
{
try
{
Company company = dbContext.Companies.Where(x => x.Id == companyModel.Id).FirstOrDefault();
if (company == null)
{
base.HandleError(companyModel, CommonLayer.LookUps.ErrorType.Critical, null, Resources.NotFound);
return;
}
if (Validate(companyModel))
{
return;
}
CompanyMapper.Map(dbContext, companyModel, company);
base.SaveChanges();
companyModel.AddSuccess(Resources.CompanyUpdatedSuccessfully, LookUps.SuccessType.Full);
}
catch (Exception ex)
{
base.HandleError(companyModel, CommonLayer.LookUps.ErrorType.Exception, ex);
base.UndoUpdates();
}
}
public ActionResult Delete(int id)
{
var company = _company.GetCompanyById(id);
var serializeCompany = CompanyMapper.SerializeCompany(company);
return(PartialView(serializeCompany));
}
public Either <string, CompanyView> Add(CompanyView companyView)
{
try
{
var companyExists = _dbContext.Companies.Exists(company => company.Name.Equals(companyView.Name));
if (companyExists)
{
return("company already exists");
}
var model = CompanyMapper.ToModel(companyView);
var view = companyView;
_dbContext.Companies.Add(model);
_dbContext.SaveChanges();
view.Id = model.Id;
return(view);
}
catch (Exception ex)
{
_logger.LogError("can't add company: {0} - ", companyView.Name, ex);
return(string.Format("can't add company"));
}
}
public async Task <CompanyDto> GetAsync(int id)
{
var entity = await _companyRepository.FindAsync(id);
var businessEntity = await _businessEntityRepository.FindAsync(entity.BusinessEntityId);
return(CompanyMapper.ToDto(entity, businessEntity));
}
public ActionResult <IList <CompanyViewModel> > GetAllCompaniesWithSubscription()
{
var userId = User.GetUserId();
var studentId = _studentService.GetStudentIdForUser(userId);
var allCompanies = _companyService.GetAllCompanies();
var viewModels = allCompanies.Select(c => CompanyMapper.ToViewModel(c, studentId)).ToList();
return(Ok(viewModels));
}
public void ConvertToView()
{
var model = BuildCompany();
var viewExpected = BuildCompanyView();
var view = CompanyMapper.ToView(model);
view.Should().BeEquivalentTo(viewExpected);
}
public void ConvertToModel()
{
var view = BuildCompanyView();
var modelExpected = BuildCompany();
var model = CompanyMapper.ToModel(view);
model.Should().BeEquivalentTo(modelExpected);
}
public GenericListModel <CompanyModel> GetSearchCompaniesList(DataTableSearchParameters <Nullable <bool> > dataTableSearchParameters)
{
GenericListModel <CompanyModel> baseListModel = new GenericListModel <CompanyModel>();
try
{
//if (!base.CompanyHasPermision(baseListModel))
// return baseListModel;
IQueryable <Company> companies = prepareSearch(dataTableSearchParameters.search.value);
foreach (JQDTColumnOrder order in dataTableSearchParameters.order)
{
switch (order.column)
{
case 0:
if (order.dir == JQDTColumnOrderDirection.asc)
{
companies = companies.OrderBy(c => c.Name);
}
else
{
companies = companies.OrderByDescending(c => c.Name);
}
break;
case 1:
if (order.dir == JQDTColumnOrderDirection.asc)
{
companies = companies.OrderBy(c => c.Notes);
}
else
{
companies = companies.OrderByDescending(c => c.Notes);
}
break;
}
}
baseListModel.Total = companies.Count();
companies = companies.Skip(dataTableSearchParameters.start);
if (dataTableSearchParameters.length != -1)
{
companies = companies.Take(dataTableSearchParameters.length);
}
CompanyMapper.Map(dbContext, companies.ToList(), baseListModel.List);
}
catch (Exception ex)
{
base.HandleError(baseListModel, CommonLayer.LookUps.ErrorType.Critical, ex);
}
return(baseListModel);
}
public ActionResult Update([FromBody] companyViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var serializeCompany = CompanyMapper.SerializeCompany(model);
var newCompany = _company.EditCompany(serializeCompany);
return(Ok(newCompany));
}
public async Task <bool> EditAsync(CompanyDto dto)
{
if (dto.Id == 0)
{
return(false);
}
var entity = CompanyMapper.FromDto(dto);
return(await _companyRepository.UpdateAsync(entity));
}
public ActionResult CompanyList(int NowPage = 0)
{
VMCompanyList Result = new VMCompanyList();
Result.list = JsonConvert.SerializeObject(CompanyMapper.Companylist(company.GetCompanyList(), Url));
Result.Count = company.GetCompanyListCount();
Result.AllPage = Paging.SumPage(Result.Count, 10);
Result.NowPage = NowPage;
Result.NewPage = (Result.AllPage == 0) ? 0 : Result.NowPage + 1;
Result.CompanyName = "";
return(View(Result));
}
public async Task <IActionResult> Create([Bind("ID,Name,Trade,CompanyEmail,Street,Town,PostalCode,Voivodeship,Country,OwnerID")] CompaniesViewModel company)
{
if (ModelState.IsValid)
{
company.ownerID = HttpContext.Session.GetObjectFromJson <int>("ownerID");
_context.Add(CompanyMapper.MapViewToCompany(company));
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(company));
}
public ActionResult CompanyLists(VMCompanySeacher search)
{
VMCompanyList result = new VMCompanyList();
UserRole role = UserRole.All;
result.CompanyList = CompanyMapper.Companylist(company.GetCompanyList(role, search.StatuString, search.CompanyName, search.NowPage), Url);
result.Count = company.GetCompanyListCount(role, search.StatuString, search.CompanyName);
result.AllPage = Paging.SumPage(result.Count, 10);
result.NowPage = search.NowPage;
result.NewPage = (result.AllPage == 0) ? 0 : result.NowPage + 1;
result.CompanyName = "";
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void testCompanyMapper()
{
Company compEntity = new Company
{
token = System.Guid.NewGuid(),
CompanyName = "Company1",
Departments =
new List <Department>()
{
new Department()
{
token = System.Guid.NewGuid(), DepartmentName = "Comp1-Department1", Address = "Comp1-Dep1-Address1"
, Employees = new List <Employee>()
{
new Employee()
{
token = System.Guid.NewGuid(), FirstName = "Comp1-Dep1-FName1", LastName = "Comp1-Dep1-LName1", JobTitle = "Comp1-Dep1-Title1", MailingAddress = "Comp1-Dep1-Address1"
},
new Employee()
{
token = System.Guid.NewGuid(), FirstName = "Comp1-Dep1-FName2", LastName = "Comp1-Dep1-LName2", JobTitle = "Comp1-Dep1-Title2", MailingAddress = "Comp1-Dep1-Address2"
},
new Employee()
{
token = System.Guid.NewGuid(), FirstName = "Comp1-Dep1-FName3", LastName = "Comp1-Dep1-LName3", JobTitle = "Comp1-Dep1-Title3", MailingAddress = "Comp1-Dep1-Address3"
},
}
},
new Department()
{
token = System.Guid.NewGuid(), DepartmentName = "Comp1-Department2", Address = "Comp1-Dep2-Address2"
, Employees = new List <Employee>()
{
new Employee()
{
token = System.Guid.NewGuid(), FirstName = "Comp1-Dep2-FName1", LastName = "Comp1-Dep2-LName1", JobTitle = "Comp1-Dep2-Title1", MailingAddress = "Comp1-Dep2-Address1"
},
new Employee()
{
token = System.Guid.NewGuid(), FirstName = "Comp1-Dep2-FName2", LastName = "Comp1-Dep2-LName2", JobTitle = "Comp1-Dep2-Title2", MailingAddress = "Comp1-Dep2-Address2"
},
}
}
}
};
CompanyModel compModel = CompanyMapper.toModel(compEntity);
Company compEntity2 = CompanyMapper.toEntity(new Company(), compModel); // convert it back from Entity to Model
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(compEntity.ByProperties(), compEntity2);
}
public async Task <IActionResult> Index()
{
bool isAuthenticated = User.Identity.IsAuthenticated;
if (isAuthenticated)
{
var companies = _context.Companies.Where(s => s.ownerID == HttpContext.Session.GetObjectFromJson <int>("ownerID"));
return(View(CompanyMapper.MapCompaniesListToView(companies, _context)));
//return View(await _context.Companies.Where(s => s.ownerID == HttpContext.Session.GetObjectFromJson<int>("ownerID")).ToListAsync());
}
return(RedirectToAction("Login", "Account", new { area = "" }));
}
public ActionResult Update(employeeViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var company = _company.GetCompanyById(model.MCompany.Id);
var serializeCompany = CompanyMapper.SerializeCompany(company);
model.MCompany = serializeCompany;
var serializeEmployee = EmployeeMapper.SerializeEmployee(model);
var newEmployee = _employee.EditEmployee(serializeEmployee);
return(Ok(newEmployee));
}
public Either <string, IEnumerable <CompanyView> > GetAll()
{
try
{
_logger.LogInformation("get company list");
return(_dbContext.Companies.Select(company => CompanyMapper.ToView(company))
.ToList());
}
catch (Exception ex)
{
_logger.LogError("can't get company list: ", ex);
return("can't get company list");
}
}
public List <T> RetrieveCompaniesByTerminal <T>(BaseEntity entity)
{
var LstCompanies = new List <T>();
var LstResult = Dao.ExecuteQueryProcedure(Mapper.GetRetrieveCompaniesByTerminalStatement(entity));
if (LstResult.Count > 0)
{
var objs = new CompanyMapper().BuildObjects(LstResult);
foreach (var c in objs)
{
LstCompanies.Add((T)Convert.ChangeType(c, typeof(T)));
}
}
return(LstCompanies);
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var company = await _context.Companies.SingleOrDefaultAsync(m => m.ID == id);
if (company == null)
{
return(NotFound());
}
PrepareVoivodeshipsAndCountires();
return(View(CompanyMapper.MapCompanyToView(company, _context)));
}
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var company = await _context.Companies
.SingleOrDefaultAsync(m => m.ID == id);
if (company == null)
{
return(NotFound());
}
return(View(CompanyMapper.MapCompanyToView(company, _context)));
}
public Either <string, CompanyView> Get(long id)
{
try
{
var company = _dbContext.Companies.Find(id);
if (company == null)
{
return("company not found");
}
return(CompanyMapper.ToView(company));
}
catch (Exception ex)
{
_logger.LogError("can't get company with id: {0} - ", id, ex);
return("can't get company");
}
}
public async Task <IActionResult> Create(CompanyModel company)
{
if (!this.ValidateISIN(company.ISIN))
{
return(BadRequest("ISIN value must begin with two letters and be unique"));
}
//Create Company
var newCompany = await companyDAO.CreateCompany(new Company.DataAccess.Models.Company
{
Name = company.Name,
ISIN = company.ISIN,
Website = company.Website
});
//Create Tickers
foreach (var ticker in company.Ticker)
{
await tickerDAO.CreateTicker(new Company.DataAccess.Models.Ticker {
CompanyId = newCompany.Id, Name = ticker
});
}
//Create Exchanges and link to Copmany in join table
var exchanges = new List <Company.DataAccess.Models.Exchange>();
foreach (var exchange in company.CompanyExchange)
{
var newExchange = await exchangeDAO.CreateExchange(new Company.DataAccess.Models.Exchange {
Name = exchange
});
exchanges.Add(newExchange);
await companyExchangeDAO.CreateCompanyExchange(new Company.DataAccess.Models.CompanyExchange {
CompanyId = newCompany.Id, ExchangeId = newExchange.Id
});
}
var companyInfo = CompanyMapper.DAOToAPIModel(newCompany, exchanges, newCompany.Ticker.ToList());
return(Ok(companyInfo));
}
public void Should_Map_And_Associate_New_ToolsLocalization_Created_In_EditedCompanyViewModel_To_Exisiting_Company_That_never_Had_Any_ToolsLocalization_Associated_Before()
{
//Arrange
var companyServiceMock = new Mock<ICompanyService>();
var CompanyAreaServiceMock = new Mock<ICompanyAreasService>();
var dummieCompanyViewModel = CompanyDummies.CreateOneEditCompanyViewModelWithCompanyArea();
var companyShouldReturn = CompanyDummies.CreatePortofinoCompany();
var actualCountBeforeUpdate = companyShouldReturn.CompanyAreas.Count;
companyServiceMock.Setup(s => s.FindCompany(dummieCompanyViewModel.Id)).Returns(companyShouldReturn);
var companyMapper = new CompanyMapper(companyServiceMock.Object, CompanyAreaServiceMock.Object);
//Act
var companyMapped = companyMapper.EditCompanyViewModelToCompany(dummieCompanyViewModel);
//Assert
Assert.AreEqual(0, actualCountBeforeUpdate);
Assert.AreEqual(dummieCompanyViewModel.CompanyAreas.Count(c => c.Selected), companyMapped.CompanyAreas.Count);
companyServiceMock.VerifyAll();
}
public void Map_ToolsLocalization_In_Company_To_View_When_Company_Have_Any_CompanyArea_Mapped()
{
//Arrange
var companyServiceMock = new Mock<ICompanyService>();
var CompanyAreaServiceMock = new Mock<ICompanyAreasService>();
var dummieCompany = CompanyDummies.CreatePortoveranoWithCompanyArea();
var dummieToolsLocaliations = CompanyAreasDummies.CreateListOfCompanyAreas();
companyServiceMock.Setup(x => x.FindCompany(It.IsAny<Company>())).Returns(dummieCompany);
CompanyAreaServiceMock.Setup(x => x.ListCompanyAreas())
.Returns(dummieToolsLocaliations);
var companyMapper = new CompanyMapper(companyServiceMock.Object, CompanyAreaServiceMock.Object);
//Act
var companyViewModel = companyMapper.CompanyToEditCompanyViewModel(dummieCompany);
//Assert
CompanyAreaServiceMock.VerifyAll();
Assert.AreEqual(companyViewModel.CompanyAreas.Count(), dummieToolsLocaliations.Count);
Assert.IsTrue(companyViewModel.CompanyAreas.Any(t => t.Selected));
}
public void Should_Map_EditedCompanyViewModel_To_Company_With_No_CompanyArea_Registered()
{
//Arrange
var companyServiceMock = new Mock<ICompanyService>();
var CompanyAreaServiceMock = new Mock<ICompanyAreasService>();
var dummieCompanyViewModel = CompanyDummies.CreateOneEditCompanyViewModelWithNoCompanyArea();
var companyShouldReturn = CompanyDummies.CreatePortofinoCompany();
companyServiceMock.Setup(s => s.FindCompany(dummieCompanyViewModel.Id)).Returns(companyShouldReturn);
var companyMapper = new CompanyMapper(companyServiceMock.Object, CompanyAreaServiceMock.Object);
//Act
companyMapper.EditCompanyViewModelToCompany(dummieCompanyViewModel);
//Assert
companyServiceMock.VerifyAll();
}
public void Should_Return_EditCompanyViewModel_With_ToolsLocalization_Data()
{
//Arrange
var companyServiceMock = new Mock<ICompanyService>();
var CompanyAreaServiceMock = new Mock<ICompanyAreasService>();
var company = CompanyDummies.CreatePortofinoCompany();
CompanyAreaServiceMock.Setup(x => x.ListCompanyAreas())
.Returns(CompanyAreasDummies.CreateListOfCompanyAreas);
var companyMapper = new CompanyMapper(companyServiceMock.Object, CompanyAreaServiceMock.Object);
//Act
companyMapper.CompanyToEditCompanyViewModel(company);
//Assert
CompanyAreaServiceMock.VerifyAll();
}
public void Should_Map_Company_To_EditedCompanyViewModel()
{
//Arrange
var companyServiceMock = new Mock<ICompanyService>();
var CompanyAreaServiceMock = new Mock<ICompanyAreasService>();
var dummieCompanyViewModel = CompanyDummies.CreateOneEditCompanyViewModel();
var companyShouldReturn = CompanyDummies.CreatePortofinoCompany();
companyServiceMock.Setup(s => s.FindCompany(dummieCompanyViewModel.Id)).Returns(companyShouldReturn);
var companyMapper = new CompanyMapper(companyServiceMock.Object, CompanyAreaServiceMock.Object);
//Act
var companyMapped = companyMapper.EditCompanyViewModelToCompany(dummieCompanyViewModel);
//Assert
Assert.IsNotNull(companyMapped);
companyServiceMock.VerifyAll();
}
