private void btnSetPayDaysAndLimit_Click(object sender, RoutedEventArgs e)
{
txtAccountPeriodDays.ClearValidationError();
txtTotalCreditLimit.ClearValidationError();
vm = this.DataContext as CustomerVM;
vm.AccountPeriodInfo.CustomerID = vm.BasicInfo.CustomerID;
if (vm.AccountPeriodInfo.AccountPeriodDays.Value < 0)
{
txtAccountPeriodDays.Validation("账期天数不能小于0");
return;
}
if (vm.AccountPeriodInfo.TotalCreditLimit.Value < 0)
{
txtTotalCreditLimit.Validation("账期额度不能小于0");
return;
}
if (!ValidateRight())
{
return;
}
new CustomerFacade().SetCollectionPeriodAndRating(vm.AccountPeriodInfo, (obj, args) =>
{
if (args.FaultsHandle())
{
return;
}
CPApplication.Current.CurrentPage.Context.Window.Alert(ResCollectionPeriodAndRating.Msg_SaveOk);
});
}
/// <summary>
/// Private method to merge in the model
/// </summary>
/// <returns></returns>
private CustomerVM GetUpdatedModel()
{
CustomerVM model = new CustomerVM();
RepopulateListsFromCacheSession(model);
model.Message = "";
if (sessionManager.CurrentCustomer != null)
{
model.CustomerItem = sessionManager.CurrentCustomer;
}
//***************************************NEED WHITE LIST ---- BLACK LIST ------ TO PREVENT OVERPOSTING **************************
bool result = TryUpdateModel(model);//This also validates and sets ModelState
//*******************************************************************************************************************************
if (sessionManager.CurrentCustomer != null)
{
//*****************************************PREVENT OVER POSTING ATTACKS******************************************************
//Get the values for read only fields from session
MergeNewValuesWithOriginal(model.CustomerItem);
//***************************************************************************************************************************
}
SetAccessContext(model);
return(model);
}
// GET: ADMIN/Accounts/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Account account = db.Accounts.Find(id);
if (account == null)
{
return(HttpNotFound());
}
CustomerVM acc = new CustomerVM()
{
Id = account.Id,
Username = account.Username,
IsActive = account.IsActive,
FirstName = account.Customer.FirstName,
LastName = account.Customer.LastName,
Phone = account.Customer.Phone,
Address = account.Customer.Address,
Email = account.Customer.Email,
Birthday = account.Customer.Birthday
};
return(View(acc));
}
public ActionResult EditCustomerPartial(string birthNo)
{
if (!checkSession())
{
return(RedirectToAction("Index", "Index"));
}
/*Debug.Indent();
* Debug.WriteLine("Ditt personummer er: " + birthNo);*/
var customer = _adminService.getCustomerByBirthNo(birthNo);
PostalArea tempPA = _adminService.getPostalAreaByPostCode(customer.PostCode);
/*PostalArea postalArea = new PostalArea()
* {
* Area = tempPA.Area
* };*/
var model = new CustomerVM()
{
BirthNo = customer.BirthNo,
FirstName = customer.FirstName,
LastName = customer.LastName,
Address = customer.Address,
PhoneNo = customer.PhoneNo,
PostCode = customer.PostCode,
PostalArea = tempPA.Area
};
return(PartialView("_EditCustomersPartial", model));
}
public ActionResult Search(CustomerVM customerVmValue)
{
using (var db = new CustomerEntities())
{
var customerSearchResults = from customerRec in db.Customers
where ((customerVmValue.Name == null) || (customerRec.Name == customerVmValue.Name.Trim())) &&
((customerVmValue.City == null) || (customerRec.City == customerVmValue.City.Trim())) &&
((customerVmValue.State == null) || (customerRec.State == customerVmValue.State.Trim()))
select new
{
Name = customerRec.Name
,
City = customerRec.City
,
State = customerRec.State
};
List <Customer> lstCustomer = new List <Customer>();
foreach (var record in customerSearchResults)
{
Customer customerValue = new Customer();
customerValue.Name = record.Name;
customerValue.City = record.City;
customerValue.State = record.State;
lstCustomer.Add(customerValue);
}
customerVmValue.Customers = lstCustomer;
return(View(customerVmValue));
}
}
public CustomerController()
{
repositoryUser = new CustomerDAO();
repositoryCountry = new CountryDAO();
repositoryUserRole = new CustomerRoleDAO();
vm = new CustomerVM();
}
public ActionResult CustomerInsert(CustomerVM vm)
{
if (ModelState.IsValid)
{
if ((List <CustomerVM>)Session["SessionContext"] == null)
{
List <CustomerVM> ctl = new List <CustomerVM>();
ctl.Add(vm);
SessionContext sc = new SessionContext();
sc.UserList = ctl;
Session["SessionContext"] = sc.UserList;
return(Json(true, JsonRequestBehavior.AllowGet));
}
else
{
List <CustomerVM> vm2 = (List <CustomerVM>)Session["SessionContext"];
vm2.Add(vm);
Session["SessionContext"] = vm2;
return(Json(true, JsonRequestBehavior.AllowGet));
}
}
else
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
}
// GET: CustomerVMs/Create
public ActionResult Create()
{
ViewBag.StateList = db.States;
var model = new CustomerVM();
return(View(model));
}
public void GetUserInfo()
{
CustomerProfile c = new CustomerProfile();
CustomerVM cvm = new CustomerVM();
using (SqlConnection con = new SqlConnection(connectionString))
{
try
{
con.Open();
SqlCommand sqlCommand = new SqlCommand("SELECT name, phonenumber, email, address where username ='******' ");
SqlDataReader myReader = sqlCommand.ExecuteReader();
while (myReader.Read())
{
string Name1 = (string)myReader["name"];
int Phone1 = (int)myReader["phonenumber"];
string Email1 = (string)myReader["email"];
string Address1 = (string)myReader["address"];
cvm.Name = Name1;
cvm.PhoneNumber = Phone1;
cvm.Email = Email1;
cvm.Address = Address1;
}
con.Close();
}
catch (SqlException e)
{
Console.WriteLine(e + "Kunne ikke udfylde listen");
}
}
}
public void CreateTest()
{
PartialViewResult rv = (PartialViewResult)_controller.Create();
Assert.IsInstanceOfType(rv.Model, typeof(CustomerVM));
CustomerVM vm = rv.Model as CustomerVM;
Customer v = new Customer();
v.CustomerName = "NgFJvC0s";
v.Contract = "hvW";
v.ContractPhone = "wJ33Sm";
vm.Entity = v;
_controller.Create(vm);
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
var data = context.Set <Customer>().FirstOrDefault();
Assert.AreEqual(data.CustomerName, "NgFJvC0s");
Assert.AreEqual(data.Contract, "hvW");
Assert.AreEqual(data.ContractPhone, "wJ33Sm");
Assert.AreEqual(data.CreateBy, "user");
Assert.IsTrue(DateTime.Now.Subtract(data.CreateTime.Value).Seconds < 10);
}
}
private IPagedList <CustomerVM> GetListVMTypeCustomerList(int Page)
{
List <CustomerVM> customerVMs = new List <CustomerVM>();
int sl = 1;
foreach (var item in customerService.CustomerList())
{
CustomerVM customerVM = new CustomerVM()
{
SerialNo = sl,
CustomerVMId = item.CustomerId,
CustomerVMName = item.CustomerName,
ContactNoVM = item.ContactNo,
DistrictVM = item.District,
SubDistrictVM = item.SubDistrict,
AreaVM = item.Area,
GoogleMapAddressVM = item.GoogleMapAddress,
RoadNoVM = item.RoadNo,
HouseNoVM = item.HouseNo
};
sl++;
customerVMs.Add(customerVM);
}
return(customerVMs.ToPagedList(Page, 10));
}
public HttpResponseMessage Delete(HttpRequestMessage request, CustomerVM customerVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
customerVM.IsDeleted = true;
Customer _customer = _customersRepository.GetSingleByCustomerID(customerVM.ID);
_customer.UpdateCustomer(customerVM);
_customersRepository.Commit();
response = request.CreateResponse(HttpStatusCode.OK);
}
return response;
}));
}
public HttpResponseMessage Create(HttpRequestMessage request, CustomerVM customerVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToArray());
}
else
{
if (_customersRepository.CustomerExists(customerVM.Email, customerVM.Name))
{
ModelState.AddModelError("Invalid user", "Email or Name already exists");
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToArray());
}
else
{
Customer newCustomer = new Customer();
newCustomer = AutoMapper.Map <CustomerVM, Customer>(customerVM);
_customersRepository.Insert(newCustomer);
_customersRepository.Commit();
// Update view model
customerVM = AutoMapper.Map <Customer, CustomerVM>(newCustomer);
response = request.CreateResponse <CustomerVM>(HttpStatusCode.Created, customerVM);
}
}
return response;
}));
}
public async Task <ActionResult> Index()
{
var cityList = db.Cities.ToList().OrderBy(m => m.CityName);
var CustomersList = await Task.Run(() => db.Customers.ToList());
List <CustomerVM> CustomersListVMList = new List <CustomerVM>();
foreach (var item in CustomersList)
{
CustomerVM CustVM = new CustomerVM();
CustVM.CustomerID = item.CustomerID;
CustVM.CustomerName = item.CustomerName;
CustVM.CustomerNumber = item.CustomerNumber;
if (item.CustomerID != 0)
{
var city = cityList.FirstOrDefault(t => t.CityID == item.CustomerCityID);
if (city != null)
{
CustVM.CustomerCityName = city.CityName;
}
}
CustomersListVMList.Add(CustVM);
}
return(View(CustomersListVMList));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Surname,FirstName,Email")] CustomerVM customerVM)
{
if (id != customerVM.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
if (!CustomerActive(customerVM.Id))
{
return(NotFound());
}
try
{
var customer = await _context.Customers.Where(c => c.Deleted == false).FirstOrDefaultAsync(m => m.Id == id);
customer.FirstName = customerVM.FirstName;
customer.Surname = customerVM.Surname;
customer.Email = customerVM.Email;
await _context.SaveChangesAsync();
}
catch (Exception e)
{
customerVM.Message = "Something went wrong, ensure all fields are completed and try again";
return(View(customerVM));
}
return(RedirectToAction(nameof(Index)));
}
return(View(customerVM));
}
public async Task <ActionResult> Create(int Id = 0)
{
CustomerVM CustomerVM;
if (Id == 0)
{
CustomerVM = new CustomerVM();
var cityActiveList = db.Cities.ToList().Where(m => m.Flag.Equals("A")).OrderBy(m => m.CityName);
CustomerVM.CityList = cityActiveList.Select(s => new SelectListItem()
{
Text = s.CityName, Value = s.CityID.ToString()
});
}
else
{
CustomerVM = new CustomerVM();
Customer Customer = new Customer();
var cityActiveList = db.Cities.ToList().OrderBy(m => m.CityName);
CustomerVM.CityList = cityActiveList.Select(s => new SelectListItem()
{
Text = s.CityName, Value = s.CityID.ToString()
});
Customer = await Task.Run(() => db.Customers.Find(Id));
if (Customer != null)
{
CustomerVM.CustomerID = Customer.CustomerID;
CustomerVM.CustomerName = Customer.CustomerName;
CustomerVM.CustomerNumber = Customer.CustomerNumber;
CustomerVM.CustomerCityID = (Int64)Customer.CustomerCityID;
}
}
return(View(CustomerVM));
}
private async Task <WrapperListCustomerVM> SetHistoryOverview(WrapperListCustomerVM vm, string FactoryId)
{
var data = new GetDataListHistory();
//Task<WrapperCustomerHistory>[] listOftask = new Task<WrapperCustomerHistory>[vm.ListOfData.Count];
WrapperCustomerHistory[] listOftask = new WrapperCustomerHistory[vm.ListOfData.Count];
for (int i = 0; i < vm.ListOfData.Count; i++)
{
CustomerVM temp = vm.ListOfData.ElementAt(i);
data.ClientId = temp.CustomerId;
data.PageNumber = -1;
data.PageSize = -1;
data.FactoryId = FactoryId;
listOftask[i] = await GetCustomerHistory(data);
int len = listOftask[i].ListOfData.Count - 1;
vm.ListOfData.ElementAt(i).PaidAmount = listOftask[i].ListOfData[len].PaidAmount;
vm.ListOfData.ElementAt(i).RecievableAmount = listOftask[i].ListOfData[len].RecievableAmount;
vm.ListOfData.ElementAt(i).RecievedAmount = listOftask[i].ListOfData[len].RecievedAmount;
vm.ListOfData.ElementAt(i).PayableAmount = listOftask[i].ListOfData[len].PayableAmount;
}
// await Task.WhenAll(listOftask);
//for (int i = 0; i < vm.ListOfData.Count; i++)
//{
// //CustomerHistory te = GetCustomerHistoryOverview(listOftask[i].Result);
// CustomerHistory te = GetCustomerHistoryOverview(listOftask[i]);
// vm.ListOfData.ElementAt(i).PaidAmount = te.PaidAmount;
// vm.ListOfData.ElementAt(i).RecievableAmount = te.RecievableAmount;
// vm.ListOfData.ElementAt(i).RecievedAmount = te.RecievedAmount;
// vm.ListOfData.ElementAt(i).PayableAmount = te.PayableAmount;
//}
return(vm);
}
public ActionResult EditCustomer(int id)
{
/*if (id == null)
* {
* return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
* }*/
// Declare productVM
CustomerVM model;
using (Db db = new Db())
{
// Get the product
CustomerDTO dto = db.Customers.Find(id);
// Make sure product exists
if (dto == null)
{
return(Content("هذا العميل غير موجود "));
}
// init model
model = new CustomerVM(dto);
}
// Return view with model
return(View(model));
}
public ActionResult UpdateCustomer(CustomerVM model)
{
if (!checkSession())
{
return(RedirectToAction("Index", "Index"));
}
if (ModelState.IsValid)
{
var newPostalArea = new PostalArea()
{
Area = model.PostalArea,
PostCode = model.PostCode
};
// Attempt to create new postal area:
_adminService.addPostalArea(newPostalArea);
Customer customer = new Customer()
{
BirthNo = model.BirthNo,
FirstName = model.FirstName,
LastName = model.LastName,
Address = model.Address,
PhoneNo = model.PhoneNo,
PostCode = model.PostCode
};
_adminService.updateCustomer(customer);
return(Json(new { success = true }));
}
// else
return(PartialView("_EditCustomersPartial", model));
}
public IActionResult CustomerMaster(int?page, int ID)
{
int pageNumber = page ?? 1;
ViewBag.MsgShow = TempData["Error"];
CustomerVM model = new CustomerVM();
model.CustomerList = _CustomerService.AllCustomerList().ToPagedList(pageNumber, PageSize);
if (ID != 0)
{
var data = _CustomerService.GetCustomerByID(ID);
Customer cust = new Customer
{
ID = data.ID,
Name = data.Name,
Email = data.Email,
IsActive = data.IsActive,
Address = data.Address,
Phone = data.Phone,
Skype = data.Skype
};
model.Customer = cust;
}
return(View(model));
}
public void DeleteTest()
{
Customer v = new Customer();
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
v.CustomerName = "NgFJvC0s";
v.Contract = "hvW";
v.ContractPhone = "wJ33Sm";
context.Set <Customer>().Add(v);
context.SaveChanges();
}
PartialViewResult rv = (PartialViewResult)_controller.Delete(v.ID.ToString());
Assert.IsInstanceOfType(rv.Model, typeof(CustomerVM));
CustomerVM vm = rv.Model as CustomerVM;
v = new Customer();
v.ID = vm.Entity.ID;
vm.Entity = v;
_controller.Delete(v.ID.ToString(), null);
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
Assert.AreEqual(context.Set <Customer>().Count(), 1);
}
}
public ActionResult EnterSearch()
{
CustomerVM vm = new CustomerVM();
vm.Customers = new List <CustomerModel>();
return(View("SearchCustomers", vm));
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id,Name,Email,CreateDate,isActive")] CustomerVM customer)
{
if (id != customer.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var updateCustomer = _mapper.Map <CustomerVM, Customer>(customer);
_customerAppService.Update(updateCustomer);
}
catch (DbUpdateConcurrencyException)
{
if (!CustomerExists(customer.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(customer));
}
public async Task <IActionResult> Create([Bind("CustomerId,CustomerName,CustomerBussinessDetails,CustomerDescription,Contact,Address,Email,IsActive,DateAdded,DateUpdated")] CustomerVM customerVM)
{
if (ModelState.IsValid)
{
customerVM.DateAdded = DateTime.Now;
customerVM.IsActive = true;
HttpClient client = _helperAPI.InitializeClient();
//client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", HttpContext.Session.GetString("token"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", TempData.Peek("Token").ToString());
var content = new StringContent(JsonConvert.SerializeObject(customerVM), Encoding.UTF8, "application/json");
//Task has been cancelled exception occured here, and Api method never hits while debugging
HttpResponseMessage res = client.PostAsync("api/Customers", content).Result;
if (res.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
}
return(View(customerVM));
//if (ModelState.IsValid)
//{
// _context.Add(customerVM);
// await _context.SaveChangesAsync();
// return RedirectToAction(nameof(Index));
//}
//return View(customerVM);
}
public ActionResult Quote(string firstName, string lastName, string emailAddress, DateTime DOB, string hadDUI, int?tickets, string coverage, int carYear, string carMake, string carModel)
{
using (CarInsuranceEntities db = new CarInsuranceEntities())
{
var customer = new Customer()
{
FirstName = firstName, LastName = lastName, EmailAddress = emailAddress, DOB = DOB, HadDUI = hadDUI, Tickets = tickets, Coverage = coverage
};
var car = new Car()
{
CarYear = carYear, CarMake = carMake.ToLower(), CarModel = carModel.ToLower()
};
customer.Quote = getQuote(customer, car);
db.Customers.Add(customer);
db.Cars.Add(car);
db.SaveChanges();
var customerVm = new CustomerVM()
{
FirstName = customer.FirstName, LastName = customer.LastName, Quote = customer.Quote, Coverage = customer.Coverage
};
return(View(customerVm));
}
}
private async Task <bool> CustomerVMExists(long id)
{
if (id == 0)
{
return(false);
}
CustomerVM customerVM = new CustomerVM();
HttpClient client = _helperAPI.InitializeClient();
//client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", HttpContext.Session.GetString("token"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", TempData.Peek("Token").ToString());
HttpResponseMessage res = await client.GetAsync("api/Customers/" + id);
if (res.IsSuccessStatusCode)
{
var result = res.Content.ReadAsStringAsync().Result;
customerVM = JsonConvert.DeserializeObject <CustomerVM>(result);
}
if (customerVM == null)
{
return(false);
}
return(true);
//return _context.CustomerVM.Any(e => e.CustomerId == id);
}
public string createCustomer(CustomerVM model)
{
try
{
if (model != null)
{
Database.Customer entity = new Database.Customer();
entity.Name = model.Name;
entity.Address = model.Address;
//entity.lo = model.Locality;
entity.EmailId = model.EmailId;
entity.MobileNo = model.MobileNo;
entity.City = model.City;
entity.State = model.State;
entity.Password = model.Password;
entity.Zipcode = model.Zipcode;
_dbContext.Customers.Add(entity);
_dbContext.SaveChanges();
return("");
}
}
catch (Exception ex)
{
return(ex.Message);
}
return("");
}
public bool AddCustomer(CustomerVM custVM)
{
try
{
MasterDbContext db = new MasterDbContext();
Customer l_oCust = new Customer();
//l_oCust.groupI = model.groupId;
//l_oCust.cust_gstin=model
//db.users.Add(l_oUser);
//db.SaveChanges();
l_oCust.cust_name = custVM.cust_name;
l_oCust.cust_uid_type = custVM.cust_uid_type;
l_oCust.cust_uid = custVM.cust_uid;
l_oCust.cust_dob = custVM.cust_dob;
l_oCust.remarks = custVM.remarks;
l_oCust.cust_gstin = custVM.firstfield + custVM.secondField + custVM.thirdfield;
db.customers.Add(l_oCust);
db.SaveChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public ActionResult Update(Guid?id)
{
if (id == null)
{
return(RedirectToAction("List", "Customer", new { area = "Member" }));
}
Customer data = _customerService.GetById((Guid)id);
CustomerVM model = new CustomerVM()
{
ID = data.ID,
CustomerCode = data.CustomerCode,
Name = data.Name,
ContactName = data.ContactName,
Address = data.Address,
TaxNumber = data.TaxNumber,
Tax = data.Tax,
Phone = data.Phone,
Email = data.Email,
District = data.District,
City = data.City,
Country = data.Country,
};
return(View(model));
}
public async Task <string> AddUpdateUser(CustomerVM customerVM)
{
CustomerDomainModel customerDM = new CustomerDomainModel();
AutoMapper.Mapper.Map(customerVM, customerDM);
return(await customerBusiness.AddUpdateCustomer(customerDM));
}
public IEnumerable<ICustomerVM> GetAllCustomers()
{
var toReturn = new List<ICustomerVM>();
foreach (Customer customer in sampleRepo.GetAllCustomers()) {
var cust = new CustomerVM(sampleRepo);
cust.Load(customer);
toReturn.Add(cust);
}
return toReturn.OrderBy(cust => cust.FirstName);
}
private void AddCustomer()
{
var customer = new CustomerVM(_customersService);
SubscribeHandlers(customer);
_customers.Add(customer);
}
private void UpdateSelectedCustomer(CustomerVM oldSelectedCustomer)
{
if (oldSelectedCustomer == null) return;
SelectedCustomer = Customers.FirstOrDefault(customer => customer.ID.Equals(oldSelectedCustomer.ID));
}
private void SubscribeHandlers(CustomerVM customer)
{
customer.EntityDeleted += (s, e) => _customers.Remove(SelectedCustomer);
}
public SampleSessionData()
{
sampleRepo = new SampleDataRepository();
Customer = new CustomerVM(sampleRepo);
}
public MasterCustomersEditVM(CustomerVM editingCustomer)
{
_editingCustomer = editingCustomer;
SetDefaultEditProperties();
}
