コード例 #1
0
        /// <summary>
        /// get month identity
        /// </summary>
        /// <param name="startId">start month identity</param>
        /// <param name="endId">end month identity</param>
        /// <returns></returns>
        public List<HeadEntity> getEntities(MonthIdentity startId,
                MonthIdentity endId)
        {
            if (startId == null)
            {
                startId = _coreDriver.StartMonthId;
            }
            if (endId == null)
            {
                endId = _coreDriver.CurCalendarMonthId;
            }
            List<HeadEntity> ret = new List<HeadEntity>();
            foreach (HeadEntity head in _list)
            {
                if (head.MonthID.CompareTo(endId) > 0)
                {
                    break;
                }

                if (head.MonthID.CompareTo(startId) >= 0)
                {
                    ret.Add(head);
                }
            }
            return ret;
        }
コード例 #2
0
        /// <summary>
        /// get month identity
        /// </summary>
        /// <param name="startId">start month identity</param>
        /// <param name="endId">end month identity</param>
        /// <returns></returns>
        public List <HeadEntity> getEntities(MonthIdentity startId,
                                             MonthIdentity endId)
        {
            if (startId == null)
            {
                startId = _coreDriver.StartMonthId;
            }
            if (endId == null)
            {
                endId = _coreDriver.CurCalendarMonthId;
            }
            List <HeadEntity> ret = new List <HeadEntity>();

            foreach (HeadEntity head in _list)
            {
                if (head.MonthID.CompareTo(endId) > 0)
                {
                    break;
                }

                if (head.MonthID.CompareTo(startId) >= 0)
                {
                    ret.Add(head);
                }
            }
            return(ret);
        }
コード例 #3
0
 /// <summary>
 /// Get amount
 /// </summary>
 /// <param name="id"></param>
 /// <returns></returns>
 public CurrencyAmount GetAmount(MonthIdentity id)
 {
     if (_list.ContainsKey(id))
     {
         CurrencyAmount amount;
         _list.TryGetValue(id, out amount);
         return new CurrencyAmount(amount);
     }
     return new CurrencyAmount();
 }
コード例 #4
0
        /// <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);
        }
コード例 #5
0
        /// <summary>
        /// get amount
        /// </summary>
        /// <param name="monthID"></param>
        /// <returns></returns>
        public CurrencyAmount getAmount(MonthIdentity monthID)
        {
            CurrencyAmount sum = new CurrencyAmount();
            CurrencyAmount amount;

            if (_amountList.TryGetValue(monthID, out amount))
            {
                sum.AddTo(amount);
            }

            return(sum);
        }
コード例 #6
0
        /// <summary>
        /// add currency amount
        /// </summary>
        /// <param name="monthId"></param>
        /// <param name="amount"></param>
        internal void addAmount(MonthIdentity monthId, CurrencyAmount amount)
        {
            CurrencyAmount v1;

            if (_amountList.TryGetValue(monthId, out v1))
            {
                v1.AddTo(amount);
                return;
            }
            // put
            _amountList.Add(monthId, amount);
        }
コード例 #7
0
        /// <summary>
        /// Get sum of amount from start month to end month
        /// </summary>
        /// <param name="startId">id of start month</param>
        /// <param name="endId">id of end month</param>
        /// <returns></returns>
        public CurrencyAmount GetSumAmount(MonthIdentity startId,
                MonthIdentity endId)
        {
            CurrencyAmount sum = new CurrencyAmount();
            foreach (var item in _list)
            {
                if (item.Key.CompareTo(startId) >= 0 && item.Key.CompareTo(endId) <= 0)
                {
                    sum.AddTo(item.Value);
                }
            }

            return sum;
        }
コード例 #8
0
        /// <summary>
        /// Add amount 
        /// </summary>
        /// <param name="monthId"></param>
        /// <param name="amount"></param>
        internal void AddAmount(MonthIdentity monthId, CurrencyAmount amount)
        {
            _sum.AddTo(amount);

            if (_list.ContainsKey(monthId))
            {
                CurrencyAmount sum;
                _list.TryGetValue(monthId, out sum);
                sum.AddTo(amount);
            }
            else
            {
                _list.Add(monthId, new CurrencyAmount(amount));
            }
        }
