public ResponseDto Register(NewCustomerDto newAccountDto)
{
try
{
var customer = new Customer(
newAccountDto.CustomerId,
newAccountDto.firstName,
newAccountDto.lastName,
newAccountDto.identityDocument,
true,
DateTime.UtcNow
);
var nhibernateSession = _sessionFactory.OpenSession();
nhibernateSession.Save(customer);
nhibernateSession.Flush();
return(new ResponseDto
{
HttpStatusCode = StatusCodes.Status201Created,
Response = new ApiStringResponse("Customer Created")
});
}
catch (Exception ex)
{
//TODO: Log exception async, for now write exception in the console
Console.WriteLine(ex.Message);
return(new ResponseDto
{
HttpStatusCode = StatusCodes.Status500InternalServerError,
Response = new ApiStringResponse("Server Internal Error")
});
}
}
public IActionResult Post([FromBody] NewCustomerDto newCustomerDto)
{
newCustomerDto.CustomerId = Guid.NewGuid().ToString();
ResponseDto response = _customerApplicationService.Register(newCustomerDto);
return(StatusCode(response.HttpStatusCode, response.Response));
}
public ActionResult <CustomerViewModel> AddNewCustomer([FromBody] NewCustomerDto data)
{
try {
if (data == null)
{
return(StatusCode(400));
}
if (!ModelState.IsValid)
{
return(new InvalidInputResponse(ModelState));
}
var customer = _command.Create(data);
if (customer != null)
{
return(StatusCode(201, customer));
}
else
{
return(StatusCode(500, "Something Went Wrong please try again later"));
}
} catch (DuplicateTinNumberException tinDuplicate) {
ModelState.AddModelError("TIN No", tinDuplicate.Message);
return(new InvalidInputResponse(ModelState));
} catch (DuplicatePhonenumberException phoneDuplicate) {
ModelState.AddModelError("Telephone", phoneDuplicate.Message);
return(new InvalidInputResponse(ModelState));
} catch (Exception e) {
_logger.LogError(500, e.StackTrace, e.Message);
return(StatusCode(500, e.Message));
}
}
public async Task <IActionResult> Post([FromBody] NewCustomerDto data, [FromServices] ICreateCustomerService service)
{
var result = await service.Create(data);
if (result.IsSucccess())
{
return(CreatedAtAction(nameof(Get), result.Model.CustomerId, result.Model));
}
return(BadRequest(result.Errors));
}
public Customer CustomerForCreation(NewCustomerDto customer)
{
if (!_customerQuery.IsTinUnique(customer.tin.Trim()))
{
throw new DuplicateTinNumberException(customer.tin.Trim());
}
Customer newCustomer = new Customer()
{
FullName = customer.FullName,
Tin = customer.tin,
Email = customer.email,
Type = customer.type,
CreditLimit = customer.creditLimit,
PaymentPeriod = customer.paymentPeriod
};
foreach (var item in customer.addresses)
{
newCustomer.Address.Add(new Address()
{
Country = item.Country,
City = item.City,
SubCity = item.SubCity,
Location = item.Location,
PhoneNumber = item.PhoneNumber
});
}
foreach (var item in customer.telephones)
{
if (!_customerQuery.IsPhoneUnique(item.number.Trim()))
{
throw new DuplicatePhonenumberException(item.number);
}
newCustomer.PhoneNumber.Add(new PhoneNumber()
{
Number = item.number,
Type = item.type
});
}
foreach (var item in customer.socialMedias)
{
newCustomer.SocialMedia.Add(new SocialMedia()
{
Site = item.site,
Address = item.address
});
}
return(newCustomer);
}
public async Task <ActionResult> CreateCustomerAsync([FromBody] NewCustomerDto newCustomer)
{
var newCustomerCommand = new CreateCustomerCommand(
newCustomer.Name,
newCustomer.Email,
newCustomer.Address,
newCustomer.Phone,
newCustomer.Age);
var customer = await mediator.Send(newCustomerCommand);
return(Ok(customer));
}
public CustomerViewModel Create(NewCustomerDto newCustomer)
{
try {
var customer = _factory.CustomerForCreation(newCustomer);
_database.Customer.Add(customer);
_database.Save();
return(_factory.CustomerForView(customer));
} catch (Exception e) {
_logger.LogError(1, e.Message, e);
return(null);
}
}
public async Task <ServiceResult <CustomerDto> > Create(NewCustomerDto data)
{
try
{
var newCustomer = _mapper.Map <NewCustomer>(data);
var createdCustomer = await _repo.CreateCustomer(newCustomer);
return(ServiceResult <CustomerDto> .Success(_mapper.Map <CustomerDto>(createdCustomer)));
}
catch (ArgumentException e)
{
return(ServiceResult <CustomerDto> .Error("ERR_VALIDATION", e.Message));
}
}
public IHttpActionResult NewCustomer(NewCustomerDto newCustomerDto)
{
Account newCustomer = new Account()
{
Name = newCustomerDto.Name,
PhoneNumber = newCustomerDto.PhoneNumber,
Balance = newCustomerDto.Balance,
Pin = "0000"
};
newCustomer.AccountNumber = 1000000000;
_context.Accounts.Add(newCustomer);
_context.SaveChanges();
return(Ok());
}
public ActionResult <CustomerDto> Create([FromBody] NewCustomerDto data)
{
try
{
var customer = _mapper.Map <NewCustomerDto, Customer>(data);
var newCustomer = _service.CreateCustomer(customer);
var result = _mapper.Map <Customer, CustomerDto>(newCustomer);
return(CreatedAtAction(nameof(Get), new { id = newCustomer.Id }, result));
}
catch (ArgumentException)
{
return(BadRequest());
}
}
public async Task RegisterCompanyWithOwner(NewCustomerDto customer)
{
using (var uow = UnitOfWorkProvider.Create())
{
try
{
var company = new CompanyDto
{
Ico = customer.Ico,
JoinDate = DateTime.Now,
Name = customer.Name
};
var employee = new EmployeeCreateDto()
{
Email = customer.Email,
FirstName = customer.FirstName,
LastName = customer.LastName,
PasswordHash = customer.Password,
Company = company,
Role = Role.Owner
};
// no need to create company as it is created in employee service by default
await _employeeService.RegisterCustomerAsync(employee);
await uow.Commit();
int companyId = (await _companyService.GetByIco(customer.Ico)).Id;
var payment = new PaymentDto
{
Amount = 300,
CompanyId = companyId,
DueDate = DateTime.Now.AddDays(30),
VariableNumber = "1212100" + companyId
};
_paymentService.Create(payment);
await uow.Commit();
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
}
}
public async Task <IActionResult> Post([FromBody] NewCustomerDto customer)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = await _customerService.CreateAsync(customer);
if (result is null)
{
return(BadRequest());
}
return(CreatedAtAction("Get", new { id = result.Id }, result));
}
/// <summary>
/// Creates a new customer
/// </summary>
/// <param name="newCustomer"></param>
/// <returns></returns>
public async Task <CustomerDto> CreateAsync(NewCustomerDto newCustomer)
{
var customerEntity = _mapper.Map <Customer>(newCustomer);
customerEntity.Id = Guid.NewGuid();
customerEntity.CreatedAt = DateTime.UtcNow;
_ctx.Customers.Add(customerEntity);
if (await _ctx.SaveChangesAsync() == 1)
{
return(_mapper.Map <CustomerDto>(customerEntity));
}
return(null);
}
public async Task <ActionResult <CustomerDto> > AddCustomer([FromBody] NewCustomerDto newCustomer)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ResponseDto <string>()
{
message = ErrorMessage.InvalidModel
}));
}
CustomerDto customer;
ResponseDto <CustomerDto> response = new ResponseDto <CustomerDto>()
{
statusCode = "201",
message = "successfully created new customer"
};
try
{
if (HttpContext.IsInRole(RoleNames.LaundryEmployee) || HttpContext.IsInRole(RoleNames.LaundryOwner))
{
customer = await customerRepository.AddCustomer(newCustomer, HttpContext.User.Identity.Name, HttpContext.GetUserRole());
response.data = customer;
return(CreatedAtAction(nameof(GetCustomer), new { id = customer.Id }, response));
}
return(Unauthorized());
}
catch (Exception e)
{
response.statusCode = "400";
if (e.Message == ErrorMessage.InvalidToken)
{
response.message = ErrorMessage.InvalidToken;
return(BadRequest(response));
}
else if (e.Message == ErrorMessage.UsernameAlreadyExist)
{
response.message = ErrorMessage.UsernameAlreadyExist;
return(BadRequest(response));
}
response.statusCode = "500";
return(StatusCode(500, response));
}
}
public IActionResult AddNewCustomer([FromBody] NewCustomerDto newCustomerDto)
{
var result = _customerService.AddCustomer(
newCustomerDto.Name,
newCustomerDto.Email,
newCustomerDto.Address,
newCustomerDto.City,
newCustomerDto.Phone,
LoggedInUserId
);
if (!result.IsFaulted)
{
return(Ok(result.Payload));
}
else
{
return(BadRequest(result.ErrorMessage));
}
}
public async Task <ServiceResult <CustomerDto> > Create(NewCustomerDto data)
{
try
{
var newCustomer = _mapper.Map <NewCustomer>(data);
var createdCustomer = await _repo.CreateCustomer(newCustomer);
await _publisher.Publish <CustomerCreatedEvent>(new
{
CustomerId = createdCustomer.CustomerId.Id,
Name = createdCustomer.Name,
BirthDate = createdCustomer.BirthDate,
Type = createdCustomer.Type.ToString(),
CreatedAt = createdCustomer.CreatedAt
});
return(ServiceResult <CustomerDto> .Success(_mapper.Map <CustomerDto>(createdCustomer)));
}
catch (ArgumentException e)
{
return(ServiceResult <CustomerDto> .Error("ERR_VALIDATION", e.Message));
}
}
public async Task <ActionResult> Register(NewCustomerDto customer)
{
var isIcoAlreadyRegistered = (await CompanyFacade.GetAsyncByIco(customer.Ico)) != null;
var isEmailAlreadyRegistered = (await EmployeeFacade.GetAsyncByEmail(customer.Email)) != null;
if (isIcoAlreadyRegistered)
{
ModelState.AddModelError("Ico", "Ico is already registered");
return(View());
}
if (isEmailAlreadyRegistered)
{
ModelState.AddModelError("Email", "Account with that email already exists!");
return(View());
}
await CompanyFacade.RegisterCompanyWithOwner(customer);
AddAuthTicket(customer.Email, Role.Owner.ToString());
return(RedirectToAction("Index", "Home"));
}
public async Task <Guid> Create(NewCustomerDto newCustomer)
{
return(await Mediator.Send(new CreateCustomerCommand { NewCustomer = newCustomer }));
}
//private readonly LaundryApiContext _context;
//private readonly IMapper mapper;
//private readonly IRepositoryHelper repositoryHelper;
//public CustomerRespository(LaundryApiContext _context, IMapper mapper,IRepositoryHelper repositoryHelper)
//{
// this._context = _context;
// this.mapper = mapper;
// this.repositoryHelper = repositoryHelper;
//}
//public async Task<CustomerDto> AddCustomer(NewCustomerDto newCustomerDto, string username,string userRole)
//{
// try
// {
// Employee employee=null;
// Laundry laundry=null;
// if (userRole == RoleNames.LaundryOwner)
// laundry = repositoryHelper.GetLaundryByUsername(username);
// else
// employee = repositoryHelper.GetEmployeeByUsername(username);
// var customerInDb = laundry == null
// ? _context.Customers.SingleOrDefault(x => x.LaundryId
// == employee.LaundryId && x.Username == newCustomerDto.Username)
// : _context.Customers.SingleOrDefault(x => x.LaundryId
// == laundry.Id && x.Username == newCustomerDto.Username);
// if (customerInDb != null)
// {
// if (customerInDb.IsDeleted)
// {
// customerInDb.IsDeleted = false;
// customerInDb.Name = newCustomerDto.Name;
// customerInDb.PhoneNumber = newCustomerDto.PhoneNumber;
// customerInDb.Address = newCustomerDto.Address;
// await _context.SaveChangesAsync();
// }
// else
// throw new Exception(ErrorMessage.UsernameAlreadyExist);
// }
// else
// customerInDb= await AddCustomer(newCustomerDto, userRole, employee, laundry);
// var returnObj = mapper.Map<CustomerDto>(customerInDb);
// return returnObj;
// }
// catch(Exception e)
// {
// if (e.Message==ErrorMessage.UsernameAlreadyExist)
// throw new Exception(ErrorMessage.UsernameAlreadyExist);
// throw new Exception(ErrorMessage.FailedDbOperation);
// }
//}
//public async Task<bool> UpdateCustomer(CustomerDto customerDto)
//{
// try
// {
// //get the customer
// Customer customerInDb =await _context.Customers.FindAsync(customerDto.Id);
// //validate that the customer exist
// if (customerInDb == null)
// throw new Exception(ErrorMessage.EntityDoesNotExist);
// //update the changes
// customerInDb.Address = customerDto.Address;
// customerInDb.Name = customerDto.Name;
// customerInDb.PhoneNumber = customerDto.PhoneNumber;
// customerInDb.UpdatedAt = DateTime.Now;
// customerInDb.Username = customerDto.Username;
// //save changes
// await _context.SaveChangesAsync();
// return true;
// }
// catch(Exception e)
// {
// if (e.Message == ErrorMessage.EntityDoesNotExist)
// throw new Exception(ErrorMessage.EntityDoesNotExist);
// throw new Exception(ErrorMessage.FailedDbOperation);
// }
//}
//public async void UpdateTotalPurchase(Guid customerId, decimal amt)
//{
// try
// {
// Customer customerInDb = await _context.Customers.FindAsync(customerId);
// if (customerInDb == null)
// throw new Exception(ErrorMessage.UserDoesNotExist);
// customerInDb.TotalPurchase = customerInDb.TotalPurchase + amt;
// await _context.SaveChangesAsync();
// return;
// }
// catch
// {
// throw new Exception(ErrorMessage.FailedDbOperation);
// }
//}
//public void DeleteCustomer(Guid customerId)
//{
// try
// {
// Customer customerInDb = _context.Customers.Find( customerId);
// if (customerInDb == null)
// throw new Exception(ErrorMessage.EntityDoesNotExist);
// customerInDb.IsDeleted = true;
// _context.SaveChanges();
// return;
// }
// catch(Exception e)
// {
// if (e.Message == ErrorMessage.EntityDoesNotExist)
// throw new Exception(ErrorMessage.EntityDoesNotExist);
// throw new Exception(ErrorMessage.FailedDbOperation);
// }
//}
//public CustomerDto GetCustomer(Guid customerId)
//{
// try
// {
// var customer = _context.Customers.SingleOrDefault(c => c.Id == customerId && c.IsDeleted==false);
// if (customer == null)
// throw new Exception(ErrorMessage.EntityDoesNotExist);
// var _customer = mapper.Map<CustomerDto>(customer);
// return _customer;
// }
// catch(Exception e)
// {
// if (e.Message == ErrorMessage.EntityDoesNotExist)
// throw new Exception(ErrorMessage.EntityDoesNotExist);
// throw new Exception(ErrorMessage.FailedDbOperation);
// }
//}
//public IEnumerable<CustomerDto> GetCustomer(string customerName, string username)
//{
// IEnumerable<Customer> customers;
// if(string.IsNullOrWhiteSpace(username) && !string.IsNullOrWhiteSpace(customerName))
// customers= _context.Customers.Where(x => x.Name.Contains(customerName) && !x.IsDeleted);
// else if (string.IsNullOrWhiteSpace(customerName) && !string.IsNullOrWhiteSpace(username) )
// customers = _context.Customers.Where(x => x.Username.Contains(customerName) && !x.IsDeleted);
// else
// customers = _context.Customers.Where(x => x.Name.Contains(customerName) && x.Username.Contains(username) && !x.IsDeleted);
// if (customers.Count() == 0)//db search return nothing
// throw new Exception(ErrorMessage.NoEntityMatchesSearch);
// return mapper.Map<IEnumerable<CustomerDto>>(customers);
//}
//public IEnumerable<CustomerDto> GetCustomer(string laundryUsername)
//{
// Laundry laundry=repositoryHelper.GetLaundryByUsername(laundryUsername);
// IEnumerable<Customer> debtors=_context.Customers.Where(x => x.LaundryId == laundry.Id && x.Debt > 0);
// if (debtors.Count() == 0)
// throw new Exception(ErrorMessage.NoEntityMatchesSearch);
// return mapper.Map<IEnumerable<CustomerDto>>(debtors);
//}
//public PagedList<CustomerDto> GetPage(int pageSize, string laundryUsername, int pageNumber = 1, string searchParam = "")
//{
// var laundry = repositoryHelper.GetLaundryByUsername(laundryUsername);
// var customerList = _context.Customers.Where(x => x.IsDeleted == false && x.LaundryId == laundry.Id).ToList();
// if (searchParam != "")
// {
// customerList = customerList.Where(x => x.Name.Contains(searchParam.ToLower())).ToList();
// if(customerList.Count() / pageSize <= pageNumber)
// pageNumber= 1;
// }
// var page = customerList.Skip((pageNumber - 1) * pageSize).Take(pageSize);
// var maxPage = customerList.Count / (decimal)pageSize;
// PagedList<CustomerDto> obj = new PagedList<CustomerDto>()
// {
// Data = mapper.Map<IEnumerable<CustomerDto>>(page),
// PageIndex = pageNumber,
// PageSize = pageSize,
// };
// if (maxPage < 1)
// obj.MaxPageIndex = 1;
// else
// {
// int _num;
// try
// {_num = Convert.ToInt32(Convert.ToString(maxPage).Split(".")[1]);}
// catch
// { _num = 0;}
// obj.MaxPageIndex = _num > 0 ? Convert.ToInt32(maxPage + 1) - 1 : Convert.ToInt32(maxPage);
// }
// return obj;
//}
//private async Task<Customer> AddCustomer(NewCustomerDto newCustomerDto,string userRole,Employee employee, Laundry laundry)
//{
// //map the customerdto to the customer obj and update missing properties
// Customer customer = mapper.Map<Customer>(newCustomerDto);
// customer.CreatedAt = DateTime.Now;
// customer.TotalPurchase = 0;
// customer.UpdatedAt = DateTime.Now;
// customer.Debt = 0;
// customer.Name = customer.Name.ToLower();
// //assign the customer a laundryId and/or employeeId
// if (userRole == RoleNames.LaundryEmployee && employee != null)
// {
// customer.EmployeeId = employee.Id;
// customer.LaundryId = employee.LaundryId;
// //updating employee object and laundry object
// _context.Laundries.Find(laundry.Id).NoOfCustomers += 1;
// _context.Employees.Find(employee.Id).NoOfCustomers += 1;
// }
// else
// {
// customer.LaundryId = laundry.Id;
// _context.Laundries.Find(laundry.Id).NoOfCustomers += 1;
// }
// await _context.Customers.AddAsync(customer);
// await _context.SaveChangesAsync();
// return customer;
//}
//public IEnumerable<CustomerDto> SearchForCustomer(string searchParam,string paramType)
//{
// List<Customer> customer;
// if (paramType == "email")
// customer = _context.Customers.Where(x => x.Username.Contains(searchParam)).ToList();
// else if (paramType == "name")
// customer = _context.Customers.Where(x => x.Name.Contains( searchParam)).ToList();
// else
// customer = _context.Customers.Where(x => x.PhoneNumber.Contains(searchParam)).ToList();
// IEnumerable<CustomerDto> customers=mapper.Map<IEnumerable<CustomerDto>>(customer);
// return customers;
//}
public Task <CustomerDto> AddCustomer(NewCustomerDto newCustomer, string username, string userRole)
{
throw new NotImplementedException();
}
