public static async Task<HeadEntity> CreateVendorDoc(CoreDriver coreDriver, DateTime date)
{
HeadEntity headEntity = new HeadEntity(coreDriver,
coreDriver.MdMgmt);
headEntity.setPostingDate(date);
headEntity.SetDocumentType(DocumentType.VENDOR_INVOICE);
headEntity.SetDocText(TestData.TEXT_VENDOR_DOC);
ItemEntity item1 = headEntity.CreateEntity();
MasterDataIdentity_GLAccount rec_account = new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_CASH);
item1.SetVendor(new MasterDataIdentity(TestData.VENDOR_BUS),
rec_account);
item1.SetAmount(CreditDebitIndicator.CREDIT, TestData.AMOUNT_VENDOR);
ItemEntity item2 = headEntity.CreateEntity();
item2.SetGLAccount(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_COST));
item2.SetAmount(CreditDebitIndicator.DEBIT, TestData.AMOUNT_VENDOR);
item2.SetBusinessArea(new MasterDataIdentity(
TestData.BUSINESS_AREA_WORK));
try
{
await headEntity.SaveAsync(true);
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
return headEntity;
}
public static async Task<HeadEntity> CreateGLDoc(CoreDriver coreDriver, DateTime date)
{
HeadEntity headEntity = new HeadEntity(coreDriver,
coreDriver.MdMgmt);
headEntity.setPostingDate(date);
headEntity.SetDocumentType(DocumentType.GL);
headEntity.SetDocText(TestData.TEXT_GL_DOC);
ItemEntity item1 = headEntity.CreateEntity();
item1.SetGLAccount(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_BANK));
item1.SetAmount(CreditDebitIndicator.CREDIT, TestData.AMOUNT_GL);
ItemEntity item2 = headEntity.CreateEntity();
item2.SetGLAccount(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_CASH));
item2.SetAmount(CreditDebitIndicator.DEBIT, TestData.AMOUNT_GL);
try
{
await headEntity.SaveAsync(true);
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
return headEntity;
}
public async Task Initialize()
{
_coreDriver = new CoreDriver();
await StoragePreparation.EstablishFolder_2012_07(
TestFolderPath.CREATING_TRANSDATA_WITH_TEMPLATE
, _coreDriver);
}
public async Task Initialize()
{
_coreDriver = new CoreDriver();
await StoragePreparation.EstablishFolder_2012_07(
TestFolderPath.CREATING_MASTERDATA_PATH
, _coreDriver);
}
/// <summary>
/// constructor
/// </summary>
private DataCore()
{
_monthAdapter = new MonthAdapter(this);
_reportAdatper = new ReportTypesAdapter(this);
_costAdapter = new CostReportsAdapter(this);
_coreDriver = new CoreDriver();
}
public async Task Initialize()
{
StorageFolder folder = await StoragePreparation.CreateRootFolder(
TestFolderPath.LOADING_EMPTY_DATA_PATH);
_coreDriver = new CoreDriver();
_coreDriver.RootFolder = folder;
await _coreDriver.RestartAsync();
}
public async Task Initialize()
{
StorageFolder folder = await StoragePreparation.PrepareDataForLoadingAsync(
TestFolderPath.LOADING_DATA_PATH);
_coreDriver = new CoreDriver();
_coreDriver.RootFolder = folder;
await _coreDriver.RestartAsync();
}
/// <summary>
/// check transaction data
/// </summary>
/// <param name="coreDriver"></param>
public static void CheckTransactionData(CoreDriver coreDriver)
{
TransactionDataManagement transManagement = coreDriver.TransMgmt;
MonthIdentity[] monthIds = coreDriver.MonthIds;
// Assert.AreEqual(2, monthIds.length);
MonthLedger ledger07 = transManagement.GetLedger(monthIds[0]);
MonthLedger ledger08 = transManagement.GetLedger(monthIds[1]);
CheckLedger2012_07(ledger07.Entities);
CheckLedger2012_08(ledger08.Entities);
}
/// <summary>
/// check core driver
/// </summary>
/// <param name="coreDriver"></param>
private void checkCore(CoreDriver coreDriver)
{
Assert.AreEqual(true, coreDriver.IsInitialize);
MasterDataManagement masterData = coreDriver.MdMgmt;
foreach (MasterDataType type in Enum.GetValues(typeof(MasterDataType)))
{
MasterDataFactoryBase factory = masterData
.GetMasterDataFactory(type);
Assert.AreEqual(0, factory.AllEntities.Count);
}
TransactionDataManagement tranData = coreDriver
.TransMgmt;
Assert.IsTrue(null != tranData);
MonthIdentity[] monthIds = coreDriver.MonthIds;
Assert.AreEqual(1, monthIds.Length);
}
public static void CheckAccountBalance(CoreDriver coreDriver)
{
TransactionDataManagement transMgmt = coreDriver.TransMgmt;
GLAccountBalanceCollection balCol = transMgmt.AccountBalanceCol;
MonthIdentity month07 = new MonthIdentity(2012, 7);
MonthIdentity month08 = new MonthIdentity(2012, 8);
MasterDataIdentity_GLAccount glAccount2 = new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_CASH);
GLAccountBalanceItem balItem = balCol.GetBalanceItem(glAccount2);
CurrencyAmount amount2 = new CurrencyAmount(123.45 - 23.45);
Assert.AreEqual(amount2, balItem.Sum);
Assert.AreEqual(amount2, balItem.GetAmount(month07));
Assert.AreEqual(new CurrencyAmount(), balItem.GetAmount(month08));
Assert.AreEqual(amount2, balCol.GetGroupBalance(GLAccountGroupENUM.CASH));
Assert.AreEqual(amount2,
balCol.GetGroupBalance(GLAccountGroupENUM.CASH, month07, month07));
Assert.AreEqual(new CurrencyAmount(),
balCol.GetGroupBalance(GLAccountGroupENUM.CASH, month08, month08));
// cost
Assert.AreEqual(new CurrencyAmount(123.45),
balCol.GetGroupBalance(GLAccountGroupENUM.COST_PURE));
Assert.AreEqual(new CurrencyAmount(123.45), balCol.GetGroupBalance(
GLAccountGroupENUM.COST_PURE, month07, month07));
Assert.AreEqual(new CurrencyAmount(), balCol.GetGroupBalance(
GLAccountGroupENUM.COST_PURE, month08, month08));
// revenue
Assert.AreEqual(new CurrencyAmount(-543.21),
balCol.GetGroupBalance(GLAccountGroupENUM.SALARY));
Assert.AreEqual(new CurrencyAmount(-543.21),
balCol.GetGroupBalance(GLAccountGroupENUM.SALARY, month07, month07));
Assert.AreEqual(new CurrencyAmount(),
balCol.GetGroupBalance(GLAccountGroupENUM.SALARY, month08, month08));
}
public async static Task CreateTemplate(CoreDriver coreDriver,
EntryTemplatesManagement tempMgmt)
{
// vendor
VendorEntry vendorEntry = new VendorEntry(coreDriver, coreDriver.MdMgmt);
vendorEntry.SetValue(EntryTemplate.AMOUNT, TestData.AMOUNT_VENDOR);
vendorEntry.SetValue(VendorEntry.VENDOR, new MasterDataIdentity(
TestData.VENDOR_BUS));
vendorEntry.SetValue(EntryTemplate.TEXT, TestData.TEXT_VENDOR_DOC);
vendorEntry.SetValue(VendorEntry.REC_ACC,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_CASH));
vendorEntry.SetValue(VendorEntry.GL_ACCOUNT,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_COST));
vendorEntry.SetValue(VendorEntry.BUSINESS_AREA, new MasterDataIdentity(
TestData.BUSINESS_AREA_WORK));
await tempMgmt.SaveAsTemplate(vendorEntry, TestData.TEXT_VENDOR_DOC);
// GL
GLAccountEntry glEntry = new GLAccountEntry(coreDriver, coreDriver.MdMgmt);
glEntry.SetValue(EntryTemplate.TEXT, TestData.TEXT_GL_DOC);
glEntry.SetValue(GLAccountEntry.SRC_ACCOUNT,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_BANK));
glEntry.SetValue(GLAccountEntry.DST_ACCOUNT,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_CASH));
await tempMgmt.SaveAsTemplate(glEntry, TestData.TEXT_GL_DOC);
// customer
CustomerEntry customerEntry = new CustomerEntry(coreDriver, coreDriver.MdMgmt);
customerEntry.SetValue(EntryTemplate.TEXT, TestData.TEXT_CUSTOMER_DOC);
customerEntry.SetValue(CustomerEntry.CUSTOMER, new MasterDataIdentity(
TestData.CUSTOMER1));
customerEntry.SetValue(CustomerEntry.REC_ACC,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_BANK));
customerEntry.SetValue(CustomerEntry.GL_ACCOUNT,
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_REV));
await tempMgmt.SaveAsTemplate(customerEntry, TestData.TEXT_CUSTOMER_DOC);
}
public static void CreateMasterData(CoreDriver coreDriver)
{
///
/// check the factory is initialized, and the factory with no master data
///
MasterDataManagement masterDataManagement = coreDriver.MdMgmt;
// vendor
VendorMasterDataFactory vendorFactory = (VendorMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.VENDOR);
Assert.AreEqual(0, vendorFactory.MasterDataCount);
// customer
CustomerMasterDataFactory customerFactory = (CustomerMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.CUSTOMER);
Assert.AreEqual(0, customerFactory.MasterDataCount);
// business area
BusinessAreaMasterDataFactory businessFactory = (BusinessAreaMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.BUSINESS_AREA);
Assert.AreEqual(0, businessFactory.MasterDataCount);
// bank key
BankKeyMasterDataFactory bankKeyFactory = (BankKeyMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.BANK_KEY);
Assert.AreEqual(0, bankKeyFactory.MasterDataCount);
// bank account
BankAccountMasterDataFactory bankAccountFactory = (BankAccountMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.BANK_ACCOUNT);
Assert.AreEqual(0, bankAccountFactory.MasterDataCount);
// GL account
GLAccountMasterDataFactory accountFactory = (GLAccountMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.GL_ACCOUNT);
Assert.AreEqual(0, accountFactory.MasterDataCount);
/** add master data entities */
// vendor
VendorMasterData vendor = (VendorMasterData)vendorFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.VENDOR_BUS), TestData.VENDOR_BUS_DESCP);
Assert.IsTrue(vendor != null);
vendor = (VendorMasterData)vendorFactory.CreateNewMasterDataBase(
new MasterDataIdentity(TestData.VENDOR_SUBWAY),
TestData.VENDOR_SUBWAY_DESCP);
Assert.IsTrue(vendor != null);
// duplicate id
try
{
vendorFactory.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.VENDOR_SUBWAY), TestData.VENDOR_SUBWAY_DESCP);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
// customer
CustomerMasterData customer = (CustomerMasterData)customerFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.CUSTOMER1), TestData.CUSTOMER1_DESCP);
Assert.IsTrue(customer != null);
customer = (CustomerMasterData)customerFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.CUSTOMER2), TestData.CUSTOMER2_DESCP);
Assert.IsTrue(customer != null);
// duplicate id
try
{
customerFactory.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.CUSTOMER2), TestData.CUSTOMER2_DESCP);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
// bank key
BankKeyMasterData bankKey = (BankKeyMasterData)bankKeyFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BANK_KEY), TestData.BANK_KEY_DESCP);
Assert.IsTrue(bankKey != null);
// duplicate id
try
{
bankKeyFactory.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BANK_KEY), TestData.BANK_KEY_DESCP);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
// bank account
MasterDataIdentity bankKeyId = new MasterDataIdentity(TestData.BANK_KEY);
BankAccountNumber accountNum = new BankAccountNumber(
TestData.BANK_ACCOUNT_CMB_6235_ACC);
BankAccountMasterData bankAcc = (BankAccountMasterData)bankAccountFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BANK_ACCOUNT_CMB_6235),
TestData.BANK_ACCOUNT_CMB_6235_DESCP, accountNum,
bankKeyId, BankAccountType.SAVING_ACCOUNT);
Assert.IsTrue(bankAcc != null);
accountNum = new BankAccountNumber(TestData.BANK_ACCOUNT_CMB_6620_ACC);
bankAcc = (BankAccountMasterData)bankAccountFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BANK_ACCOUNT_CMB_6620),
TestData.BANK_ACCOUNT_CMB_6620_DESCP, accountNum,
bankKeyId, BankAccountType.CREDIT_CARD);
Assert.IsTrue(bankAcc != null);
// duplicate id
try
{
bankAccountFactory.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BANK_ACCOUNT_CMB_6620),
TestData.BANK_ACCOUNT_CMB_6620_DESCP, accountNum, bankKey,
BankAccountType.SAVING_ACCOUNT);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
// business area
BusinessAreaMasterData businessArea = (BusinessAreaMasterData)businessFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BUSINESS_AREA_ENTERTAIN),
TestData.BUSINESS_AREA_ENTERTAIN_DESCP,
CriticalLevel.MEDIUM);
Assert.IsTrue(businessArea != null);
businessArea = (BusinessAreaMasterData)businessFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BUSINESS_AREA_WORK),
TestData.BUSINESS_AREA_WORK_DESCP, CriticalLevel.HIGH);
Assert.IsTrue(businessArea != null);
businessArea = (BusinessAreaMasterData)businessFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BUSINESS_AREA_SNACKS),
TestData.BUSINESS_AREA_SNACKS_DESCP, CriticalLevel.LOW);
Assert.IsTrue(businessArea != null);
// duplicate id
try
{
businessArea = (BusinessAreaMasterData)businessFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BUSINESS_AREA_SNACKS),
TestData.BUSINESS_AREA_SNACKS_DESCP,
CriticalLevel.LOW);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
// G/L account
MasterDataIdentity bankAccId = new MasterDataIdentity(
TestData.BANK_ACCOUNT_CMB_6235);
GLAccountMasterData glAccount = (GLAccountMasterData)accountFactory
.CreateNewMasterDataBase(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_BANK),
TestData.GL_ACCOUNT_BANK_DESCP, bankAccId);
Assert.IsTrue(glAccount != null);
glAccount = (GLAccountMasterData)accountFactory
.CreateNewMasterDataBase(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_CASH),
TestData.GL_ACCOUNT_CASH_DESCP);
Assert.IsTrue(glAccount != null);
glAccount.SetInitAmount(TestData.AMOUNT_VENDOR);
glAccount = (GLAccountMasterData)accountFactory
.CreateNewMasterDataBase(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_COST),
TestData.GL_ACCOUNT_COST_DESCP);
Assert.IsTrue(glAccount != null);
glAccount = (GLAccountMasterData)accountFactory
.CreateNewMasterDataBase(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_EQUITY),
TestData.GL_ACCOUNT_EQUITY_DESCP);
Assert.IsTrue(glAccount != null);
glAccount = (GLAccountMasterData)accountFactory
.CreateNewMasterDataBase(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_REV), TestData.GL_ACCOUNT_REV_DESCP);
Assert.IsTrue(glAccount != null);
// duplicate id
try
{
accountFactory.CreateNewMasterDataBase(
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_REV),
TestData.GL_ACCOUNT_REV_DESCP);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
}
public static void CheckMasterData(CoreDriver _coreDriver)
{
Assert.AreEqual(true, _coreDriver.IsInitialize);
MasterDataManagement masterDataManagement = _coreDriver.MdMgmt;
List<MasterDataBase> datas;
// check vendor data
VendorMasterDataFactory vendorFactory = (VendorMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.VENDOR);
Assert.AreEqual(2, vendorFactory.MasterDataCount);
datas = vendorFactory.AllEntities;
Assert.AreEqual(TestData.VENDOR_BUS, datas[0].Identity.ToString());
Assert.AreEqual(TestData.VENDOR_BUS_DESCP, datas[0].Descp);
Assert.AreEqual(TestData.VENDOR_SUBWAY, datas[1].Identity.ToString());
Assert.AreEqual(TestData.VENDOR_SUBWAY_DESCP, datas[1].Descp);
// check customer data
CustomerMasterDataFactory customerFactory = (CustomerMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.CUSTOMER);
Assert.AreEqual(2, customerFactory.MasterDataCount);
datas = customerFactory.AllEntities;
Assert.AreEqual(TestData.CUSTOMER1, datas[0].Identity.ToString());
Assert.AreEqual(TestData.CUSTOMER1_DESCP, datas[0].Descp);
Assert.AreEqual(TestData.CUSTOMER2, datas[1].Identity.ToString());
Assert.AreEqual(TestData.CUSTOMER2_DESCP, datas[1].Descp);
// check business area
BusinessAreaMasterDataFactory businessAreaFactory = (BusinessAreaMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.BUSINESS_AREA);
Assert.AreEqual(3, businessAreaFactory.MasterDataCount);
datas = businessAreaFactory.AllEntities;
Assert.AreEqual(TestData.BUSINESS_AREA_WORK, datas[0].Identity
.ToString());
Assert.AreEqual(TestData.BUSINESS_AREA_WORK_DESCP, datas[0].Descp);
Assert.AreEqual(CriticalLevel.HIGH,
((BusinessAreaMasterData)datas[0]).CriLevel);
Assert.AreEqual(TestData.BUSINESS_AREA_SNACKS, datas[1].Identity
.ToString());
Assert.AreEqual(TestData.BUSINESS_AREA_SNACKS_DESCP, datas[1].Descp);
Assert.AreEqual(CriticalLevel.LOW,
((BusinessAreaMasterData)datas[1]).CriLevel);
Assert.AreEqual(TestData.BUSINESS_AREA_ENTERTAIN, datas[2].Identity
.ToString());
Assert.AreEqual(TestData.BUSINESS_AREA_ENTERTAIN_DESCP,
datas[2].Descp);
Assert.AreEqual(CriticalLevel.MEDIUM,
((BusinessAreaMasterData)datas[2]).CriLevel);
// check bank key
BankKeyMasterDataFactory bankKeyFactory = (BankKeyMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.BANK_KEY);
Assert.AreEqual(1, bankKeyFactory.MasterDataCount);
datas = bankKeyFactory.AllEntities;
Assert.AreEqual(TestData.BANK_KEY, datas[0].Identity.ToString());
Assert.AreEqual(TestData.BANK_KEY_DESCP, datas[0].Descp);
// check bank account
BankAccountMasterDataFactory bankAccountFactory = (BankAccountMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.BANK_ACCOUNT);
Assert.AreEqual(2, bankAccountFactory.MasterDataCount);
datas = bankAccountFactory.AllEntities;
Assert.AreEqual(TestData.BANK_ACCOUNT_CMB_6235, datas[0].Identity
.ToString());
Assert.AreEqual(TestData.BANK_ACCOUNT_CMB_6235_DESCP, datas[0].Descp);
Assert.AreEqual(TestData.BANK_ACCOUNT_CMB_6235_ACC,
((BankAccountMasterData)datas[0]).AccountNumber
.ToString());
Assert.AreEqual(BankAccountType.SAVING_ACCOUNT,
((BankAccountMasterData)datas[0]).BankAccType);
Assert.AreEqual(TestData.BANK_ACCOUNT_CMB_6620, datas[1].Identity
.ToString());
Assert.AreEqual(TestData.BANK_ACCOUNT_CMB_6620_DESCP, datas[1].Descp);
Assert.AreEqual(TestData.BANK_ACCOUNT_CMB_6620_ACC,
((BankAccountMasterData)datas[1]).AccountNumber
.ToString());
Assert.AreEqual(BankAccountType.CREDIT_CARD,
((BankAccountMasterData)datas[1]).BankAccType);
// check G/L account
GLAccountMasterDataFactory accountFactory = (GLAccountMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.GL_ACCOUNT);
Assert.AreEqual(5, accountFactory.MasterDataCount);
datas = accountFactory.AllEntities;
Assert.AreEqual(TestData.GL_ACCOUNT_CASH, datas[0].Identity
.ToString());
Assert.AreEqual(TestData.GL_ACCOUNT_CASH_DESCP, datas[0].Descp);
Assert.AreEqual(TestData.AMOUNT_VENDOR, ((GLAccountMasterData)datas[0]).InitAmount);
Assert.AreEqual(TestData.GL_ACCOUNT_BANK, datas[1].Identity
.ToString());
Assert.AreEqual(TestData.GL_ACCOUNT_BANK_DESCP, datas[1].Descp);
Assert.AreEqual(TestData.BANK_ACCOUNT_CMB_6235,
((GLAccountMasterData)datas[1]).BankAccount.ToString());
Assert.AreEqual(new CurrencyAmount(), ((GLAccountMasterData)datas[1]).InitAmount);
Assert.AreEqual(TestData.GL_ACCOUNT_EQUITY, datas[2].Identity
.ToString());
Assert.AreEqual(TestData.GL_ACCOUNT_EQUITY_DESCP, datas[2].Descp);
Assert.AreEqual(new CurrencyAmount(), ((GLAccountMasterData)datas[2]).InitAmount);
Assert.AreEqual(TestData.GL_ACCOUNT_REV, datas[3].Identity
.ToString());
Assert.AreEqual(TestData.GL_ACCOUNT_REV_DESCP, datas[3].Descp);
Assert.AreEqual(new CurrencyAmount(), ((GLAccountMasterData)datas[3]).InitAmount);
Assert.AreEqual(TestData.GL_ACCOUNT_COST, datas[4].Identity
.ToString());
Assert.AreEqual(TestData.GL_ACCOUNT_COST_DESCP, datas[4].Descp);
Assert.AreEqual(new CurrencyAmount(), ((GLAccountMasterData)datas[4]).InitAmount);
}
internal AbstractManagement(CoreDriver coreDriver)
{
_coreDriver = coreDriver;
}
/// <summary>
/// create root folder for creation test in 2012_07
/// </summary>
/// <param name="name"></param>
/// <param name="coreDriver"></param>
/// <returns></returns>
public static async Task EstablishFolder_2012_07(String name
, CoreDriver coreDriver)
{
coreDriver.RootFolder = await CreateRootFolder(name);
await coreDriver.RestartAsync();
MonthIdentity monthId;
monthId = new MonthIdentity(2012, 7);
coreDriver.SetStartMonthId(monthId);
}
internal AbstractManagement(CoreDriver coreDriver)
{
_coreDriver = coreDriver;
}