コード例 #9
0
        /// <summary>
        /// set starting month id
        /// </summary>
        /// <param name="monthId"></param>
        /// <returns></returns>
        public bool SetStartMonthId(MonthIdentity monthId)
        {
            // check
            if (this._startMonthId.CompareTo(monthId) <= 0)
            {
                return(false);
            }

            this._startMonthId = monthId;

            // save meta data
            saveMetaData();

            return(true);
        }
コード例 #10
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="monthId"></param>
        /// <returns></returns>
        public ObservableCollection <AbstractAdapterItem> GetItems(MonthIdentity monthId)
        {
            CoreDriver coreDriver = _dataCore.BackendCoreDriver;

            if (coreDriver.IsInitialize == false)
            {
                return(_items);
            }

            if (_curMonthId == null ||
                _curMonthId.Equals(monthId) == false)
            {
                // clear
                _items.Clear();

                // change month
                _curMonthId = monthId;
                GLAccountBalanceCollection balCol = coreDriver.TransMgmt.AccountBalanceCol;
                MasterDataManagement       mdMgmt = coreDriver.MdMgmt;

                // for each cost group
                List <CostReportItem> costList = new List <CostReportItem>();
                foreach (GLAccountGroupENUM group in GLAccountGroup.COST_GROUP)
                {
                    List <MasterDataIdentity_GLAccount> ids = mdMgmt
                                                              .GetGLAccountsBasedGroup(group);
                    // for g/l account in each group
                    foreach (MasterDataIdentity_GLAccount id in ids)
                    {
                        // get master data
                        GLAccountMasterData masterData = (GLAccountMasterData)mdMgmt
                                                         .GetMasterData(id, MasterDataType.GL_ACCOUNT);
                        // get balance item
                        GLAccountBalanceItem item = balCol.GetBalanceItem(id);
                        costList.Add(new CostReportItem(id, masterData.Descp
                                                        , item.GetAmount(_curMonthId), this));
                    }
                }
                // sort
                costList.Sort();
                foreach (CostReportItem costItem in costList)
                {
                    _items.Add(costItem);
                }
            }

            return(_items);
        }
コード例 #11
0
        /// <summary>
        /// get amount
        /// </summary>
        /// <param name="startId">start month identity</param>
        /// <param name="endId">end month identity</param>
        /// <returns></returns>
        public CurrencyAmount getAmount(MonthIdentity startId, MonthIdentity endId)
        {
            CurrencyAmount    amount = new CurrencyAmount();
            List <HeadEntity> docs   = this.getEntities(startId, endId);

            foreach (HeadEntity head in docs)
            {
                List <ItemEntity> items = head.Items;
                foreach (ItemEntity item in items)
                {
                    amount.AddTo(getAmountFromItem(item));
                }
            }

            return(amount);
        }
コード例 #12
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="monthId"></param>
        /// <returns></returns>
        public ObservableCollection<AbstractAdapterItem> GetItems(MonthIdentity monthId)
        {
            CoreDriver coreDriver = _dataCore.BackendCoreDriver;
            if (coreDriver.IsInitialize == false)
            {
                return _items;
            }

            if (_curMonthId == null
                || _curMonthId.Equals(monthId) == false)
            {
                // clear
                _items.Clear();

                // change month
                _curMonthId = monthId;
                GLAccountBalanceCollection balCol = coreDriver.TransMgmt.AccountBalanceCol;
                MasterDataManagement mdMgmt = coreDriver.MdMgmt;

                // for each cost group
                List<CostReportItem> costList = new List<CostReportItem>();
                foreach (GLAccountGroupENUM group in GLAccountGroup.COST_GROUP)
                {
                    List<MasterDataIdentity_GLAccount> ids = mdMgmt
                            .GetGLAccountsBasedGroup(group);
                    // for g/l account in each group
                    foreach (MasterDataIdentity_GLAccount id in ids)
                    {
                        // get master data
                        GLAccountMasterData masterData = (GLAccountMasterData)mdMgmt
                                .GetMasterData(id, MasterDataType.GL_ACCOUNT);
                        // get balance item
                        GLAccountBalanceItem item = balCol.GetBalanceItem(id);
                        costList.Add(new CostReportItem(id, masterData.Descp
                            , item.GetAmount(_curMonthId), this));
                    }
                }
                // sort 
                costList.Sort();
                foreach(CostReportItem costItem in costList)
                {
                    _items.Add(costItem);
                }                
            }

            return _items;
        }
