public IActionResult AddCustomer([FromBody] CustomerCreateDto customerCreateDto)
{
if (customerCreateDto == null)
{
return(BadRequest("customercreate object was null"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Customer customer = Mapper.Map <Customer>(customerCreateDto);
_customerRepository.Add(customer);
bool result = _customerRepository.Save();
if (!result)
{
//return new StatusCodeResult(500);
throw new Exception("Something went wrong while adding new customer");
}
return(Ok(Mapper.Map <CustomerDto>(customer)));
//return CreatedAtRoute("GetSingleCustomer", new { id = customer.Id }, Mapper.Map<CustomerDto>(customer));
}
private void btnLuu_Click(object sender, EventArgs e)
{
CustomerCreateDto cus = new CustomerCreateDto()
{
Name = txtHoKH.Text.ToString(),
NumberPhone = txtSDT.Text.ToString(),
Email = txtEmail.Text.ToString(),
Points = 0,
IdentifyNumber = txtCMND.Text.ToString(),
BirthDate = dtmNgaySinh.Value
};
Result result = null;
var taskCreateStaff = Task.Factory.StartNew(() => result = customerbll.AddOrUpdateCustomer(cus));
var taskOpenWaitingForm = Task.Factory.StartNew(() => openWaitingForm());
taskOpenWaitingForm.Wait();
taskCreateStaff.Wait();
if (!result.IsSuccess)
{
CreateDataGridView();
}
if (result.IsSuccess)
{
MessageBox.Show(result.ResultMessage, "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
}
else
{
MessageBox.Show(result.ResultMessage, "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
}
bindingSource.DataSource = customerbll.GetAllCustomer();
CreateDataGridView();
}
public int Add(CustomerCreateDto newCustomer)
{
var mapper = Mapper.GetMapperConfiguration();
Entity.Customer cust = mapper.Map <CustomerCreateDto, Entity.Customer>(newCustomer);
return(_customerRepository.Add(cust));
}
public IActionResult AddCustomer([FromBody] CustomerCreateDto customerCreateDto)
{
if (customerCreateDto == null)
{
return(BadRequest("Empty Customer Object"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Customer ToAdd = Mapper.Map <Customer>(customerCreateDto);
_customerRepository.Add(ToAdd);
bool result = _customerRepository.Save();
if (!result)
{
//return new StatusCodeResult(500);
throw new Exception("Error Adding Customer");
}
// return Ok(Mapper.Map<CustomerDto>(ToAdd));
return(CreatedAtRoute("GetSingleCustomer", new { id = ToAdd.Id }, Mapper.Map <CustomerDto>(ToAdd)));
}
public IActionResult Create(/*long customerId,*/ [FromBody] CustomerCreateDto customerCreateDto)
{
//Logic.BL.Common.Domain.Singleton.LoggerBasSingleton.Instance.Log("Inicio de función");
//Logic.BL.Common.Domain.Singleton.LoggerThreadSafe1Singleton.Instance.Log("Inicio de función");
//Logic.BL.Common.Domain.Singleton.LoggerThreadSafe2Singleton.Instance.Log("Inicio de función");
//Logic.BL.Common.Domain.Singleton.LoggerThreadSafe3Singleton.Instance.Log("Inicio de función");
Logic.BL.Common.Domain.Singleton.LoggerThreadSafe4LazySingleton.Instance.Log("Inicio Evento");
bool uowStatus = false;
try
{
uowStatus = _unitOfWork.BeginTransaction();
Customer customer = _customerCreateAssembler.toEntity(customerCreateDto);
_customerRepository.Create(customer);
_unitOfWork.Commit(uowStatus);
return(StatusCode(StatusCodes.Status201Created, new ApiStringResponseDto("Created!")));//Ok();
Logic.BL.Common.Domain.Singleton.LoggerThreadSafe4LazySingleton.Instance.Log("Termino Evento Correctamente");
}
catch (Exception e)
{
Logic.BL.Common.Domain.Singleton.LoggerThreadSafe4LazySingleton.Instance.Log("Error Evento" + e.ToString());
_unitOfWork.Rollback(uowStatus);
//return StatusCode(500, new { error = e.Message });
Console.WriteLine(e.StackTrace);
return(StatusCode(StatusCodes.Status500InternalServerError, new ApiStringResponseDto("Internal Server Error")));
}
}
public IActionResult AddCustomer([FromBody] CustomerCreateDto customerDto)
{
_logger.LogInformation("-----> AddCustomer()");
if (customerDto == null)
{
return(BadRequest("customercreate object was null"));
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var toadd = Mapper.Map <Customer>(customerDto);
_customerRepository.Add(toadd);
var result = _customerRepository.Save();
if (!result)
{
throw new Exception("something went wrong when add new customer");
}
return(CreatedAtRoute("GetSingleCustomer", new { id = toadd.Id }, Mapper.Map <CustomerDto>(toadd)));
}
public IActionResult AddCustomer([FromBody] CustomerCreateDto customerCreateDto)
{
if (customerCreateDto == null)
{
return(BadRequest("customer create object was null"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Customer toAdd = Mapper.Map <Customer>(customerCreateDto);
_customerRepository.Add(toAdd);
bool result = _customerRepository.Save();
if (!result)
{
throw new Exception("(POST):something went wrong when adding a new customer");
}
//return Ok(Mapper.Map<CustomerDto>(toAdd));
return(CreatedAtRoute("GetSingleCustomer", new { id = toAdd.Id }, Mapper.Map <CustomerDto>(toAdd)));
}
public CustomerDto Create(CustomerCreateDto model)
{
Customer_Category CustomerCategory = _context.Customer_Categories
.Single(x => x.Customer_CategoryId == model.Customer_CategoryId);
ApplicationUser user = _context.Users.Single(x => x.Email == model.Email);
var entry = new Customer
{
CustomerName = model.CustomerName,
CustomerLastName = model.CustomerLastName,
CustomerAge = model.CustomerAge,
Customer_CategoryId = model.Customer_CategoryId,
Customer_Category = CustomerCategory,
Email = user.Email,
UserEmail = user.Email,
User = user,
CustomerId = id++
};
_context.Customers.Add(entry);
_context.SaveChanges();
return(_mapper.Map <CustomerDto>(entry));
}
public IActionResult AddNewCustomer([FromBody] CustomerCreateDto newCustomer)
{
if (newCustomer == null)
{
return(BadRequest());
}
else
{
var newCustomerModel = _mapper.Map <InsuranceCustomer>(newCustomer);
var calculatedPremium = ratingEngine.Rate(newCustomerModel);
_logger.LogInformation($"RatingEngine returned unrounded premium of: {calculatedPremium}");
var roundedPremium = Math.Round(calculatedPremium, 2);
newCustomerModel.Premium = roundedPremium;
_logger.LogInformation($"Rounded premium is: {roundedPremium}");
_repo.AddCustomer(newCustomerModel);
_repo.Save();
newCustomerModel.Premium = Math.Round(newCustomerModel.Premium, MidpointRounding.ToEven);
var quoteReadDTO = _mapper.Map <CustomerQuoteReadDto>(newCustomerModel);
return(CreatedAtRoute(nameof(GetCustomerById), new { id = newCustomerModel.Id }, quoteReadDTO));
}
}
public IActionResult Add([FromBody] CustomerCreateDto customerCreateDto)
{
if (customerCreateDto == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Customer toAdd = Mapper.Map <Customer>(customerCreateDto);
toAdd.Created = DateTime.Now;
_customerRepository.Add(toAdd);
if (!_customerRepository.Save())
{
throw new Exception("Creating an item failed on save.");
}
Customer newItem = _customerRepository.GetSingle(toAdd.Id);
return(CreatedAtRoute(nameof(GetSingle), new { id = newItem.Id },
Mapper.Map <CustomerDto>(newItem)));
}
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)));
}
// C
public async Task <Customer> CreateCustomerAsync(CustomerCreateDto createCustomerDto)
{
Customer customer = _mapper.Map <Customer>(createCustomerDto);
_customerRepo.Insert(customer);
await _customerRepo.Save();
return(customer);
}
public ActionResult Create(CustomerCreateDto customerCreateDto)
{
var customerModel = _mapper.Map <Customer>(customerCreateDto);
_customerService.Create(customerModel);
_customerService.SaveChanges();
var customerReadFullDto = _mapper.Map <CustomerReadFullDto>(customerModel);
return(CreatedAtRoute(nameof(GetCustomer), new { id = customerReadFullDto.Id }, customerReadFullDto));
}
public IActionResult Save([FromBody] CustomerCreateDto req)
{
if (req == null)
{
return(BadRequest());
}
var userEntity = Mapper.Map <Customer>(req);
_posrepo.SaveCustomer(userEntity);
return(CreatedAtRoute("GetCustomerById", new { id = userEntity.CustId }, userEntity));
}
public async Task <IActionResult> CreateCustomer([FromBody] CustomerCreateDto dto)
{
var response = await _userService.AddAsync(dto);
if (response == null)
{
return(BadRequest(new { message = "Username is already taken." }));
}
return(Ok(response));
}
public ActionResult <CustomerReadDto> CreateCustomer(CustomerCreateDto customerCreateDto)
{
var customerModel = _mapper.Map <customer>(customerCreateDto);
_customer.CreateCustomer(customerModel);
_customer.SaveChanges();
var customerReadDto = _mapper.Map <CustomerReadDto>(customerModel);
return(CreatedAtRoute(nameof(GetCustomerById), new { Id = customerReadDto.CustomerId }, customerReadDto));
}
public IHttpActionResult CreateCustomer(CustomerCreateDto customerDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var customer = _mapper.Map <CustomerCreateDto, Customer>(customerDto);
_context.Customers.Add(customer);
_context.SaveChanges();
return(Created(Request.RequestUri + "/" + customer.ID, customerDto));
}
public IActionResult Create([FromBody] CustomerCreateDto parm)
{
if (_customerService.Any(m => m.bm == parm.zzmc))
{
return(toResponse(StatusCodeType.Error, $"客户组织名称 {parm.zzmc} 已存在，不能重复！"));
}
//从 Dto 映射到 实体
var company = parm.Adapt <uf_khxx>().ToCreate(_tokenManager.GetSessionInfo());
return(toResponse(_customerService.Add(company)));
}
public async Task <ActionResult <CustomerDto> > CreateCustomer([FromBody] CustomerCreateDto customer)
{
var customerEntity = _mapper.Map <Customer>(customer);
_customerRepository.CreateCustomer(customerEntity);
var customerToMap = _mapper.Map <CustomerDto>(customerEntity);
_logger.LogInformation("Creating a customer");
return(CreatedAtRoute("GetCustomer", new { customerId = customerToMap.CustomerId }, customerToMap));
}
public ActionResult Add([FromBody] CustomerCreateDto customer)
{
var id = _customerController.Add(customer);
if (id > 0)
{
return(Created(string.Format($"/api/Customers/{id}", id), "Customer has been created"));
}
else
{
return(BadRequest("There is problem with request"));
}
}
public async Task <IActionResult> CreateCustomer([FromBody] CustomerCreateDto customerDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var customer = mapper.Map <CustomerCreateDto, Customer>(customerDto);
repository.Add(customer);
await unitOfWork.CompleteAsync();
return(Ok(customer));
}
public IActionResult AddCustomer([FromBody] CustomerCreateDto customerCreateDto)
{
Customer toAdd = _mapper.Map <Customer>(customerCreateDto);
_customerRepository.Add(toAdd);
bool result = _customerRepository.Save();
if (!result)
{
return(new StatusCodeResult(500));
}
return(CreatedAtRoute("GetSingleCustomer", new { id = toAdd.Id }, _mapper.Map <CustomerDto>(toAdd)));
}
public async Task <ActionResult <Customer> > CreateCustomerAsync(CustomerCreateDto customerCreateDto)
{
var customerModel = _mapper.Map <Customer>(customerCreateDto);
await _repository.CreateAsync(customerModel);
await _repository.SaveChangesAsync();
// here we query the customer that we just created in order to load its navigation property
customerModel = await _repository.GetByIdAsync(customerModel.Id);
var customerReadDto = _mapper.Map <CustomerReadDto>(customerModel);
return(CreatedAtRoute(nameof(GetCustomerAsync), new { customerReadDto.Id }, customerReadDto));
}
public ActionResult <CustomerReadDto> CreateCustomer(CustomerCreateDto customerCreateDto)
{
//create on object from Dto to mappe it to Model
var customerModel = _mapper.Map <Customer>(customerCreateDto);
_customerRepository.CreateCustomer(customerModel);
_customerRepository.SaveChanges();
//
var customerReadDto = _mapper.Map <CustomerReadDto>(customerModel);
//retun CreateAtRoute in the name of our method (GetCustomer) that retrieve a single customer
//then create Anonymous new customer object then pass back
return(CreatedAtRoute(nameof(GetCustomer), new { customerReadDto.Id }, customerReadDto));
}
public async Task <IActionResult> AddCustomer([FromBody] CustomerCreateDto customerDto)
{
Customer customer = null;
try
{
customer = await _salesSerivce.CreateCustomerAsync(customerDto);
}
catch (Exception ex)
{
_logger.LogError(ex, "Couldn't add customer to database");
return(BadRequest("Failed to add customer to database"));
}
return(Ok(customer));
}
public Result AddOrUpdateCustomer(CustomerCreateDto CustomerDto)
{
var entityTemp = db.Customers.FirstOrDefault(x => x.Email.Equals(CustomerDto.Email));
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <CustomerCreateDto, Customer>();
});
IMapper mapper = config.CreateMapper();
var cus = mapper.Map <CustomerCreateDto, Customer>(CustomerDto);
if (entityTemp == null)
{
db.Customers.Add(cus);
}
else
{
entityTemp.Name = CustomerDto.Name;
entityTemp.NumberPhone = CustomerDto.NumberPhone;
entityTemp.IdentifyNumber = CustomerDto.IdentifyNumber;
entityTemp.BirthDate = CustomerDto.BirthDate;
entityTemp.Email = CustomerDto.Email;
}
try
{
db.SaveChanges();
}
catch (DbEntityValidationException e)
{
return(new Result
{
ResultMessage = e
.EntityValidationErrors
.LastOrDefault()
.ValidationErrors
.LastOrDefault()
.ErrorMessage,
IsSuccess = false
});
}
return(new Result
{
ResultMessage = "Thao Tác thành công",
IsSuccess = true
});
}
public async Task<CustomerDto> AddAsync(CustomerCreateDto dto)
{
var users = await _userRepository.GetAllAsync(new CustomerFilterDto() { Username = dto.Username });
if(users?.FirstOrDefault() != null)
{
return null;
}
var entity = dto.Adapt<Customer>();
entity.Password = BC.HashPassword(dto.Password);
await _userRepository.AddAsync(entity);
var result = await Authenticate(entity.Username, dto.Password);
return result;
}
public IHttpActionResult EditCustomer(int id, CustomerCreateDto customerDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var cust = _context.Customers.FirstOrDefault(x => x.ID == id);
if (cust == null)
{
return(NotFound());
}
_mapper.Map(customerDto, cust);
_context.SaveChanges();
return(Ok(_mapper.Map <Customer, CustomerDto>(cust)));
}
public CustomerDto Create(CustomerCreateDto model)
{
Customer_Category CustomerCategory = _context.Customer_Categories
.Single(x => x.Customer_CategoryId == model.Customer_CategoryId);
var entry = new Customer
{
CustomerName = model.CustomerName,
CustomerAge = model.CustomerAge,
Customer_CategoryId = model.Customer_CategoryId,
Customer_Category = CustomerCategory,
CustomerId = id++
};
_context.Customers.Add(entry);
_context.SaveChanges();
return(_mapper.Map <CustomerDto>(entry));
}
public async Task <IActionResult> CreateCustomer([FromForm] CustomerCreateDto createDto)
{
var id = Convert.ToInt32(User.Identity.Name);
//Auto映射
var customer = mapper.Map <Customers>(createDto);
//查询细分类名称
var customerSegmentation = await context.CustomerSegmentations.FindAsync(customer.CustomerSegmentationID);
customer.CreateID = id;
customer.EmployeesID = id;
customer.CreateTime = DateTime.Now;
customer.CustomerSegmentationName = customerSegmentation.Name;
customer.Image = "https://www.zhangqueque.top:5001/UserImg/1_1_1.png";
if (createDto.UploadFile != null)
{
if (createDto.UploadFile.Length > 25165824)
{
return(Ok(new { code = 1, msg = "文件不能大于3M！" }));
}
//文件名复杂，避免重复覆盖
string fileName = customer.Name + customer.Email + customer.Phone + createDto.UploadFile.FileName;
//设置文件存储的路劲
string filePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "CustomerImg", fileName);
//服务端保存文件
using (var stream = System.IO.File.Create(filePath))
{
await createDto.UploadFile.CopyToAsync(stream);
}
customer.Image = Request.Scheme + "://" + Request.Host + "/CustomerImg/" + fileName;
}
await context.Customers.AddAsync(customer);
await context.SaveChangesAsync();
return(Ok(new { code = 0, msg = "客户添加成功！" }));
}
