public void StockNotActive()
{
var stock = new Stock(Guid.NewGuid());
stock.List("ABC", "ABC Pty Ltd", new Date(2020, 01, 01), false, AssetCategory.AustralianStocks);
var transaction = new OpeningBalance()
{
Id = Guid.NewGuid(),
Date = new Date(2000, 01, 01),
Stock = stock,
Comment = "Test Opening Balance",
Units = 100,
AquisitionDate = new Date(2020, 02, 01),
CostBase = 4500.00m,
};
var mockRepository = new MockRepository(MockBehavior.Strict);
var holding = mockRepository.Create <IHolding>();
var cashAccount = mockRepository.Create <ICashAccount>();
var handler = new OpeningBalanceHandler();
Action a = () => handler.Apply(transaction, holding.Object, cashAccount.Object);
a.Should().Throw <StockNotActiveException>();
mockRepository.Verify();
}
private IEnumerable <IPortfolioTransaction> ResultStockTransactionsWithRollover(IReadOnlyHolding holding, IStockResolver stockResolver)
{
var parcels = holding.Parcels(Date);
foreach (var parcel in parcels)
{
var parcelProperties = parcel.Properties[Date];
// create parcels for resulting stock
foreach (var resultingStock in ResultingStocks)
{
int units = (int)Math.Ceiling(parcelProperties.Units * ((decimal)resultingStock.NewUnits / (decimal)resultingStock.OriginalUnits));
decimal costBase = parcelProperties.CostBase * resultingStock.CostBasePercentage;
var stock = new Stock(Guid.Empty);
var transaction = new OpeningBalance()
{
Id = Guid.NewGuid(),
Date = ImplementationDate,
Stock = stockResolver.GetStock(resultingStock.Stock),
Units = units,
CostBase = costBase,
AquisitionDate = parcel.AquisitionDate,
Comment = Description
};
yield return(transaction);
}
}
}
public void DeserializeOpeningBalance()
{
var serializer = new RestClientSerializer();
var transactionId = Guid.NewGuid();
var stockId = Guid.NewGuid();
var json = "{\"id\":\"" + transactionId + "\","
+ "\"stock\":\"" + stockId + "\","
+ "\"type\":\"openingbalance\","
+ "\"transactionDate\":\"2000-01-10\","
+ "\"comment\":\"comment\","
+ "\"description\":\"description\","
+ "\"units\":100,"
+ "\"costBase\":1450.45,"
+ "\"aquisitionDate\":\"2000-01-01\"}";
var transaction = serializer.Deserialize <Transaction>(json);
var expected = new OpeningBalance()
{
Id = transactionId,
Stock = stockId,
TransactionDate = new Date(2000, 01, 10),
Comment = "comment",
Description = "description",
Units = 100,
CostBase = 1450.45m,
AquisitionDate = new Date(2000, 01, 01)
};
transaction.Should().BeEquivalentTo(expected);
}
public void OpeningBalance()
{
var stock = new Stock(Guid.NewGuid());
stock.List("ABC", "ABC Pty Ltd", new Date(1974, 01, 01), false, AssetCategory.AustralianStocks);
var transaction = new OpeningBalance()
{
Id = Guid.NewGuid(),
Date = new Date(2020, 01, 01),
Stock = stock,
Comment = "Test Opening Balance",
Units = 100,
AquisitionDate = new Date(2020, 02, 01),
CostBase = 4500.00m,
};
var mockRepository = new MockRepository(MockBehavior.Strict);
var holding = mockRepository.Create <IHolding>();
holding.Setup(x => x.AddParcel(new Date(2020, 01, 01), new Date(2020, 02, 01), 100, 4500.00m, 4500.00m, transaction)).Returns(default(IParcel));
var cashAccount = mockRepository.Create <ICashAccount>();
var handler = new OpeningBalanceHandler();
handler.Apply(transaction, holding.Object, cashAccount.Object);
mockRepository.Verify();
}
public void Apply(OpeningBalanceOccurredEvent @event)
{
var holding = _Holdings[@event.Stock];
if (holding == null)
{
var stock = _StockResolver.GetStock(@event.Stock);
holding = _Holdings.Add(stock, @event.Date);
holding.CgtEventOccurred += Holding_CgtEventOccurred;
}
var openingBalance = new OpeningBalance
{
Id = @event.TransactionId,
Date = @event.Date,
Stock = holding.Stock,
Comment = @event.Comment,
AquisitionDate = @event.AquisitionDate,
Units = @event.Units,
CostBase = @event.CostBase
};
var handler = _TransactionHandlers.GetService <OpeningBalance>();
handler.Apply(openingBalance, holding, _CashAccount);
_Transactions.Add(openingBalance);
}
private void BillingStyle_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter)
{
OpeningBalance.Focus();
}
}
public ActionResult Save(OpeningBalance objOpeningBalance)
{
if (ModelState.IsValid)
{
OpeningBalanceBLL objOpeningBalanceBLL = new OpeningBalanceBLL();
objOpeningBalanceBLL.CreateOpeningBalnce(objOpeningBalance);
}
return(Redirect("Save"));
}
protected void btntransfer_Click(object sender, EventArgs e)
{
OpeningBalance ob = new OpeningBalance();
ob.CreatedBy = Session["UserName"].ToString();
ob.Flag = "transfer";
ob.strFY = Convert.ToInt32(strFY.ToString());
ob.Save();
message("Opening Balance Transfered Successfully");
}
internal static OpeningBalance getOpeningBalance(HttpResponseMessage response)
{
var openingBalance = new OpeningBalance();
var jsonObj = JsonConvert.DeserializeObject <Dictionary <string, object> >(response.Content.ReadAsStringAsync().Result);
if (jsonObj.ContainsKey("opening_balance"))
{
openingBalance = JsonConvert.DeserializeObject <OpeningBalance>(jsonObj["opening_balance"].ToString());
}
return(openingBalance);
}
/// <summary>
/// Updates the existing opening balance information.
/// </summary>
/// <param name="update_info">The update_info is the OpeningBalance object which contains the updation information.</param>
/// <returns>OpeningBalance object.</returns>
public OpeningBalance UpdateOpeningBalance(OpeningBalance update_info)
{
var url = baseAddress + "/openingbalances";
var json = JsonConvert.SerializeObject(update_info);
var jsonstring = new Dictionary <object, object>();
jsonstring.Add("JSONString", json);
var response = ZohoHttpClient.put(url, getQueryParameters(jsonstring));
return(SettingsParser.getOpeningBalance(response));
}
protected override void CopyFieldsToTransaction()
{
if (_Transaction == null)
{
_Transaction = new OpeningBalance();
}
base.CopyFieldsToTransaction();
var openingBalance = (OpeningBalance)_Transaction;
openingBalance.TransactionDate = RecordDate;
openingBalance.Units = Units;
openingBalance.CostBase = CostBase;
openingBalance.AquisitionDate = AquisitionDate;
}
public void AddOpeningBalanceNoExistingHoldings()
{
var mockRepository = new MockRepository(MockBehavior.Strict);
var stock = new Stock(Guid.NewGuid());
stock.List("ABC", "ABC Pty Ltd", new Date(1974, 01, 01), false, AssetCategory.AustralianStocks);
var stockResolver = mockRepository.Create <IStockResolver>();
stockResolver.Setup(x => x.GetStock(stock.Id)).Returns(stock);
var handler = mockRepository.Create <ITransactionHandler>();
OpeningBalance transaction = null;
handler.Setup(x => x.Apply(It.IsAny <IPortfolioTransaction>(), It.IsAny <IHolding>(), It.IsAny <ICashAccount>()))
.Callback <IPortfolioTransaction, IHolding, ICashAccount>((t, h, c) => transaction = (OpeningBalance)t)
.Verifiable();
var transactionHandlers = mockRepository.Create <IServiceFactory <ITransactionHandler> >();
transactionHandlers.Setup(x => x.GetService <OpeningBalance>()).Returns(handler.Object);
var portfolio = new Portfolio(Guid.NewGuid(), stockResolver.Object, transactionHandlers.Object);
var transactionId = Guid.NewGuid();
portfolio.AddOpeningBalance(stock.Id, new Date(2000, 01, 01), new Date(1999, 01, 01), 100, 1000.00m, "Comment", transactionId);
using (new AssertionScope())
{
portfolio.Holdings[stock.Id].EffectivePeriod.Should().Be(new DateRange(new Date(2000, 01, 01), Date.MaxValue));
transaction.Should().BeEquivalentTo(new
{
Id = transaction.Id,
Date = new Date(2000, 01, 01),
Stock = stock,
Comment = "Comment",
Units = 100,
CostBase = 1000.00m
});
}
mockRepository.Verify();
}
public int InsertOpeningBalance(JVMasterModel model)
{
int i = 0;
using (EHMSEntities ent = new EHMSEntities())
{
int fyid = Utility.GetCurrentFiscalYearID();
foreach (var item in model.objOpeningBalanceModelViewList)
{
int count = ent.OpeningBalances.Where(x => x.AccountHeadId == item.AccountHeadId && x.FiscalYear >= fyid).Count();
if (count > 0)
{
var OpeningBal = (from x in ent.OpeningBalances
where (x.AccountHeadId == item.AccountHeadId && x.FiscalYear == fyid)
select x);
foreach (OpeningBalance opng in OpeningBal)
{
opng.DrAmount = item.DrAmount;
opng.CrAmount = item.CrAmount;
}
}
else
{
if (item.DrAmount + item.CrAmount != 0)
{
var objOpening = new OpeningBalance()
{
FiscalYear = fyid,
AccountHeadId = item.AccountHeadId,
DrAmount = item.DrAmount,
CrAmount = item.CrAmount,
Status = true
};
ent.OpeningBalances.Add(objOpening);
}
}
i = ent.SaveChanges();
}
return(i);
}
}
public string CreateOpeningBalnce(OpeningBalance objOpeningBalance)
{
int noRowCount = 0;
objDataAccess = DataAccess.NewDataAccess();
objDbCommand = objDataAccess.GetCommand(true, IsolationLevel.Serializable);
objDbCommand.AddInParameter("OpeningBalanceDate", objOpeningBalance.OpeningBalanceDate);
objDbCommand.AddInParameter("AccountType", objOpeningBalance.AccountType);
objDbCommand.AddInParameter("PartyId", objOpeningBalance.PartyId);
objDbCommand.AddInParameter("Ammount", objOpeningBalance.Amount);
objDbCommand.AddInParameter("CreatedBy", SessionUtility.STSessionContainer.UserID);
try
{
noRowCount = objDataAccess.ExecuteNonQuery(objDbCommand, "[dbo].uspCreateOpeningBalnce", CommandType.StoredProcedure);
if (noRowCount > 0)
{
objDbCommand.Transaction.Commit();
return("Save Successfully");
}
else
{
objDbCommand.Transaction.Rollback();
return("Save Failed");
}
}
catch (Exception ex)
{
objDbCommand.Transaction.Rollback();
throw new Exception("Database Error Occured", ex);
}
finally
{
objDataAccess.Dispose(objDbCommand);
}
}
public void ApplyOpeningBalance()
{
var mockRepository = new MockRepository(MockBehavior.Strict);
var portfolio = PortfolioTestCreator.CreateDefaultPortfolio();
var events = new List <Event>();
var repository = mockRepository.Create <IRepository <Portfolio> >();
repository.Setup(x => x.Update(It.IsAny <Portfolio>())).Callback <Portfolio>(x => events.AddRange(x.FetchEvents()));
var service = new PortfolioTransactionService(portfolio, repository.Object);
var transaction = new OpeningBalance()
{
Id = Guid.NewGuid(),
Stock = PortfolioTestCreator.Stock_ARG.Id,
TransactionDate = new Date(2007, 01, 01),
Comment = "",
Units = 50,
CostBase = 0.98m,
AquisitionDate = new Date(2005, 01, 01)
};
var result = service.ApplyTransaction(transaction);
result.Should().HaveOkStatus();
events.Should().BeEquivalentTo(new[]
{
new OpeningBalanceOccurredEvent(portfolio.Id, 1, transaction.Id, new Date(2007, 01, 01), PortfolioTestCreator.Stock_ARG.Id, "")
{
Units = 50,
CostBase = 0.98m,
AquisitionDate = new Date(2005, 01, 01)
}
});
mockRepository.Verify();
}
public void HasBeenAppliedResultStocks()
{
var mockRepository = new MockRepository(MockBehavior.Strict);
var stock = new Stock(Guid.NewGuid());
stock.List("ABC", "ABC Pty Ltd", new Date(1974, 01, 01), false, AssetCategory.AustralianStocks);
var stock2 = new Stock(Guid.NewGuid());
stock2.List("XYZ", "XYZ Pty Ltd", new Date(1974, 01, 01), false, AssetCategory.AustralianStocks);
var resultStocks = new Transformation.ResultingStock[] {
new Transformation.ResultingStock(stock2.Id, 1, 1, 10.00m, new Date(2020, 02, 01))
};
var transformation = new Transformation(Guid.NewGuid(), stock, new Date(2020, 01, 01), "Test Transformation", new Date(2020, 02, 01), 10.00m, true, resultStocks);
var transaction = new OpeningBalance()
{
Id = Guid.NewGuid(),
Date = new Date(2020, 02, 01),
Stock = stock2,
Comment = "Test Opening Balance",
Units = 100,
CostBase = 10.00m
};
var transactions = mockRepository.Create <IPortfolioTransactionList>();
transactions.Setup(x => x.ForHolding(stock2.Id, transformation.ImplementationDate)).Returns(new IPortfolioTransaction[] { transaction });
var result = transformation.HasBeenApplied(transactions.Object);
result.Should().BeTrue();
mockRepository.Verify();
}
private void BuildModelForBuildModelForOpeningBalance(DbDataReader objDataReader, OpeningBalance objOpeningBalance)
{
DataTable objDataTable = objDataReader.GetSchemaTable();
foreach (DataRow dr in objDataTable.Rows)
{
String column = dr.ItemArray[0].ToString();
switch (column)
{
case "OpeningBalanceId":
if (!Convert.IsDBNull(objDataReader["OpeningBalanceId"]))
{
objOpeningBalance.OpeningBalanceId = Convert.ToSByte(objDataReader["OpeningBalanceId"]);
}
break;
case "OpeningBalanceDate":
if (!Convert.IsDBNull(objDataReader["OpeningBalanceDate"]))
{
objOpeningBalance.OpeningBalanceDate = Convert.ToDateTime(objDataReader["OpeningBalanceDate"].ToString());
}
break;
case "AccountType":
if (!Convert.IsDBNull(objDataReader["AccountType"]))
{
objOpeningBalance.AccountType = objDataReader["AccountType"].ToString();
}
break;
case "PartyId":
if (!Convert.IsDBNull(objDataReader["PartyId"]))
{
objOpeningBalance.PartyId = Convert.ToByte(objDataReader["PartyId"]);
}
break;
case "PartyName":
if (!Convert.IsDBNull(objDataReader["PartyName"]))
{
objOpeningBalance.PartyName = objDataReader["PartyName"].ToString();
}
break;
case "Ammount":
if (!Convert.IsDBNull(objDataReader["Ammount"]))
{
objOpeningBalance.Amount = Convert.ToDecimal(objDataReader["Ammount"].ToString());
}
break;
case "Remarks":
if (!Convert.IsDBNull(objDataReader["Remarks"]))
{
objOpeningBalance.Remarks = objDataReader["Remarks"].ToString();
}
break;
default:
break;
}
}
}
public OpeningBalanceViewModel(OpeningBalance openingBalance, RestClient restClient)
: base(openingBalance, "Opening Balance", TransactionStockSelection.Stocks, restClient)
{
}
static void Main(string[] args)
{
try
{
var service = new ZohoBooks();
service.initialize("{authtoken}", "{organization id}");
SettingsApi settingsApi = service.GetSettingsApi();
Console.WriteLine("----------------Preferences-------------");
var preferences = settingsApi.GetPreferences();
var autoreminders = preferences.auto_reminders;
Console.WriteLine("Auto Reminders");
foreach (var autoreminder in autoreminders)
{
Console.WriteLine("sub:{0},body:{1},notification Type:{2}", autoreminder.subject, autoreminder.body, autoreminder.notification_type);
}
var addrFormat = preferences.address_formats;
Console.WriteLine("cust addrformat:{0},Organisation Format:{1}", addrFormat.customer_address_format, addrFormat.organization_address_format);
var updateInfo = new Preferences()
{
convert_to_invoice = false,
notify_me_on_online_payment = true,
is_show_powered_by = true,
is_estimate_enabled = false,
};
var updateMsg = settingsApi.UpdatePreferences(updateInfo);
var newUnit = new Unit()
{
unit = "new unit"
};
var addUnit = settingsApi.CreateUnit(newUnit);
Console.WriteLine(addUnit);
var deleteUnit = settingsApi.DeleteUnit("{Unit id}");
Console.WriteLine(deleteUnit);
Console.WriteLine("----------------------------------------------------\n------------------Tax and TaxGroups-----------------");
var taxeslist = settingsApi.GetTaxes();
var taxes = taxeslist;
var taxId = taxes[0].tax_id;
foreach (var tax in taxes)
{
Console.WriteLine("taxId:{0},name:{1},percentage:{2},Type:{3}", tax.tax_id, tax.tax_name, tax.tax_percentage, tax.tax_type);
}
var tax1 = settingsApi.GetTax(taxId);
Console.WriteLine("taxId:{0},name:{1},percentage:{2},Type:{3}", tax1.tax_id, tax1.tax_name, tax1.tax_percentage, tax1.tax_type);
var newTaxInfo = new Tax()
{
tax_name = "VAT1",
tax_percentage = 5
};
var newTax = settingsApi.CreateTax(newTaxInfo);
Console.WriteLine("taxId:{0},name:{1},percentage:{2},Type:{3}", newTax.tax_id, newTax.tax_name, newTax.tax_percentage, newTax.tax_type);
var updateInfo1 = new Tax()
{
tax_percentage = 6,
tax_type = "compound_tax",
};
var updatedTax = settingsApi.UpdateTax(newTax.tax_id, updateInfo1);
Console.WriteLine("taxId:{0},name:{1},percentage:{2},Type:{3}", updatedTax.tax_id, updatedTax.tax_name, updatedTax.tax_percentage, updatedTax.tax_type);
var deletemsg = settingsApi.DeleteTax(updatedTax.tax_id);
Console.WriteLine(deletemsg);
var taxgroup = settingsApi.GetTaxGroup("71917000000259007");
Console.WriteLine("the tax group {0} contains the taxes", taxgroup.tax_group_name);
var taxes1 = taxgroup.taxes;
foreach (var tax in taxes1)
{
Console.WriteLine("taxId:{0},name:{1},percentage:{2},Type:{3}", tax.tax_id, tax.tax_name, tax.tax_percentage, tax.tax_type);
}
var newTaxGroupInfo = new TaxGroupToCreate()
{
tax_group_name = "purchase",
taxes = taxes[0].tax_id + "," + taxes[2].tax_id,
};
var newTaxGroup = settingsApi.CreateTaxGroup(newTaxGroupInfo);
var taxGroupId = newTaxGroup.tax_group_id;
Console.WriteLine("the tax group {0} contains the taxes of tax percentage{1}", newTaxGroup.tax_group_name, newTaxGroup.tax_group_percentage);
var taxes2 = newTaxGroup.taxes;
foreach (var tax in taxes2)
{
Console.WriteLine("taxId:{0},name:{1},percentage:{2},Type:{3}", tax.tax_id, tax.tax_name, tax.tax_percentage, tax.tax_type);
}
var updateInfo2 = new TaxGroupToCreate()
{
tax_group_name = "purcha",
taxes = taxes[0].tax_id + "," + taxes[2].tax_id,
};
var updateTaxGroup = settingsApi.UpdateTaxGroup(taxGroupId, updateInfo2);
Console.WriteLine("the tax group {0} updated as the taxes of tax percentage{1}", updateTaxGroup.tax_group_name, updateTaxGroup.tax_group_percentage);
var deleteMsg = settingsApi.DeleteTaxGroup(taxGroupId);
Console.WriteLine(deleteMsg);
Console.WriteLine("----------------------------------------------------\n------------------Opening balence-----------------");
var openingbalence = settingsApi.GetOpeningBalance();
Console.WriteLine("The accounts in opening balance {0}", openingbalence.opening_balance_id);
var accounts = openingbalence.accounts;
foreach (var account in accounts)
{
Console.WriteLine("account id:{3},account name:{0},debit/ccredit:{1},amount:{2}", account.account_name, account.debit_or_credit, account.amount, account.account_id);
}
var newOpeningbalanceInfo = new OpeningBalance()
{
date = "2014-05-06",
accounts = new List <Account>()
{
new Account()
{
account_id = "71917000000000379",
debit_or_credit = "credit",
amount = 200,
currency_id = "71917000000000099",
},
}
};
var newOpeningbalance = settingsApi.CreateOpeningBalance(newOpeningbalanceInfo);
Console.WriteLine("The accounts in opening balance {0}", newOpeningbalance.opening_balance_id);
var accounts1 = newOpeningbalance.accounts;
foreach (var account in accounts1)
{
Console.WriteLine("account id:{3},account name:{0},debit/ccredit:{1},amount:{2}", account.account_name, account.debit_or_credit, account.amount, account.account_id);
}
var updateInfo3 = new OpeningBalance()
{
date = "2014-05-06",
accounts = new List <Account>()
{
new Account()
{
account_id = "71917000000000379",
debit_or_credit = "credit",
amount = 400,
currency_id = "71917000000000099",
},
}
};
var updatedOpeningbalance = settingsApi.UpdateOpeningBalance(updateInfo3);
Console.WriteLine("The accounts in opening balance {0}", updatedOpeningbalance.opening_balance_id);
var accounts2 = updatedOpeningbalance.accounts;
foreach (var account in accounts2)
{
Console.WriteLine("account id:{3},account name:{0},debit/ccredit:{1},amount:{2}", account.account_name, account.debit_or_credit, account.amount, account.account_id);
}
var delmsg = settingsApi.DeleteOpeningBalance();
Console.WriteLine(delmsg);
Console.WriteLine("----------------------------------------------------\n------------------Reminders-----------------");
var reminders = settingsApi.GetAutoPaymentReminders();
var autoRemindId = reminders[1].autoreminder_id;
foreach (var reminder in reminders)
{
Console.WriteLine("reminder Id:{0}\n is_enable:{1}\nbody:{2}\n", reminder.autoreminder_id, reminder.is_enabled, reminder.body);
}
var reminderAndPlaceholder = settingsApi.GetAnAutoPaymentReminder(autoRemindId);
var reminder1 = reminderAndPlaceholder.autoreminder;
Console.WriteLine("reminder Id:{0}\n is_enable:{1}\nbody:{2}\n", reminder1.autoreminder_id, reminder1.is_enabled, reminder1.body);
var placeholder = reminderAndPlaceholder.placeholders;
Console.WriteLine("placeholders Invoices are");
var invoices = placeholder.Invoice;
foreach (var invoice in invoices)
{
Console.WriteLine("name:{0},value:{1}", invoice.name, invoice.value);
}
Console.WriteLine("placeholders Customers are");
var customers = placeholder.Customer;
foreach (var customer in customers)
{
Console.WriteLine("name:{0},value:{1}", customer.name, customer.value);
}
Console.WriteLine("placeholders Organizations are are");
var organizations = placeholder.Organization;
foreach (var organization in organizations)
{
Console.WriteLine("name:{0},value:{1}", organization.name, organization.value);
}
var reminderenable = settingsApi.EnableAutoReminder(autoRemindId);
Console.WriteLine(reminderenable);
var reminderdisable = settingsApi.DisableAutoReminder(autoRemindId);
Console.WriteLine(reminderdisable);
var updateInfo4 = new AutoReminder()
{
is_enabled = true,
type = "days_before_due_date",
address_type = "remind_customer_and_cc_me"
};
var updateMsg1 = settingsApi.UpdateAnAutoReminder(autoRemindId, updateInfo4);
Console.WriteLine(updateMsg1);
var parameters = new Dictionary <object, object>();
parameters.Add("type", "open_reminder");
var manualreminders = settingsApi.GetManualReminders(parameters);
var manualRemindId = manualreminders[0].manualreminder_id;
foreach (var manualreminder in manualreminders)
{
Console.WriteLine("reminder Id:{0}\n is_enable:{1}\nbody:{2}\ncc_me:{3}", manualreminder.manualreminder_id, manualreminder.type, manualreminder.body, manualreminder.cc_me);
}
var manualreminder1 = settingsApi.GetManualReminder(manualRemindId);
var reminder2 = manualreminder1.manualreminder;
Console.WriteLine("reminder Id:{0}\n is_enable:{1}\nbody:{2}\ncc_me:{3}", reminder2.manualreminder_id, reminder2.type, reminder2.body, reminder2.cc_me);
var placeholder1 = manualreminder1.placeholders;
Console.WriteLine("placeholders Invoices are");
var invoices1 = placeholder.Invoice;
foreach (var invoice in invoices1)
{
Console.WriteLine("name:{0},value:{1}", invoice.name, invoice.value);
}
Console.WriteLine("placeholders Customers are");
var customers1 = placeholder.Customer;
foreach (var customer in customers1)
{
Console.WriteLine("name:{0},value:{1}", customer.name, customer.value);
}
Console.WriteLine("placeholders Organizations are are");
var organizations1 = placeholder.Organization;
foreach (var organization in organizations1)
{
Console.WriteLine("name:{0},value:{1}", organization.name, organization.value);
}
var updateInfo5 = new ManualReminder()
{
cc_me = true
};
var updatedmsg = settingsApi.UpdateManualReminder(manualRemindId, updateInfo5);
Console.WriteLine(updatedmsg);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.ReadKey();
}
