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)); }