protected override void OnViewLoaded()
{
_Cars = new ObservableCollection <Car>();
try
{
WithClient <IInventoryService>(_ServiceFactory.CreateClient <IInventoryService>(), inventoryClient =>
{
Car[] cars = inventoryClient.GetAllCars();
if (cars != null)
{
foreach (Car car in cars)
{
_Cars.Add(car);
}
}
});
}
catch (FaultException ex)
{
if (ErrorOccured != null)
{
ErrorOccured(this, new ErrorMessageEventArgs(ex.Message));
}
}
catch (Exception ex)
{
if (ErrorOccured != null)
{
ErrorOccured(this, new ErrorMessageEventArgs(ex.Message));
}
}
}
private void GetOrders()
{
//if (!string.IsNullOrWhiteSpace(SearchTerm))
//{
IsBusy = true;
IOrderService order_service = service_factory.CreateClient <IOrderService>();
using (order_service)
{
try
{
//Orders = new ObservableCollection<Order>(order_service.FindOrdersByCompany((Company)CurrentCompany, SearchTerm));
var account = SelectedAccount as Account;
if (account != null)
{
Orders = new ObservableCollection <Order>(order_service.GetInvoicableOrdersByAccount(CurrentCompanyKey, account.AccountKey));
MessageToDisplay = Orders.Count.ToString() + " order(s) found";
}
}
catch (Exception ex)
{
MessageToDisplay = ex.Message;
IsBusy = false;
return;
}
}
//}
//else
//{
// MessageToDisplay = "You must enter a search term in order to find an... order?";
//}
IsBusy = false;
}
public async void ValidateAddress(AddressWrapper which_address)
{
IAddressService addr_service = service_factory.CreateClient <IAddressService>();
using (addr_service)
{
try
{
Task <AddressPostal> task = addr_service.GetAddressInfoByPostalAsync(which_address.AddressPostalCode);
await task;
AddressPostal postal_info = task.Result;
if (postal_info != null)
{
which_address.AddressCity = postal_info.CityName;
which_address.AddressState = postal_info.StateCode;
which_address.AddressCounty = postal_info.CountyName;
which_address.AddressCountry = postal_info.CountryName;
}
else
{
event_aggregator.GetEvent <AccountUpdatedEvent>().Publish("Postal code not found");
}
}
catch (Exception ex)
{
event_aggregator.GetEvent <AccountUpdatedEvent>().Publish(ex.Message);
return;
}
}
}
private void GetCompanyOpenOrders()
{
var proxy = service_factory.CreateClient <IOrderService>();
var company = new Company()
{
CompanyKey = CurrentCompanyKey
};
var open_order_col = new ObservableCollection <OrderWrapper>();
using (proxy)
{
//Task<List<Order>> orders = proxy.GetOrdersByCompanyAsync(company);
var orders = proxy.GetOrdersByCompany(company);
//await orders;
foreach (var order in orders)
{
var id = new QIQODate()
{
Date = (DateTime)order.DeliverByDate,
EntityType = "Account",
EntityName = order.Account.AccountName,
BackgroundBrush = Brushes.LightGreen,
DateDescription = $"Due Date\nOrder: {order.OrderNumber}",
DateType = QIQODateType.OrderDeliverByDate,
FontWeight = FontWeights.Bold
};
_working_days.Add(id);
}
}
}
private void GenEmployeeCode()
{
// TODO: add code to go get an employee code that doesn't already exist!
var account_service = service_factory.CreateClient <ICompanyService>();
CurrentEmployee.PersonCode = account_service.GetCompanyNextNumber((Company)CurrentCompany, QIQOEntityNumberType.EmployeeNumber);
account_service.Dispose();
}
private void RemoveAccount(Guid accountid)
{
var accountSvc = _serviceFactory.CreateClient <IAccountService>();
accountSvc.DeleteAccount(accountid);
RefreshViewModelAccounts();
_view.BindForm();
}
public IEnumerable <LookupItem> GetProjectLookupAsync()
{
WithClient <IProjectService>(_serviceFactory.CreateClient <IProjectService>(), projectClient =>
{
_projects = projectClient.GetProjectLookup();
});
return(_projects);
}
private void OnRecalculateCostsForAssemblyCommand(string partId)
{
//ToDo refactor this to accept parameter as int
int intPartId = Int32.Parse(partId);
WithClient(_serviceFactory.CreateClient <IPartService>(), partClient =>
{
partClient.RecalculateCostsForAssembly(intPartId);
});
}
protected override void OnViewLoaded()
{
_Rentals = new ObservableCollection <CustomerRentalData>();
WithClient <IRentalService>(_ServiceFactory.CreateClient <IRentalService>(), rentalClient =>
{
CustomerRentalData[] rentals = rentalClient.GetCurrentRentals();
if (rentals != null)
{
// convert returned data into observable collection so binding can refresh automatically
Rentals.Merge(rentals);
}
});
}
private void OnDeleteCarCommand(Car obj)
{
bool carIsRented = false;
WithClient <IRentalService>(_ServiceFactory.CreateClient <IRentalService>(), rentalClient => {
carIsRented = rentalClient.IsCarCurrentlyRented(obj.CarId);
});
if (!carIsRented)
{
CancelEventArgs args = new CancelEventArgs();
if (ConfirmDelete != null)
{
ConfirmDelete(this, args);
}
if (!args.Cancel)
{
try
{
WithClient <IInventoryService>(_ServiceFactory.CreateClient <IInventoryService>(), inventoryClient =>
{
inventoryClient.DeleteCar(obj.CarId);
_Cars.Remove(obj);
});
}
catch (FaultException e)
{
if (ErrorOccured != null)
{
ErrorOccured(this, new ErrorMessageEventArgs(e.Message));
}
}
catch (Exception e)
{
if (ErrorOccured != null)
{
ErrorOccured(this, new ErrorMessageEventArgs(e.Message));
}
}
}
else
{
if (ErrorOccured != null)
{
ErrorOccured(this, new ErrorMessageEventArgs("Cannot delete this car. It is currently rented."));
}
}
}
}
protected override void OnViewLoaded()
{
_parts = new ObservableCollection <Part>();
WithClient(_serviceFactory.CreateClient <IPartService>(), partClient =>
{
Part[] parts = partClient.GetAllParts();
if (parts != null)
{
foreach (Part part in parts)
{
_parts.Add(part);
}
}
});
}
public void obtain_service_factory_and_proxy_from_container()
{
IServiceFactory factory = ObjectBase.Container.GetExportedValue <IServiceFactory>();
IInventoryService proxy = factory.CreateClient <IInventoryService>();
Assert.IsTrue(proxy is InventoryClient);
}
protected override void OnViewLoaded()
{
_Cars = new ObservableCollection <Car>();
WithClient <IInventoryService>(_ServiceFactory.CreateClient <IInventoryService>(), inventoryClient =>
{
Car[] cars = inventoryClient.GetAllCars();
if (cars != null)
{
foreach (Car car in cars)
{
_Cars.Add(car);
}
}
});
}
private void GetAccounts()
{
if (!string.IsNullOrWhiteSpace(SearchTerm))
{
IsBusy = true;
IsLoading = true;
var account_service = _serviceFactory.CreateClient <IAccountService>();
using (account_service)
{
try
{
Accounts = new ObservableCollection <Client.Entities.Account>(account_service.FindAccountByCompany((Company)CurrentCompany, SearchTerm));
MessageToDisplay = Accounts.Count.ToString() + " account(s) found";
}
catch (Exception ex)
{
MessageToDisplay = ex.Message;
return;
}
}
}
else
{
MessageToDisplay = "You must enter a search term in order to find an account";
}
IsLoading = false;
IsBusy = false;
}
private async void GetCompanyOpenOrders()
{
HeaderMessage = "Open Orders (Loading...)";
IsLoading = true;
var proxy = _serviceFactory.CreateClient <IOrderService>();
var company = new Company()
{
CompanyKey = CurrentCompanyKey
};
using (proxy)
{
var orders = proxy.GetOrdersByCompanyAsync(company);
await orders;
if (orders.Result.Count > 0)
{
foreach (var order in orders.Result)
{
OpenOrders.Add(Map(order));
}
SelectedItem = OpenOrders[0];
SelectedItemIndex = 0;
HeaderMessage = "Open Orders (" + OpenOrders.Count.ToString() + ") X";
}
else
{
HeaderMessage = "Open Orders (0)";
}
}
IsLoading = false;
}
protected override void OnViewLoaded()
{
_orders = new ObservableCollection <Order>();
WithClient(_serviceFactory.CreateClient <IOrderService>(), orderClient =>
{
Order[] orders = orderClient.GetAllOrders();
if (orders != null)
{
foreach (Order order in orders)
{
_orders.Add(order);
}
}
});
}
protected override void OnViewLoaded()
{
_stocks = new ObservableCollection <Part>();
WithClient(_serviceFactory.CreateClient <IPartService>(), stockClient =>
{
Part[] stocks = stockClient.GetAllParts();
if (stocks != null)
{
foreach (Part stock in stocks)
{
_stocks.Add(stock);
}
}
});
}
protected override void OnViewLoaded()
{
_Suppliers = new ObservableCollection <Supplier>();
WithClient(_serviceFactory.CreateClient <ISupplierService>(), supplierClient =>
{
Supplier[] suppliers = supplierClient.GetAllSuppliers();
if (suppliers != null)
{
foreach (Supplier supplier in suppliers)
{
_Suppliers.Add(supplier);
}
}
});
}
public void obtain_service_factory_and_procy_from_container()
{
IServiceFactory factory = ObjectBase.Container.GetExportedValue <IServiceFactory>();
IAuthenticationService proxy = factory.CreateClient <IAuthenticationService>();
Assert.IsTrue(proxy is AuthenticationClient);
}
public void GivenAContainter_WhenITryToGetAFileServiceFactory_IGetTheFileServiceFactory()
{
IServiceFactory factory = this.Resolve <IServiceFactory>();
IFileService proxy = factory.CreateClient <IFileService>();
proxy.Should().BeOfType <FileServiceClient>();
}
/// <summary>
/// Create a new object which will handle all communication to/from a specific client.
/// </summary>
/// <param name="remoteEndPoint">Remote end point</param>
/// <returns>Created client</returns>
protected override INetworkService CreateClient(EndPoint remoteEndPoint)
{
if (remoteEndPoint == null)
{
throw new ArgumentNullException("remoteEndPoint");
}
return(_clientFactory.CreateClient(remoteEndPoint));
}
public void GivenAContainter_WhenITryToGetADocumentProxyFactory_IGetTheDocumentFactory()
{
IServiceFactory factory = this.Resolve <IServiceFactory>();
IDocument proxy = factory.CreateClient <IDocument>();
proxy.Should().BeOfType <DocumentClient>();
}
public List <FeeSchedule> GetFeeSchedules(Product product)
{
var fs_service = _service_factor.CreateClient <IFeeScheduleService>();
using (fs_service)
{
try
{
var fs_list = fs_service.GetFeeSchedulesByProductAsync(product);
return(new List <FeeSchedule>(fs_list.Result));
}
catch
{
return(new List <FeeSchedule>());
}
}
}
public async Task <IActionResult> Get(int order_key)
{
Order ord;
try
{
using (var proxy = _serviceFactory.CreateClient <IOrderService>())
{
ord = await proxy.GetOrderAsync(order_key);
}
var order_vm = _entityService.Map(ord);
foreach (var item in ord.OrderItems)
{
order_vm.OrderItems.Add(_entityService.Map(item));
}
return(Json(order_vm));
}
catch (Exception ex)
{
return(Json(ex));
}
}
protected override void OnViewLoaded()
{
_productTree = new ObservableCollection <HierarchyNode <ProductTree> >();
WithClient(_serviceFactory.CreateClient <IPartService>(), partClient =>
{
_productTree.Add(partClient.GetProductTree());
});
}
protected override void OnViewLoaded()
{
// can check properties for null here if not want to re-get every time view shows
WithClient <IInventoryService>(_ServiceFactory.CreateClient <IInventoryService>(), inventoryClient =>
{
Cars = inventoryClient.GetAllCars();
});
}
public void obtain_service_factory_and_proxy_from_container()
{
using (var container = ObjectBase.Container) {
IServiceFactory factory = container.Resolve <IServiceFactory>();
IInventoryService proxy = factory.CreateClient <IInventoryService>();
Assert.True(proxy is InventoryClient);
}
}
private void DoSave()
{
ExecuteFaultHandledOperation(() =>
{
var product = SelectedProduct as ProductWrapper;
IProductService product_service = service_factory.CreateClient <IProductService>();
IEntityProductService entity_product_service = service_factory.CreateClient <IEntityProductService>();
using (TransactionScope scope = new TransactionScope()) // TransactionScopeAsyncFlowOption.Enabled
{
using (product_service)
{
//*** Make sure the attributes are set before the save happens!!
int ret_val = product_service.CreateProduct(product.Model);
// We need to create a relationship in the entity product table too, or adding new products is a waste of time.
if (product.ProductKey == 0)
{
EntityProduct ent_prod = new EntityProduct()
{
EntityProductEntityKey = CurrentCompanyKey,
EntityProductEntityTypeKey = QIQOEntityType.Company,
ProductKey = ret_val,
EntityProductSeq = 1,
ProductType = product.ProductType,
Comment = string.Format($"New product {product.ProductName} (Key: {ret_val.ToString()}) entry for company {CurrentCompanyName}")
};
using (entity_product_service)
{
int ep_ret = entity_product_service.CreateEntityProduct(ent_prod);
}
product.ProductKey = ret_val;
}
product.AcceptChanges();
//Products.Add(product);
AddNewProductToCache(product);
SelectedProduct = null;
RaisePropertyChanged("Products");
}
scope.Complete();
}
event_aggregator.GetEvent <ProductNewProductCompleteEvent>().Publish(ViewNames.ProductHomeView);
});
}
private void GetCompanyRepLists()
{
var employee_service = service_factory.CreateClient <IEmployeeService>();
using (employee_service)
{
AccountRepList = new ObservableCollection <Representative>(employee_service.GetAccountRepsByCompany(CurrentCompanyKey));
SalesRepList = new ObservableCollection <Representative>(employee_service.GetSalesRepsByCompany(CurrentCompanyKey));
}
}
private void LoadSuppliers()
{
WithClient(_serviceFactory.CreateClient <ISupplierService>(), suppliersClient =>
{
if (suppliersClient == null)
{
return;
}
Supplier[] suppliers = suppliersClient.GetAllSuppliers();
if (suppliers == null)
{
return;
}
_suppliers = new List <Supplier>();
foreach (Supplier supplier in suppliers.OrderBy(p => p.Name))
{
_suppliers.Add(supplier);
}
});
}