コード例 #13
0
        /// <summary>
        /// check customer document
        /// </summary>
        /// <param name="customerDoc"></param>
        private static void checkCustomerDoc(HeadEntity customerDoc)
        {
            // check document number
            Assert.AreEqual(TestData.DOC_NUM2, customerDoc.DocNumber
                            .ToString());
            // check posting date
            Assert.AreEqual(TestData.DATE_2012_07, customerDoc.PstDate.ToString(
                                MasterDataUtils.DATE_FORMAT));
            MonthIdentity monthId = customerDoc.MonthID;

            Assert.AreEqual(TestData.YEAR, monthId.FiscalYear);
            Assert.AreEqual(TestData.MONTH_07, monthId.FiscalMonth);
            // check document type
            Assert.AreEqual(DocumentType.CUSTOMER_INVOICE,
                            customerDoc.DocType);
            // check text
            Assert.AreEqual(TestData.TEXT_CUSTOMER_DOC, customerDoc.DocText);
            // check is reversed
            Assert.AreEqual(false, customerDoc.IsReversed);

            Assert.AreEqual(2, customerDoc.ItemCount);
            List <ItemEntity> items = customerDoc.Items;

            // check revenue item
            Assert.AreEqual(0, items[0].LineNum);
            Assert.AreEqual(AccountType.GL_ACCOUNT, items[0].AccType);
            Assert.AreEqual(CreditDebitIndicator.CREDIT, items[0].CdIndicator);
            Assert.AreEqual(TestData.AMOUNT_CUSTOMER, items[0].Amount);
            Assert.AreEqual(null, items[0].Customer);
            Assert.AreEqual(null, items[0].Vendor);
            Assert.AreEqual(TestData.GL_ACCOUNT_REV, items[0].GLAccount
                            .ToString());
            Assert.AreEqual(null, items[0].BusinessArea);

            // check customer item
            Assert.AreEqual(1, items[1].LineNum);
            Assert.AreEqual(AccountType.CUSTOMER, items[1].AccType);
            Assert.AreEqual(CreditDebitIndicator.DEBIT, items[1].CdIndicator);
            Assert.AreEqual(TestData.AMOUNT_CUSTOMER, items[1].Amount);
            Assert.AreEqual(TestData.CUSTOMER1, items[1].Customer.ToString());
            Assert.AreEqual(null, items[1].Vendor);
            Assert.AreEqual(TestData.GL_ACCOUNT_BANK, items[1].GLAccount
                            .ToString());
            Assert.AreEqual(null, items[1].BusinessArea);
        }
