def scriptTipos(self):
self.viewTipo.clear()
for t in self.mem.types.arr:
total = Money(self.mem, 0, self.mem.localcurrency)
for i in self.mem.data.investments_active().arr:
if i.product.type == t:
if self.radCurrent.isChecked():
total = total + i.balance().local()
else:
total = total + i.invertido().local()
if t.id == 11: #Accounts
total = total + self.accounts
if total.isGTZero():
if t.id == 11: #Accounts
self.viewTipo.pie.appendData(t.name.upper(), total, True)
else:
self.viewTipo.pie.appendData(t.name.upper(), total)
if self.radCurrent.isChecked():
self.viewTipo.pie.setTitle(
self.tr("Investment current balance by product type"))
else:
self.viewTipo.pie.setTitle(
self.tr("Invested balance by product type"))
self.viewTipo.display()
def balance(self, fecha=None, type=eMoneyCurrency.User):
"""Función que calcula el balance de una cuenta
Solo asigna balance al atributo balance si la fecha es actual, es decir la actual
Parámetros:
- pg_cursor cur Cursor de base de datos
- date fecha Fecha en la que calcular el balance
Devuelve:
- Decimal balance Valor del balance
type=2, account currency
type=3 localcurrency
"""
cur = self.mem.con.cursor()
if fecha == None:
fecha = date.today()
cur.execute(
'select sum(amount) from accountsoperations where accounts_id=' +
str(self.id) + " and datetime::date<='" + str(fecha) + "';")
res = cur.fetchone()[0]
cur.close()
if res == None:
return Money(self.mem, 0, self.resultsCurrency(type))
if type == eMoneyCurrency.Account:
return Money(self.mem, res, self.currency)
elif type == eMoneyCurrency.User:
if fecha == None:
dt = self.mem.localzone.now()
else:
dt = dtaware_day_end_from_date(fecha, self.mem.localzone_name)
return Money(self.mem, res,
self.currency).convert(self.mem.localcurrency, dt)
def reload(self):
#Junta accountsoperations y creditcardsoperations y sobre esa subquery uni hace un group by
rows = self.mem.con.cursor_rows("""
select date_part('year',datetime)::int as year, date_part('month',datetime)::int as month, sum(amount) as value
from (
SELECT accountsoperations.datetime, accountsoperations.concepts_id, accountsoperations.amount FROM accountsoperations where concepts_id={0}
UNION ALL
SELECT creditcardsoperations.datetime, creditcardsoperations.concepts_id, creditcardsoperations.amount FROM creditcardsoperations where concepts_id={0}
) as uni
group by date_part('year',datetime), date_part('month',datetime) order by 1,2 ;
""".format(self.concept.id))
if len(rows) == 0: #Due it may have no data
return
self.firstyear = int(rows[0]['year'])
hh = [
self.tr("Year"),
self.tr("January"),
self.tr("February"),
self.tr("March"),
self.tr("April"),
self.tr("May"),
self.tr("June"),
self.tr("July"),
self.tr("August"),
self.tr("September"),
self.tr("October"),
self.tr("November"),
self.tr("December"),
self.tr("Total")
]
data = []
# Create all data spaces filling year
for year in range(self.firstyear, date.today().year + 1):
data.append([
year,
] + [None] * 13)
# Fills spaces with values
for row in rows:
for rowdata in data:
if rowdata[0] == row['year']:
rowdata[row['month']] = Money(self.mem, row['value'],
self.mem.localcurrency)
rowdata[13] = lor_sum_row(
rowdata, 1, 12, Money(self.mem, 0, self.mem.localcurrency))
total = lor_sum_column(data, 13, 0,
len(data) - 1,
Money(self.mem, 0, self.mem.localcurrency))
data.append([self.tr("Total")] + ["#crossedout"] * 12 + [
total,
])
self.mqtwReport.setData(hh, None, data)
def net(self, type=eMoneyCurrency.Product):
if type == 1:
return Money(self.mem, self._net, self.investment.product.currency)
elif type == 2:
return Money(self.mem, self._net,
self.investment.product.currency).convert_from_factor(
self.investment.account.currency,
self.currency_conversion)
elif type == 3:
return Money(self.mem, self._net,
self.investment.product.currency).convert_from_factor(
self.investment.account.currency,
self.currency_conversion).local(self.datetime)
def __init__(self, mem, inversion, dividend=None, parent=None):
"""
Si dividend es None se insertar
Si dividend es un objeto se modifica"""
QWidget.__init__(self, parent)
self.setupUi(self)
self.mem = mem
self.dividend = dividend
self.investment = inversion
self.net = 0
self.tpc = 0
self.wdgDT.setLocalzone(self.mem.localzone_name)
self.wdgDT.show_microseconds(False)
self.wdgDT.show_timezone(False)
self.lblGross.setText(
self.tr("Gross in {}").format(
currency_symbol(self.investment.product.currency)))
self.lblGrossAccount.setText(
self.tr("Gross converted to {}").format(
currency_symbol(self.investment.account.currency)))
if dividend == None: #insertar
ConceptManager_for_dividends(mem).qcombobox(self.cmb)
self.cmb.setCurrentIndex(0)
self.dividend = Dividend(self.mem)
self.dividend.investment = inversion
self.cmd.setText(self.tr("Add new dividend"))
self.wdgDT.set(None, self.mem.localzone_name)
self.wdgCurrencyConversion.setConversion(
Money(self.mem, self.txtBruto.decimal(),
self.investment.product.currency),
self.investment.account.currency, self.wdgDT.datetime(), None)
else: #modificar
ConceptManager_for_dividends(mem).qcombobox(
self.cmb, self.dividend.concept)
self.wdgDT.set(self.dividend.datetime, self.mem.localzone_name)
self.wdgCurrencyConversion.setConversion(
Money(self.mem, self.txtBruto.decimal(),
self.investment.product.currency),
self.investment.account.currency, self.wdgDT.datetime(),
self.dividend.currency_conversion)
self.txtBruto.setText(
self.dividend.gross(eMoneyCurrency.Account).amount)
self.txtNeto.setText(
self.dividend.net(eMoneyCurrency.Account).amount)
self.txtRetencion.setText(self.dividend.taxes)
self.txtComision.setText(
self.dividend.commission(eMoneyCurrency.Account).amount)
self.txtDPA.setText(self.dividend.dpa)
self.cmd.setText(self.tr("Edit dividend"))
def dps(self, type=eMoneyCurrency.Product):
"Dividend per share"
if type == 1:
return Money(self.mem, self.dpa, self.investment.product.currency)
elif type == 2:
return Money(self.mem, self.dpa,
self.investment.product.currency).convert_from_factor(
self.investment.account.currency,
self.currency_conversion)
elif type == 3:
return Money(self.mem, self.dpa,
self.investment.product.currency).convert_from_factor(
self.investment.account.currency,
self.currency_conversion).local(self.datetime)
def amount(self, type=eMoneyCurrency.Product):
money = Money(
self.mem,
self.shares * self.price *
self.investment.product.real_leveraged_multiplier(),
self.investment.product.currency)
if type == eMoneyCurrency.Product:
return money
elif type == eMoneyCurrency.Account:
dt = dtaware_day_end_from_date(self.date, self.mem.localzone_name)
return money.convert(self.investment.account.currency, dt)
elif type == eMoneyCurrency.User:
dt = dtaware_day_end_from_date(self.date, self.mem.localzone_name)
return money.convert(self.investment.account.currency,
dt).convert(self.mem.localcurrency, dt)
def shares(self):
resultado = Decimal(0)
if self.radDes.isChecked(): #DESINVERSION
perdida = Money(self.mem, self.txtSimulacion.decimal(),
self.investment.product.currency
) #Va disminuyendo con las distintas operaciones
q = Quote(self.mem).init__create(
self.investment.product,
datetime.now(timezone(self.mem.localzone_name)),
self.txtValorAccion.decimal())
for rec in self.investment.op_actual.arr:
pendiente = rec.pendiente(q)
if (perdida + pendiente).isZero():
resultado = resultado + rec.shares
break
elif (perdida + pendiente).isGTZero():
resultado = resultado + rec.shares
perdida = perdida + pendiente
elif (perdida + pendiente).isLTZero():
# Si de tantas shares queda pendiente "pendiente"
# X queda la perdida
shares = abs(
int(perdida.amount * rec.shares / pendiente.amount))
resultado = resultado + Decimal(
shares
) #Se resta porque se debe calcular antes de quitarse el pendiente
break
else: #REINVERSION
resultado = Decimal(
int(self.txtSimulacion.decimal() /
self.txtValorAccion.decimal()))
return resultado
def on_txtBruto_textChanged(self):
self.wdgCurrencyConversion.setConversion(
Money(self.mem, self.txtBruto.decimal(),
self.investment.product.currency),
self.investment.account.currency, self.wdgDT.datetime(),
self.wdgCurrencyConversion.factor)
self.calcular()
def __init__(self, mem, inversion , parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.showMaximized()
self.mem=mem
self.investment=inversion
if self.investment.id==None:
qmessagebox(self.tr("You can't set a selling price to a unsaved investment"))
return
if self.investment.op_actual.length()==0:
qmessagebox(self.tr("You don't have shares to sale in this investment"))
return
self.puntoventa=Decimal(0)#Guarda el resultado de los cálculos
self.investmentsoperations=None
if self.mem.gainsyear==True:
self.chkGainsTime.setCheckState(Qt.Checked)
else:
self.chkGainsTime.setEnabled(False)
self.mqtw.setSettings(self.mem.settings, "frmSellingPoint", "mqtw")
self.mqtwSP.setSettings(self.mem.settings, "frmSellingPoint", "mqtwSP")
self.spnGainsPercentage.setValue(self.mem.settingsdb.value_float("frmSellingPoint/lastgainpercentage", "10"))
self.lblPriceSymbol.setText(currency_symbol(self.investment.product.currency))
self.lblAmountSymbol.setText(currency_symbol(self.investment.account.currency))
def m_target_gains(self, dInvested):
try:
shares=dInvested/self.entry
value= (self.target-self.entry)*shares
value=-value if self.short==True else value
except:
value= Decimal(0)
return Money(self.mem, value, self.product.currency)
def m_stop_loss_losses(self, dInvested):
try:
shares=dInvested/self.entry
value= (self.stoploss-self.entry)*shares
value=-value if self.short==True else value
except:
value= Decimal(0)
return Money(self.mem, value, self.product.currency)
def net(self, emoneycurrency, current):
r = Money(self.mem, 0, self.investment.resultsCurrency(emoneycurrency))
for d in self.arr:
if current == True and self.investment.op_actual.length(
) > 0 and d.datetime < self.investment.op_actual.first().datetime:
continue
else:
r = r + d.net(emoneycurrency)
return r
def update_tables(self):
#Actualiza el indice de referencia porque ha cambiado
self.investment.op_actual.get_valor_benchmark(self.mem.data.benchmark)
self.on_chkOperaciones_stateChanged(self.chkOperaciones.checkState())
self.chkOperaciones.setEnabled(True)
self.investment.op_actual.myqtablewidget(
self.mqtwInvestmentCurrent,
self.investment.product.result.basic.last,
type=1)
self.investment.op_historica.myqtablewidget(
self.mqtwInvestmentHistorical, type=1)
if self.investment.product.currency == self.investment.account.currency: #Multidivisa
self.grpCurrentAccountCurrency.hide()
self.grpHistoricalAccountCurrency.hide()
else:
m = Money(self.mem, 1, self.investment.account.currency)
self.grpCurrentAccountCurrency.setTitle(
self.tr("Current status in account currency ( {} = {} at {} )"
).format(
m.string(6),
m.convert(self.investment.product.currency,
self.mem.localzone.now()).string(6),
m.conversionDatetime(
self.investment.product.currency,
self.mem.localzone.now())))
self.investment.op_actual.myqtablewidget(
self.mqtwInvestmentCurrentAccountCurrency,
self.investment.product.result.basic.last,
type=2)
self.investment.op_historica.myqtablewidget(
self.mqtwInvestmentHistoricalAccountCurrency, type=2)
self.lblAge.setText(
self.tr("Current operations average age: {0}".format(
days2string(self.investment.op_actual.average_age()))))
if self.investment != None: #We are adding a new investment
self.on_chkHistoricalDividends_stateChanged(
self.chkHistoricalDividends.checkState())
self.chkHistoricalDividends.setEnabled(True)
def RankingManager_from_current_operations(mem):
r = RankingManager(mem)
for product in mem.data.investments.ProductManager_with_investments_distinct_products(
).arr:
current = Money(mem, 0, mem.localcurrency)
historical = Money(mem, 0, mem.localcurrency)
dividends = Money(mem, 0, mem.localcurrency)
for inv in mem.data.investments.arr:
if inv.product.id == product.id:
current = current + inv.op_actual.pendiente(
inv.product.result.basic.last, 3)
historical = historical + inv.op_historica.consolidado_bruto(
type=3)
dividends = dividends + inv.dividends.gross(
eMoneyCurrency.User, current=False)
r.append(Ranking(mem, product, current, historical, dividends))
r.sort_by_total()
return r
def scriptCountry(self):
self.viewCountry.clear()
for c in self.mem.countries.arr:
total = Money(self.mem, 0, self.mem.localcurrency)
for i in self.mem.data.investments_active().arr:
if i.product.stockmarket.country == c:
if self.radCurrent.isChecked():
total = total + i.balance().local()
else:
total = total + i.invertido().local()
if total.isGTZero():
self.viewCountry.pie.appendData(c.name.upper(), total)
if self.radCurrent.isChecked():
self.viewCountry.pie.setTitle(
self.tr("Investment current balance by country"))
else:
self.viewCountry.pie.setTitle(
self.tr("Invested balance by country"))
self.viewCountry.display()
def scriptApalancado(self):
self.viewApalancado.clear()
for a in self.mem.leverages.arr:
total = Money(self.mem, 0, self.mem.localcurrency)
for i in self.mem.data.investments_active().arr:
if i.product.leveraged == a:
if self.radCurrent.isChecked():
total = total + i.balance().local()
else:
total = total + i.invertido().local()
if a.id == eLeverageType.NotLeveraged: #Accounts
total = total + self.accounts
if total.isGTZero():
self.viewApalancado.pie.appendData(a.name.upper(), total)
if self.radCurrent.isChecked():
self.viewApalancado.pie.setTitle(
self.tr("Investment current balance by leverage"))
else:
self.viewApalancado.pie.setTitle(
self.tr("Invested balance by leverage"))
self.viewApalancado.display()
def scriptTPC(self):
self.viewTPC.clear()
for r in range(0, 11):
total = Money(self.mem, 0, self.mem.localcurrency)
for i in self.mem.data.investments_active().arr:
if ceil(i.product.percentage / 10.0) == r:
if self.radCurrent.isChecked():
total = total + i.balance().local()
else:
total = total + i.invertido().local()
if r == 0:
total = total + self.accounts
if total.isGTZero():
self.viewTPC.pie.appendData("{0}% variable".format(r * 10),
total)
if self.radCurrent.isChecked():
self.viewTPC.pie.setTitle(
self.tr("Investment current balance by variable percentage"))
else:
self.viewTPC.pie.setTitle(
self.tr("Invested balance by variable percentage"))
self.viewTPC.display()
def on_cmbProducts_currentIndexChanged(self, index):
"""To invoke this function you must call self.cmbProducts.setCurrentIndex()"""
self.product = self.mem.data.products.find_by_id(
self.cmbProducts.itemData(index))
if self.product != None:
self.lblFinalPrice.setText(
self.tr("Final price in {} ({})").format(
self.product.currency,
currency_symbol(self.product.currency)))
if self.product.hasSameLocalCurrency():
self.lblShares.setText(self.tr("Shares calculated"))
else:
self.lblShares.setText(
self.tr("Shares calculated with {} at {}").format(
Money(self.mem, 1,
self.mem.localcurrency).conversionFactorString(
self.product.currency,
self.mem.localzone.now()),
self.mem.localzone.now()))
#Fills self.cmbInvestments with all product investments or with zero shares product investments
if self.chkWithoutShares.checkState() == Qt.Checked:
self.investments = self.mem.data.investments.InvestmentManager_with_investments_with_the_same_product_with_zero_shares(
self.product)
else:
self.investments = self.mem.data.investments.InvestmentManager_with_investments_with_the_same_product(
self.product)
self.investments.qcombobox(self.cmbInvestments,
tipo=3,
selected=None,
obsolete_product=False,
investments_active=None,
accounts_active=None)
self.mem.settings.setValue("wdgCalculator/product",
self.product.id)
self.cmbPrice_load()
self.txtLeveraged.setText(self.product.leveraged.multiplier)
self.txtFinalPrice.textChanged.disconnect()
self.txtFinalPrice.setText(
round(
self.txtProductPrice.decimal() *
Decimal(1 +
Decimal(self.spnProductPriceVariation.value()) *
self.txtLeveraged.decimal() / 100), 6))
self.txtFinalPrice.textChanged.connect(
self.on_txtFinalPrice_textChanged)
self.calculate()
def __calcular(self):
#Setting self.investmentsoperations variable
if self.chkPonderanAll.checkState()==Qt.Checked:#Results are in self.mem.localcurrency
self.investmentsoperations=self.mem.data.investments_active().Investment_merging_current_operations_with_same_product(self.investment.product).op_actual
self.investmentsoperations.myqtablewidget(self.mqtw)
else:#Results in account currency
self.investmentsoperations=InvestmentOperationCurrentHomogeneusManager(self.mem, self.investment)
if self.chkGainsTime.checkState()==Qt.Checked:
self.investmentsoperations=self.investment.op_actual.ObjectManager_copy_until_datetime(self.mem.localzone.now()-datetime.timedelta(days=365))
else:
self.investmentsoperations=self.investment.op_actual.ObjectManager_copy_until_datetime(self.mem.localzone.now())
self.investmentsoperations.myqtablewidget(self.mqtw, self.investment.product.result.basic.last, eMoneyCurrency.Account)
sumacciones=self.investmentsoperations.shares()
#Calculations
if sumacciones==Decimal(0):
self.puntoventa=Money(self.mem, 0, self.investment.account.currency)
else:
if self.radTPC.isChecked()==True:
percentage=Percentage(self.spnGainsPercentage.value(), 100)
self.puntoventa=self.investmentsoperations.selling_price_to_gain_percentage_of_invested(percentage, eMoneyCurrency.Account)
elif self.radPrice.isChecked()==True:
if self.txtPrice.isValid():#Si hay un number bien
self.puntoventa=Money(self.mem, self.txtPrice.decimal(), self.investment.product.currency)
self.cmd.setEnabled(True)
else:
self.puntoventa=Money(self.mem, 0, self.investment.product.currency)
self.cmd.setEnabled(False)
elif self.radGain.isChecked()==True:
if self.txtGanancia.isValid():#Si hay un number bien
self.puntoventa=self.investmentsoperations.selling_price_to_gain_money(Money(self.mem, self.txtGanancia.decimal(), self.investment.product.currency))
self.cmd.setEnabled(True)
else:
self.puntoventa=Money(self.mem, 0, self.investment.account.currency)
self.cmd.setEnabled(False)
quote=Quote(self.mem).init__create(self.investment.product, self.mem.localzone.now(), self.puntoventa.amount)
self.tab.setTabText(1, self.tr("Selling point: {0}".format(self.puntoventa)))
self.tab.setTabText(0, self.tr("Current state: {0}".format(quote.money())))
self.investmentsoperations.myqtablewidget(self.mqtwSP, quote, eMoneyCurrency.Account)
if self.chkPonderanAll.checkState()==Qt.Checked:
self.cmd.setText(self.tr("Set selling price to all investments of {0} to gain {1}").format(self.puntoventa, self.investmentsoperations.pendiente(quote, eMoneyCurrency.Account)))
else:
self.cmd.setText(self.tr("Set {0} shares selling price to {1} to gain {2}").format(sumacciones, self.puntoventa, self.investmentsoperations.pendiente(quote, eMoneyCurrency.Account)))
def derivatives_adjustments(self):
if hasattr(self, "_derivatives_adjustments") is False:
## WRONG IF SEVERAL CURRENCY IN ADJUSTMENTS
self._derivatives_adjustments = self.mem.con.cursor_one_field(
"""
select
sum(amount)
from
accountsoperations
where
concepts_id in (%s) AND
date_part('year',datetime)=%s and
date_part('month',datetime)=%s
""", (eConcept.DerivativesAdjustment, self.year, self.month))
return Money(self.mem, self._derivatives_adjustments,
self.mem.localcurrency)
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 calculate(self):
"""Checks if compulsory fields are ok, if not changes style to red, else calculate mqtw and shares"""
if self.txtAmount.isValid() and self.txtFinalPrice.isValid():
finalprice = Money(self.mem, self.txtFinalPrice.decimal(),
self.product.currency).convert(
self.mem.localcurrency).amount
if self.product.type.id in (eProductType.Share,
eProductType.ETF): #Shares
self.txtShares.setText(
round(self.txtAmount.decimal() / finalprice, 0))
else:
self.txtShares.setText(
round(self.txtAmount.decimal() / finalprice, 6))
porcentages = [2.5, 5, 7.5, 10, 15, 30]
self.mqtw.table.setColumnCount(3)
self.mqtw.table.setHorizontalHeaderItem(
0, QTableWidgetItem(self.tr("% Gains")))
self.mqtw.table.setHorizontalHeaderItem(
1, QTableWidgetItem(self.tr("Price")))
self.mqtw.table.setHorizontalHeaderItem(
2, QTableWidgetItem(self.tr("Gains")))
self.mqtw.table.clearContents()
self.mqtw.applySettings()
self.mqtw.table.setRowCount(len(porcentages))
for i, tpc in enumerate(porcentages):
self.mqtw.table.setItem(
i, 0,
Percentage(tpc, 100).qtablewidgetitem())
tpcprice = self.txtFinalPrice.decimal() * Decimal(1 +
tpc / 100)
self.mqtw.table.setItem(
i, 1,
self.product.money(tpcprice).qtablewidgetitem())
self.mqtw.table.setItem(
i, 2,
self.product.money(
self.txtShares.decimal() *
(tpcprice -
self.txtFinalPrice.decimal())).qtablewidgetitem())
def scriptPCI(self):
self.viewPCI.clear()
for mode in self.mem.investmentsmodes.arr:
total = Money(self.mem, 0, self.mem.localcurrency)
for i in self.mem.data.investments_active().arr:
for o in i.op_actual:
if o.pci_position() == mode.id:
if self.radCurrent.isChecked():
total = total + o.balance(
i.product.result.basic.last,
eMoneyCurrency.User)
else:
total = total + o.invertido(eMoneyCurrency.User)
if mode.id == 'c':
total = total + self.accounts
self.viewPCI.pie.appendData(mode.name.upper(), total)
if self.radCurrent.isChecked():
self.viewPCI.pie.setTitle(
self.tr("Investment current balance by Put / Call / Inline"))
else:
self.viewPCI.pie.setTitle(
self.tr("Invested balance by Put / Call / Inline"))
self.viewPCI.display()
def balance(self, date=None):
"""Give the sum of all accounts balances in self.arr"""
res = Money(self.mem, 0, self.mem.localcurrency)
for ac in self.arr:
res = res + ac.balance(date, type=3)
return res
def money(self, amount):
return Money(self.mem, amount, self.currency)
def myqtablewidget(self, wdg, emoneycurrency, current=True):
wdg.table.setColumnCount(7)
wdg.table.setHorizontalHeaderItem(0, qcenter(self.tr("Date")))
wdg.table.setHorizontalHeaderItem(1, qcenter(self.tr("Concept")))
wdg.table.setHorizontalHeaderItem(2, qcenter(self.tr("Gross")))
wdg.table.setHorizontalHeaderItem(3, qcenter(self.tr("Withholding")))
wdg.table.setHorizontalHeaderItem(4, qcenter(self.tr("Comission")))
wdg.table.setHorizontalHeaderItem(5, qcenter(self.tr("Net")))
wdg.table.setHorizontalHeaderItem(6, qcenter(self.tr("DPS")))
#DATA
wdg.applySettings()
wdg.table.clearContents()
currency = self.investment.resultsCurrency(emoneycurrency)
wdg.table.setRowCount(self.length() + 1)
sumneto = Money(self.mem, 0, currency)
sumbruto = Money(self.mem, 0, currency)
sumretencion = Money(self.mem, 0, currency)
sumcomision = Money(self.mem, 0, currency)
for i, d in enumerate(self.arr):
if current == True and self.investment.op_actual.length(
) > 0 and d.datetime < self.investment.op_actual.first().datetime:
wdg.table.hideRow(i)
continue
else:
wdg.table.showRow(i)
sumneto = sumneto + d.net(emoneycurrency)
sumbruto = sumbruto + d.gross(emoneycurrency)
sumretencion = sumretencion + d.retention(emoneycurrency)
sumcomision = sumcomision + d.commission(emoneycurrency)
wdg.table.setItem(i, 0,
qdatetime(d.datetime, self.mem.localzone_name))
wdg.table.setItem(i, 1, qleft(d.opercuenta.concept.name))
wdg.table.setItem(i, 2, d.gross(emoneycurrency).qtablewidgetitem())
wdg.table.setItem(i, 3,
d.retention(emoneycurrency).qtablewidgetitem())
wdg.table.setItem(i, 4,
d.commission(emoneycurrency).qtablewidgetitem())
wdg.table.setItem(i, 5, d.net(emoneycurrency).qtablewidgetitem())
wdg.table.setItem(i, 6, d.dps(emoneycurrency).qtablewidgetitem())
wdg.table.setItem(self.length(), 1, qleft(self.tr("TOTAL")))
wdg.table.setItem(self.length(), 2, sumbruto.qtablewidgetitem())
wdg.table.setItem(self.length(), 3, sumretencion.qtablewidgetitem())
wdg.table.setItem(self.length(), 4, sumcomision.qtablewidgetitem())
wdg.table.setItem(self.length(), 5, sumneto.qtablewidgetitem())
return (sumneto, sumbruto, sumretencion, sumcomision)
def commission(self):
r = Money(self.mem, 0, self.mem.localcurrency)
for d in self.arr:
r = r + d.commission(eMoneyCurrency.User)
return r
def retention(self):
r = Money(self.mem, 0, self.mem.localcurrency)
for d in self.arr:
r = r + d.retention(eMoneyCurrency.User)
return r
def gross(self):
r = Money(self.mem, 0, self.mem.localcurrency)
for d in self.arr:
r = r + d.gross(eMoneyCurrency.User)
return r
