public async Task CanAdd()
{
var company = new Company {
CompanyId = 999, Name = "New Company", Created = DateTime.UtcNow, Modified = DateTime.UtcNow
};
var newCompany = await _companyRepository.AddAsync(company).ConfigureAwait(false);
Assert.Equal("New Company", newCompany.Name);
}
public async Task AddAsync(CompanyDTO company)
{
if (company != null)
{
await _companyRepository.AddAsync(_mapper.Map <CompanyDTO, Company>(company));
}
}
public async Task <bool> AddAsync(CompanyDto dto)
{
var entity = CompanyMapper.FromDto(dto);
var result = await _companyRepository.AddAsync(entity);
return(result.Id != 0);
}
public async Task <DomainCompany> AddAsync(DomainCompany company)
{
company.Created = DateTime.UtcNow;
company.Email = company.Email.ToLowerInvariant();
CompanyEntity entity = _mapper.Map <DomainCompany, CompanyEntity>(company);
// Creating customer in billing system
var customerCreateOptions = new DomainCustomerCreateOptions
{
Email = entity.Email
};
DomainCustomer customer;
try
{
customer = await _billingCustomerService.AddAsync(customerCreateOptions);
}
catch (BillingException e)
{
throw new BadRequestException(string.Format("Failed to register customer {0}: {1}", entity.Email, e));
}
entity.BillingCustomerId = customer.Id;
entity = await _companyRepository.AddAsync(entity);
return(_mapper.Map <CompanyEntity, DomainCompany>(entity));
}
public async Task <CompanyResponse> SaveAsync(Company company)
{
var existingUsername = await _companyRepository.FindByUsername(company.Username);
if (existingUsername != null)
{
return(new CompanyResponse("This username is being used by another user"));
}
var existingEmail = await _companyRepository.FindByEmail(company.Email);
if (existingEmail != null)
{
return(new CompanyResponse("This email is being used by another user"));
}
try
{
await _companyRepository.AddAsync(company);
await _unitOfWork.CompleteAsync();
return(new CompanyResponse(company));
}
catch (Exception e)
{
return(new CompanyResponse($"An error ocurred while saving the company: {e.Message}"));
}
}
public async Task <IActionResult> Post([FromBody] AddCompanyViewModel model)
{
if (model == null)
{
return(BadRequest());
}
if (await _companyRepo.IsExistNameAsync(model.Name))
{
ModelState.AddModelError("Name", Resources.Global.Common.ThisNameExist);
return(BadRequest(ModelState.GetWithErrorsKey()));
}
var company = new Company(model.Name);
var affectedRows = await _companyRepo.AddAsync(company);
if (affectedRows > 0)
{
var viewModel = AutoMapper.Mapper.Map <CompanyViewModel>(company);
return(CreatedAtRoute("GetCompany", new { id = company.Number }, viewModel));
}
return(BadRequest());
}
public async Task <CreateCompanyViewModel> CreateAsync(CreateCompanyViewModel model)
{
var company = mapper.Map(model);
await companyRepository.AddAsync(company);
await dataContext.SaveChangeAsync();
return(model);
}
public async Task <IResultModel> Add(CompanyAddModel model)
{
var entity = _mapper.Map <CompanyEntity>(model);
//if (await _repository.Exists(entity))
//{
//return ResultModel.HasExists;
//}
var result = await _repository.AddAsync(entity);
return(ResultModel.Result(result));
}
public async Task <CreateCompanyCommandResponse> Handle(CreateCompanyCommand request, CancellationToken cancellationToken)
{
var entity = _mapper.Map <Company>(request);
await _companyRepository.AddAsync(entity);
_logger.LogInformation("Created company Id: {0}, Name: {1}", entity.Id, entity.Name);
var uri = _uriService.Get(entity.Id, nameof(Company));
return(new CreateCompanyCommandResponse(uri));
}
public async Task <CompanyResponse> SaveAsync(Company company)
{
try
{
await _companyRepository.AddAsync(company);
return(new CompanyResponse(company));
}
catch (Exception ex)
{
return(new CompanyResponse($"An error occurred when saving the Company: {ex.Message}"));
}
}
public async Task RegisterCompanyAsync(Company company)
{
string password = passwordGenerator.GeneratePassword();
await companyRepository.AddAsync(company);
await companyRepository.SaveChangesAsync();
await AddUserPasswordAsync(company.User, password);
await AddUserToRoleAsync(company.User, Roles.COMPANY);
await emailService.SendEmailAsync(company.User.Email, password);
}
public async Task <Response <Company> > SaveAsync(Company company)
{
try
{
await _companyRepository.AddAsync(company);
await _unitOfWork.CompleteAsync();
return(new Response <Company>(company));
}
catch (Exception ex)
{
return(new Response <Company>($"An error occorred when saving the user: {ex.Message}"));
}
}
public async Task <CompanyResponse> SaveAsync(Company company)
{
try
{
await _companyRepository.AddAsync(company);
await _unitOfWork.CompleteAsync();
return(new CompanyResponse(company));
}
catch (Exception e)
{
return(new CompanyResponse($"An error ocurred while saving the company: {e.Message}"));
}
}
public async Task <IActionResult> CreateAsync([FromBody] Company company)
{
Logger.LogDebug("CreateAsync");
if (company == null)
{
return(BadRequest(new BadRequestError("The company is null")));
}
await CompanyRepository.AddAsync(company);
return(CreatedAtRoute("GetCompanyById", new
{
Controller = "Companies",
id = company.CompanyId
}, company));
}
public async Task <CompanyResponse> SaveAsync(Company company)
{
try
{
await _companyRepository.AddAsync(company);
await _unitOfWork.CompleteAsync();
return(new CompanyResponse(company));
}
catch (Exception ex)
{
//DO some logging stuff
return(new CompanyResponse($"An error occured when saving company: {ex.Message}"));
}
}
public async Task <IActionResult> Create([FromBody] CompanyForManipulationDto company)
{
if (company == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(UnprocessableEntity(ModelState.GetValidationErrors()));
}
var companyToAdd = _mapper.Map <Company>(company);
await _companyRepository.AddAsync(companyToAdd);
return(CreatedAtRoute("GetCompany", companyToAdd, new { id = companyToAdd.Id }));
}
public async Task AddAsync(CompanyModel model)
{
model = await ValidateAsync(model);
await _companyRepository.AddAsync(new Company
{
Address = model.Address,
CNPJ = model.CNPJ,
CreatedDate = DateTimeOffset.UtcNow,
ID = Guid.NewGuid(),
Name = model.Name,
Phone = model.Phone,
QtdCars = model.QtdCars.Value,
QtdMotorcycles = model.QtdMotorcycles.Value,
});
await _companyRepository.SaveChangeAsync();
}
public async Task <ApplicationResponse <bool> > AddCompany(AddCompanyDto addCompanyDto)
{
var isValidUser = await _companyRepository.GetAsync(x => x.Name == addCompanyDto.Name.Trim());
if (isValidUser is not null)
{
return(new ApplicationResponse <bool>(ResponseState.Error, ResponseMessage.Error.ValidCompany));
}
await _companyRepository.AddAsync(new Company
{
Name = addCompanyDto.Name,
Phone = addCompanyDto.Phone
});
return(new ApplicationResponse <bool>(true));
}
public async Task <Response <bool> > Handle(CreateCompanyCommand request, CancellationToken cancellationToken)
{
var company = new HiSign.Domain.Entities.Company
{
Name = request.Name,
Address = request.Address,
PhoneNumber = request.PhoneNumber,
BankAccount = request.BankAccount,
BusinessLicense = request.BusinessLicense,
Email = request.Email,
TaxCode = request.TaxCode,
Created = DateTime.Now,
Representaive = request.Representaive
};
await _companyRepository.AddAsync(company);
return(new Response <bool>(true));
}
public async Task CreateAsync(CompanyData createData)
{
var validate = await _createValidationRules.ValidateAsync(createData).ConfigureAwait(false);
if (!validate.IsValid)
{
throw new EntityValidationException(validate.ToString("~"));
}
var company = _mapper.Map <Company>(createData);
if (createData == null)
{
throw new NullReferenceException();
}
if (await _repository.IsExistAsync(x => x.Name == company.Name))
{
throw new RecordAlreadyExistException();
}
await _repository.AddAsync(company).ConfigureAwait(false);
await _unitOfWork.CompleteAsync().ConfigureAwait(false);
}
public async Task <ServiceResult <int> > Create(CompanyCreateOrUpdateRequestViewModel viewModel)
{
var model = new Company();
MapViewModelToModel(viewModel, model);
var validator = new CompanyCreateOrUpdateRequestViewModelValidator();
var validationResult = await validator.ValidateAsync(model);
if (!validationResult.IsValid)
{
return(ServiceResultFactory.Fail <int>(validationResult));
}
await _repository.AddAsync(model);
var changes = await _repository.SaveChangesAsync();
if (changes == 0)
{
return(ServiceResultFactory.Fail <int>("Insert fails"));
}
return(ServiceResultFactory.Success(model.Id));
}
public async Task <long> CreateAsync(CreateCompany dto)
{
var company = new Company(dto.Name, (int)dto.EstablishmentYear);
return(await _companyRepository.AddAsync(company));
}
public Task AddCompanyAsync(Data.AppTrackEntities.company company)
{
return(_companyRepository.AddAsync(company));
}
public override async Task <int> HandleCommand(InsertCompanyCommand request, CancellationToken cancellationToken)
{
var id = 0;
using (var conn = DALHelper.GetConnection())
{
conn.Open();
using (var trans = conn.BeginTransaction())
{
try
{
request.Model.Address.CreatedDate = DateTime.Now;
request.Model.Address.CreatedBy = request.LoginSession?.Id ?? 0;
request.Model.Address.ModifiedDate = DateTime.Now;
request.Model.Address.ModifiedBy = request.LoginSession?.Id ?? 0;
var addressId = await addressRepository.AddAsync(request.Model.Address);
request.Model.Contact.CreatedDate = DateTime.Now;
request.Model.Contact.CreatedBy = request.LoginSession?.Id ?? 0;
request.Model.Contact.ModifiedDate = DateTime.Now;
request.Model.Contact.ModifiedBy = request.LoginSession?.Id ?? 0;
var contactId = await contactRepository.AddAsync(request.Model.Contact);
request.Model.AddressId = addressId;
request.Model.ContactId = contactId;
request.Model.CreatedDate = DateTime.Now;
request.Model.CreatedBy = request.LoginSession?.Id ?? 0;
request.Model.ModifiedDate = DateTime.Now;
request.Model.ModifiedBy = request.LoginSession?.Id ?? 0;
id = await companyRepository.AddAsync(request.Model);
Company company = await companyQueries.GetByIdAsync(id);
var filePath = await storageFile.getCompanyFilePathAsync(company);
if ((request.Model.ImageData?.Length ?? 0) > Constant.MaxImageLength)
{
throw new BusinessException("Image.OutOfLength");
}
if (request.Model.IsChangedImage && (request.Model.ImageData?.Length ?? 0) > 0)
{
string type = CommonHelper.GetImageType(System.Text.Encoding.ASCII.GetBytes(request.Model.ImageData));
if (!CommonHelper.IsImageType(type))
{
throw new BusinessException("Image.WrongType");
}
string base64Data = request.Model.ImageData.Substring(request.Model.ImageData.IndexOf(",") + 1);
string fileName = Guid.NewGuid().ToString().Replace("-", "");
company.LogoPath = await storageFile.SaveCompanyLogo(filePath, type, base64Data);
await companyRepository.UpdateAsync(company);
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (id > 0)
{
trans.Commit();
}
else
{
try { trans.Rollback(); } catch { }
}
}
}
}
return(id);
}
public async Task <IActionResult> CreateAsync([FromBody] NewCompanyRequest model)
{
var company = await _companyRepository.AddAsync(model);
return(StatusCode((int)HttpStatusCode.Created, company));
}
//Basic
public async Task <int> AddAsync(CompanyEntity companyEntity)
{
return(await _companyRepository.AddAsync(companyEntity));
}