コード例 #14
0
        /// <summary>
        /// check vendor document
        /// </summary>
        /// <param name="vendorDoc"></param>
        private static void checkVendorDoc(HeadEntity vendorDoc)
        {
            // check document number
            Assert.AreEqual(TestData.DOC_NUM1, vendorDoc.DocNumber
                            .ToString());
            // check posting date
            Assert.AreEqual(TestData.DATE_2012_07, vendorDoc.PstDate.ToString(MasterDataUtils.DATE_FORMAT));
            MonthIdentity monthId = vendorDoc.MonthID;

            Assert.AreEqual(TestData.YEAR, monthId.FiscalYear);
            Assert.AreEqual(TestData.MONTH_07, monthId.FiscalMonth);
            // check document type
            Assert.AreEqual(DocumentType.VENDOR_INVOICE, vendorDoc.DocType);
            // check text
            Assert.AreEqual(TestData.TEXT_VENDOR_DOC, vendorDoc.DocText);
            // check is reversed
            Assert.AreEqual(false, vendorDoc.IsReversed);

            Assert.AreEqual(2, vendorDoc.ItemCount);
            List <ItemEntity> items = vendorDoc.Items;

            // check the vendor item
            Assert.AreEqual(0, items[0].LineNum);
            Assert.AreEqual(AccountType.VENDOR, items[0].AccType);
            Assert.AreEqual(CreditDebitIndicator.CREDIT, items[0].CdIndicator);
            Assert.AreEqual(TestData.AMOUNT_VENDOR, items[0].Amount);
            Assert.AreEqual(null, items[0].Customer);
            Assert.AreEqual(TestData.VENDOR_BUS, items[0].Vendor.ToString());
            Assert.AreEqual(TestData.GL_ACCOUNT_CASH, items[0].GLAccount
                            .ToString());
            Assert.AreEqual(null, items[0].BusinessArea);

            // check cost item
            Assert.AreEqual(1, items[1].LineNum);
            Assert.AreEqual(AccountType.GL_ACCOUNT, items[1].AccType);
            Assert.AreEqual(CreditDebitIndicator.DEBIT, items[1].CdIndicator);
            Assert.AreEqual(TestData.AMOUNT_VENDOR, items[1].Amount);
            Assert.AreEqual(null, items[1].Customer);
            Assert.AreEqual(null, items[1].Vendor);
            Assert.AreEqual(TestData.GL_ACCOUNT_COST, items[1].GLAccount
                            .ToString());
            Assert.AreEqual(TestData.BUSINESS_AREA_WORK, items[1].BusinessArea
                            .ToString());
        }
コード例 #15
0
        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));
        }
コード例 #16
0
        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));
        }
コード例 #17
0
        /// <summary>
        /// establish folder
        /// </summary>
        private async Task establishFolderAsync()
        {
            // set meta data
            int year  = DateTime.Today.Year;
            int month = DateTime.Today.Month;

            // set starting month identity
            try
            {
                _startMonthId = new MonthIdentity(year, month);
                // _curMonthId = new MonthIdentity(year, month);
            }
            catch (FiscalYearRangeException e)
            {
                this.logDebugInfo(this.GetType(), 300, e.ToString(),
                                  MessageType.ERRO);
                throw new SystemException(e);// bug
            }
            catch (FiscalMonthRangeException e)
            {
                this.logDebugInfo(this.GetType(), 302, e.ToString(),
                                  MessageType.ERRO);
                throw new SystemException(e);// bug
            }

            await saveMetaDataAsync();

            foreach (var item in _managements)
            {
                if (item.Value.NeedEstablishFile)
                {
                    await item.Value.EstablishFilesAsync();
                }
            }
            _isInitialized = true;
        }
コード例 #18
0
        public CoreDriver()
        {
            _infos = new List <DebugInformation>();

            _listenerManagement = new ListenersManagement();
            // _listenerManagement.addCloseLedgerListener(_closeLedgerListener);

            // managements
            _managements = new Dictionary <String, AbstractManagement>();

            MasterDataManagement mdMgmt = new MasterDataManagement(this);

            _managements.Add(MASTERDATA, mdMgmt);


            _managements.Add(TRANDATA, new TransactionDataManagement(this, mdMgmt));
            _managements.Add(REPORTDATA, new ReportsManagement(this, mdMgmt));
            _managements.Add(TEMPLATE, new EntryTemplatesManagement(this, mdMgmt));

            _startMonthId = null;

            _isInitialized = false;
            _language      = Language.SimpleChinese;
        }
コード例 #19
0
        /// <summary>
        /// Get Ledger
        /// </summary>
        /// <param name="monthId"></param>
        /// <returns></returns>
        public MonthLedger GetLedger(MonthIdentity monthId)
        {
            // get current calendar month
            MonthIdentity curMonthId = _coreDriver.CurCalendarMonthId;

            // check whether ledger beyond the range
            if (_coreDriver.StartMonthId.CompareTo(monthId) > 0
                    || curMonthId.CompareTo(monthId) < 0)
            {
                return null;
            }

            // create new month ledger
            MonthLedger monthLedger;
            if (!_list.TryGetValue(monthId, out monthLedger))
            {
                monthLedger = new MonthLedger(monthId);
                _list.Add(monthId, monthLedger);
            }

            return monthLedger;
        }
