private async Task <ResponseMessagesDto> CreateCompanyAsync(CreateCompanyDto companyDto)
{
var result = await _companyRepository.InsertAsync(new Company()
{
Name = companyDto.Name,
Description = companyDto.Description,
TenantId = companyDto.TenantId
});
await UnitOfWorkManager.Current.SaveChangesAsync();
if (result.Id != 0)
{
return(new ResponseMessagesDto()
{
Id = result.Id,
SuccessMessage = AppConsts.SuccessfullyInserted,
Success = true,
Error = false,
});
}
return(new ResponseMessagesDto()
{
Id = 0,
ErrorMessage = AppConsts.InsertFailure,
Success = false,
Error = true,
});
}
public async Task <CreateCompanyResultDto> Create(CreateCompanyDto createCompanyDto, int userId)
{
var company = new Company();
company.Address = createCompanyDto.Address;
company.BrandName = createCompanyDto.BrandName;
company.Logo = createCompanyDto.Logo;
company.Name = createCompanyDto.Name;
company.RegistrationNumber = createCompanyDto.RegistrationNumber;
company.UserId = userId;
company.VatNumber = createCompanyDto.VatNumber;
if (await _userRolesRepository.GetAsync(filter: o => o.UserId == userId && o.RoleId == (int)Roles.CompanyOwner) == null)
{
var userRole = new UserRole()
{
RoleId = (int)Roles.CompanyOwner,
UserId = userId
};
await _userRolesRepository.InsertAsync(userRole);
}
return(new CreateCompanyResultDto()
{
CompanyId = (await _companiesRepository.InsertAsync(company)).Id
});
}
private async Task <ResponseMessagesDto> UpdateCompanyAsync(CreateCompanyDto companyDto)
{
var result = await _companyRepository.UpdateAsync(new Company()
{
Id = companyDto.Id,
Name = companyDto.Name,
Description = companyDto.Description,
});
if (result != null)
{
return(new ResponseMessagesDto()
{
Id = result.Id,
SuccessMessage = AppConsts.SuccessfullyUpdated,
Success = true,
Error = false,
});
}
return(new ResponseMessagesDto()
{
Id = 0,
ErrorMessage = AppConsts.UpdateFailure,
Success = false,
Error = true,
});
}
public async Task <IActionResult> Create(CreateCompanyDto createCompanyDto)
{
CreateCompanyModel companyModel = _mapper.Map <CreateCompanyModel>(createCompanyDto);
await _companyService.Create(companyModel);
return(Ok());
}
public async Task <IActionResult> CreateAsync([FromBody] CreateCompanyDto item)
{
Company entity = _mapper.Map <Company>(item);
_companyRepository.Create(entity);
await _companyRepository.SaveChangesAsync();
return(Ok(_mapper.Map <GetCompanyDto>(entity)));
}
public async Task CreateCompany(CreateCompanyDto input)
{
var company = new Company()
{
Name = input.Name
};
await _companyRepository.InsertAsync(company);
await CurrentUnitOfWork.SaveChangesAsync();
}
public async Task <ActionResult <CompanyDto> > CreateCompany(CreateCompanyDto createCompanyDto)
{
var entity = _mapper.Map <Company>(createCompanyDto);
_companyRepository.AddCompany(entity);
await _companyRepository.SaveAysnc();
var returnDto = _mapper.Map <CompanyDto>(entity);
return(CreatedAtRoute(nameof(GetCompany), new { companyId = returnDto.id }, returnDto));
}
public async Task <Dto> CreateCompany <Dto>(CreateCompanyDto createCompanyDto)
{
Company company = _mapper.Map <Company>(createCompanyDto);
company.HashedPassword = _passwordHasher.Hash(createCompanyDto.Password);
company = await _repository.Add(company);
Dto mappedCompany = _mapper.Map <Dto>(company);
return(mappedCompany);
}
public async Task <IActionResult> CreateCompany([FromBody] CreateCompanyDto company)
{
var companyEntity = _mapper.Map <Company>(company);
_repository.Company.CreateCompany(companyEntity);
await _repository.SaveAsync();
var companyToReturn = _mapper.Map <CompanyDto>(companyEntity);
return(CreatedAtRoute("CompanyById", new { id = companyToReturn.Id }, companyToReturn));
}
public async Task <IActionResult> Create(CreateCompanyDto item)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ModelStateResult(ModelState)));
}
var createCompanyResultDto = await _companiesService.Create(item, UserId);
return(Ok(createCompanyResultDto));
}
public async Task <IActionResult> Post([FromBody] CreateCompanyDto companyDto)
{
var result = await _companyService.Create(companyDto);
if (!_companyService.Success())
{
return(BadRequest(_companyService.Errors));
}
return(Ok(result));
}
public CreateCompanyCommand(CreateCompanyDto dto)
{
Dto = dto;
var validator = new Validator();
var result = validator.Validate(this);
if (!result.IsValid)
{
throw new ValidationException(result.Errors);
}
}
public ActionResult <CompanyDto> AddCompany(CreateCompanyDto company)
{
var companyModel = _mapper.Map <Company>(company);
_leadsRepo.AddCompany(companyModel);
_leadsRepo.Save();
var companyToReturn = _mapper.Map <CompanyDto>(companyModel);
return(CreatedAtRoute("GetCompanyById",
new { Id = companyModel.Id }, companyToReturn));
}
public async Task <ActionResult> PostCompany(CreateCompanyDto createCompanyDto)
{
try
{
CompanyDto companyDto = await _business.CreateCompany <CompanyDto>(createCompanyDto);
return(Created(companyDto.Id.ToString(), companyDto));
} catch (DbUpdateException)
{
return(BadRequest($"A company with the mail \"{createCompanyDto.Mail}\" already exists."));
}
}
public async Task <IActionResult> Create([FromBody] CreateCompanyDto company)
{
if (ModelState.IsValid)
{
var @new = await uow.Company.Create(mapper.Map <Company>(company));
await uow.CommitAsync();
return(CreatedAtAction("Get", "Company", new { id = @new.Id }, mapper.Map <GetCompanyDto>(@new)));
}
return(BadRequest(ModelState));
}
async public Task <IActionResult> createCompany(CreateCompanyDto companyDto)
{
ServiceResponse <List <GetCompanyAdminDto> > response = await _companyService.CreateCompany(companyDto);
if (response.Success)
{
return(Ok(response.Data));
}
else
{
return(BadRequest(response.Message));
}
}
public async Task <bool> CreateCompany(CreateCompanyDto company)
{
string sUrl = _LocalUrlBase;
string companyJson = JsonConvert.SerializeObject(company);
var client = _clientFactory.CreateClient();
var stringContent = new StringContent(companyJson, Encoding.UTF8, "application/json");
var respons = await client.PostAsync(sUrl, stringContent);
Console.WriteLine(respons);
return(true);
}
// Validate
private async Task <IResponseDTO> ValidateCreatingCompany(CreateCompanyDto options, Data.DbModels.CompanySchema.Company company)
{
try
{
// Validate Name
if (_appDbContext.Companies.Any(x => x.Name.Trim().ToLower() == options.Name.Trim().ToLower() && !x.IsDeleted))
{
_response.Errors.Add($"Company name '{options.Name}' already exist, please try a new one.");
}
// Validate Email
if (_appDbContext.Companies.Any(x => x.Email.Trim().ToLower() == options.Email.Trim().ToLower() && !x.IsDeleted))
{
_response.Errors.Add($"Company email '{options.Email}' already exist, please try a new one.");
}
// Country
var country = await _appDbContext.Countries.FirstOrDefaultAsync(x => x.Id == options.CountryId);
if (country == null)
{
_response.Errors.Add($"The specified country id does not exist.");
}
else if (country.IsDeleted)
{
_response.Errors.Add($"The specified country '{country.Name}' is deleted.");
}
else
{
company.Country = country;
}
_response.IsPassed = true;
}
catch (Exception ex)
{
_response.IsPassed = false;
_response.Data = null;
_response.Errors.Add($"Error: {ex.Message}");
}
if (_response.Errors.Count > 0)
{
_response.Errors = _response.Errors.Distinct().ToList();
_response.IsPassed = false;
_response.Data = null;
return(_response);
}
return(_response);
}
public async Task <ResponseMessagesDto> CreateOrEditAsync(CreateCompanyDto companyDto)
{
ResponseMessagesDto result;
if (companyDto.Id == 0)
{
result = await CreateCompanyAsync(companyDto);
}
else
{
result = await UpdateCompanyAsync(companyDto);
}
return(result);
}
public async Task <GetCompanyDto> Create(CreateCompanyDto companyDto)
{
var validations = await _companyValidator.CreateValidate(companyDto);
if (validations.IsValid)
{
await _companyRepository.Create(_mapper.Map <Company>(companyDto));
var result = await Filter(new FilterCompanyDto { Name = companyDto.Name, Cnpj = companyDto.Cnpj, Fundation = companyDto.Fundation });
}
Errors.AddRange(validations.Errors.Select(erro => erro.ErrorMessage));
return(null);
}
public async Task <CompanyDto> CreateAsync(CreateCompanyDto createCompanyDto)
{
using (UnitOfWork)
{
var company = new Company(
createCompanyDto.CompanyName,
createCompanyDto.HeadQuarters,
createCompanyDto.FoundationDate,
createCompanyDto.EmployersCount,
Guid.NewGuid());
await _companyRepository.CreateAsync(company);
await UnitOfWork.SaveChangesAsync();
return(ObjectMapper.Map <Company, CompanyDto>(company));
}
}
public IActionResult CreateCompany([FromBody] CreateCompanyDto companyDto)
{
if (companyDto == null)
{
return(BadRequest());
}
Company company = Mapper.Map <Company>(companyDto);
_companiesRepository.AddCompany(company);
if (!_companiesRepository.Save())
{
return(StatusCode(500, "A problem happened with handling you request."));
}
return(CreatedAtRoute("GetById", new { id = company.Id }, company));
}
public async Task <IResponseDTO> CreateCompany(CreateCompanyDto options, int userId)
{
try
{
var company = _mapper.Map <Data.DbModels.CompanySchema.Company>(options);
// Validate
var validationResult = await ValidateCreatingCompany(options, company);
if (!validationResult.IsPassed)
{
return(validationResult);
}
// Set the data
company.CreatedBy = userId;
company.CreatedOn = DateTime.Now;
company.IsActive = true;
// save to the database
await _appDbContext.Companies.AddAsync(company);
var save = await _appDbContext.SaveChangesAsync();
if (save == 0)
{
_response.IsPassed = false;
_response.Errors.Add("Database did not save the object");
return(_response);
}
_response.IsPassed = true;
_response.Message = "Company is created successfully";
}
catch (Exception ex)
{
_response.Data = null;
_response.IsPassed = false;
_response.Errors.Add($"Error: {ex.Message}");
}
return(_response);
}
public async Task <ValidationResult> CreateValidate(CreateCompanyDto companyDto)
{
var validations = Validate(companyDto);
if (!validations.IsValid)
{
return(validations);
}
var query = await _companyRepository.Get();
if (query.Any(company => company.Name.IsEquals(companyDto.Name)))
{
validations.Errors.Add(new ValidationFailure("Error", "Name must be unique."));
}
if (query.Any(company => company.Cnpj.IsEquals(companyDto.Cnpj.OnlyNumbers())))
{
validations.Errors.Add(new ValidationFailure("Error", "CNPJ must be unique."));
}
return(validations);
}
public async Task <IActionResult> CreateCompanyToUser([FromBody] CreateCompanyDto dto)
{
var user = await _userManager.GetByIdentityAsync(this);
if (user == null)
{
return(Unauthorized());
}
var mappedCompany = _mapper.Map <CreateCompanyDto, Company>(dto);
var createdCompany = await _userCompanyService.AddCompanyToUserAsync(user, mappedCompany);
if (createdCompany == null)
{
return(BadRequest("Can't create company"));
}
return(Created(Url.GetEntityByIdUrl(nameof(Get),
"Company",
createdCompany.Id.ToString(),
Request.Scheme),
_mapper.Map <Company, CompanyDto>(createdCompany)));
}
async Task <ServiceResponse <List <GetCompanyAdminDto> > > ICompanyService.CreateCompany(CreateCompanyDto companyDto)
{
ServiceResponse <List <GetCompanyAdminDto> > response = new ServiceResponse <List <GetCompanyAdminDto> >();
if (await _context.Companies.FirstOrDefaultAsync(a => a.companyName == companyDto.companyName) != null)
{
response.Success = false;
response.Message = "This company already has an account";
return(response);
}
string finalString = new IDGenerator.IDGenerator().generate();
Company newCompany = new Company(finalString, companyDto.companyName, companyDto.companyTier, companyDto.companyDescription, true);
await _context.Companies.AddAsync(newCompany);
await _context.SaveChangesAsync();
List <Company> newCompanyList = await _context.Companies.ToListAsync();
response.Data = newCompanyList.Select(a => new GetCompanyAdminDto(a.companyId, a.companyName, a.companyTier, a.companyDescription, a.isActive)).ToList();;
return(response);
}
public async Task <GetCompanyDto> CreateCompany(CreateCompanyDto dto)
{
return(await new CreateCompanyCommand(dto).CreateCompany(UserInfo));
}
public async Task <IResponseDTO> CreateCompany([FromBody] CreateCompanyDto options)
{
_response = await _companyService.CreateCompany(options, LoggedInUserId);
return(_response);
}
