public IHttpActionResult AddCustomer(CustomerView objCustomerRec)
{
try
{
CustomerRecord objCustomerData = new CustomerRecord();
objCustomerRec.CopyProperties(objCustomerData);
_CustomerService.Create(objCustomerData);
if (objCustomerRec.FK_CommiteId > 0)
{
CommiteMember member = new CommiteMember();
member.FK_CommiteId = objCustomerRec.FK_CommiteId;
member.FK_CustomerId = objCustomerData.Id;
member.IsActive = true;
member.CreatedDate = member.UpdatedDate = System.DateTime.Now;
member.UpdatedBy = member.CreatedBy = objCustomerData.CreatedBy;
_MemberService.Create(member);
}
return(Ok(objCustomerRec));
}
catch (Exception ex)
{
throw ex;
}
}
public void UpdatingACustomer()
{
var customer = new CustomerRecord
{
Firstname = "Bjorn",
Lastname = "Stroustrup",
BirthDay = "12/30/1950"
};
var csvFile = Path.GetTempFileName();
var lineFile = new LineFile(csvFile);
var repo = new CustomerRepository <CustomerRecord>(lineFile, ';');
repo.Open();
repo.Store(customer);
customer.Firstname = "Bjarne";
repo.Store(customer);
repo.Close();
var lines = File.ReadAllLines(csvFile);
const string lineExpected = "Bjarne;Stroustrup;12/30/1950;";
Assert.IsTrue(lines.Length == 1);
Assert.AreEqual(lineExpected, lines[0]);
}
public void ToDataRow()
{
var customerRecord = new CustomerRecord
{
Id = 1,
FirstName = "John",
LastName = "Smith",
AccountBalance = 25.60m,
DateJoined = new DateTime(2018, 9, 15),
IsActive = true,
};
var propertyMapper = new PropertyMapper <CustomerRecord>();
var dataRowMapper = new DataRowMapper <CustomerRecord>(propertyMapper);
var dataColumnMapper = new DataColumnMapper <CustomerRecord>(propertyMapper);
var dataTable = new DataTable();
var dataColumns = dataColumnMapper.ToDataColumns().ToArray();
dataTable.Columns.AddRange(dataColumns);
var dataRow = dataRowMapper.ToDataRow(dataTable, customerRecord);
CustomerRecordAssert.Equal(customerRecord, dataRow);
}
// ******************************************
static void Main(string[] args)
{
// Initialize AKV provider
var sqlColumnEncryptionAzureKeyVaultProvider = new SqlColumnEncryptionAzureKeyVaultProvider(AzureActiveDirectoryAuthenticationCallback);
// Register AKV provider
SqlConnection.RegisterColumnEncryptionKeyStoreProviders(customProviders: new Dictionary <string, SqlColumnEncryptionKeyStoreProvider>(capacity: 1, comparer: StringComparer.OrdinalIgnoreCase)
{
{ SqlColumnEncryptionAzureKeyVaultProvider.ProviderName, sqlColumnEncryptionAzureKeyVaultProvider }
});
Console.WriteLine("AKV provider Registered");
// Create connection to database
using (SqlConnection sqlConnection = new SqlConnection(s_connectionString))
{
var cmkName = "CMK_WITH_AKV";
var cekName = "CEK_WITH_AKV";
var tblName = "AKV_TEST_TABLE";
var customer = new CustomerRecord(1, @"Microsoft", @"Corporation");
try
{
sqlConnection.Open();
// Drop Objects if exists
dropObjects(sqlConnection, cmkName, cekName, tblName);
// Create Column Master Key with AKV Url
createCMK(sqlConnection, cmkName, sqlColumnEncryptionAzureKeyVaultProvider);
Console.WriteLine("Column Master Key created.");
// Create Column Encryption Key
createCEK(sqlConnection, cmkName, cekName, sqlColumnEncryptionAzureKeyVaultProvider);
Console.WriteLine("Column Encryption Key created.");
// Create Table with Encrypted Columns
createTbl(sqlConnection, cekName, tblName);
Console.WriteLine("Table created with Encrypted columns.");
// Insert Customer Record in table
insertData(sqlConnection, tblName, customer);
Console.WriteLine("Encryted data inserted.");
// Read data from table
verifyData(sqlConnection, tblName, customer);
Console.WriteLine("Data validated successfully.");
}
finally
{
// Drop table and keys
dropObjects(sqlConnection, cmkName, cekName, tblName);
Console.WriteLine("Dropped Table, CEK and CMK");
}
Console.WriteLine("Completed AKV provider Sample.");
Console.ReadKey();
}
}
public bool PutCustomer(Guid id, string firstname)
{
CustomerRecord apiCustomer = new CustomerRecord()
{
customer = new Customer {
id = id.ToString()
}
};
var apiResult = Task.Run(() => Api.PutCustomersAsync(id, firstname));
//For the sake of example added a 5 second timeout for calling functions
apiResult.Wait(5000);
if (apiResult.IsCompleted)
{
try
{
var customerObj = JsonConvert.DeserializeObject <string>(apiResult.Result);
//We do not know the response so if not empty assume success
return(!string.IsNullOrEmpty(customerObj));
}
catch
{
return(false);
}
}
return(false);
}
public void Adding2Customers()
{
const string lineExpected1 = "Dennis;Ritchie;9/9/1941;";
var customer1 = new CustomerRecord
{
Firstname = "Dennis",
Lastname = "Ritchie",
BirthDay = "9/9/1941"
};
const string lineExpected2 = "Ken;Thompson;2/4/1943;";
var customer2 = new CustomerRecord
{
Firstname = "Ken",
Lastname = "Thompson",
BirthDay = "2/4/1943"
};
var csvFile = Path.GetTempFileName();
var lineFile = new LineFile(csvFile);
var repo = new CustomerRepository <CustomerRecord>(lineFile, ';');
repo.Open();
repo.Store(customer1);
repo.Store(customer2);
repo.Close();
var lines = File.ReadAllLines(csvFile);
Assert.AreEqual(lineExpected1, lines[0]);
Assert.AreEqual(lineExpected2, lines[1]);
}
private CustomerIdNameReadModel GetIdNameResult(CustomerRecord customerRecord)
{
var id = new CustomerIdentity(customerRecord.Id);
var name = $"{customerRecord.FirstName} {customerRecord.LastName}";
return(new CustomerIdNameReadModel(id, name));
}
public void CanUpdateAggregateCustomerRecords()
{
try
{
var customer = _CustomerService.GetCustomerByID("1");
CustomerRecord nameRecord = customer.CustomerDataRecords.Where(r => r.Property.Name == "Name").FirstOrDefault();
Assert.AreEqual(nameRecord.Property.Name, "Name");
Assert.AreEqual(nameRecord.Type.Name, "Customer");
Assert.AreEqual(nameRecord.Value, "Hadar");
CustomerRecord ageRecord = customer.CustomerDataRecords.Where(r => r.Property.Name == "Age").FirstOrDefault();
Assert.AreEqual(ageRecord.Property.Name, "Age");
Assert.AreEqual(ageRecord.Type.Name, "Customer");
Assert.AreEqual(ageRecord.Value, "47");
nameRecord.Value = "UpdatedName";
ageRecord.Value = "42";
_CustomerService.UpdateCustomerRecords(customer);
AggregateCustomer retreivedCreatedCustomer = _CustomerService.GetCustomerByID("1");
CustomerRecord updatedNameRecord = customer.CustomerDataRecords.Where(r => r.Property.Name == "Name").FirstOrDefault();
Assert.AreEqual(updatedNameRecord.Property.Name, "Name");
Assert.AreEqual(updatedNameRecord.Type.Name, "Customer");
Assert.AreEqual(updatedNameRecord.Value, "UpdatedName");
CustomerRecord updatedAgeRecord = customer.CustomerDataRecords.Where(r => r.Property.Name == "Age").FirstOrDefault();
Assert.AreEqual(updatedAgeRecord.Property.Name, "Age");
Assert.AreEqual(updatedAgeRecord.Type.Name, "Customer");
Assert.AreEqual(updatedAgeRecord.Value, "42");
}
catch (Exception ex)
{
Assert.Fail("Expected no exception, but got: " + ex.Message);
}
}
private CustomerDetailReadModel GetCustomerDetailReadModel(CustomerRecord customerRecord)
{
var id = new CustomerIdentity(customerRecord.Id);
var firstName = customerRecord.FirstName;
var lastName = customerRecord.LastName;
var openOrders = customerRecord.Orders
.Where(e => e.OrderStatusId != OrderStatus.Closed)
.Count();
var lastOrderDate = customerRecord.Orders
.Max(e => (DateTime?)e.OrderDate);
var totalOrders = customerRecord.Orders
.Count;
var totalOrderValue = customerRecord.Orders
.SelectMany(e => e.OrderItems)
.Select(e => e.UnitPrice * e.Quantity)
.Sum(e => (decimal?)e)
.GetValueOrDefault();
var topProducts = customerRecord.Orders
.SelectMany(e => e.OrderItems)
.GroupBy(e => e.Product)
.OrderByDescending(e => e.Count())
.Select(e => e.Key.ProductName)
.ToList();
return(new CustomerDetailReadModel(id, firstName, lastName, openOrders, lastOrderDate, totalOrders, totalOrderValue, topProducts));
}
// Workaround for constraints set on the database. Some fields don't allow an empty value. It must be set to null explicitly.
protected void ReplaceEmptyStringWithNull(CustomerEntity customerEntity, CustomerRecord customerRecord)
{
if (string.IsNullOrEmpty(customerEntity.Suffix) || string.IsNullOrEmpty(customerEntity.Suffix.Trim()))
{
customerRecord.Suffix = null;
}
if (string.IsNullOrEmpty(customerEntity.Prefix) || string.IsNullOrEmpty(customerEntity.Prefix.Trim()))
{
customerRecord.Prefix = null;
}
if (string.IsNullOrEmpty(customerEntity.Email) || string.IsNullOrEmpty(customerEntity.Email.Trim()))
{
customerRecord.Email = null;
}
if (string.IsNullOrEmpty(customerEntity.Email2) || string.IsNullOrEmpty(customerEntity.Email2.Trim()))
{
customerRecord.Email2 = null;
}
if (string.IsNullOrEmpty(customerEntity.Comment) || string.IsNullOrEmpty(customerEntity.Comment.Trim()))
{
customerRecord.Comment = null;
}
}
public CustomerRecord Create(CustomerRecord customer)
{
Microsoft.EntityFrameworkCore.ChangeTracking.EntityEntry <CustomerRecord> entry =
_context.Customers.Add(customer);
_context.SaveChanges();
return(entry.Entity);
}
private void UpdateCustomerRecord(CustomerRecord customerRecord, Customer customer)
{
customerRecord.Id = customer.Id;
customerRecord.ReferenceNumber = customer.ReferenceNumber.ToString();
customerRecord.FirstName = customer.FirstName;
customerRecord.LastName = customer.LastName;
}
// GET: Customer/Delete/5
public ActionResult Delete(CustomerRecord customerID)
{
var d = rentalHouseEntities.CustomerRecords.Where(x => x.id == customerID.id).FirstOrDefault();
rentalHouseEntities.CustomerRecords.Remove(d);
rentalHouseEntities.SaveChanges();
return(RedirectToAction("CustomerRecord"));
}
private Customer GetCustomer(CustomerRecord customerRecord)
{
var identity = new CustomerIdentity(customerRecord.Id);
var firstName = customerRecord.FirstName;
var lastName = customerRecord.LastName;
return(new Customer(identity, firstName, lastName));
}
public async Task <ActionResult> DeleteConfirmed(Guid id)
{
CustomerRecord customerRecord = await db.CustomerRecords.FindAsync(id);
db.CustomerRecords.Remove(customerRecord);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
private static BrowseCustomersRecordResponse GetResponse(CustomerRecord customerRecord)
{
return(new BrowseCustomersRecordResponse
{
Id = customerRecord.Id,
FirstName = customerRecord.FirstName,
LastName = customerRecord.LastName,
});
}
private Customer GetCustomer(CustomerRecord customerRecord)
{
var id = new CustomerIdentity(customerRecord.Id);
var referenceNumber = CustomerReferenceNumber.Parse(customerRecord.ReferenceNumber);
var firstName = customerRecord.FirstName;
var lastName = customerRecord.LastName;
return(new Customer(id, referenceNumber, firstName, lastName));
}
public ActionResult Create([Bind(Exclude = "id")] CustomerRecord customerRecord)
{
if (!ModelState.IsValid)
{
return(View());
}
rentalHouseEntities.CustomerRecords.Add(customerRecord);
rentalHouseEntities.SaveChanges();
return(RedirectToAction("CustomerRecord"));
}
private void UpdateCustomerRecord(CustomerRecord customerRecord, Customer customer)
{
var id = customer.Id.Value;
var firstName = customer.FirstName;
var lastName = customer.LastName;
customerRecord.Id = id;
customerRecord.FirstName = firstName;
customerRecord.LastName = lastName;
}
private ViewCustomerQueryResponse GetResponse(CustomerRecord customerRecord)
{
var id = customerRecord.Id;
var firstName = customerRecord.FirstName;
var lastName = customerRecord.LastName;
// TODO: VC: Fill in
/*
*
* var openOrders = customerRecord.Orders
* .Where(e => e.OrderStatusId != OrderStatus.Shipped
|| e.OrderStatusId != OrderStatus.Cancelled)
|| .Count();
||
||var lastOrderDate = customerRecord.Orders
|| .Max(e => (DateTime?)e.OrderDate);
||
||var totalOrders = customerRecord.Orders
|| .Count;
||
||var totalOrderValue = customerRecord.Orders
|| .SelectMany(e => e.OrderItems)
|| .Select(e => e.UnitPrice * e.Quantity)
|| .Sum(e => (decimal?)e)
|| .GetValueOrDefault();
||
||var topProducts = customerRecord.Orders
|| .SelectMany(e => e.OrderItems)
|| .GroupBy(e => e.Product)
|| .OrderByDescending(e => e.Count())
|| .Select(e => e.Key.ProductName)
|| .ToList();
||
*/
var openOrders = 0;
var lastOrderDate = DateTime.MinValue;
var totalOrders = 2;
var totalOrderValue = 30.25m;
var topProducts = new List <string>();
return(new ViewCustomerQueryResponse
{
Id = id,
FirstName = firstName,
LastName = lastName,
OpenOrders = openOrders,
LastOrderDate = lastOrderDate,
TotalOrders = totalOrders,
TotalOrderValue = totalOrderValue,
TopProducts = topProducts
});
}
private ListCustomersRecordResponse GetResponse(CustomerRecord customerRecord)
{
var id = customerRecord.Id;
var name = $"{customerRecord.FirstName} {customerRecord.LastName}";
return(new ListCustomersRecordResponse
{
Id = id,
Name = name,
});
}
internal static Customer GetEntity(this CustomerRecord customer)
{
return(customer == null ? null :
new Customer()
{
Email = customer.Email,
Fullname = customer.Fullname,
BillingAddress = customer.BillingAddress.GetEntity(),
ShippingAddress = customer.ShippingAddress.GetEntity()
});
}
public IActionResult Put(long id, [FromBody] CustomerRecord customer)
{
var record = _sqliteRepository.GetById(id);
if (record == null)
{
return(NotFound());
}
customer.Id = id;
_sqliteRepository.Update(customer);
return(NoContent());
}
public IHttpActionResult UpdateCustomer(CustomerRecord objCustomerRec)
{
try
{
_CustomerService.Update(objCustomerRec);
return(Ok(objCustomerRec));
}
catch (Exception ex)
{
throw ex;
}
}
private CustomerHeaderReadModel GetCustomerHeaderReadModel(CustomerRecord customerRecord)
{
var id = new CustomerIdentity(customerRecord.Id);
var firstName = customerRecord.FirstName;
var lastName = customerRecord.LastName;
var openOrders = customerRecord.Orders
.Where(e => e.OrderStatusId != OrderStatus.Closed)
.Count();
return(new CustomerHeaderReadModel(id, firstName, lastName, openOrders));
}
public ActionResult Edit(CustomerRecord customerID)
{
var orignalRecord = (from m in rentalHouseEntities.CustomerRecords where m.id == customerID.id select m).First();
if (!ModelState.IsValid)
{
return(View(orignalRecord));
}
rentalHouseEntities.Entry(orignalRecord).CurrentValues.SetValues(customerID);
rentalHouseEntities.SaveChanges();
return(RedirectToAction("CustomerRecord"));
}
public CustomerRecord ToCustomerRecord(CustomerRecord record)
{
record.Name = this.Name;
record.Age = this.Age;
record.Phones = this.Phones.Select(phone => new PhoneRecord
{
Type = phone.Type,
AreaCode = phone.AreaCode,
Number = phone.Number
}).ToList()
;
return(record);
}
public async Task <CreateCustomerResponse> CreateCustomerAsync(CreateCustomerRequest request)
{
var customer = new CustomerRecord {
EmailAddress = request.EmailAddress,
Name = request.Name,
Username = request.Username
};
await DataAccessClient.CreateCustomerAsync(customer);
return(new CreateCustomerResponse {
Customer = customer
});
}
public async Task <ActionResult> Edit([Bind(Include = "TypeId,PropertyId,Value,CustomerId,RecordId")] CustomerRecord customerRecord)
{
if (ModelState.IsValid)
{
db.Entry(customerRecord).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.PropertyId = new SelectList(db.Properties, "PropertyId", "Name", customerRecord.PropertyId);
ViewBag.TypeId = new SelectList(db.Types, "TypeId", "Name", customerRecord.TypeId);
return(View(customerRecord));
}
/// <summary>
/// Handles the MouseDoubleClick event of the customerRecordsListBox control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Input.MouseButtonEventArgs"/> instance containing the event data.</param>
private void customerRecordsListBox_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
CustomerRecord customerRecord = (this.customerRecordsListBox.SelectedItem as CustomerRecord);
CustomerRecordWindow window = new CustomerRecordWindow();
window.Date = customerRecord.Date;
window.Note = customerRecord.Text;
if (window.OpenWindowInMode(OpenWindowMode.Edit) == true)
{
customerRecord.Date = window.Date;
customerRecord.Text = window.Note;
this.RefreshSelectedCustomer();
}
}