コード例 #20
0
 /// <summary>
 /// add currency amount
 /// </summary>
 /// <param name="monthId"></param>
 /// <param name="amount"></param>
 internal void addAmount(MonthIdentity monthId, CurrencyAmount amount)
 {
     CurrencyAmount v1;
     if (_amountList.TryGetValue(monthId, out v1))
     {
         v1.AddTo(amount);
         return;
     }
     // put
     _amountList.Add(monthId, amount);
 }
コード例 #21
0
        /// <summary>
        /// get amount
        /// </summary>
        /// <param name="monthID"></param>
        /// <returns></returns>
        public CurrencyAmount getAmount(MonthIdentity monthID)
        {
            CurrencyAmount sum = new CurrencyAmount();
            CurrencyAmount amount;
            if (_amountList.TryGetValue(monthID, out amount))
            {
                sum.AddTo(amount);
            }

            return sum;
        }
コード例 #22
0
 /// <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);
 }
コード例 #23
0
 public MonthItem(MonthIdentity monthId, MonthAdapter parent)
     : base(monthId, String.Empty, parent)
 {
 }
コード例 #24
0
        /// <summary>
        /// load meta data
        /// </summary>
        /// <exception cref="MetaDataFormatException">Format exception of the meta-data file</exception>
        private async Task loadMetaDataAsync()
        {
            StorageFile mdFile = await _rootFolder.GetFileAsync(META_DATA);

            if (mdFile == null)
            {
                return;
            }

            try
            {
                IList <string> lines = await FileIO.ReadLinesAsync(mdFile);

                int startYear     = 0;
                int startMonth    = 0;
                int versionNumber = 0;
                foreach (string line in lines)
                {
                    String[] values = line.Split('=');
                    if (values.Length != 2)
                    {
                        throw new MetaDataFormatException("Meta data format error.");
                    }

                    if (values[0].Equals(START_MONTH_TAG))
                    {
                        startMonth = Int32.Parse(values[1]);
                    }
                    else if (values[0].Equals(START_YEAR_TAG))
                    {
                        startYear = Int32.Parse(values[1]);
                    }
                    else if (values[0].Equals(VERSION))
                    {
                        versionNumber = Int32.Parse(values[1]);
                    }
                }

                _startMonthId = new MonthIdentity(startYear, startMonth);
                // _curMonthId = new MonthIdentity(curYear, curMonth);
                // check version
                bool ret = this.versionCheck(versionNumber);
                if (ret == false)
                {
                    throw new MetaDataFormatException("Version Error");
                }
            }
            catch (ArgumentNullException e)
            {
                throw new MetaDataFormatException(e.Message);
            }
            catch (FormatException e)
            {
                throw new MetaDataFormatException(e.Message);
            }
            catch (OverflowException e)
            {
                throw new MetaDataFormatException(e.Message);
            }
            finally
            {
            }
        }
コード例 #25
0
 /// <summary>
 /// constructor
 /// </summary>
 /// <param name="docNum"></param>
 /// <param name="monthIdentity"></param>
 public DocumentIdentity(DocumentNumber docNum, MonthIdentity monthIdentity)
 {
     _docNumber = docNum;
     _monthIdentity = monthIdentity;
 }
