public IActionResult AddCompany([FromBody] CompanyCreateDto companyDto)
{
if (companyDto is null)
{
return(BadRequest(ModelState));
}
if (_companyRepository.Exists(c => c.Name == companyDto.Name))
{
ModelState.AddModelError("", "Company already exists in the database");
return(StatusCode(500, ModelState));
}
Company company = _mapper.Map <Company>(companyDto);
_companyRepository.Add(company);
if (_companyRepository.Save() > 0)
{
return(CreatedAtRoute("GetCompany", company.Id, company));
}
else
{
ModelState.AddModelError("", "Something went erong saving the company");
return(StatusCode(500, ModelState));
}
}
public IActionResult Create([FromBody] CompanyCreateDto companyCreateDto)
{
Company company = _companyCreateAssembler.toEntity(companyCreateDto);
_companyRepository.Create(company);
return(StatusCode(StatusCodes.Status201Created, new ApiStringResponseDto("Company Created!")));
}
public ActionResult Create(CompanyCreateDto model)
{
model.UserId = HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier);
_companyService.Create(model);
return(Ok(Response.WriteAsync(JsonConvert.SerializeObject(model,
new JsonSerializerSettings {
Formatting = Formatting.Indented
}))));
}
public async Task CanCreateAndDeleteCompanies()
{
var newCompany = new CompanyCreateDto
{
Name = "Test Company"
};
var company = await _httpClientHelper.PostAsync <CompanyCreateDto, CompanyDto>(_baseUrl + "create", newCompany).ConfigureAwait(false);
Assert.Equal("Test Company", company.Name);
await _httpClientHelper.DeleteAsync(_baseUrl + $"DeleteCompanyById{API_VERSION}/{company.CompanyId}").ConfigureAwait(false);
}
public IActionResult Create([FromBody] CompanyCreateDto parm)
{
if (_companyService.Any(m => m.CompanyNo == parm.CompanyNo))
{
return(toResponse(StatusCodeType.Error, $"添加公司编码 {parm.CompanyNo} 已存在，不能重复！"));
}
//从 Dto 映射到 实体
var company = parm.Adapt <Base_Company>().ToCreate(_tokenManager.GetSessionInfo());
return(toResponse(_companyService.Add(company)));
}
public async Task <ActionResult> UpdateAsync(int id, CompanyCreateDto companyCreateDto)
{
var companyModel = _mapper.Map <Models.Company>(companyCreateDto);
if (await _companyRepository.UpdateAsync(id, companyModel))
{
await _companyRepository.SaveChangesAsync();
return(Ok());
}
return(NotFound());
}
public async Task OnGetAsync()
{
Company = new CompanyCreateDto();
CagegoryLookupList.AddRange(
(await _companyAppService.GetCagegoryLookupAsync(new LookupRequestDto {
MaxResultCount = LimitedResultRequestDto.MaxMaxResultCount
})).Items
.Select(t => new SelectListItem(t.DisplayName, t.Id.ToString()))
.ToList());
await Task.CompletedTask;
}
public ActionResult <CompanyCreateDto> CreateCompany(CompanyCreateDto companyCreateDto)
{
// Map Dto to Model
var companyModel = _mapper.Map <Company>(companyCreateDto);
_repository.CreateCompany(companyModel);
_repository.SaveChanges();
var companyReadDto = _mapper.Map <CompanyReadDto>(companyModel);
// CreatedAtRoute creates 201 created with specified values.
return(CreatedAtRoute(nameof(GetCompanyById), new { Id = companyReadDto.Id }, companyReadDto));
}
public void Create(CompanyCreateDto model)
{
var contactInfo = _mapper.Map <CompanyCreateDto, ContactInfo>(model);
Company company = new Company()
{
UserId = model.UserId,
NameCompany = model.NameCompany,
ContactInfo = contactInfo
};
_companyRepository.Insert(company);
_companyRepository.Save();
}
public async Task <IActionResult> CreateAsync([FromBody] CompanyCreateDto company, ApiVersion version)
{
Logger.LogDebug(nameof(CreateAsync));
var newCompany = new Company
{
Name = company.Name
};
var repoCompany = await _repositoryFactory.CompanyRepository.AddCompanyAsync(newCompany).ConfigureAwait(false);
var result = _companyToDtoConverter.Convert(repoCompany);
return(new ObjectResult(result)
{
StatusCode = StatusCodes.Status201Created
});
}
//[Authorization(Power = "PRIV_COMPANY_CREATE")]
public IActionResult Create([FromBody] CompanyCreateDto parm)
{
if (_companyService.Any(m => m.CompanyNo == parm.CompanyNo))
{
return(toResponse(StatusCodeType.Error, $"添加公司编码 {parm.CompanyNo} 已存在，不能重复！"));
}
var helper = new Common.SerialNoHelper();
var serialno = helper.Generate("N20"); //生成编码
//从 Dto 映射到 实体
var company = parm.Adapt <Base_Company>().ToCreate(_tokenManager.GetSessionInfo());
return(toResponse(_companyService.Add(company)));
}
public CompanyDto CreateCompany(CompanyCreateDto dto)
{
var repoUser = _contextManager.CreateRepositiry <IUserRepo>();
var user = repoUser.GetById(dto.UserId);
var repoCompany = _contextManager.CreateRepositiry <ICompanyRepo>();
var company = repoCompany.GetCompanyByName(dto.Name);
if (!(company == null))
{
throw new ValidationException("Company with name <" + dto.Name + "> is already exists.");
}
var entity = _mapper.Map <Company>(dto);
repoCompany.Add(entity);
_contextManager.Save();
var repoCompUser = _contextManager.CreateRepositiry <ICompanyUserLinkRepo>();
var companyUser = new CompanyUserLink
{
CompanyId = entity.Id,
UserId = user.Id,
UserCompanyRole = (int)Model.Enums.CompanyUserRoleEnum.Owner
};
repoCompUser.Add(companyUser);
_contextManager.Save();
var repoCompSub = _contextManager.CreateRepositiry <ICompanySubRepo>();
var companySub = new CompanySubscription
{
CompanyId = entity.Id,
UserId = user.Id,
SubEndDt = DateTime.UtcNow.Date,
UseTrialVersion = (int)Model.Enums.CompanyTrialVersionEnum.ReadyToUseTrial
};
repoCompSub.Add(companySub);
_contextManager.Save();
return(_mapper.Map <CompanyDto>(entity));
}
public IActionResult CreateCompany([FromBody] CompanyCreateModel model)
{
try
{
var companyCreateDto = new CompanyCreateDto
{
Name = model.Name,
UserId = model.UserId,
Type = model.Type,
Description = model.Description
};
var data = _service.CreateCompany(companyCreateDto);
return(Ok(data));
}
catch (ValidationException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult <CompanyReadDto> > CreateAsync(CompanyCreateDto companyCreateDto)
{
if (!companyCreateDto.EstablishmentYear.HasValue)
{
return(ValidationProblem("THe field EstablishmentYear cannot be empty"));
}
var companyModel = _mapper.Map <Models.Company>(companyCreateDto);
await _companyRepository.CreateAsync(companyModel);
foreach (var modelEmployee in companyModel.Employees)
{
await _employeeRepository.CreateAsync(modelEmployee);
}
await _companyRepository.SaveChangesAsync();
return(Ok(new { id = companyModel.Id }));
}
public async Task <ActionResult <CompanyDto> > CompanyCreate([FromBody] CompanyCreateDto dto)
{
CompanyCreateDtoValidator validator = new CompanyCreateDtoValidator();
ValidationResult result = await validator.ValidateAsync(dto);
if (result.IsValid)
{
var userId = User.Claims
.Single(p => p.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier").Value;
var manager = await _dbContext.Managers
.Include(x => x.Company)
.SingleOrDefaultAsync(x => x.ApplicationUserId == userId);
#region 驗證
if (!manager.ManagerConfirmed)
{
return(Problem(title: "禁止修改", detail: "企業使用者尚未驗證", statusCode: 403));
}
if (manager.Company != null)
{
return(Problem(title: "禁止修改", detail: "無法新增多個公司", statusCode: 403));
}
if (await _dbContext.Companies.AnyAsync(x => x.RegistrationNumber == dto.RegistrationNumber))
{
result.Errors.Add(new ValidationFailure("registrationNumber", "統一編號已經被使用"));
return(BadRequest(result.Errors));
}
#endregion
var entity = _mapper.Map <Company>(dto);
manager.Company = entity;
_dbContext.Managers.Update(manager);
await _dbContext.SaveChangesAsync();
var routeValues = new { companyId = entity.CompanyId };
var returnDto = _mapper.Map <CompanyDto>(entity);
return(CreatedAtAction(nameof(GetCompany), routeValues, returnDto));
}
return(BadRequest(result.Errors));
}
public void CreateDeleteCompanyTest()
{
Random rng = new Random();
//arrange
var dto = new CompanyCreateDto
{
Name = "Nameasdasd",
Type = 1,
Description = "CompanyDtoDescriptionCompanyDto"
};
//act
var result = _companyService.CreateCompany(dto);
var companyID = result.Id;
//assert
Assert.AreNotEqual(0, result.Id);
_companyService.DeleteCompany(companyID);
}
public async Task <IActionResult> AddCompanyAsync(CompanyCreateDto com)
{
if (!ModelState.IsValid)
{
return(BadRequest("Fill all fields"));
}
var company = _mapper.Map <Company>(com);
try
{
company = await _companiesService.CreateAsync(company);
return(Created(Request.Path, company.Id));
}
catch (EntityPresentException e)
{
return(BadRequest(e.Message));
}
catch
{
return(this.ServerError("Failed to create company"));
}
}
public Company toEntity(CompanyCreateDto companyDto)
{
return(_mapper.Map <Company>(companyDto));
}
