//
// GET: /Manage/Index
public async Task <ActionResult> Index(ManageMessageId?message)
{
var userId = User.Identity.GetUserId();
model.Orders = OrderDataService.UserOrders(userId);
model.CustomerAccountInfo = CustomerDataService.GetCustomer(userId);
//ViewBag.StatusMessage =
// message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
// : message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
// : message == ManageMessageId.SetTwoFactorSuccess ? "Your two-factor authentication provider has been set."
// : message == ManageMessageId.Error ? "An error has occurred."
// : message == ManageMessageId.AddPhoneSuccess ? "Your phone number was added."
// : message == ManageMessageId.RemovePhoneSuccess ? "Your phone number was removed."
// : "";
//var userId = User.Identity.GetUserId();
//var model = new IndexViewModel
//{
// HasPassword = HasPassword(),
// PhoneNumber = await UserManager.GetPhoneNumberAsync(userId),
// TwoFactor = await UserManager.GetTwoFactorEnabledAsync(userId),
// Logins = await UserManager.GetLoginsAsync(userId),
// BrowserRemembered = await AuthenticationManager.TwoFactorBrowserRememberedAsync(userId)
//};
return(View(model));
}
private void FillViewBag()
{
var allCustomers = new CustomerDataService().GetAllCustomers().ToList();
// Create a SelectListItem list from the alarm class configurations which are distinct by their names
ViewBag.Customers =
allCustomers.GroupBy(x => x.Id)
.Select(x => x.FirstOrDefault()).Select(
x =>
new SelectListItem
{
Text = x.Name,
Value = x.Id.ToString()
})
.ToList();
ViewBag.SaleStates = EnumHelper.GetSelectList(typeof(SalesState));
ViewBag.Currencies = EnumHelper.GetSelectList(typeof(Currency));
var allExporters = new ExporterDataService().GetAllExporters().ToList();
ViewBag.Exporters =
allExporters.GroupBy(x => x.Id)
.Select(x => x.FirstOrDefault()).Select(
x =>
new SelectListItem
{
Text = x.Name,
Value = x.Id.ToString()
})
.ToList();
}
private async void InitializeData()
{
DialogService _dialogService = new DialogService();
CustomerDataService _customerDataService = new CustomerDataService();
if (Application.Current.Properties.ContainsKey("transCustomer"))
{
_customerEmail = (string)Application.Current.Properties["transCustomer"];
_dialogService.ShowLoading("Loading...");
var pricings = await _customerDataService.GetCustomersPricing(_customerEmail);
if (pricings != null)
{
CustomerPricings = pricings.ToObservableCollection();
_dialogService.HideLoading();
}
else
{
_dialogService.HideLoading();
await _dialogService.ShowDialog("Not found", "Customer information does not exist.", "Ok");
var navServ = App.ViewNavigationService;
await navServ.GoBack();
}
}
else
{
await _dialogService.ShowDialog("Not found", "Customer information does not exist.", "Ok");
var navServ = App.ViewNavigationService;
await navServ.GoBack();
}
}
protected async Task HandleValidSubmit()
{
//Customer.CountryId = int.Parse(CountryId);
//Customer.JobCategoryId = int.Parse(JobCategoryId);
if (Customer.CustomerID == 0) //new
{
var addedCustomer = await CustomerDataService.AddCustomer(Customer);
if (addedCustomer != null)
{
StatusClass = "alert-success";
Message = "Nieuwe klant succesvol toegevoegd.";
Saved = true;
}
else
{
StatusClass = "alert-danger";
Message = "Er is iets misgegaan tijdens het aanmaken van een nieuwe klant. Probeer het opnieuw.";
Saved = false;
}
}
else
{
await CustomerDataService.UpdateCustomer(Customer);
StatusClass = "alert-success";
Message = "Klantgegevens zijn succesvol bijgewerkt.";
Saved = true;
}
}
public CustomerDataServiceTests()
{
_dbContext = A.Fake <IDbContext>();
_currentTenantProvider = new CurrentTenantProvider();
_sut = new CustomerDataService(_dbContext, _currentTenantProvider, new DummyLinqQuery());
_fixture = new Fixture();
}
public IEnumerable <CustomerModel> GetAllCustomers(SearchModel searchModele)
{
CustomerDataService oDataService = new CustomerDataService();
IEnumerable <CustomerModel> customers = oDataService.GetAll(searchModele);
return(customers);
}
public ActionResult EditCustomer(int customerId)
{
var customerDataService = new CustomerDataService();
var customer = customerDataService.GetCustomerById(customerId);
return(PartialView(new CustomerViewModel(customer)));
}
public async Task<JsonResult> GetCustomers(string query, bool validateOnly)
{
if (validateOnly)
{
var emptyQueryable = new EnumerableQuery<Customer>(new Customer[0]);
try
{
emptyQueryable.Where(query);
return Json(new { Valid = true });
}
catch (ParseException ex)
{
return Json(new { Valid = false, ex.Message });
}
}
var service = new CustomerDataService();
var result = await service.GetAllCustomersAsync();
IQueryable<Customer> queryableResult = result.AsQueryable();
if (!string.IsNullOrWhiteSpace(query))
{
queryableResult = queryableResult.Where(query);
}
return Json(queryableResult.ToArray());
}
public IActionResult CreateCustomer([FromBody] CreateCustomerRequest request)
{
CustomerDataService customerService = new CustomerDataService(customerRepository, domainEventPublisher);
Customer customer = customerService.CreateCustomer(request.Name, request.CreditLimit);
CreateCustomerResponse createCustomerResponse = new CreateCustomerResponse(customer.Id);
return(Ok(createCustomerResponse));
}
public async Task GetCustomerKeyNotFound()
{
var databaseRepoMock = new Mock <IDatabaseRepository>();
databaseRepoMock.Setup(repo => repo.ReadDatabase().Result).Returns(TestDatabaseFilled);
var customerDataService = new CustomerDataService(databaseRepoMock.Object, _mockLogger.Object);
await Assert.ThrowsAnyAsync <KeyNotFoundException>(async() => await customerDataService.GetCustomer(-999));
}
public void GetCustomerDataFromCsvFileTestWithNoFile()
{
var normalFilePath = Path.GetFullPath("./TestData/SampleData.csv");
var customerDataService = new CustomerDataService(normalFilePath);
var wrongFilePath = Path.GetFullPath("./TestData/SampleDataNotExisting.csv");
Assert.Throws <FileLoadException>(() => customerDataService.GetCustomerDataFromCsvFile(wrongFilePath));
}
public CustomerControllerTests()
{
SpreadsheetInfo.SetLicense("FREE-LIMITED-KEY");
var normalFilePath = Path.GetFullPath("./TestData/SampleData.csv");
var customerDataService = new CustomerDataService(normalFilePath);
customerController = new CustomerController(customerDataService);
}
public void GetCustomerDataFromCsvFileTestWithNormalFile()
{
var filePath = Path.GetFullPath("./TestData/SampleData1.csv");
var customerDataService = new CustomerDataService(filePath);
var results = customerDataService.GetCustomerDataFromCsvFile(filePath);
Assert.Equal(30, results.Count);
}
protected async Task DeleteCustomer()
{
await CustomerDataService.DeleteCustomer(Customer.Id);
StatusClass = "alert-success";
Message = "Deleted successfully";
Saved = true;
}
public async Task AddCustomerNoDatabase()
{
var databaseRepoMock = new Mock <IDatabaseRepository>();
databaseRepoMock.Setup(repo => repo.ReadDatabase().Result);
databaseRepoMock.Setup(repo => repo.SaveDatabase(TestDatabaseFilled()));
var customerDataService = new CustomerDataService(databaseRepoMock.Object, _mockLogger.Object);
await Assert.ThrowsAnyAsync <Exception>(async() => await customerDataService.AddCustomer("BadTest"));
}
public CustomerViewModel(CustomerDataService CustomerDataService)
{
_customerDataService = CustomerDataService;
Customers = new BindableCollection <Customers>();
addCustomerCommand = new AddCustomerCommand(this);
deleteCustomerCommand = new DeleteCustomerCommand(this);
EditCustomerCommand = new EditCustomerCommand(this);
CustomerConverter = new CustomerConverter();
Load();
}
public async Task GetCustomerSuccess()
{
var databaseRepoMock = new Mock <IDatabaseRepository>();
databaseRepoMock.Setup(repo => repo.ReadDatabase().Result).Returns(TestDatabaseFilled);
var customerDataService = new CustomerDataService(databaseRepoMock.Object, _mockLogger.Object);
var customer = await customerDataService.GetCustomer(1);
Assert.NotNull(customer);
}
public async Task ListAllCustomersTest()
{
var databaseRepoMock = new Mock <IDatabaseRepository>();
databaseRepoMock.Setup(repo => repo.ReadDatabase().Result).Returns(TestDatabaseFilled);
var customerDataService = new CustomerDataService(databaseRepoMock.Object, _mockLogger.Object);
var customers = await customerDataService.ListAllCustomers();
Assert.NotEmpty(customers);
}
protected override async Task OnInitializedAsync()
{
Saved = false;
Guid.TryParse(CustomerId, out var customerId);
if (customerId != Guid.Empty) //new Customer is being created
{
Customer = await CustomerDataService.GetCustomerDetails(customerId);
}
}
public ActionResult EditCustomer(CustomerViewModel customer)
{
var customerDataService = new CustomerDataService();
var result = customerDataService.UpdateCustomer(customer);
return(new JsonResult()
{
Data = customer,
ContentType = "application/json"
});
}
public ActionResult DeleteCustomer(int customerId)
{
var result = new CustomerDataService().DeleteCustomerById(customerId);
return(new JsonResult()
{
Data = result,
ContentType = "application/json",
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
public ActionResult GetCustomer(string customerName)
{
var customers = new CustomerDataService().GetCustomerByNameWithWildCard(customerName);
return(new JsonResult()
{
Data = customers,
ContentType = "application/json",
JsonRequestBehavior = JsonRequestBehavior.AllowGet,
});
}
public void GetCustomerDetailsTest()
{
//arrange
var service = new CustomerDataService(repository);
//act
var customer = service.GetByEmailAsync("*****@*****.**");
//assert
Assert.IsNotNull(customer);
}
public ActionResult GetCustomers()
{
var customers = new CustomerDataService().GetAllCustomers();
return(new JsonResult()
{
Data = customers,
ContentType = "application/json",
JsonRequestBehavior = JsonRequestBehavior.AllowGet,
MaxJsonLength = Int32.MaxValue
});
}
public async Task AddCustomerSuccess()
{
var databaseRepoMock = new Mock <IDatabaseRepository>();
databaseRepoMock.Setup(repo => repo.ReadDatabase().Result).Returns(TestDatabaseFilled);
databaseRepoMock.Setup(repo => repo.SaveDatabase(TestDatabaseFilled()));
var customerDataService = new CustomerDataService(databaseRepoMock.Object, _mockLogger.Object);
var customer = await customerDataService.AddCustomer("Barbara");
Assert.Equal(5, customer.Id);
Assert.Equal("Barbara", customer.Name);
}
public async Task AddCustomerNewList()
{
var databaseRepoMock = new Mock <IDatabaseRepository>();
databaseRepoMock.Setup(repo => repo.ReadDatabase().Result).Returns(_testDatabaseEmpty);
databaseRepoMock.Setup(repo => repo.SaveDatabase(_testDatabaseEmpty));
var customerDataService = new CustomerDataService(databaseRepoMock.Object, _mockLogger.Object);
var customer = await customerDataService.AddCustomer("Barbara");
Assert.Equal(1, customer.Id);
Assert.Equal("Barbara", customer.Name);
}
protected override async Task OnInitializedAsync()
{
if (Guid.TryParse(CustomerId, out SelectedCustomerId))
{
Customer = await CustomerDataService.GetCustomerById(SelectedCustomerId);
SelectedCustomerTypeId = Customer.CustomerTypeId.ToString();
}
var list = await CustomerTypeDataService.GetAllCustomerTypes();
CustomerTypes = new ObservableCollection <CustomerTypeVm>(list);
SelectedCustomerTypeId = CustomerTypes.FirstOrDefault().CustomerTypeId.ToString();
}
public void GetCustomerByQueryStringTests()
{
var normalFilePath = Path.GetFullPath("./TestData/SampleData.csv");
var customerDataService = new CustomerDataService(normalFilePath);
var result = customerDataService.GetCustomerByQueryString(string.Empty, 1, 50, out var total).Count;
Assert.True(result > 30);
Assert.True(total >= result);
var searchStr = "rtabar@hotmail";
result = customerDataService.GetCustomerByQueryString(searchStr, 1, 50, out total).Count;
Assert.True(result == 1);
Assert.True(total == 1);
}
public CustomerObjectCollection GetFilter(string name, string vat)
{
CustomerObjectCollection customers;
try
{
customers = new CustomerDataService().GetFilter(name, vat);
}
catch (System.Exception exception1)
{
System.Exception innerException = exception1;
throw new System.Exception(MethodBase.GetCurrentMethod().Name, innerException);
}
return(customers);
}
protected async Task HandleValidSubmit()
{
CustomerDetailVm.CustomerTypeId = Guid.Parse(SelectedCustomerTypeId);
ApiResponse <CustomerDetailVm> response;
if (SelectedCustomerId == Guid.Empty)
{
response = await CustomerDataService.CreateCustomer(CustomerDetailVm);
}
else
{
response = await CustomerDataService.UpdateCustomer(CustomerDetailVm);
}
HandleResponse(response);
}
protected async Task HandleValidSubmit()
{
if (Customer.Id == Guid.Empty) //new
{
var addedCustomer = await CustomerDataService.AddCustomer(Customer);
if (addedCustomer != Guid.Empty)
{
StatusClass = "alert-success";
Message = "New Customer added successfully.";
Saved = true;
}
else
{
StatusClass = "alert-danger";
Message = "Something went wrong adding the new Customer. Please try again.";
Saved = false;
}
}
}