コード例 #26
0
        /// <summary>
        /// load month identity
        /// </summary>
        /// <param name="monthId"></param>
        /// <returns></returns>
        /// <exception cref="TransactionDataFileFormatException"></exception>
        public async Task<MonthLedger> Load(MonthIdentity monthId)
        {
            // construct month ledger
            MonthLedger monthledger = new MonthLedger(monthId);
            _list.Add(monthId, monthledger);

            _coreDriver.logDebugInfo(
                    this.GetType(),
                    102,
                    String.Format("Loading transaction data {0} ...",
                            monthId.ToString()), MessageType.INFO);

            // get file path
            StorageFile file = await generateFilePath(monthId, false);
            if (file == null)
            {// empty
                return monthledger;
            }
            _coreDriver.logDebugInfo(this.GetType(), 109,
                    String.Format("Transaction data file: {0} .", file.Path),
                    MessageType.INFO);
            try
            {
                string text = await FileIO.ReadTextAsync(file);
                XDocument xdoc = XDocument.Parse(text);

                XElement rootElem = xdoc.Element(TransDataUtils.XML_ROOT);
                // no root element
                if (rootElem == null)
                {
                    throw new TransactionDataFileFormatException(file.Path);
                }

                // -------------------------------------------------------------------
                // parse all the documents
                foreach (XElement elem in rootElem.Elements(TransDataUtils.XML_DOCUMENT))
                {
                    HeadEntity head = HeadEntity.Parse(_coreDriver,
                            _masterDataMgmt, elem);
                    _coreDriver
                            .logDebugInfo(
                                    this.GetType(),
                                    172,
                                    String.Format(
                                            "Document {0} add to list during loading.",
                                            head.DocIdentity
                                                    .ToString()),
                                    MessageType.INFO);
                    monthledger.Add(head);

                    // raise load document
                    _coreDriver.ListenerMgmt.LoadDoc(this, head);

                    // raise reverse document
                    if (head.IsReversed)
                        _coreDriver.ListenerMgmt.ReverseDoc(head);
                }
                // -----------------------------------------------------------------

                return monthledger;
            }
            catch (TransactionDataFileFormatException e)
            {
                _coreDriver.logDebugInfo(this.GetType(), 170, e.Message,
                        MessageType.ERRO);
                throw new TransactionDataFileFormatException(file.Path);
            }

        }
コード例 #27
0
        public CoreDriver()
        {
            _infos = new List<DebugInformation>();

            _listenerManagement = new ListenersManagement();
            // _listenerManagement.addCloseLedgerListener(_closeLedgerListener);

            // managements
            _managements = new Dictionary<String, AbstractManagement>();

            MasterDataManagement mdMgmt = new MasterDataManagement(this);
            _managements.Add(MASTERDATA, mdMgmt);


            _managements.Add(TRANDATA, new TransactionDataManagement(this, mdMgmt));
            _managements.Add(REPORTDATA, new ReportsManagement(this, mdMgmt));
            _managements.Add(TEMPLATE, new EntryTemplatesManagement(this, mdMgmt));

            _startMonthId = null;

            _isInitialized = false;
            _language = Language.SimpleChinese;
        }
コード例 #28
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="docNum"></param>
 /// <param name="fiscalYear"></param>
 /// <param name="fiscalMonth"></param>
 /// <exception cref="FiscalYearRangeException"></exception>
 /// <exception cref="FiscalMonthRangeException"></exception>
 public DocumentIdentity(DocumentNumber docNum, int fiscalYear,
         int fiscalMonth)
 {
     _docNumber = docNum;
     _monthIdentity = new MonthIdentity(fiscalYear, fiscalMonth);
 }
コード例 #29
0
 /// <summary>
 /// store month identity
 /// </summary>
 /// <param name="monthId"></param>
 public async void Store(MonthIdentity monthId)
 {
     await StoreAsync(monthId);
 }
コード例 #30
0
        /// <summary>
        /// get ledger
        /// </summary>
        /// <param name="fiscalYear"></param>
        /// <param name="fiscalMonth"></param>
        /// <returns></returns>
        public MonthLedger GetLedger(int fiscalYear, int fiscalMonth)
        {
            MonthIdentity monthId;
            try
            {
                monthId = new MonthIdentity(fiscalYear, fiscalMonth);
            }
            catch (FiscalYearRangeException)
            {
                return null;
            }
            catch (FiscalMonthRangeException)
            {
                return null;
            }

            return GetLedger(monthId);
        }
