def __init__(self, mem, account, parent=None):
QDialog.__init__(self, parent)
self.mem=mem
self.account=account#Registro de account
self.setupUi(self)
self.showMaximized()
self.cmdDatos.setEnabled(False)
self.wdgDtPago.show_microseconds(False)
self.wdgDtPago.show_timezone(False)
self.wdgDtPago.setTitle(self.tr("Select payment time"))
self.creditcardoperations=CreditCardOperationManager(self.mem)#CreditCardOperationManager. Selected will be another CreditCardOperationManager
self.mqtwOperations.setSettings(self.mem.settings, "frmAccountsReport", "mqtwOperations")
self.mqtwOperations.table.customContextMenuRequested.connect(self.on_mqtwOperations_customContextMenuRequested)
self.mqtwCreditCards.setSettings(self.mem.settings, "frmAccountsReport", "mqtwCreditCards")
self.mqtwCreditCards.table.customContextMenuRequested.connect(self.on_mqtwCreditCards_customContextMenuRequested)
self.mqtwCreditCardOperations.setSettings(self.mem.settings, "frmAccountsReport", "mqtwCreditCardOperations")
self.mqtwCreditCardOperations.table.customContextMenuRequested.connect(self.on_mqtwCreditCardOperations_customContextMenuRequested)
self.mqtwCreditCardOperations.setSelectionMode(QAbstractItemView.SelectRows, QAbstractItemView.MultiSelection)
self.mqtwCreditCardOperationsHistorical.setSettings(self.mem.settings, "frmAccountsReport", "mqtwCreditCardOperationsHistorical")
self.wdgDtPago.set(datetime.now(), self.mem.localzone_name)
currencies_qcombobox(self.cmbCurrency)
self.mem.data.banks_active().qcombobox(self.cmbEB)
if self.account is None:
self.account_insert=True
self.account=Account(self.mem)
self.lblTitulo.setText(self.tr("New account data"))
self.tab.setCurrentIndex(0)
self.tab.setTabEnabled(1, False)
self.tab.setTabEnabled(2, False)
self.chkActiva.setChecked(True)
self.chkActiva.setEnabled(False)
self.mqtwOperations.setEnabled(False)
self.cmdDatos.setText(self.tr("Add a new account"))
else:
self.account_insert=False
self.account.needStatus(1)
self.tab.setCurrentIndex(0)
self.lblTitulo.setText(self.account.name)
self.txtAccount.setText(self.account.name)
self.txtNumero.setText(str(self.account.number))
self.cmbEB.setCurrentIndex(self.cmbEB.findData(self.account.bank.id))
self.cmbEB.setEnabled(False)
self.cmbCurrency.setCurrentIndex(self.cmbCurrency.findData(self.account.currency))
self.cmbCurrency.setEnabled(False)
self.chkActiva.setChecked(self.account.active)
self.cmdDatos.setText(self.tr("Update account data"))
dtFirst=Assets(self.mem).first_datetime_allowed_estimated()
dtLast=Assets(self.mem).last_datetime_allowed_estimated()
self.wdgYM.initiate(dtFirst.year, dtLast.year, date.today().year, date.today().month)
self.on_wdgYM_changed()
self.mqtwCreditCards_update()
def __init__(self, mem, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.mem=mem
self.selected=None
self.viewIncomes=VCPie()
self.viewIncomes.setSettings(self.mem.settings, "wdgConcepts", "viewIncomes")
self.layIncomes.addWidget(self.viewIncomes)
self.viewExpenses=VCPie()
self.viewExpenses.setSettings(self.mem.settings, "wdgConcepts", "viewExpenses")
self.layExpenses.addWidget(self.viewExpenses)
self.expenses=ConceptManager_by_operationtype(mem, 1)
self.expenseslist=None
self.incomes=ConceptManager_by_operationtype(mem, 2)
self.incomeslist=None
self.mqtwExpenses.setSettings(self.mem.settings, "wdgConcepts", "mqtwExpenses")
self.mqtwExpenses.table.customContextMenuRequested.connect(self.on_mqtwExpenses_customContextMenuRequested)
self.mqtwIncomes.setSettings(self.mem.settings, "wdgConcepts", "mqtwIncomes")
self.mqtwIncomes.table.customContextMenuRequested.connect(self.on_mqtwIncomes_customContextMenuRequested)
dtFirst=Assets(self.mem).first_datetime_allowed_estimated()
dtLast=Assets(self.mem).last_datetime_allowed_estimated()
self.wdgYM.initiate(dtFirst.year, dtLast.year, date.today().year, date.today().month)
self.wdgYM.changed.connect(self.on_wdgYM_changed)
self.on_wdgYM_changed()
self.tab.setCurrentIndex(0)
def __init__(self, mem, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.mem = mem
dtFirst = Assets(self.mem).first_datetime_allowed_estimated()
dtLast = Assets(self.mem).last_datetime_allowed_estimated()
self.wy.initiate(dtFirst.year, dtLast.year, date.today().year)
self.wy.changed.connect(self.on_wy_mychanged)
self.wy.label.hide()
self.wy.hide()
self.wym.initiate(dtFirst.year, dtLast.year,
date.today().year,
date.today().month)
self.wym.changed.connect(self.on_wym_mychanged)
self.wym.label.hide()
self.mqtw.setSettings(self.mem.settings, "wdgInvestmentsOperations",
"mqtw")
self.mqtw.table.customContextMenuRequested.connect(
self.on_mqtw_customContextMenuRequested)
self.mqtwCurrent.setSettings(self.mem.settings,
"wdgInvestmentsOperations", "mqtwCurrent")
self.mqtwCurrent.table.customContextMenuRequested.connect(
self.on_mqtwCurrent_customContextMenuRequested)
self.tab.setCurrentIndex(0)
self.load()
self.load_current()
def __init__(self, mem, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.mem = mem
dtFirst = Assets(self.mem).first_datetime_allowed_estimated()
dtLast = Assets(self.mem).last_datetime_allowed_estimated()
#Adding more months that needed to allow month and december previous calculations
self.tmm = TotalMonthManager_from_month(self.mem, dtFirst.year,
dtFirst.month, dtLast.year, 12)
self.mqtwTotal.setSettings(self.mem.settings, "wdgDerivativesReport",
"mqtwTotal")
self.mqtwTotal.table.cellDoubleClicked.connect(
self.on_mqtwTotal_cellDoubleClicked)
self.mqtwTotal.table.customContextMenuRequested.connect(
self.on_mqtwTotal_customContextMenuRequested)
self.mqtwTotal.table.setSelectionBehavior(
QAbstractItemView.SelectItems)
self.mqtwTotal.table.itemSelectionChanged.connect(
self.on_mqtwTotal_itemSelectionChanged)
self.wyData.initiate(dtFirst.year, dtLast.year, date.today().year)
self.tab.setCurrentIndex(0)
self.tmm_data = TotalMonthManager_from_manager_extracting_year(
self.tmm, self.wyData.year)
self.load_data()
self.load_data_second_tab()
self.wyData.changed.connect(
self.on_wyData_mychanged
) #Used my due to it took default on_wyData_changed
def load_data(self):
inicio=datetime.now()
self.mqtw.applySettings()
self.mqtw.table.setRowCount(date.today().year-self.wdgYear.year+1+1)
lastsaldo=Money(self.mem)
sumdividends=Money(self.mem)
sumgains=Money(self.mem)
sumexpenses=Money(self.mem)
sumincomes=Money(self.mem)
sumicdg=Money(self.mem)
hh=[self.tr("Year"), self.tr("Initial balance"), self.tr("Final balance"), self.tr("Difference"), self.tr("Incomes"), self.tr("Net gains"), self.tr("Net dividends"), self.tr("Expenses"), self.tr("I+G+D-E")]
data=[]
for i in range(self.dt_report_start.year, self.dt_report_end.year+1):
#dt_start=dtaware_year_start(i, self.mem.localzone_name)
dt_end=dtaware_year_end(i, self.mem.localzone_name)
if self.progress.wasCanceled():
break;
else:
self.progress.setValue(self.progress.value()+1)
si=lastsaldo
sf=Assets(self.mem).saldo_total(self.mem.data.investments, dt_end.date())
expenses=Assets(self.mem).saldo_anual_por_tipo_operacion( i,1)#+Assets(self.mem).saldo_anual_por_tipo_operacion (cur,i, 7)#expenses + Facturación de tarjeta
dividends=Assets(self.mem).dividends_neto( i)
incomes=Assets(self.mem).saldo_anual_por_tipo_operacion( i,2)-dividends #Se quitan los dividends que luego se suman
gains=Assets(self.mem).consolidado_neto(self.mem.data.investments, i)
self.dates.append(dt_end.date())
self.expenses.append(-expenses.amount)
self.dividends.append(dividends.amount)
self.incomes.append(incomes.amount)
self.gains.append(gains.amount)
gi=incomes+dividends+gains+expenses
data.append([
i,
si,
sf,
(sf-si),
incomes,
gains,
dividends,
expenses,
gi,
])
sumdividends=sumdividends+dividends
sumgains=sumgains+gains
sumexpenses=sumexpenses+expenses
sumincomes=sumincomes+incomes
sumicdg=sumicdg+gi
lastsaldo=sf
data.append([self.tr("Total"), "#crossedout","#crossedout","#crossedout",sumincomes,sumgains,sumdividends,sumexpenses,sumicdg])
self.mqtw.setData(hh, None, data)
debug("wdgAPR > load_data: {}".format(datetime.now()-inicio))
def __init__(self, mem, parent=None, name=None):
"""Simulations is the SimulationManager where the new simulation is going to be appended"""
QWidget.__init__(self, parent)
self.setupUi(self)
self.mem = mem
self.parent = parent
self.simulation = None #Simulation to be created
self.mem.simulationtypes.qcombobox(self.cmbSimulationTypes)
self.wdgStarting.set(
Assets(self.mem).first_datetime_allowed_estimated(),
self.mem.localzone_name)
self.wdgEnding.set(
Assets(self.mem).last_datetime_allowed_estimated(),
self.mem.localzone_name)
self.simcon = None #Simulation connection
def __init__(self, mem, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.mem = mem
self.hoy = date.today()
self.viewTPC = VCPie()
self.viewTPC.setSettings(self.mem.settings, "wdgInvestmentClasses",
"viewTPC")
self.layTPC.addWidget(self.viewTPC)
self.viewPCI = VCPie()
self.viewPCI.setSettings(self.mem.settings, "wdgInvestmentClasses",
"viewPCI")
self.layPCI.addWidget(self.viewPCI)
self.viewTipo = VCPie()
self.viewTipo.setSettings(self.mem.settings, "wdgInvestmentClasses",
"viewTipo")
self.layTipo.addWidget(self.viewTipo)
self.viewApalancado = VCPie()
self.viewApalancado.setSettings(self.mem.settings,
"wdgInvestmentClasses",
"viewApalancado")
self.layApalancado.addWidget(self.viewApalancado)
self.viewCountry = VCPie()
self.viewCountry.setSettings(self.mem.settings, "wdgInvestmentClasses",
"viewCountry")
self.layCountry.addWidget(self.viewCountry)
self.viewProduct = VCPie()
self.viewProduct.setSettings(self.mem.settings, "wdgInvestmentClasses",
"viewProduct")
self.layProduct.addWidget(self.viewProduct)
self.accounts = Assets(self.mem).saldo_todas_accounts(self.hoy).local()
self.tab.setCurrentIndex(2)
def __init__(self, mem, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.tab.setCurrentIndex(0)
self.mem=mem
self.progress = QProgressDialog(self.tr("Filling data of the report"), self.tr("Cancel"), 0,0)
self.progress.setModal(True)
self.progress.setWindowTitle(self.tr("Calculating data..."))
self.progress.setWindowIcon(QIcon(":/xulpymoney/coins.png"))
self.progress.setMinimumDuration(0)
self.mqtw.setSettings(self.mem.settings, "wdgAPR", "mqtw")
self.mqtwReport.setSettings(self.mem.settings, "wdgAPR", "mqtwReport")
dtFirst=Assets(self.mem).first_datetime_allowed_estimated()
dtLast=Assets(self.mem).last_datetime_allowed_estimated()
currentyear=self.mem.settingsdb.value_integer("wdgAPR/cmbYear", dtFirst.year)
self.wdgYear.initiate(dtFirst.year, dtLast.year, currentyear)#Push an wdgYear changed
self.wdgYear.changed.connect(self.on_my_wdgYear_changed)
self.on_my_wdgYear_changed()
def lblTotal_update(self):
investments = self.investments.balance()
accounts = self.mem.data.accounts_active().balance()
total = Assets(self.mem).saldo_total(
self.mem.data.investments_active(), self.mem.localzone.now())
if self.chkInactivas.checkState() == Qt.Checked:
self.lblTotal.setText(self.tr("There aren't invested assets"))
else:
self.lblTotal.setText(
self.tr("""Accounts balance: {0}
Zero risk investments balance: {1}
Zero risk assests balance: {2} ( {3} from your total assets {4} )""").format(
accounts, investments, accounts + investments,
Percentage((accounts + investments).amount, total.amount),
total))
def init__from_db(self, year, lastyear_assests=None):
cur=self.mem.con.cursor()
if lastyear_assests==None:
self.lastyear_assests=Assets(self.mem).saldo_total(self.mem.data.investments, date(year-1, 12, 31))
else:
self.lastyear_assests=lastyear_assests
cur.execute("select * from annualtargets where year=%s", (year, ))
if cur.rowcount==0:
self.year=year
self.percentage=0
else:
row=cur.fetchone()
self.year=year
self.percentage=row['percentage']
self.saved_in_db=True
cur.close()
return self
def load_data(self):
self.product.needStatus(2)
percentage_down=Percentage(self.spnDown.value(), 100)
percentage_gains=Percentage(self.spnGains.value(), 100)
self.prm=ProductRangeManager(self.mem, self.product, percentage_down, percentage_gains)
self.prm.setInvestRecomendation(self.cmbRecomendations.currentIndex())
onlyaccount=-1 if self.chkOnlyAccount.isChecked() is False else self.cmbOnlyAccount.itemData(self.cmbOnlyAccount.currentIndex())
self.prm.mqtw(self.mqtw, self.chkOnlyFirst.isChecked(), onlyaccount)
self.mem.settingsdb.setValue("wdgProductRange/spnDown_product_{}".format(self.product.id), self.spnDown.value())
self.mem.settingsdb.setValue("wdgProductRange/spnGains_product_{}".format(self.product.id), self.spnGains.value())
self.mem.settingsdb.setValue("wdgProductRange/invest_product_{}".format(self.product.id), self.txtInvertir.text())
self.mem.settingsdb.setValue("wdgProductRange/invest_recomendation_{}".format(self.product.id), self.cmbRecomendations.currentIndex())
self.mem.settingsdb.setValue("wdgProductRange/product", self.product.id)
self.mem.settings.sync()
s=self.tr("Product current price: {} at {}").format(
self.product.result.basic.last.money(),
self.product.result.basic.last.datetime,
)
s=s + "\n" + self.tr("Product price limits: {}").format(self.product.result.ohclYearly.string_limits())
s=s + "\n" + self.tr("Total invested: {}. Current balance: {} ({})").format(
self.investment_merged.invertido(),
self.investment_merged.balance(),
self.investment_merged.op_actual.tpc_total(self.product.result.basic.last),
)
s=s + "\n" + self.tr("Average price: {}").format(
self.investment_merged.op_actual.average_price()
)
s=s + "\n" + self.tr("Selling price to gain {}: {}. Gains at this selling price: {} ({})").format(
percentage_gains,
self.investment_merged.op_actual.selling_price_to_gain_percentage_of_invested(percentage_gains, eMoneyCurrency.Product),
self.investment_merged.op_actual.gains_from_percentage(percentage_gains, eMoneyCurrency.Product),
percentage_between(self.product.result.basic.last.money(), self.investment_merged.op_actual.selling_price_to_gain_percentage_of_invested(percentage_gains, eMoneyCurrency.Product)),
)
s=s + "\n\n"+ self.tr("Zero risk assets: {}".format(Assets(self.mem).patrimonio_riesgo_cero(date.today())))
self.lblTotal.setText(s)
def gains(self):
if hasattr(self, "_gains") is False:
self._gains = Assets(self.mem).consolidado_neto(
self.mem.data.investments, self.year, self.month)
return self._gains
def incomes(self):
if hasattr(self, "_incomes") is False:
self._incomes = Assets(self.mem).saldo_por_tipo_operacion(
self.year, self.month, 2) - self.dividends()
return self._incomes
def dividends(self):
if hasattr(self, "_dividends") is False:
self._dividends = Assets(self.mem).dividends_neto(
self.year, self.month)
return self._dividends
def expenses(self):
if hasattr(self, "_expenses") is False:
self._expenses = Assets(self.mem).saldo_por_tipo_operacion(
self.year, self.month,
1) #La facturación de tarjeta dentro esta por el union
return self._expenses
def total_invested_real(self):
if hasattr(self, "_total_invested_real") is False:
self._total_invested_real = Assets(self.mem).invested_real(
self.last_day())
return self._total_invested_real
def total_bonds(self):
if hasattr(self, "_total_bonds") is False:
self._total_bonds = Assets(self.mem).saldo_todas_inversiones_bonds(
self.last_day())
return self._total_bonds
def total_investments_with_daily_adjustments(self):
if hasattr(self, "_total_investments_with_daily_adjustments") is False:
self._total_investments_with_daily_adjustments = Assets(
self.mem).saldo_todas_inversiones_with_daily_adjustment(
self.last_day())
return self._total_investments_with_daily_adjustments
def variables(self):
self.vTotalLastYear=Assets(self.mem).saldo_total(self.mem.data.investments, date(date.today().year-1, 12, 31))
self.vTotal=Assets(self.mem).saldo_total(self.mem.data.investments, date.today())
def body(self):
# About
self.header(self.tr("About Xulpymoney"), 1)
# Assets
self.header(self.tr("Assets"), 1)
self.simpleParagraph(self.tr("Total assets of the user are {}.").format(self.vTotal))
if self.vTotalLastYear.isZero()==False:
moreorless=self.tr("more")
if (self.vTotal-self.vTotalLastYear).isLTZero():
moreorless=self.tr("less")
self.simpleParagraph(self.tr("It's a {} {} of the total assets at the end of the last year.").format(Percentage(self.vTotal-self.vTotalLastYear, self.vTotalLastYear), moreorless))
# Assets by bank
self.header(self.tr("Assets by bank"), 2)
self.mem.frmMain.on_actionBanks_triggered()
model=self.mem.frmMain.w.mqtwBanks.officegeneratorModel()
model.removeColumns([1,])
model.odt_table(self, 10, 8 )
self.simpleParagraph(self.tr("Sum of all bank balances is {}").format(self.mem.frmMain.w.banks.balance()))
self.pageBreak(True)
# Assests current year
self.header(self.tr("Assets current year evolution"), 2)
#wdgTotal
self.mem.frmMain.on_actionTotalReport_triggered()
model=self.mem.frmMain.w.mqtw.officegeneratorModel("mqtwTotal")
model.odt_table(self, 26, 6)
## Target
target=AnnualTarget(self.mem).init__from_db(date.today().year)
self.simpleParagraph(self.tr("The investment system has established a {} year target.").format(target.percentage)+" " +
self.tr("With this target you will gain {} at the end of the year.").format(self.mem.localmoney(target.annual_balance())) +" " +
self.tr("Up to date you have got {} (gains + dividends) what represents a {} of the target.").format(self.mem.frmMain.w.tmm.dividends()+self.mem.frmMain.w.tmm.gains(), Percentage(self.mem.frmMain.w.tmm.gains()+self.mem.frmMain.w.tmm.dividends(), target.annual_balance())))
self.pageBreak(True)
### Assets evolution graphic
self.header(self.tr("Assets graphical evolution"), 2)
self.mem.frmMain.w.load_graphic(animations=False)
self.mem.frmMain.w.tab.setCurrentIndex(1)
savefile="{}/wdgTotal.png".format(self.dir)
self.mem.frmMain.w.wdgTS.ts.save(savefile)
self.addImage(savefile, savefile)
self.illustration([savefile, ], 25, 13, savefile)
self.pageBreak()
### Current year investment gains by product type
self.header(self.tr("Current year investment gains group by product type"), 2)
self.mem.frmMain.w.on_actionGainsByProductType_triggered()
model=self.mem.frmMain.w.tab.currentWidget().children()[1].officegeneratorModel("mqtwTotal")#Widget generated dinamically. mqtw is childre[1]
model.odt_table(self, 18, 9)
self.pageBreak()
## Accounts
self.header(self.tr("Current Accounts"), 1)
data=[]
self.mem.data.accounts_active().order_by_name()
for account in self.mem.data.accounts_active().arr:
data.append((account.name, account.bank.name, account.balance()))
self.table( [self.tr("Account"), self.tr("Bank"), self.tr("Balance")], data, [6, 6, 3], 9)
self.simpleParagraph(self.tr("Sum of all account balances is {}").format(self.mem.data.accounts_active().balance()))
self.pageBreak(True)
## Investments
self.header(self.tr("Current investments"), 1)
self.header(self.tr("Investments list"), 2)
self.simpleParagraph(self.tr("Next list is sorted by the distance in percent to the selling point."))
self.mem.frmMain.on_actionInvestments_triggered()
model=self.mem.frmMain.w.mqtwInvestments.officegeneratorModel()
model.removeColumns([1, 2, 3, 4])
model.odt_table(self, 26, 8 )
suminvertido=self.mem.data.investments_active().invested()
sumpendiente=self.mem.data.investments_active().pendiente()
if suminvertido.isZero()==False:
self.simpleParagraph(self.tr("Sum of all invested assets is {}.").format(suminvertido))
self.simpleParagraph(self.tr("Investment gains (positive minus negative results): {} - {} are {}, what represents a {} of total assets.").format(self.mem.data.investments_active().pendiente_positivo(), self.mem.data.investments_active().pendiente_negativo(), sumpendiente, Percentage(sumpendiente, suminvertido)))
self.simpleParagraph(self.tr(" Assets average age: {}").format( days2string(self.mem.data.investments_active().average_age())))
else:
self.simpleParagraph(self.tr("There aren't invested assets"))
self.pageBreak(True)
### Current Investment Operations list
self.header(self.tr("Current investment operations"), 2)
self.mem.frmMain.on_actionInvestmentsOperations_triggered()
model=self.mem.frmMain.w.mqtwCurrent.officegeneratorModel(self.tr("CurrentInvestmentOperations"))
model.removeColumns([8, 9, 11])
model.odt_table(self, 26, 6)
self.pageBreak(True)
### Graphics wdgInvestments clases
self.mem.frmMain.on_actionInvestmentsClasses_triggered()
self.mem.frmMain.w.open_all_tabs()#Load tabs to finish animations
self.mem.frmMain.w.viewTPC.on_actionShowData_triggered()
self.mem.frmMain.w.viewTipo.on_actionShowData_triggered()
self.mem.frmMain.w.viewApalancado.on_actionShowData_triggered()
self.mem.frmMain.w.viewProduct.on_actionShowData_triggered()
self.mem.frmMain.w.viewCountry.on_actionShowData_triggered()
self.mem.frmMain.w.viewPCI.on_actionShowData_triggered()
self.header(self.tr("Investments group by variable percentage"), 2)
savefile="{}/wdgInvestmentsClasses_canvasTPC_legend.png".format(self.dir)
self.mem.frmMain.w.tab.setCurrentIndex(0)
self.sleep(2)
self.mem.frmMain.w.viewTPC.pie.save(savefile)
self.addImage(savefile, savefile)
self.illustration([savefile, ], 25, 13, savefile)
self.pageBreak(True)
self.header(self.tr("Investments group by investment type"), 2)
savefile="{}/wdgInvestmentsClasses_canvasTipo_legend.png".format(self.dir)
self.mem.frmMain.w.tab.setCurrentIndex(2)
self.sleep(2)
self.mem.frmMain.w.viewTipo.pie.save(savefile)
self.addImage(savefile, savefile)
self.illustration([savefile, ], 25, 13, savefile)
self.pageBreak(True)
self.header(self.tr("Investments group by leverage"), 2)
savefile="{}/wdgInvestmentsClasses_canvasApalancado_legend.png".format(self.dir)
self.mem.frmMain.w.tab.setCurrentIndex(3)
self.sleep(2)
self.mem.frmMain.w.viewApalancado.pie.save(savefile)
self.addImage(savefile, savefile)
self.illustration([savefile, ], 25, 13, savefile)
self.pageBreak(True)
self.header(self.tr("Investments group by investment product"), 2)
savefile="{}/wdgInvestmentsClasses_canvasProduct_legend.png".format(self.dir)
self.mem.frmMain.w.tab.setCurrentIndex(5)
self.sleep(2)
self.mem.frmMain.w.viewProduct.pie.save(savefile)
self.addImage(savefile, savefile)
self.illustration([savefile, ], 25, 13, savefile)
self.pageBreak(True)
self.header(self.tr("Investments group by country"), 2)
savefile="{}/wdgInvestmentsClasses_canvasCountry_legend.png".format(self.dir)
self.mem.frmMain.w.tab.setCurrentIndex(4)
self.sleep(2)
self.mem.frmMain.w.viewCountry.pie.save(savefile)
self.addImage(savefile, savefile)
self.illustration([savefile, ], 25, 13, savefile)
self.pageBreak(True)
self.header(self.tr("Investments group by Call/Put/Inline"), 2)
savefile="{}/wdgInvestmentsClasses_canvasPCI_legend.png".format(self.dir)
self.mem.frmMain.w.tab.setCurrentIndex(1)
self.sleep(2)
self.mem.frmMain.w.viewPCI.pie.save(savefile)
self.addImage(savefile, savefile)
self.illustration([savefile, ], 25, 13, savefile)
self.mem.frmMain.showMaximized()
self.pageBreak(True)
#Orders report
self.header(self.tr("Investments orders"), 1)
self.mem.frmMain.on_actionOrders_triggered()
self.simpleParagraph(self.tr("These are the current investment orders that have been set in your banks"))
model=self.mem.frmMain.w.mqtwOrders.officegeneratorModel("mqtwOrders")
model.odt_table(self, 26, 8)
self.pageBreak(True)
#Dividend report
self.header(self.tr("Dividend estimations report"), 1)
self.mem.frmMain.on_actionDividendsReport_triggered()
model=self.mem.frmMain.w.mqtw.officegeneratorModel("mqtwDividendsReport")
model.odt_table(self, 26, 8)
self.simpleParagraph(self.tr("If I keep this investment during a year, I'll get {0}").format(Assets(self.mem).dividends_estimated()))
self.pageBreak(True)
# Ranking de investments
self.header(self.tr("Historical investments ranking"), 1)
self.mem.frmMain.on_actionInvestmentRanking_triggered()
model=self.mem.frmMain.w.mqtwCurrentOperations.officegeneratorModel("mqtwCurrentOperations")
model.vh=list(range(1, len(model.data)+1))
model.odt_table(self, 26, 8)
def load_data(self):
def investments(arr, min, max):
resultado = ""
for i in arr:
if i[0] >= min and i[0] < max:
o = i[1]
resultado = resultado + self.tr(
"{0} {1} ({2}): {3} shares of {4} = {5}\n".format(
str(o.datetime)[:16], o.investment.name,
o.investment.account.name, round(o.shares, 0),
o.money_price(type=1), o.gross(type=1)))
return resultado[:-1]
######################################################
inicio = datetime.datetime.now()
#Makes and array arr with investment current operations and sorts it
arr = []
maxoper = 0
for i in self.mem.data.investments_active().arr:
for o in i.op_actual.arr:
if self.cmbShowOptions.currentIndex(
) == 0 and o.show_in_ranges == True: #Show qualified
if maxoper < o.referenciaindice.quote:
maxoper = o.referenciaindice.quote
arr.append((o.referenciaindice.quote, o))
elif self.cmbShowOptions.currentIndex(
) == 1 and i.product.type.id in (
eProductType.Share, eProductType.Warrant,
eProductType.ETF): #Shares, Warrants, ETF
if maxoper < o.referenciaindice.quote:
maxoper = o.referenciaindice.quote
arr.append((o.referenciaindice.quote, o))
elif self.cmbShowOptions.currentIndex(
) == 2 and i.product.type.id in (
eProductType.PrivateBond,
eProductType.PublicBond): #Bonds
if maxoper < o.referenciaindice.quote:
maxoper = o.referenciaindice.quote
arr.append((o.referenciaindice.quote, o))
elif self.cmbShowOptions.currentIndex(
) == 3 and i.product.type.id in (eProductType.Fund, ): #Funds
if maxoper < o.referenciaindice.quote:
maxoper = o.referenciaindice.quote
arr.append((o.referenciaindice.quote, o))
elif self.cmbShowOptions.currentIndex() == 4:
if maxoper < o.referenciaindice.quote:
maxoper = o.referenciaindice.quote
arr.append((o.referenciaindice.quote, o))
arr = sorted(arr, key=lambda row: row[1].datetime, reverse=False)
#Makes and array from minimum to benchmark maximum + 2% to minimum
ranges = []
if maxoper == 0: ##NO hay operinvestments
maximo = self.cmbBenchmarkCurrent_price() * (
1 + 2 * Decimal(self.spin.value() / 100))
else:
maximo = maxoper * (1 + 2 * Decimal(self.spin.value() / 100)
) ##1.04 en caso de 2
minimo = self.txtMinimo.decimal()
PuntRange = minimo
while PuntRange < maximo:
ranges.insert(0, PuntRange)
PuntRange = PuntRange * (1 + Decimal(self.spin.value() / 100))
#Calculate zero risk assests and range number covered
zeroriskplusbonds = Assets(self.mem).patrimonio_riesgo_cero(
datetime.date.today()
) # +Assets(self.mem).saldo_todas_inversiones_bonds(datetime.date.today()).amount
rangescovered = int(zeroriskplusbonds.amount /
self.txtInvertir.decimal())
self.mqtw.table.setColumnCount(2)
for i, s in enumerate([self.tr("Range"), self.tr("Investments")]):
self.mqtw.table.setHorizontalHeaderItem(i, QTableWidgetItem(s))
#Iterates all ranges and prints mqtw
self.mqtw.applySettings()
self.mqtw.table.clearContents()
self.mqtw.table.setRowCount(len(ranges))
colorized = 0
for i, r in enumerate(ranges): ###De mayor a menor
top = r * (1 + Decimal(self.spin.value() / 100))
bottom = r
self.mqtw.table.setItem(
i, 0, qcenter("{}-{}".format(int(bottom), int(top))))
self.mqtw.table.setItem(
i, 1, QTableWidgetItem(investments(arr, bottom, top)))
if bottom < self.cmbBenchmarkCurrent_price():
if self.cmbBenchmarkCurrent_price(
) <= top: ##Colorize current price
self.mqtw.table.item(i, 0).setBackground(eQColor.Red)
if colorized <= rangescovered:
self.mqtw.table.item(i, 1).setBackground(eQColor.Green)
colorized = colorized + 1
#Prints label
self.lblTotal.setText(
self.
tr("{} green colorized ranges of {} benchmark are covered by zero risk and bonds balance ({})."
).format(colorized, self.benchmark.name, zeroriskplusbonds))
print("wdgIndexRange > load_data: {0}".format(datetime.datetime.now() -
inicio))
def total_zerorisk(self):
if hasattr(self, "_total_zerorisk") is False:
self._total_zerorisk = Assets(self.mem).patrimonio_riesgo_cero(
self.last_day())
return self._total_zerorisk
def total_accounts(self):
if hasattr(self, "_total_accounts") is False:
self._total_accounts = Assets(self.mem).saldo_todas_accounts(
self.last_day())
return self._total_accounts
def load_report(self):
inicio=datetime.now()
sumgd=Money(self.mem, 0, self.mem.localcurrency)
self.mqtwReport.applySettings()
self.mqtwReport.table.setRowCount(date.today().year-self.wdgYear.year+1+1)
hh=[self.tr("Year"), self.tr("Invested balance"), self.tr("Investment valoration"), self.tr("Difference"),
self.tr("%"), "", self.tr("Net gains + Dividends"), self.tr("Custody commissions"),
self.tr("Taxes"), "", self.tr("Investments Commissions")]
data=[]
for i in range(self.wdgYear.year, date.today().year+1):
if self.progress.wasCanceled():
break;
else:
self.progress.setValue(self.progress.value()+1)
dt_start=dtaware_year_start(i, self.mem.localzone_name)
dt_end=dtaware_year_end(i, self.mem.localzone_name)
sinvested=Assets(self.mem).invested(date_last_of_the_year(i))
sbalance=Assets(self.mem).saldo_todas_inversiones(date_last_of_the_year(i))+Assets(self.mem).saldo_todas_inversiones_with_daily_adjustment(date_last_of_the_year(i))
gd=Assets(self.mem).consolidado_neto(self.mem.data.investments, i)+Assets(self.mem).dividends_neto(i)
sumgd=sumgd+gd
data.append([
i,
sinvested,
sbalance,
sbalance-sinvested,
percentage_between(sinvested, sbalance),
"#crossedout",
gd,
Assets(self.mem).custody_commissions(dt_start, dt_end),
Assets(self.mem).taxes(dt_start, dt_end),
"#crossedout",
Assets(self.mem).investments_commissions(dt_start, dt_end)
])
report_custody_commissions=Assets(self.mem).custody_commissions(self.dt_report_start, self.dt_report_end)
report_taxes=Assets(self.mem).taxes(self.dt_report_start, self.dt_report_end)
data.append([
self.tr("Total"),
"#crossedout",
"#crossedout",
"#crossedout",
"#crossedout",
"#crossedout",
sumgd,
report_custody_commissions,
report_taxes,
"#crossedout",
Assets(self.mem).investments_commissions(self.dt_report_start, self.dt_report_end)
])
self.mqtwReport.setData(hh, None, data)
diff=Assets(self.mem).saldo_todas_inversiones(date_last_of_the_year(date.today().year)) + Assets(self.mem).saldo_todas_inversiones_with_daily_adjustment(date_last_of_the_year(date.today().year)) - Assets(self.mem).invested(date_last_of_the_year(date.today().year))
s=""
s=s+"\n"+self.tr("Difference between invested amount and current invesment balance is {}.").format(diff)
s=s+"\n"+self.tr("From {} I've generated {} gains (investment commisions are included).").format(self.wdgYear.year, sumgd)
s=s+"\n"+self.tr("Sum of taxes and custody commissions is {}.".format(report_taxes+report_custody_commissions))
s=s+"\n"+self.tr("So, I've generated {} gains.").format(sumgd+report_taxes+report_custody_commissions)
balance=diff+sumgd+report_taxes+report_custody_commissions
if balance.isGETZero():
s=s+"\n"+self.tr("So I'm wining {} which is {} per year.").format(balance, self.mem.localmoney(balance.amount/(date.today().year-self.wdgYear.year+1)))
else:
s=s+"\n"+self.tr("So I'm losing {} which is {} per year.").format(balance, self.mem.localmoney(balance.amount/(date.today().year-self.wdgYear.year+1)))
self.lblReport.setText(s)
debug("wdgAPR > load_report: {0}".format(datetime.now()-inicio))
def total_investments_real(self):
if hasattr(self, "_total_investments_real") is False:
self._total_investments_real = Assets(
self.mem).saldo_todas_inversiones_real(self.last_day())
return self._total_investments_real
def __init__(self, mem, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.mem = mem
self.mem.data.benchmark.needStatus(2)
c = wdgCuriosity(self.mem)
c.setTitle(self.tr("Since when there is data in the database?"))
c.setText("The first data is from {}".format(
Assets(self.mem).first_database_datetime()))
self.layout.addWidget(c)
c = wdgCuriosity(self.mem)
c.setTitle(
self.
tr("Which is the investment I gain more money in the last three years?"
))
selected = None
maxgains = Money(self.mem, 0, self.mem.localcurrency)
for inv in self.mem.data.investments.arr:
consolidado = inv.op_historica.consolidado_bruto(type=3)
if maxgains < consolidado:
maxgains = consolidado
selected = inv
if selected == None:
c.setText(self.tr("You still hasn't gains"))
else:
c.setText(
self.
tr("The investment I gain more money is {} in {} ({}). I got {}."
.format(selected.name, selected.account.name,
selected.account.bank.name, maxgains)))
self.layout.addWidget(c)
c = wdgCuriosity(self.mem)
c.setTitle(
self.
tr("Which is the product I gain more money in the last three years?"
))
c.setText(self.tr(""))
self.layout.addWidget(c)
c = wdgCuriosity(self.mem)
c.setTitle(self.tr("Which is the benchmark highest and lowest price?"))
if self.mem.data.benchmark.result.ohclDaily.length() == 0:
c.setText(self.tr("Current benchmarck hasn't data."))
else:
highest = self.mem.data.benchmark.result.ohclDaily.highest()
lowest = self.mem.data.benchmark.result.ohclDaily.lowest()
c.setText(
self.
tr("Current benchmarck ({}) highest price is {}. It took place at {}. Lowest price is {} and took place at {}."
.format(self.mem.data.benchmark.name,
self.mem.data.benchmark.money(highest.high),
highest.date,
self.mem.data.benchmark.money(lowest.low),
lowest.date)))
self.layout.addWidget(c)
c = wdgCuriosity(self.mem)
c.setTitle(self.tr("How many quotes are there in the database?"))
c.setText(
self.tr("There are {} quotes in this Xulpymoney database.".format(
self.mem.con.cursor_one_field("select count(*) from quotes"))))
self.layout.addWidget(c)
c = wdgCuriosity(self.mem)
c.setTitle(self.tr("Which product has the highest quote?"))
c.setText(self.tr(""))
self.layout.addWidget(c)
c = wdgCuriosity(self.mem)
operations = AccountOperationManagerHeterogeneus(self.mem)
operations.load_from_db(
"select * from accountsoperations where amount = (select max(amount) from accountsoperations) order by datetime desc limit 1"
)
c.setTitle(
self.tr("Which is the amount of the largest account operation?"))
if operations.length() == 1:
o = operations.first()
c.setText(
self.
tr("The largest account operation took place at {}. It's concept was '{}' and it's amount was {}."
.format(o.datetime, o.concept.name,
o.account.money(o.amount))))
else:
c.setText(self.tr("There are not account operations yet."))
self.layout.addWidget(c)
c = wdgCuriosity(self.mem)
c.setTitle(
self.tr(
"Which is the amount of the largest credit card operation?"))
c.setText(self.tr(""))
self.layout.addWidget(c)
c = wdgCuriosity(self.mem)
c.setTitle(
self.tr(
"Which is the amount of the largest investment operation?"))
c.setText(self.tr(""))
self.layout.addWidget(c)
self.layout.addSpacerItem(
QSpacerItem(10, 10, QSizePolicy.Expanding, QSizePolicy.Expanding))
