public async Task RegisterAsync(CustomerViewModel accountViewModel)
{
var customer = _mapper.Map <Customer>(accountViewModel);
customer.CustomerId = Guid.NewGuid().ToString();
await _customerRepository.AddAsync(customer);
}
public async Task <CustomerSignUpResult> SignUpCustomerAsync(Customer customer)
{
CustomerSignUpResult customerSignUpResult = null;
CustomerExistanceResult customerExistanceResult = await CustomerRepository.CustomerExistsAysnc(customer);
if (customerExistanceResult == null)
{
customerSignUpResult = await CustomerRepository.AddAsync(customer);
}
else
{
if (customerExistanceResult.EmailAddress.Equals(customer.EmailAddress) &&
customerExistanceResult.PhoneNumber.Equals(customer.PhoneNumber))
{
throw new CustomerAlreadyExistsException(customer.PhoneNumber, customer.EmailAddress);
}
if (customerExistanceResult.EmailAddress.Equals(customer.EmailAddress))
{
throw new CustomerAlreadyExistsException(customer.EmailAddress);
}
if (customerExistanceResult.PhoneNumber.Equals(customer.PhoneNumber))
{
throw new CustomerAlreadyExistsException(customer.PhoneNumber);
}
}
if (customerSignUpResult == null || customerSignUpResult.CustomerSignUpStatus == CustomerSignUpStatus.Failed)
{
throw new CustomerSignUpFailedException(customer.EmailAddress);
}
return(customerSignUpResult);
}
public async Task <Guid> Handle(RegisterRedBetCustomerCommand request, CancellationToken cancellationToken)
{
var customer = new RedBetCustomer(request.FirstName, request.LastName, request.AddressStreet, request.AddressNumber, request.AddressZipCode, request.FavoriteFootballTeam);
await _customerRepository.AddAsync(customer);
return(customer.Id);
}
public async Task CreateAsync(string name, string surname, string phoneNumber, string flatNumber, string buildingNumber, string street, string city, string zipCode)
{
var customer = new Customer(name, surname, phoneNumber);
customer.AddAddress(new CustomerAddress(flatNumber, buildingNumber, street, city, zipCode));
await _customerRepository.AddAsync(customer);
}
public async Task <Customer> Add(string email, string name, int groupId)
{
try
{
var oldUser = await _customerRepository.FirstOrDefaultAsync(x => x.Email == email);
if (oldUser != null)
{
throw new ApplicationException("User already exist");
}
var cus = new Customer
{
Email = email,
Name = name,
UserGroupId = groupId
};
await _customerRepository.AddAsync(cus);
return(cus);
}
catch (Exception ex)
{
throw;
}
}
public async Task <ActionResult <CustomerForGetDTO> > Post(CustomerForAddDTO model)
{
if (await _customerRepository.IsExistByPhone(model.Phone).ConfigureAwait(true))
{
return(Conflict(new ApiResponse(409, StringConcatenates.Exist("Phone", model.Phone))));
}
if (await _customerRepository.IsExistByEmail(model.Email).ConfigureAwait(true))
{
return(Conflict(new ApiResponse(409, StringConcatenates.Exist("Email", model.Email))));
}
Customer customer = _mapper.Map <Customer>(model);
string password = SecurePassword.GeneratePassword(8);
SecurePassword.CreatePasswordHash(password, out byte[] passwordHash, out byte[] passwordSalt);
customer.PasswordHash = passwordHash;
customer.PasswordSalt = passwordSalt;
await _customerRepository.AddAsync(customer).ConfigureAwait(true);
await _unitOfWork.CompleteAsync().ConfigureAwait(true);
Email.Send("Momen", customer.Email, "password", password);
CustomerForGetDTO customerDto = _mapper.Map <CustomerForGetDTO>(customer);
return(Ok(customerDto));
}
public async Task <Guid> Handle(RegisterMrGreenCustomerCommand request, CancellationToken cancellationToken)
{
var customer = new MrGreenCustomer(request.FirstName, request.LastName, request.AddressStreet, request.AddressNumber, request.AddressZipCode, request.PersonalNumber);
await _customerRepository.AddAsync(customer);
return(customer.Id);
}
public async Task <IResult> Handle(CreateCustomerCommand request, CancellationToken cancellationToken)
{
var isCustomerExits = await _customerMongoRepository.GetListAsync(u => u.Username == request.Username);
if (isCustomerExits.FirstOrDefault() != null)
{
return(new ErrorResult(Messages.NameAlreadyExist));
}
var customer = new Customer
{
//classın özellikleri buraya yazılır.
Username = request.Username,
Accounts = request.Accounts,
Active = request.Active,
Address = request.Address,
Birthdate = request.Birthdate,
Email = request.Email,
Name = request.Name,
RecordDate = DateTime.Now,
Tier_and_details = request.Tier_and_details
};
await _customerMongoRepository.AddAsync(customer);
return(new SuccessResult(Messages.Added));
}
public async Task <IActionResult> Post([FromBody] AddCustomerViewModel model)
{
if (model == null)
{
return(BadRequest());
}
var customerType = await _customerTypeRepo.GetAsync(model.CustomerTypeId);
if (customerType == null)
{
return(NotFound(Resources.Customers.CustomerResource.CustomerTypeNotFound));
}
if (await _customerRepo.IsExistNameAsync(model.Name))
{
ModelState.AddModelError("Name", Resources.Global.Common.ThisNameExist);
return(BadRequest(ModelState.GetWithErrorsKey()));
}
var customer = new Customer(model.Name, customerType.Id, model.Note);
var affectedRows = await _customerRepo.AddAsync(customer);
if (affectedRows > 0)
{
_customerRepo.LoadReferences(customer);
var viewModel = AutoMapper.Mapper.Map <CustomerViewModel>(customer);
return(CreatedAtRoute("GetCustomer", new { id = customer.Number }, viewModel));
}
return(BadRequest());
}
public async Task <IActionResult> AddCustomerAsync([FromBody] CustomerCreateDto customerCreateDto)
{
if (customerCreateDto == null)
{
return(BadRequest("Please supplier customer details"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Customer toAdd = Mapper.Map <Customer>(customerCreateDto);
_customerRepository.AddAsync(toAdd);
bool result = await _customerRepository.SaveAsync();
if (!result)
{
return(new StatusCodeResult(500));
}
return(CreatedAtRoute("GetSingleCustomer",
new { id = toAdd.Id },
Mapper.Map <CustomerDto>(toAdd)));
}
public Task <Maybe <CustomerDto> > CreateCustomerAsync(string name)
{
var customer = Customer.Create(name);
var customerDto = customer.Map(c => _converter.ToDto(c));
return(customerDto.Map(async c => await _repository.AddAsync(c)));
}
public async Task <IActionResult> Create(CustomerModel customer)
{
var model = Mapper.Map <Customer>(customer);
var changesMade = await _repository.AddAsync(model);
return(Ok(changesMade));
}
public async Task <ServiceResult <int> > Create(int companyId, CustomerCreateOrUpdateRequestViewModel viewModel)
{
var model = new Customer();
MapViewModelToModel(viewModel, model);
model.CompanyId = companyId;
var validator = new CustomerCreateOrUpdateRequestViewModelValidator();
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 CreateOrModifyAsync(CustomerViewModel customer)
{
var entity = await _customerRepository.GetItemByOpenIdAsync(customer.OpenId);
if (entity == null || entity.Id <= 0)
{
await _customerRepository.AddAsync(new Customer()
{
AvatarUrl = customer.AvatarUrl,
LastLoginTime = DateTime.Now,
NickName = customer.NickName,
City = customer.City,
Country = customer.Country,
Gender = customer.Gender,
OpenId = customer.OpenId,
Province = customer.Province,
});
}
else
{
entity.AvatarUrl = customer.AvatarUrl;
entity.LastLoginTime = DateTime.Now;
entity.NickName = customer.NickName;
entity.City = customer.City;
entity.Country = customer.Country;
entity.Gender = customer.Gender;
entity.Province = customer.Province;
await _customerRepository.UpdateAsync(entity);
}
}
public async Task <CustomerDto> AddAsync(CustomerDto customerDto)
{
var customer = _mapper.Map <Customer>(customerDto);
var result = await _customerRepository.AddAsync(customer);
return(_mapper.Map <CustomerDto>(result));
}
public async Task InitializeAsync()
{
if (!_applicationOptions.Value.SeedData)
{
_logger.LogInformation("Data initialization skipped.");
return;
}
_logger.LogInformation("Initializing data...");
var customers = GetCustomers().ToList();
var products = GetProducts().ToList();
foreach (var customer in customers)
{
await _customerRepository.AddAsync(customer);
}
foreach (var product in products)
{
await _productRepository.AddAsync(product);
}
var orders = GetOrders(customers, products).ToList();
foreach (var order in orders)
{
await _orderRepository.AddAsync(order);
}
_logger.LogInformation("Data initialized.");
}
public async Task <CustomerResponseModel> CreateCustomer(CustomerRequestModel customerRequestModel)
{
var customer = _mapper.Map <Customer>(customerRequestModel);
var createdCustomer = await _customerRepository.AddAsync(customer);
return(_mapper.Map <CustomerResponseModel>(createdCustomer));
}
public async Task <string> Handle(CustomerCreateCommand request, CancellationToken cancellationToken)
{
var data = new Customer(request.Name, request.Description, request.Company, request.Phone, request.Mail, request.Address, identityService.GetOrganizationId(), identityService.GetUserId());
await customerRepository.AddAsync(data);
return(data.Id);
}
public async Task <IActionResult> PostAsync([FromBody] Customer customer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
try
{
await _customerRepo.AddAsync(customer);
await _customerRepo.SaveChangeAsync();
var returnedResource = Mapper.Map <Customer, CustomerReturnResource>(customer);
return(Ok(returnedResource));
}
catch (Exception ex)
{
return(BadRequest(new List <string> {
ex.Message
}));
}
}
public async Task <IActionResult> Create([Bind("Firstname", "Lastname")] CustomerViewModel customerView)
{
mLogger.LogInformation("Customer/Create request");
var firstname = customerView.Firstname;
var lastname = customerView.Lastname;
if (!ModelState.IsValid)
{
return(Json(new JsonResponse(false, "Validation error")));
}
var customer = new CustomerModel {
Name = firstname + " " + lastname
};
bool isNewCustomer = await mCustomerRepository.AddAsync(customer);
if (!isNewCustomer)
{
return(Json(new JsonResponse(false, $"Customer {firstname} {lastname} already exists!")));
}
HttpContext.Session.Set <CustomerModel> (SESSION_KEY, customer);
return(Json(new JsonResponse(true, "New user created!")));
}
public async Task TestRemoveAsync()
{
string id = Id.ObjectId();
var customer = new Customer(id)
{
Name = "util"
};
await _customerRepository.AddAsync(customer);
await _unitOfWork.CommitAsync();
_unitOfWork.ClearCache();
var result = await _customerRepository.SingleAsync(t => t.Id == id);
Assert.NotNull(result);
await _customerRepository.RemoveAsync(id);
await _unitOfWork.CommitAsync();
_unitOfWork.ClearCache();
result = await _customerRepository.SingleAsync(t => t.Id == id);
Assert.Null(result);
}
public async Task CreateAsync(Customer customer)
{
if (!IsValid(customer))
{
return;
}
await _customerRepository.AddAsync(customer);
}
public async Task HandleAsync(CustomerCreated @event)
{
if (await _customerRepository.ExistsAsync(@event.CustomerId))
{
throw new CustomerAlreadyExistsException(@event.CustomerId);
}
await _customerRepository.AddAsync(new Customer(@event.CustomerId));
}
public async Task <Customer> AddAsync(Customer customer)
{
if (!customer.IsValidForNewRegister())
{
return(customer);
}
return(await _customerRepository.AddAsync(customer));
}
public async Task <int> AddAsync(CustomerAddModel model)
{
var customer = CustomerFactory.Create(model, _userId);
await _customerRepository.AddAsync(customer);
await _unitOfWork.SaveChangesAsync();
return(customer.Id);
}
public override async Task <Result> Handler(CreateCustomer message)
{
var customer = new Customer(message.FirstName, message.LastName, message.Email, message.IsActive);
await _customerRepository.AddAsync(customer);
await _customerRepository.SaveEntitiesAsync();
return(new Result());
}
public async Task Handle(CustomerRegistrationConfirmedDomainEvent @event, CancellationToken cancellationToken)
{
var registration = await _customerRegistrationRepository.GetByIdAsync(
new CustomerRegistrationId(@event.CustomerRegistrationId.Value)
);
var customer = registration.CreateCustomer(_customerChecker);
await _customerRepository.AddAsync(customer);
}
public async Task <IActionResult> Create([Bind("CustomerId,Name,LegalId,Phone")] Customer customer)
{
if (ModelState.IsValid)
{
await _customerRepository.AddAsync(customer);
return(RedirectToAction(nameof(Index)));
}
return(View(customer));
}
public async Task <CustomerVm> Handle(AddCustomerCommand request, CancellationToken cancellationToken)
{
var customer = _mapper.Map <Customer>(request);
var newCustomer = await _repository.AddAsync(customer);
_logger.LogInformation($"Customer {newCustomer.FirstName} {newCustomer.LastName} is successfully created.");
return(_mapper.Map <CustomerVm>(newCustomer));
}
public async Task <Customer> Handle(CreateCustomerCommand request, CancellationToken cancellationToken)
{
var customer = await _customerRepository.AddAsync(request.Customer);
var customerMessage = new CustomerMessage(_serviceId, customer);
_messageProducer.SendMessage(_queueName, customerMessage);
_logger.Log(LogLevel.Information, $"{DateTime.Now} - Enviada mensagem pelo ServiceId: {customerMessage.ServiceId} com RequestId: {customerMessage.RequestId}");
return(await Task.FromResult(customer));
}