コード例 #31
0
 /// <summary>
 /// get file 
 /// </summary>
 /// <param name="monthId"></param>
 /// <returns></returns>
 /// <exception cref="SystemException"></exception>
 private async Task<StorageFile> generateFilePath(MonthIdentity monthId, bool createIfNotExist)
 {
     StorageFolder transactionFolder = await _coreDriver.RootFolder
         .GetFolderAsync(TRANSACTION_DATA_FOLDER);
     if (transactionFolder == null)
     {
         throw new SystemException(null); // bug
     }
     String fileName = String.Format("{0}.xml", monthId.ToString());
     
     if (createIfNotExist == false)
     {
         try
         {
             StorageFile file = await transactionFolder.GetFileAsync(fileName);
             return file;
         }
         catch (FileNotFoundException)
         {
             return null;
         }
     }
     else
     {
         StorageFile file = await transactionFolder.CreateFileAsync(fileName
                 , CreationCollisionOption.OpenIfExists);
         return file;
     }
 }
コード例 #32
0
        /// <summary>
        /// Get group balance from start month to end month
        /// </summary>
        /// <param name="accountGroup"></param>
        /// <param name="startMonthId"></param>
        /// <param name="endMonthId"></param>
        /// <returns></returns>
        /// <exception cref="SystemException"></exception>
        public CurrencyAmount GetGroupBalance(GLAccountGroupENUM accountGroup,
            MonthIdentity startMonthId, MonthIdentity endMonthId)
        {
            CurrencyAmount ret = new CurrencyAmount();
            MasterDataManagement mdMgmt = this._mdMgmt;
            foreach (var item in _items)
            {
                GLAccountMasterData glAccount;
                try
                {
                    glAccount = (GLAccountMasterData)mdMgmt
                           .GetMasterData(item.Key, MasterDataType.GL_ACCOUNT);
                }
                catch (Exception e)
                {
                    _coreDriver.logDebugInfo(this.GetType(), 183, e.Message, MessageType.ERRO);
                    throw new SystemException(e);
                }
                if (glAccount.Group.Identity == accountGroup)
                {
                    ret.AddTo(item.Value.GetSumAmount(startMonthId, endMonthId));
                }
            }

            return ret;
        }
コード例 #33
0
        /// <summary>
        /// set starting month id
        /// </summary>
        /// <param name="monthId"></param>
        /// <returns></returns>
        public bool SetStartMonthId(MonthIdentity monthId)
        {
            // check
            if (this._startMonthId.CompareTo(monthId) <= 0)
            {
                return false;
            }

            this._startMonthId = monthId;

            // save meta data
            saveMetaData();

            return true;
        }
コード例 #34
0
        /// <summary>
        /// store month ledger to file system
        /// </summary>
        /// <param name="monthId"></param>
        /// <exception cref="SystemException"></exception>
        public async Task StoreAsync(MonthIdentity monthId)
        {
            // store master data
            _coreDriver.logDebugInfo(this.GetType(), 293,
                    String.Format("Start storing %s to disk", monthId),
                    MessageType.INFO);

            _coreDriver.logDebugInfo(this.GetType(), 297,
                    "Store master data at first.", MessageType.INFO);
            await this._masterDataMgmt.StoreAsync();

            MonthLedger collection = this.GetLedger(monthId);

            StorageFile file = await this.generateFilePath(monthId, true);
            _coreDriver.logDebugInfo(this.GetType(), 297, "Generate file path: "
                    + file.Path, MessageType.INFO);
            if (file == null)
            {
                StorageFolder transactionFolder = await _coreDriver.RootFolder
                .GetFolderAsync(TRANSACTION_DATA_FOLDER);
                if (transactionFolder == null)
                {
                    throw new SystemException(null); // bug
                }
                String fileName = String.Format("{0}.xml", monthId.ToString());
                file = await transactionFolder.CreateFileAsync(fileName
                    , CreationCollisionOption.OpenIfExists);
            }


            XDocument xdoc = collection.toXML();
            _coreDriver
                    .logDebugInfo(this.GetType(), 297,
                            "Parsed document collections to XML document",
                            MessageType.INFO);
            try
            {
                await FileIO.WriteTextAsync(file, xdoc.ToString());
            }
            catch (FileNotFoundException e)
            {
                _coreDriver.logDebugInfo(this.GetType(), 316, e.Message,
                        MessageType.ERRO);
                throw new SystemException(e);
            }

            _coreDriver.logDebugInfo(this.GetType(), 335,
                    "Save document collection successfully.", MessageType.INFO);
        }
