public async Task TestUpdateCustomerIfNotExists()
{
var customer = new CustomerInput();
var result = await customersController.UpdateCustomerAsync(3, customer);
Assert.That(result, Is.InstanceOf <NotFoundResult>());
}
public async Task <IActionResult> UpdateCustomerAsync(long id, [FromBody, Required] CustomerInput customer)
{
if (context.Customers.Any(c => c.Id == id))
{
var updatedCustomer = new Customer(customer)
{
Id = id
};
try
{
context.Update(updatedCustomer);
await context.SaveChangesAsync();
}
catch (Exception)
{
return(BadRequest());
}
}
else
{
return(NotFound());
}
return(Ok());
}
public void ShouldMapWithNewAddedMap()
{
var customer = GetCustomer();
Mapper.AddMap <Customer, CustomerInput>((src, tag) =>
{
var res = new CustomerInput();
return(res);
});
Mapper.AddMap <Customer, CustomerInput>(src =>
{
var res = new CustomerInput();
res.Id = src.Id;
res.FirstName = src.FirstName;
res.LastName = src.LastName;
return(res);
});
var c1 = Mapper.Map <Customer, CustomerInput>(customer);
var c2 = Mapper.Map <CustomerInput>(customer);
c1.InjectFrom <AreEqual>(c2);
Assert.AreEqual(customer.Id, c1.Id);
Assert.AreEqual(customer.FirstName, c1.FirstName);
Assert.AreEqual(customer.LastName, c1.LastName);
}
public ViewResult Index(CustomerInput customerInput)
{
EventLog myNewLog = new EventLog
{
Log = customerInput.JournalName
};
//Выборка за необходимый период
var entries = myNewLog.Entries.Cast <EventLogEntry>().Where(x => x.TimeWritten.Date >= customerInput.FirstDate && x.TimeWritten.Date <= customerInput.SecondDate);
//Подсчет событий каждого типа
var result = entries
.GroupBy(x => x.EntryType)
.Select(x => new { TypeOfEvent = x.Key, Count = x.Count() });
foreach (var item in result)
{
Response.Write(item);
}
if (ModelState.IsValid)
{
//Перенаправление пользователя на страницу с результатами
return(View("ResultView", customerInput));
}
else
{
return(View());
}
}
public void MapperInstance()
{
var customer = GetCustomer();
var mapper1 = new MapperInstance();
var mapper2 = new MapperInstance();
mapper1.AddMap <Customer, CustomerInput>((from) =>
{
var input = new CustomerInput();
input.InjectFrom(from);
return(input);
});
mapper2.AddMap <Customer, CustomerInput>((from) =>
{
var input = new CustomerInput();
input.FirstName = from.FirstName;
return(input);
});
var input1 = mapper1.Map <CustomerInput>(customer);
var input2 = mapper2.Map <CustomerInput>(customer);
Assert.AreEqual(customer.LastName, input1.LastName);
Assert.AreEqual(null, input2.LastName);
}
private void Create(CustomerInput customerInput)
{
var customerEntity = ObjectMapper.Map <Customer>(customerInput);
SetAuditInsert(customerEntity);
customerRepository.Insert(customerEntity);
CurrentUnitOfWork.SaveChanges();
}
public async Task <IActionResult> Post([FromBody] CustomerInput customerInput)
{
var customer = _mapper.Map <Customer>(customerInput);
var created = await _customerService.AddAsync(customer);
return(Created(_mapper.Map <CustomerOutput>(created)));
}
public void BasicTest()
{
var customer = GetCustomer();
var res = new CustomerInput();
res.InjectFrom <FlatLoopInjection>(customer);
res.InjectFrom <UnflatLoopInjection>(customer);
}
public void BasicTest()
{
var customer = GetCustomer();
var res = new CustomerInput();
res.InjectFrom <Omu.ValueInjecter.Delta.Injections.FlatLoopInjection>(customer);
res.InjectFrom <Omu.ValueInjecter.Delta.Injections.UnflatLoopInjection>(customer);
}
public async Task <IActionResult> Put(string id, [FromBody] CustomerInput customerInput)
{
customerInput.PublicId = id;
var customer = _mapper.Map <Customer>(customerInput);
await _customerService.UpdateAsync(customer);
return(Accepted());
}
public ReturnData InsertData(CustomerInput input)
{
customerDatastore.InsertData(input);
return(new ReturnData
{
IsSuccess = true,
ReturnCode = 200,
ReturnMessage = "Success"
});
}
public async Task <ActionResult <dynamic> > update([FromBody] CustomerInput customer)
{
if (ModelState.IsValid)
{
await _customerService.update(customer);
return(this.StatusCode(200));
}
return(this.StatusCode(500));
}
public Customer(CustomerInput customerInput)
{
Id = customerInput.Id;
Email = customerInput.Email;
Password = customerInput.Password;
FullName = customerInput.FullName;
IsLegal = customerInput.IsLegal;
Cpf = customerInput.Cpf;
Cnpj = customerInput.Cnpj;
}
public async Task <ActionResult <CustomerDto> > PutCustomer(int id, CustomerInput input)
{
var customer = await _customerService.PutCustomer(id, input);
if (customer == null)
{
return(NotFound());
}
return(Ok(customer));
}
public async Task <CustomerDto> PostCustomer(CustomerInput input)
{
var customer = new CustomerDto();
customer.ConvertToDto(input);
_context.Customers.Add(customer);
await _context.SaveChangesAsync();
return(customer);
}
public void CreateOrEditCustomer(CustomerInput customerInput)
{
if (customerInput.Id == 0)
{
Create(customerInput);
}
else
{
Update(customerInput);
}
}
public void CreateNewOrder(CustomerInput custIn, DateTime date)
{
Order orderData = new Order();
OrderFileRepository newFile = new OrderFileRepository();
orderData.CustomerName = custIn.CustName;
orderData.State = custIn.State;
orderData.ProductType = custIn.ProductType;
orderData.Area = custIn.Area;
orderData.OrderNumber = custIn.OrderNumber;
string[] stateTaxData = File.ReadAllLines(@"Data\Taxes.txt");
for (int i = 1; i < stateTaxData.Length; i++)
{
if (stateTaxData[i].Contains(custIn.State))
{
string taxRateLine = stateTaxData[i];
orderData.TaxRate = decimal.Parse(taxRateLine.Substring(3, taxRateLine.Length - 3));
}
}
string[] productData = File.ReadAllLines(@"Data\Products.txt");
for (int i = 1; i < productData.Length; i++)
{
string[] productDataSplit = productData[i].Split(',');
if (productDataSplit[0].ToUpper() == custIn.ProductType.ToUpper())
{
orderData.CostPerSquareFoot = decimal.Parse(productDataSplit[1]);
}
if (productDataSplit[0].ToUpper() == custIn.ProductType.ToUpper())
{
orderData.LaborCostPerSquareFoot = decimal.Parse(productDataSplit[2]);
}
}
orderData.MaterialCost = orderData.Area * orderData.CostPerSquareFoot;
orderData.LaborCost = orderData.Area * orderData.LaborCostPerSquareFoot;
orderData.Tax = Math.Round((orderData.TaxRate / 100M) * (orderData.MaterialCost + orderData.LaborCost), 2);
orderData.Total = orderData.MaterialCost + orderData.LaborCost + orderData.Tax;
if (date == default(DateTime))
{
newFile.CheckAndSaveNewFile(orderData);
}
else
{
newFile.CheckAndSaveEditedFile(orderData, date);
}
}
private void Update(CustomerInput customerInput)
{
var customerEntity = customerRepository.GetAll().Where(x => !x.IsDelete).SingleOrDefault(x => x.Id == customerInput.Id);
if (customerEntity == null)
{
}
ObjectMapper.Map(customerInput, customerEntity);
SetAuditEdit(customerEntity);
customerRepository.Update(customerEntity);
CurrentUnitOfWork.SaveChanges();
}
public CustomerResult SearchCustomer(CustomerInput input)
{
var customers = new CustomerResult();
using (var connection = new SqlConnection(connectionString))
{
customers = connection.QueryFirstOrDefault <CustomerResult>(@"
SELECT CustomerID,CustomerName,CustomerLastName,Location
FROM Customer (nolock) WHERE CustomerID = @CustomerID", new { CustomerID = input.CustomerID });
}
return(customers);
}
public async Task <Customer> CreateCustomerAsync(
[Service] IImmutableMapper <CustomerInput, Customer> customerInputToCustomerMapper,
[Service] ICustomerRepository customerRepository,
CustomerInput customerInput,
CancellationToken cancellationToken)
{
var customer = customerInputToCustomerMapper.Map(customerInput);
customer = await customerRepository
.AddCustomerAsync(customer, cancellationToken)
.ConfigureAwait(false);
return(customer);
}
public void TestAddProductExpectTrue()
{
var customer = new CustomerInput()
{
CustomerName = "Anbu Mani",
EmailID = "anbu@anbu",
Mobile = "0000000000"
};
var addProduct = customerService.AddCustomer(customer);
var result = JsonConvert.DeserializeObject(addProduct.Content.ToString());
Assert.True(result.Equals("Success"));
//Assert.Throws<Exception>(() => productService.AddProduct(product));
}
public void InsertData(CustomerInput input)
{
using (var connection = new SqlConnection(connectionString))
{
var query = @"INSERT INTO Customer(CustomerID,CustomerName,CustomerLastName,Location)
VALUES(@CustomerID,@CustomerName,@CustomerLastName,@Location)";
try
{
connection.Execute(query, input);
}
catch (Exception)
{
throw;
}
}
}
public async Task TestUpdateCustomer()
{
using var context = new CustomersDbContext(dbContextOptions);
var customerDTO = new CustomerInput {
Name = "Petya", Surname = "Ivanov", Email = "*****@*****.**"
};
var customer = new Customer(customerDTO)
{
Id = 2
};
var result = await customersController.UpdateCustomerAsync(2, customerDTO);
Assert.That(result, Is.InstanceOf <OkResult>());
Assert.That(context.Find <Customer>((long)2), Is.EqualTo(customer));
}
public async Task <ActionResult <Customer> > CreateCustomerAsync([FromBody, Required] CustomerInput customer)
{
var newCustomer = new Customer(customer);
try
{
await context.AddAsync(newCustomer);
await context.SaveChangesAsync();
}
catch (Exception)
{
return(BadRequest());
}
return(CreatedAtAction("GetCustomer", new { id = newCustomer.Id }, newCustomer));
}
public async Task <T> Create <T>(CustomerInput input)
where T : CustomerOutput
{
_logger.LogTrace(GetLogMessage($@"Person Id: {input.PersonId}"));
var customer = await Repository.Queryable().Where(x => x.Id == input.PersonId)
.FirstOrDefaultAsync();
var marketer = _marketerRepository.Queryable()
.GetById(input.MarketerOrganizationId,
input.MarketerId).First();
if (customer != null)
{
return(await GetById <T>(input.PersonId));
}
if (marketer == null)
{
throw new ApplicationException("Marketer not found");
}
customer = new Customer
{
Id = input.PersonId,
MarketerId = input.MarketerId,
MarketerOrganizationId = input.MarketerOrganizationId
};
customer.InjectFrom(input);
await Repository.InsertAsync(customer, true);
var output = await GetById <T>(input.PersonId);
await Task.Run(() =>
{
RaiseEvent(new CustomerCreatedEvent <T>
{
Customer = output
});
});
return(output);
}
public async Task <CustomerDto> PutCustomer(int id, CustomerInput input)
{
var customer = await GetCustomerById(id);
_context.Entry(customer).State = EntityState.Modified;
customer.ConvertToDto(input);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(customer);
}
public ContentResult AddCustomer(CustomerInput inputData)
{
try
{
var customer = new Customer()
{
CustomerId = Guid.NewGuid(),
CustomerName = inputData.CustomerName,
EmailID = inputData.EmailID,
Mobile = inputData.Mobile
};
dbContext.Customers.Add(customer);
var result = dbContext.SaveChanges();
if (result is 1)
{
return(new ContentResult
{
Content = JsonConvert.SerializeObject("Success"),
ContentType = "application/json",
StatusCode = 200
});
}
else
{
return(new ContentResult
{
Content = JsonConvert.SerializeObject("Fail"),
ContentType = "application/json",
StatusCode = 204
});
}
}
catch (Exception ex)
{
return(new ContentResult
{
Content = JsonConvert.SerializeObject(ex.InnerException.ToString()),
ContentType = "application/json",
StatusCode = 417
});
}
}
public async Task <CustomerOutput> SaveCustomer(CustomerInput saveCustomer)
{
Customer customer;
if (saveCustomer.Id.HasValue)
{
customer = await _customerRepository.GetAsync(saveCustomer.Id.Value);
customer = saveCustomer.MapTo(customer);
await _customerRepository.UpdateAsync(customer);
}
else
{
customer = saveCustomer.MapTo <Customer>();
await _customerRepository.InsertAndGetIdAsync(customer);
}
return(customer.MapTo <CustomerOutput>());
}
public void ShouldMapProxy()
{
var customerProxy = new CustomerProxy {
FirstName = "c1", ProxyName = "proxy1", RegDate = DateTime.Now
};
Mapper.AddMap <Customer, CustomerInput>(src =>
{
var res = new CustomerInput();
res.InjectFrom(src);
res.RegDate = src.RegDate.ToShortDateString();
return(res);
});
var input = Mapper.Map <Customer, CustomerInput>(customerProxy);
Assert.AreEqual(customerProxy.RegDate.ToShortDateString(), input.RegDate);
Assert.AreEqual(customerProxy.FirstName, input.FirstName);
}
public async Task TestCreateCustomer()
{
using var context = new CustomersDbContext(dbContextOptions);
var newCustomerDTO = new CustomerInput {
Name = "Petya", Surname = "Ivanov", Email = "*****@*****.**"
};
var newCustomer = new Customer(newCustomerDTO)
{
Id = 3
};
var result = (await customersController.CreateCustomerAsync(newCustomerDTO)).Result as CreatedAtActionResult;
Assert.That(result.ActionName, Is.EqualTo("GetCustomer"));
Assert.That(result.RouteValues["id"], Is.EqualTo(3));
Assert.That(result.Value, Is.EqualTo(newCustomer));
var addedCustomer = await context.FindAsync <Customer>((long)3);
Assert.That(addedCustomer, Is.EqualTo(newCustomer));
}
public CommandResult Save(CustomerInput input)
{
return Command(input,
() => RedirectToAction<CustomerController>(x => x.Index()),
() => View("Edit"));
}
