public async Task <List <Account> > getCustomerAccount(string id, byte[] error)
{
List <Account> accounts = new List <Account>();
IntPtr AccountPtr;
await Task.Run(() =>
{
int number_fields = Accounting_Wrapper.getCustomerAccount(id, out AccountPtr, error, _ConnectionString);
IntPtr current = AccountPtr;
for (int i = 0; i < number_fields; ++i)
{
Account account = (Account)Marshal.PtrToStructure(current, typeof(Account));
current = (IntPtr)((long)current + Marshal.SizeOf(account));
accounts.Add(account);
}
Marshal.FreeCoTaskMem(AccountPtr);
});
return(accounts);
}
public async Task <List <Out> > reporting(byte[] error)
{
List <Out> outs = new List <Out>();
IntPtr OutPtr;
await Task.Run(() =>
{
int number_fields = Accounting_Wrapper.reporting(out OutPtr, error, _ConnectionString);
IntPtr current = OutPtr;
for (int i = 0; i < number_fields; ++i)
{
Out an_out = (Out)Marshal.PtrToStructure(current, typeof(Out));
current = (IntPtr)((long)current + Marshal.SizeOf(an_out));
outs.Add(an_out);
}
Marshal.FreeCoTaskMem(OutPtr);
});
return(outs);
}
public async Task <List <AOrder> > getCustomerOrders(string id, byte[] error)
{
List <AOrder> orders = new List <AOrder>();
IntPtr OrderPtr;
await Task.Run(() =>
{
int number_fields = Accounting_Wrapper.getCustomerOrders(id, out OrderPtr, error, _ConnectionString);
IntPtr current = OrderPtr;
for (int i = 0; i < number_fields; ++i)
{
AOrder order = (AOrder)Marshal.PtrToStructure(current, typeof(AOrder));
current = (IntPtr)((long)current + Marshal.SizeOf(order));
orders.Add(order);
}
Marshal.FreeCoTaskMem(OrderPtr);
});
return(orders);
}
public async Task <List <AProduct> > getOrderProducts(string id, byte[] error)
{
List <AProduct> products = new List <AProduct>();
IntPtr OrderProductPtr;
await Task.Run(() =>
{
int number_fields = Accounting_Wrapper.getOrderProducts(id, out OrderProductPtr, error, _ConnectionString);
IntPtr current = OrderProductPtr;
for (int i = 0; i < number_fields; ++i)
{
AProduct product = (AProduct)Marshal.PtrToStructure(current, typeof(AProduct));
current = (IntPtr)((long)current + Marshal.SizeOf(product));
products.Add(product);
}
Marshal.FreeCoTaskMem(OrderProductPtr);
});
return(products);
}
public async Task <List <Customer> > getCustomerById(string id, byte[] error)
{
Console.WriteLine("Hereeee");
List <Customer> customers = new List <Customer>();
IntPtr CustomerPtr;
await Task.Run(() =>
{
int number_fields = Accounting_Wrapper.getCustomerById(id, out CustomerPtr, error, _ConnectionString);
IntPtr current = CustomerPtr;
for (int i = 0; i < number_fields; ++i)
{
Customer customer = (Customer)Marshal.PtrToStructure(current, typeof(Customer));
current = (IntPtr)((long)current + Marshal.SizeOf(customer));
customers.Add(customer);
}
Marshal.FreeCoTaskMem(CustomerPtr);
});
return(customers);
}
public async Task <List <ProductSold> > getSoldProduct(byte[] error)
{
List <ProductSold> products = new List <ProductSold>();
IntPtr ProductPtr;
await Task.Run(() =>
{
int number_fields = Accounting_Wrapper.getProfit(out ProductPtr, error, _ConnectionString);
IntPtr current = ProductPtr;
for (int i = 0; i < number_fields; ++i)
{
ProductSold product = (ProductSold)Marshal.PtrToStructure(current, typeof(ProductSold));
current = (IntPtr)((long)current + Marshal.SizeOf(product));
products.Add(product);
}
Marshal.FreeCoTaskMem(ProductPtr);
});
return(products);
}
public async Task <List <Invoice> > getInvoice(byte[] error)
{
List <Invoice> invoices = new List <Invoice>();
IntPtr InvoicePtr;
await Task.Run(() =>
{
int number_fields = Accounting_Wrapper.getInvoice(out InvoicePtr, error, _ConnectionString);
IntPtr current = InvoicePtr;
for (int i = 0; i < number_fields; ++i)
{
Invoice invoice = (Invoice)Marshal.PtrToStructure(current, typeof(Invoice));
current = (IntPtr)((long)current + Marshal.SizeOf(invoice));
invoices.Add(invoice);
}
Marshal.FreeCoTaskMem(InvoicePtr);
});
return(invoices);
}