コード例 #35
0
        /// <summary>
        /// get amount
        /// </summary>
        /// <param name="startId">start month identity</param>
        /// <param name="endId">end month identity</param>
        /// <returns></returns>
        public CurrencyAmount getAmount(MonthIdentity startId, MonthIdentity endId)
        {
            CurrencyAmount amount = new CurrencyAmount();
            List<HeadEntity> docs = this.getEntities(startId, endId);
            foreach (HeadEntity head in docs)
            {
                List<ItemEntity> items = head.Items;
                foreach (ItemEntity item in items)
                {
                    amount.AddTo(getAmountFromItem(item));
                }
            }

            return amount;
        }
コード例 #36
0
        /// <summary>
        /// load meta data
        /// </summary>
        /// <exception cref="MetaDataFormatException">Format exception of the meta-data file</exception>
        private async Task loadMetaDataAsync()
        {
            StorageFile mdFile = await _rootFolder.GetFileAsync(META_DATA);

            if (mdFile == null)
            {
                return;
            }

            try
            {
               
                IList<string> lines = await FileIO.ReadLinesAsync(mdFile);

                int startYear = 0;
                int startMonth = 0;
                int versionNumber = 0;
                foreach (string line in lines)
                {
                    String[] values = line.Split('=');
                    if (values.Length != 2)
                    {
                        throw new MetaDataFormatException("Meta data format error.");
                    }

                    if (values[0].Equals(START_MONTH_TAG))
                    {
                        startMonth = Int32.Parse(values[1]);
                    }
                    else if (values[0].Equals(START_YEAR_TAG))
                    {
                        startYear = Int32.Parse(values[1]);
                    }
                    else if (values[0].Equals(VERSION))
                    {
                        versionNumber = Int32.Parse(values[1]);
                    }
                }

                _startMonthId = new MonthIdentity(startYear, startMonth);
                // _curMonthId = new MonthIdentity(curYear, curMonth);
                // check version
                bool ret = this.versionCheck(versionNumber);
                if (ret == false)
                {
                    throw new MetaDataFormatException("Version Error");
                }
            }
            catch (ArgumentNullException e)
            {
                throw new MetaDataFormatException(e.Message);
            }
            catch (FormatException e)
            {
                throw new MetaDataFormatException(e.Message);
            }
            catch (OverflowException e)
            {
                throw new MetaDataFormatException(e.Message);
            }
            finally
            {
            }
        }
コード例 #37
0
 /// <summary>
 /// Month ledger
 /// </summary>
 /// <param name="monthId"></param>
 public MonthLedger(MonthIdentity monthId)
 {
     _monthId = monthId;
     _list = new Dictionary<DocumentIdentity, HeadEntity>();
 }
コード例 #38
0
        /// <summary>
        /// establish folder
        /// </summary>
        private async Task establishFolderAsync()
        {
            // set meta data
            int year = DateTime.Today.Year;
            int month = DateTime.Today.Month;

            // set starting month identity
            try
            {
                _startMonthId = new MonthIdentity(year, month);
                // _curMonthId = new MonthIdentity(year, month);
            }
            catch (FiscalYearRangeException e)
            {
                this.logDebugInfo(this.GetType(), 300, e.ToString(),
                        MessageType.ERRO);
                throw new SystemException(e);// bug
            }
            catch (FiscalMonthRangeException e)
            {
                this.logDebugInfo(this.GetType(), 302, e.ToString(),
                        MessageType.ERRO);
                throw new SystemException(e);// bug
            }

            await saveMetaDataAsync();

            foreach (var item in _managements)
            {
                if(item.Value.NeedEstablishFile)
                    await item.Value.EstablishFilesAsync();
            }
            _isInitialized = true;
        }
コード例 #39
0
 public MonthItem(MonthIdentity monthId, MonthAdapter parent)
     : base(monthId, String.Empty, parent)
 {
 }