/// <summary>
/// 注册
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <AppSrvResult <CustomerDto> > RegisterAsync(CustomerRegisterDto input)
{
var exists = await _customerRepo.AnyAsync(t => t.Account == input.Account);
if (exists)
{
return(Problem(HttpStatusCode.Forbidden, "该账号已经存在"));
}
var customer = _mapper.Map <Customer>(input);
customer.Id = IdGenerater.GetNextId(IdGenerater.DatacenterId, IdGenerater.WorkerId);
customer.FinanceInfo = new CustomerFinance()
{
Account = customer.Account
,
Balance = 0
,
Id = customer.Id
};
await _customerRepo.InsertAsync(customer);
var dto = _mapper.Map <CustomerDto>(customer);
return(dto);
}
public async Task <ActionResult <UserDto> > Register(CustomerRegisterDto customerRegisterDto)
{
customerRegisterDto.Username = customerRegisterDto.Username.ToLower();
if (await CustomerExists(customerRegisterDto.Username))
{
return(BadRequest("Username already exists"));
}
var hmac = new System.Security.Cryptography.HMACSHA512();
var customerToCreate = new Customer
{
UserName = customerRegisterDto.Username,
FirstName = customerRegisterDto.FirstName,
LastName = customerRegisterDto.LastName,
ContactNumber = customerRegisterDto.ContactNumber,
Email = customerRegisterDto.Email,
PasswordSalt = hmac.Key,
PasswordHash = hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(customerRegisterDto.Password))
};
await _context.Customer.AddAsync(customerToCreate);
await _context.SaveChangesAsync();
return(new UserDto
{
Username = customerToCreate.UserName,
Token = _tokenService.CreateToken(customerToCreate)
});
}
public IHttpActionResult Register(CustomerRegisterDto newCustomer)
{
if (newCustomer == null || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Customer customer = Mapper.Map <Customer>(newCustomer);
var user = new User {
UserName = newCustomer.UserName
};
if (context.Users.Any(u => user.UserName == u.UserName))
{
return(BadRequest("Ta nazwa użytkownika jest już zajęta"));
}
context.Customers.Add(customer);
customer.User = user;
var result = userManager.Create(user, newCustomer.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors.ToString()));
}
userManager.AddToRole(user.Id, Role.Customer.ToString());
context.SaveChanges();
return(Ok());
}
public async Task <AppSrvResult <SimpleDto <string> > > Register(CustomerRegisterDto inputDto)
{
var exists = await _customerRepo.AnyAsync(t => t.Account == inputDto.Account);
if (exists)
{
return(Problem(HttpStatusCode.Forbidden, "该账号已经存在"));
}
var customer = _mapper.Map <Customer>(inputDto);
customer.Id = IdGenerater.GetNextId(IdGenerater.DatacenterId, IdGenerater.WorkerId);
var customerFinace = new CusFinance()
{
Account = customer.Account
,
Balance = 0
,
Id = customer.Id
};
await _cusManagerService.RegisterAsync(customer, customerFinace);
return(new SimpleDto <string>(customer.Id.ToString()));
}
public async Task <ActionResult> CustomerRegister(CustomerRegisterDto customerRegister)
{
var response = await _customerAuth.Register(customerRegister);
if (!response.Success)
{
return(BadRequest(response));
}
return(Ok(response));
}
/// <summary>
/// Creation of customer
/// </summary>
/// <param name="customerDto">Data transfer object for customers</param>
/// <returns></returns>
public async Task <Customer> CreateCustomer(CustomerRegisterDto customerDto)
{
if (customerDto.FirstName == string.Empty || customerDto.Lastname == string.Empty)
{
return(null); // Creation cannot be performed
}
var user = await _userHelperService.PrepareUser(new UserDto
{
Username = customerDto.Username,
Password = customerDto.Password
}, "Customer");
if (user != null)
{
user.Id++;
}
// Get identifier of lastly created user
var userId = QueryGenericHelper.GetLastEntity(UserContext.Users);
// Get identifier of lastly created customer
var customerId = QueryGenericHelper.GetLastEntity(UserContext.Customers);
// Creation of customer object from user a customer data
var customerResult = new Customer
{
Id = customerId?.Id + 1 ?? 1,
FirstName = customerDto.FirstName,
LastName = customerDto.Lastname,
Discount = customerDto.Discount,
User = user,
UserId = userId?.Id + 1 ?? 1
};
// Add new object to the customer collection
UserContext.Customers.Add(customerResult);
// Return new added object
return(customerResult);
}
public async Task <IActionResult> CustomerRegister(CustomerRegisterDto customerRegisterDto)
{
customerRegisterDto.FirstName = customerRegisterDto.FirstName.ToLower();
customerRegisterDto.LastName = customerRegisterDto.LastName.ToLower();
customerRegisterDto.Email = customerRegisterDto.Email.ToLower();
if (await _authRepo.CustomerExists(customerRegisterDto.Email))
{
return(BadRequest("Email already exists"));
}
var customerToCreate = _mapper.Map <Customer> (customerRegisterDto);
var createdCustomer = await _authRepo.CustomerRegister(customerToCreate, customerRegisterDto.Password);
var customerPhone = _mapper.Map <Phone> (customerRegisterDto.Phone);
var createdPhone = await _customersRepo.CustomerAddPhone(createdCustomer.Id, customerPhone);
return(StatusCode(201));
}
public async Task <CustomerUserDto> CreateCustomer([FromBody] CustomerRegisterDto customerDto)
{
var res = await _customerUnitOfWork.CustomerRepository.CreateCustomer(customerDto);
await _customerUnitOfWork.Complete();
var customerId =
_customerUnitOfWork.CustomerRepository.Find(c =>
c.FirstName == res.FirstName && c.LastName == res.LastName).SingleOrDefault();
return(new CustomerUserDto
{
Id = customerId?.Id,
FirstName = res.FirstName,
LastName = res.LastName,
Username = res.User.Username,
Discount = res.Discount
});
}
/// <summary>
/// Register - Create new user
/// </summary>
/// <param name="customerRegister"></param>
/// <returns></returns>
public async Task <ServiceResponse <int> > Register(CustomerRegisterDto customerRegister)
{
var response = new ServiceResponse <int>();
try
{
var customer = _mapper.Map <Customer>(customerRegister);
bool HasUserExisted = await UserExists(customer.Email);
if (HasUserExisted)
{
response.Success = false;
response.Message = "User already existed";
response.Code = ErrorCode.AUTH_USER_EXISTED;
return(response);
}
(customer.Password, customer.PasswordSalt) = CreateHashedPassword(customerRegister.Password);
await _context.Customers.AddAsync(customer);
await _context.SaveChangesAsync();
response.Data = customer.Id;
return(response);
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex.StackTrace);
response.Success = false;
response.Message = ex.Message;
response.Code = ErrorCode.AUTH_UNEXPECTED_ERROR;
return(response);
}
}
public async Task <ActionResult <CustomerDto> > RegisterAsync([FromBody][NotNull] CustomerRegisterDto input)
{
return(CreatedResult(await _cusService.RegisterAsync(input)));
}
//[Permission("customerRegister")]
public async Task <ActionResult <SimpleDto <string> > > Register([FromBody][NotNull] CustomerRegisterDto inputDto)
{
return(Result(await _cusService.Register(inputDto)));
}