예제 #1
0
 public TradesExtrator(
     ITaxReport taxReport,
     IBrokerParserProvider brokerParserProvider,
     IDataTransformer <Trade, ClosedOperation <Trade> > tradeTransformer,
     IEntityConvertor <Trade> tradeConvertor
     )
 {
     this.taxReport            = taxReport;
     this.brokerParserProvider = brokerParserProvider;
     this.tradeConvertor       = tradeConvertor;
     this.tradeTransformer     = tradeTransformer;
 }
예제 #2
0
        protected virtual IList <T> Load(IBrokerParserProvider brokerParserProvider, IEnumerable <StatementData> statements)
        {
            var      dataReader = brokerParserProvider.EntitiesDataReader;
            List <T> result     = new List <T>();

            foreach (var s in statements)
            {
                var entities = dataReader.Read <T>(s);
                if (entities != null && entities.Any())
                {
                    result.AddRange(entities);
                }
            }

            return(result);
        }
예제 #3
0
        public virtual void Prepare(
            IBrokerParserProvider brokerParserProvider,
            IEnumerable <StatementData> statements, ReportOptions reportOptions, Action <IList <T> > onReadyCallback)
        {
            var entities = Load(brokerParserProvider, statements);

            entities = Filter(reportOptions, entities);

            //IList<object> generalList = entities.Select(x=>(object)x).ToList();

            //foreach (var transformer in transformers)
            //{
            //    generalList = transformer.Transform(generalList);
            //}

            onReadyCallback(entities);
        }
예제 #4
0
        private List <StatementData> ParseStatements(ReportOptions reportOptions)
        {
            brokerParserProvider = brokerParserProviderFactory.CreateNew(reportOptions.BrokerCode.ToString());

            var statementParser = brokerParserProvider.StatementParser;
            var statements      = new List <StatementData>();

            var profile = reportOptions.Profile;

            foreach (var stmData in profile.Statements)
            {
                var stm = statementParser.ParseStatement(stmData);
                statements.Add(stm);
            }

            return(statements);
        }
예제 #5
0
        public ITaxReport BuildReport(ReportOptions reportOptions)
        {
            brokerParserProvider = brokerParserProviderFactory.CreateNew(reportOptions.BrokerCode.ToString());

            if (brokerParserProvider == null)
            {
                throw new TaxCalcException($"BrokerParserProvider '{reportOptions.BrokerCode}' not registered");
            }

            TaxReport taxReport  = new TaxReport(reportOptions);
            var       statements = ParseStatements(reportOptions);

            var brokerReportEntities = reportOptions.ReportEntitities;

            AccountInformationGroup accountInformationGroup = null;

            accountInformationExtrator.Prepare(brokerParserProvider, statements.Take(1), reportOptions,
                                               (accInfo) => accountInformationGroup = new AccountInformationGroup(accInfo));

            var currency = accountInformationGroup.Currency;

            if (!string.IsNullOrEmpty(currency))
            {
                reportOptions.BaseCurrency = currency;
            }

            if (brokerReportEntities.HasFlag(EntityCode.FinInstruments))
            {
                finInstrumentsExtrator.Prepare(brokerParserProvider, statements, reportOptions,
                                               (finInstr) => taxReport.FinInstruments = finInstr);
            }

            if (brokerReportEntities.HasFlag(EntityCode.Trades))
            {
                FillTrades(reportOptions, taxReport, statements);
                taxReport.TradeData.TradeAggregations = AggregateTrades(reportOptions, taxReport, taxReport.TradeData.Trades);
            }

            if (brokerReportEntities.HasFlag(EntityCode.Forex))
            {
                //FillForexTrades(reportOptions, taxReport, statements);
            }

            if (brokerReportEntities.HasFlag(EntityCode.Dividends))
            {
                dividendsEntityExtrator.Prepare(brokerParserProvider, statements, reportOptions,
                                                (dividends) => {
                    foreach (var div in dividends)
                    {
                        div.Entity.SymbolName = taxReport.FindFinInstrument(div.Symbol)?.Description ?? div.Symbol;
                    }
                    taxReport.Dividends = dividends;
                });
            }

            if (brokerReportEntities.HasFlag(EntityCode.SecuritiesLentInterests))
            {
                securitiesLentExtrator.Prepare(brokerParserProvider, statements, reportOptions,
                                               (securitiesLentInterests) => taxReport.SecuritiesLentInterests = securitiesLentInterests);
            }

            if (brokerReportEntities.HasFlag(EntityCode.Interests))
            {
                interestEntityExtrator.Prepare(brokerParserProvider, statements, reportOptions,
                                               (interests) => taxReport.Interests = interests);
            }

            if (brokerReportEntities.HasFlag(EntityCode.Fees))
            {
                feeEntityExtrator.Prepare(brokerParserProvider, statements, reportOptions,
                                          (fees) => taxReport.Fees = fees);
            }

            if (brokerReportEntities.HasFlag(EntityCode.Deposits))
            {
                depositsExtrator.Prepare(brokerParserProvider, statements, reportOptions,
                                         (deposits) => taxReport.Deposits = deposits);
            }


            return(taxReport);
        }