def _prepare_report_line(self, quantity, move_out=None, move_in=None, replenishment_filled=True, product=False, reservation=False):
timezone = self._context.get('tz')
product = product or (move_out.product_id if move_out else move_in.product_id)
is_late = move_out.date < move_in.date if (move_out and move_in) else False
move_to_match_ids = self.env.context.get('move_to_match_ids') or []
move_in_id = move_in.id if move_in else None
move_out_id = move_out.id if move_out else None
return {
'document_in': move_in._get_source_document() if move_in else False,
'document_out': move_out._get_source_document() if move_out else False,
'product': {
'id': product.id,
'display_name': product.display_name
},
'replenishment_filled': replenishment_filled,
'uom_id': product.uom_id,
'receipt_date': format_date(self.env, move_in.date) if move_in else False,
'delivery_date': format_date(self.env, move_out.date) if move_out else False,
'is_late': is_late,
'quantity': quantity,
'move_out': move_out,
'move_in': move_in,
'reservation': reservation,
'is_matched': any(move_id in [move_in_id, move_out_id] for move_id in move_to_match_ids),
}
def _compute_l10n_de_template_data(self):
self.l10n_de_template_data = [
(_("Invoice No."), 'INV/2021/12345'),
(_("Invoice Date"), format_date(self.env, fields.Date.today())),
(_("Due Date"),
format_date(self.env, fields.Date.add(fields.Date.today(),
days=7))),
(_("Reference"), 'SO/2021/45678'),
]
def _compute_l10n_din5008_template_data(self):
for record in self:
record.l10n_din5008_template_data = data = []
if record.origin:
data.append((_("Order"), record.origin))
if record.state == 'done':
data.append((_("Shipping Date"), format_date(self.env, record.date_done)))
else:
data.append((_("Shipping Date"), format_date(self.env, record.scheduled_date)))
def _compute_l10n_de_template_data(self):
for record in self:
record.l10n_de_template_data = data = []
if record.product_id:
data.append((_("Product to Repair"), record.product_id.name))
if record.lot_id:
data.append((_("Lot/Serial Number"), record.lot_id.name))
if record.guarantee_limit:
data.append((_("Warranty"),
format_date(self.env, record.guarantee_limit)))
data.append(
(_("Printing Date"), format_date(self.env,
fields.Date.today())))
def _compute_l10n_de_template_data(self):
for record in self:
record.l10n_de_template_data = data = []
if record.name:
data.append((_("Invoice No."), record.name))
if record.invoice_date:
data.append((_("Invoice Date"),
format_date(self.env, record.invoice_date)))
if record.invoice_date_due:
data.append((_("Due Date"),
format_date(self.env, record.invoice_date_due)))
if record.invoice_origin:
data.append((_("Source"), record.invoice_origin))
if record.ref:
data.append((_("Reference"), record.ref))
def test_project_update_description_profitability(self):
self.project_pigs.allow_billable = True
template_values = self.env['project.update']._get_template_values(
self.project_pigs)
today = fields.Date.context_today(self.project_pigs)
self.assertEqual(
template_values['profitability']['month'],
format_date(self.env, today, date_format='LLLL y'),
"The month used in the template should be well defined")
self.assertEqual(
template_values['profitability']['previous_month'],
format_date(self.env, (today + relativedelta(months=-1)),
date_format='LLLL'),
"The previous month used in the template should be well defined")
self.assertTrue(
template_values['profitability']['is_timesheet_uom_hour'],
"Default timesheet uom is hour.")
self.assertEqual(
template_values['profitability']['timesheet_uom'], "hours",
"Default timesheet uom should be displayed as 'hours'")
self.assertEqual(
template_values['profitability']['timesheet_unit_amount'], '0',
"Timesheet unit amount used in the template should be defined.")
self.assertEqual(
template_values['profitability']['previous_timesheet_unit_amount'],
'0',
"Previous Timesheet unit amount used in the template should be defined."
)
self.assertEqual(
template_values['profitability']['timesheet_trend'], "0",
"Timesheet trend used in the template should be well defined.")
self.assertEqual(
template_values['profitability']['costs'], "$\xa00.00",
"Project costs used in the template should be well defined")
self.assertEqual(
template_values['profitability']['revenues'], "$\xa00.00",
"Project revenues used in the template should be well defined")
self.assertEqual(template_values['profitability']['margin'], 0,
"Margin used in the template should be well defined")
self.assertEqual(
template_values['profitability']['margin_formatted'], "$\xa00.00",
"Margin formatted used in the template should be well defined")
self.assertEqual(
template_values['profitability']['margin_percentage'], "0",
"Margin percentage used in the template should be well defined")
self.assertEqual(
template_values['profitability']['billing_rate'], "0",
"Billing rate used in the template should be well defined")
def _get_days_request(self):
self.ensure_one()
closest_allocation_remaining = (
self.closest_allocation_to_expire.max_leaves -
self.closest_allocation_to_expire.leaves_taken
) if self.closest_allocation_to_expire else False
return (self.name, {
'remaining_leaves':
('%.2f' % self.remaining_leaves).rstrip('0').rstrip('.'),
'virtual_remaining_leaves':
('%.2f' % self.virtual_remaining_leaves).rstrip('0').rstrip('.'),
'max_leaves': ('%.2f' % self.max_leaves).rstrip('0').rstrip('.'),
'leaves_taken':
('%.2f' % self.leaves_taken).rstrip('0').rstrip('.'),
'virtual_leaves_taken':
('%.2f' % self.virtual_leaves_taken).rstrip('0').rstrip('.'),
'leaves_requested':
('%.2f' % (self.max_leaves - self.virtual_remaining_leaves -
self.leaves_taken)).rstrip('0').rstrip('.'),
'leaves_approved':
('%.2f' % self.leaves_taken).rstrip('0').rstrip('.'),
'closest_allocation_remaining':
('%.2f' % closest_allocation_remaining).rstrip('0').rstrip('.'),
'closest_allocation_expire':
format_date(self.env,
self.closest_allocation_to_expire.date_to,
date_format="MM/dd/yyyy")
if self.closest_allocation_to_expire.date_to else False,
'request_unit':
self.request_unit,
'icon':
self.sudo().icon_id.url,
}, self.requires_allocation, self.id)
def format_date(env, date, pattern=False):
if not date:
return ''
try:
return tools.format_date(env, date, date_format=pattern)
except babel.core.UnknownLocaleError:
return date
def test_check_single_date(self):
self.assertEqual(
len(self.so.picking_ids),
0,
"There must not be pickings for the SO when draft",
)
self.so.action_confirm()
self.assertEqual(
len(self.so.picking_ids),
1,
"There must be 1 picking for the SO when confirmed",
)
self.assertEqual(
self.so.picking_ids[0].scheduled_date,
self.date_sooner,
"The picking must be planned at the expected date",
)
self.assertEqual(
self.so_line1.procurement_group_id,
self.so_line2.procurement_group_id,
"The procurement group must be the same",
)
self.assertIn(
format_date(self.env, self.date_sooner.date()),
self.so_line1.procurement_group_id.name,
)
def test_check_same_dates(self):
# Change the date of the second line by just adding 1 hour
same_date = self.dt1 + datetime.timedelta(hours=1)
self.so_line2.commitment_date = same_date
self.assertEqual(
len(self.so.picking_ids),
0,
"There must not be pickings for the SO when draft",
)
self.so.action_confirm()
self.assertEqual(
len(self.so.picking_ids),
1,
"There must be only one picking for the SO when confirmed",
)
self.assertEqual(
self.so.picking_ids.scheduled_date,
self.date_sooner,
"The picking must be planned at the expected date",
)
self.assertEqual(
self.so_line1.procurement_group_id,
self.so_line2.procurement_group_id,
"The procurement group must be the same",
)
self.assertIn(
format_date(self.env, self.date_sooner.date()),
self.so_line1.procurement_group_id.name,
)
def _get_formatted_scheduled_date(self, source):
""" Unfortunately different source record types have different field names for their "Scheduled Date"
Therefore an extendable method is needed.
"""
if source._name == 'stock.picking':
return format_date(self.env, source.scheduled_date)
return False
def _check_unvalid_taxes(self):
invoices_in_error, errors = self.browse(), []
for invoice in self:
date_invoice = invoice.date_invoice or fields.Date.today()
for tax in invoice.mapped('invoice_line_ids.invoice_line_tax_ids'):
if tax.date_start and date_invoice < tax.date_start:
invoices_in_error |= invoice
errors.append(
_('The tax %s shall apply from %s') %
(tax.name, format_date(self.env, tax.date_start)))
if tax.date_stop and date_invoice > tax.date_stop:
invoices_in_error |= invoice
errors.append(
_('The tax %s shall apply to %s') %
(tax.name, format_date(self.env, tax.date_stop)))
return invoices_in_error, errors
def write_line(self, line_object):
"""Write a line on current line using all defined columns field name.
Columns are defined with `_get_report_columns` method.
"""
for col_pos, column in self.columns.items():
value = getattr(line_object, column['field'])
if isinstance(value, datetime.date):
value = format_date(self.env, value)
cell_type = column.get('type', 'string')
if cell_type == 'many2one':
self.sheet.write_string(
self.row_pos, col_pos, value.name or '', self.format_right)
elif cell_type == 'string':
if hasattr(line_object, 'account_group_id') and \
line_object.account_group_id:
self.sheet.write_string(self.row_pos, col_pos, value or '',
self.format_bold)
else:
self.sheet.write_string(self.row_pos, col_pos, value or '')
elif cell_type == 'amount':
if hasattr(line_object, 'account_group_id') and \
line_object.account_group_id:
cell_format = self.format_amount_bold
else:
cell_format = self.format_amount
self.sheet.write_number(
self.row_pos, col_pos, float(value), cell_format
)
elif cell_type == 'amount_currency':
if line_object.currency_id:
format_amt = self._get_currency_amt_format(line_object)
self.sheet.write_number(
self.row_pos, col_pos, float(value), format_amt
)
self.row_pos += 1
def _compute_xml_data(self):
for att in self:
if not att.registered:
wiz_obj = self.env['wizard.import.fatturapa'] \
.with_context(from_attachment=att)
fatt = wiz_obj.get_invoice_obj(att)
cedentePrestatore = fatt.FatturaElettronicaHeader.CedentePrestatore
partner_id = wiz_obj.getCedPrest(cedentePrestatore)
att.xml_supplier_id = partner_id
att.invoices_number = len(fatt.FatturaElettronicaBody)
att.invoices_total = 0
att.is_self_invoice = False
invoices_date = []
for invoice_body in fatt.FatturaElettronicaBody:
att.invoices_total += float(
invoice_body.DatiGenerali.DatiGeneraliDocumento.
ImportoTotaleDocumento or 0)
invoice_date = format_date(
att.with_context(lang=att.env.user.lang).env,
fields.Date.from_string(invoice_body.DatiGenerali.
DatiGeneraliDocumento.Data))
if invoice_date not in invoices_date:
invoices_date.append(invoice_date)
if invoice_body.DatiGenerali.DatiGeneraliDocumento.TipoDocumento \
in SELF_INVOICE_TYPES:
att.is_self_invoice = True
att.invoices_date = ' '.join(invoices_date)
else:
att.xml_supplier_id = False
att.invoices_number = 0
att.invoices_total = 0
att.is_self_invoice = False
att.invoices_date = False
def format_date(env, date, pattern=False):
if not date:
return ''
try:
return tools.format_date(env, date, date_format=pattern)
except babel.core.UnknownLocaleError:
return date
def _prepare_procurement_group_by_line(self, line):
vals = super(SaleOrder, self)._prepare_procurement_group_by_line(line)
if line._get_procurement_group_key()[0] == 24:
if line.commitment_date:
vals["name"] += "/" + format_date(line.env,
line.commitment_date.date())
return vals
def format_date(env, date, pattern=False, lang_code=False):
try:
return tools.format_date(env,
date,
date_format=pattern,
lang_code=lang_code)
except babel.core.UnknownLocaleError:
return date
def _compute_json_popover(self):
FloatConverter = self.env['ir.qweb.field.float']
for orderpoint in self:
if not orderpoint.product_id or not orderpoint.location_id:
orderpoint.json_lead_days_popover = False
continue
dummy, lead_days_description = orderpoint.rule_ids._get_lead_days(
orderpoint.product_id)
orderpoint.json_lead_days_popover = dumps({
'title':
_('Replenishment'),
'icon':
'fa-area-chart',
'popoverTemplate':
'stock.leadDaysPopOver',
'lead_days_date':
format_date(self.env, orderpoint.lead_days_date),
'lead_days_description':
lead_days_description,
'today':
format_date(self.env, fields.Date.today()),
'trigger':
orderpoint.trigger,
'qty_forecast':
FloatConverter.value_to_html(
orderpoint.qty_forecast,
{'decimal_precision': 'Product Unit of Measure'}),
'qty_to_order':
FloatConverter.value_to_html(
orderpoint.qty_to_order,
{'decimal_precision': 'Product Unit of Measure'}),
'product_min_qty':
FloatConverter.value_to_html(
orderpoint.product_min_qty,
{'decimal_precision': 'Product Unit of Measure'}),
'product_max_qty':
FloatConverter.value_to_html(
orderpoint.product_max_qty,
{'decimal_precision': 'Product Unit of Measure'}),
'product_uom_name':
orderpoint.product_uom_name,
'virtual':
orderpoint.trigger == 'manual'
and orderpoint.create_uid.id == SUPERUSER_ID,
})
def _format_afip_doc_types(self, ws, response):
""" Given the response and the Webservice used, returns a more legible message to be shown to the users. """
if ws == 'wsfe':
if response['Errors']:
raise UserError(response['Errors'])
elif response['Events']:
raise UserError(response['Events'])
result_key = 'ResultGet'
voucher_key = 'CbteTipo'
id_key = 'Id'
name_key = 'Desc'
date_from_key = 'FchDesde'
date_to_key = 'FchHasta'
elif ws == 'wsfex' or ws == 'wsbfe':
error_key = 'FEXErr' if ws == 'wsfex' else 'BFEErr'
events_key = 'FEXEvents' if ws == 'wsfex' else 'BFEEvents'
if response[error_key]['ErrMsg'] != 'OK':
raise UserError(response[error_key]['ErrMsg'])
elif response[events_key]['EventMsg'] != 'Ok':
raise UserError(response[events_key]['EventMsg'])
result_key = 'FEXResultGet' if ws == 'wsfex' else 'BFEResultGet'
voucher_key = 'ClsFEXResponse_Cbte_Tipo' if ws == 'wsfex' else 'ClsBFEResponse_Tipo_Cbte'
id_key = 'Cbte_Id'
name_key = 'Cbte_Ds'
date_from_key = 'Cbte_vig_desde'
date_to_key = 'Cbte_vig_hasta'
msg = ""
for document in response[result_key][voucher_key]:
date_from = format_date(self.env,
datetime.datetime.strptime(
document[date_from_key], '%Y%m%d'),
date_format='dd/MM/Y')
line = " - [" + str(
document[id_key]
) + "] " + document[name_key] + " Vigente desde: " + date_from
if document[date_to_key] != 'NULL':
date_to = format_date(self.env,
datetime.datetime.strptime(
document[date_to_key], '%Y%m%d'),
date_format='dd/MM/Y')
line += " hasta: " + date_to
msg += line + "\n"
return msg
def _prepare_survey_data(self, survey_sudo, answer_sudo, **post):
""" This method prepares all the data needed for template rendering, in function of the survey user input state.
:param post:
- previous_page_id : come from the breadcrumb or the back button and force the next questions to load
to be the previous ones. """
data = {
'survey':
survey_sudo,
'answer':
answer_sudo,
'breadcrumb_pages': [{
'id': page.id,
'title': page.title,
} for page in survey_sudo.page_ids],
'format_datetime':
lambda dt: format_datetime(request.env, dt, dt_format=False),
'format_date':
lambda date: format_date(request.env, date)
}
page_or_question_key = 'question' if survey_sudo.questions_layout == 'page_per_question' else 'page'
# Bypass all if page_id is specified (comes from breadcrumb or previous button)
if 'previous_page_id' in post:
previous_page_or_question_id = int(post['previous_page_id'])
new_previous_id = survey_sudo._previous_page_or_question_id(
answer_sudo, previous_page_or_question_id)
data.update({
page_or_question_key:
request.env['survey.question'].sudo().browse(
previous_page_or_question_id),
'previous_page_id':
new_previous_id
})
return data
if answer_sudo.state == 'in_progress':
page_or_question_id, is_last = survey_sudo.next_page_or_question(
answer_sudo, answer_sudo.last_displayed_page_id.id
if answer_sudo.last_displayed_page_id else 0)
data.update({
page_or_question_key: page_or_question_id,
})
if survey_sudo.questions_layout != 'one_page':
data.update({
'previous_page_id':
survey_sudo._previous_page_or_question_id(
answer_sudo, page_or_question_id.id)
})
if is_last:
data.update({'last': True})
elif answer_sudo.state == 'done' or answer_sudo.is_time_limit_reached: # Display success message
return self._prepare_survey_finished_values(
survey_sudo, answer_sudo)
return data
def _prepare_report_line(self,
quantity,
move_out=None,
move_in=None,
replenishment_filled=True,
product=False):
timezone = self._context.get('tz')
product = product or (move_out.product_id
if move_out else move_in.product_id)
is_late = move_out.date < move_in.date if (move_out
and move_in) else False
return {
'document_in':
move_in._get_source_document() if move_in else False,
'document_out':
move_out._get_source_document() if move_out else False,
'product': {
'id': product.id,
'display_name': product.display_name
},
'replenishment_filled':
replenishment_filled,
'uom_id':
product.uom_id,
'receipt_date':
format_datetime(self.env, move_in.date, timezone, 'medium')
if move_in else False,
'delivery_date':
format_datetime(self.env, move_out.date, timezone, 'medium')
if move_out else False,
'receipt_date_short':
format_date(self.env, move_in.date) if move_in else False,
'delivery_date_short':
format_date(self.env, move_out.date) if move_out else False,
'is_late':
is_late,
'quantity':
quantity,
'move_out':
move_out,
'move_in':
move_in,
}
def _compute_json_lead_days(self):
self.json_lead_days = False
for replenishment_report in self:
if not replenishment_report.orderpoint_id.product_id or not replenishment_report.orderpoint_id.location_id:
continue
orderpoint = replenishment_report.orderpoint_id
orderpoints_values = orderpoint._get_lead_days_values()
dummy, lead_days_description = orderpoint.rule_ids._get_lead_days(
orderpoint.product_id, **orderpoints_values)
replenishment_report.json_lead_days = dumps({
'template':
'stock.leadDaysPopOver',
'lead_days_date':
format_date(self.env,
replenishment_report.orderpoint_id.lead_days_date),
'lead_days_description':
lead_days_description,
'today':
format_date(self.env, fields.Date.today()),
'trigger':
orderpoint.trigger,
'qty_forecast':
self.env['ir.qweb.field.float'].value_to_html(
orderpoint.qty_forecast,
{'decimal_precision': 'Product Unit of Measure'}),
'qty_to_order':
self.env['ir.qweb.field.float'].value_to_html(
orderpoint.qty_to_order,
{'decimal_precision': 'Product Unit of Measure'}),
'product_min_qty':
self.env['ir.qweb.field.float'].value_to_html(
orderpoint.product_min_qty,
{'decimal_precision': 'Product Unit of Measure'}),
'product_max_qty':
self.env['ir.qweb.field.float'].value_to_html(
orderpoint.product_max_qty,
{'decimal_precision': 'Product Unit of Measure'}),
'product_uom_name':
orderpoint.product_uom_name,
'virtual':
orderpoint.trigger == 'manual'
and orderpoint.create_uid.id == SUPERUSER_ID,
})
def _compute_l10n_din5008_template_data(self):
for record in self:
record.l10n_din5008_template_data = data = []
if record.state in ('draft', 'sent'):
if record.name:
data.append((_("Quotation No."), record.name))
if record.date_order:
data.append((_("Quotation Date"), format_date(self.env, record.date_order)))
if record.validity_date:
data.append((_("Expiration"), format_date(self.env, record.validity_date)))
else:
if record.name:
data.append((_("Order No."), record.name))
if record.date_order:
data.append((_("Order Date"), format_date(self.env, record.date_order)))
if record.client_order_ref:
data.append((_('Customer Reference'), record.client_order_ref))
if record.user_id:
data.append((_("Salesperson"), record.user_id.name))
if 'incoterm' in record._fields and record.incoterm:
data.append((_("Incoterm"), record.incoterm.code))
def test_check_multiple_dates(self):
# Change the date of the second line
self.so_line2.commitment_date = self.dt2
self.assertEqual(
len(self.so.picking_ids),
0,
"There must not be pickings for the SO when draft",
)
self.so.action_confirm()
self.assertEqual(
len(self.so.picking_ids),
2,
"There must be 2 pickings for the SO when confirmed",
)
sorted_pickings = self.so.picking_ids.sorted(lambda x: x.scheduled_date)
self.assertEqual(
sorted_pickings[0].scheduled_date,
self.date_sooner,
"The first picking must be planned at the soonest date",
)
self.assertEqual(
sorted_pickings[1].scheduled_date,
self.date_later,
"The second picking must be planned at the latest date",
)
self.assertNotEqual(
self.so_line1.procurement_group_id,
self.so_line2.procurement_group_id,
"The procurement group must be different",
)
self.assertIn(
format_date(self.env, self.date_sooner.date()),
self.so_line1.procurement_group_id.name,
)
self.assertIn(
format_date(self.env, self.date_later.date()),
self.so_line2.procurement_group_id.name,
)
def _compute_l10n_din5008_template_data(self):
for record in self:
record.l10n_din5008_template_data = data = []
if record.state == 'draft':
data.append((_("Request for Quotation No."), record.name))
elif record.state in ['sent', 'to approve', 'purchase', 'done']:
data.append((_("Purchase Order No."), record.name))
elif record.state == 'cancel':
data.append((_("Cancelled Purchase Order No."), record.name))
if record.user_id:
data.append(
(_("Purchase Representative"), record.user_id.name))
if record.partner_ref:
data.append((_("Order Reference"), record.partner_ref))
if record.date_approve:
data.append(
(_("Order Date"), format_date(self.env,
record.date_approve)))
elif record.date_order:
data.append((_("Order Deadline"),
format_date(self.env, record.date_order)))
if record.incoterm_id:
data.append((_("Incoterm"), record.incoterm_id.code))
class HrPayrollIndex(models.TransientModel):
_name = 'hr.payroll.index'
_description = 'Index contracts'
@api.model
def default_get(self, field_list):
res = super().default_get(field_list)
res['contract_ids'] = self.env.context.get('active_ids', [])
return res
percentage = fields.Float("Percentage", widget='percentage')
description = fields.Char(
"Description",
default=lambda self: _("Wage indexed on %s") % format_date(
self.env, fields.Date.today()),
help=
"Will be used as the message specifying why the wage on the contract has been modified"
)
contract_ids = fields.Many2many('hr.contract', string="Contracts")
display_warning = fields.Boolean("Error",
compute='_compute_display_warning')
@api.depends('contract_ids')
def _compute_display_warning(self):
for index in self:
contracts = index.contract_ids
index.display_warning = any(contract.state != 'open'
for contract in contracts)
def _index_wage(self, contract):
contract.write(
{'wage': contract.wage + contract.wage * self.percentage / 100})
def action_confirm(self):
self.ensure_one()
if self.display_warning:
raise UserError(
_('You have selected non running contracts, if you really need to index them, please do it by hand'
))
if self.percentage:
for contract in self.contract_ids:
self._index_wage(contract)
contract.message_post(body=self.description,
message_type="comment",
subtype="mail.mt_note")
def get_columns_name(self, options):
columns = [{}]
columns += [{
'name': v,
'class': 'number',
'style': 'white-space:nowrap;'
} for v in [
_("Not due on %s").replace(' ', ' ') %
format_date(self.env, options['date']['date']),
_("0 - 30").replace(' ', ' '),
_("30 - 60").replace(' ', ' '),
_("60 - 90").replace(' ', ' '),
_("90 - 360").replace(' ', ' '),
_("Over 360"),
_("Total")
]]
return columns
def _retrieve_transactions(self):
start_date = self.last_sync or fields.Date().today() - relativedelta(
days=15)
last_stmt_line = self.env['account.bank.statement.line'].search(
[('date', '<=', start_date),
('online_transaction_identifier', '!=', False),
('journal_id', 'in', self.journal_ids.ids),
('online_account_id', '=', self.id)],
order="date desc",
limit=1)
transactions = []
data = {
'start_date':
format_date(self.env, start_date, date_format='yyyy-MM-dd'),
'account_id':
self.online_identifier,
'last_transaction_identifier':
last_stmt_line.online_transaction_identifier,
'currency_code':
self.journal_ids[0].currency_id.name,
}
while True:
# While this is kind of a bad practice to do, it can happen that provider_data/account_data change between
# 2 calls, the reason is that those field contains the encrypted information needed to access the provider
# and first call can result in an error due to the encrypted token inside provider_data being expired for example.
# In such a case, we renew the token with the provider and send back the newly encrypted token inside provider_data
# which result in the information having changed, henceforth why those field are passed at every loop.
data.update({
'provider_data': self.account_online_link_id.provider_data,
'account_data': self.account_data
})
resp_json = self.account_online_link_id._fetch_odoo_fin(
'/proxy/v1/transactions', data=data)
if resp_json.get('balance'):
self.balance = resp_json['balance']
if resp_json.get('account_data'):
self.account_data = resp_json['account_data']
transactions += resp_json.get('transactions', [])
if not resp_json.get('next_data'):
break
data['next_data'] = resp_json.get('next_data') or {}
return self.env['account.bank.statement']._online_sync_bank_statement(
transactions, self)
def survey_print(self,
survey_token,
review=False,
answer_token=None,
**post):
'''Display an survey in printable view; if <answer_token> is set, it will
grab the answers of the user_input_id that has <answer_token>.'''
access_data = self._get_access_data(survey_token,
answer_token,
ensure_token=False)
if access_data['validity_code'] is not True and (
access_data['has_survey_access']
or access_data['validity_code']
not in ['token_required', 'survey_closed', 'survey_void']):
return self._redirect_with_error(access_data,
access_data['validity_code'])
survey_sudo, answer_sudo = access_data['survey_sudo'], access_data[
'answer_sudo']
if survey_sudo.scoring_type == 'scoring_without_answers':
return request.render("survey.survey_403_page",
{'survey': survey_sudo})
return request.render(
'survey.survey_page_print', {
'is_html_empty':
is_html_empty,
'review':
review,
'survey':
survey_sudo,
'answer':
answer_sudo,
'questions_to_display':
answer_sudo._get_print_questions(),
'scoring_display_correction':
survey_sudo.scoring_type == 'scoring_with_answers'
and answer_sudo,
'format_datetime':
lambda dt: format_datetime(request.env, dt, dt_format=False),
'format_date':
lambda date: format_date(request.env, date),
})
def _prepare_invoice_data(self):
self.ensure_one()
if not self.partner_id:
raise UserError(_("You must first select a Customer for Subscription %s!") % self.name)
if 'force_company' in self.env.context:
company = self.env['res.company'].browse(self.env.context['force_company'])
else:
company = self.company_id
self = self.with_context(force_company=company.id, company_id=company.id)
fpos_id = self.env['account.fiscal.position'].get_fiscal_position(self.partner_id.id)
journal = self.template_id.journal_id or self.env['account.journal'].search([('type', '=', 'sale'), ('company_id', '=', company.id)], limit=1)
if not journal:
raise UserError(_('Please define a sale journal for the company "%s".') % (company.name or '', ))
next_date = fields.Date.from_string(self.recurring_next_date)
if not next_date:
raise UserError(_('Please define Date of Next Invoice of "%s".') % (self.display_name,))
periods = {'daily': 'days', 'weekly': 'weeks', 'monthly': 'months', 'yearly': 'years'}
end_date = next_date + relativedelta(**{periods[self.recurring_rule_type]: self.recurring_interval})
end_date = end_date - relativedelta(days=1) # remove 1 day as normal people thinks in term of inclusive ranges.
addr = self.partner_id.address_get(['delivery'])
return {
'account_id': self.partner_id.property_account_receivable_id.id,
'type': 'out_invoice',
'partner_id': self.partner_id.id,
'partner_shipping_id': addr['delivery'],
'currency_id': self.pricelist_id.currency_id.id,
'journal_id': journal.id,
'origin': self.code,
'fiscal_position_id': fpos_id,
'payment_term_id': self.partner_id.property_payment_term_id.id,
'company_id': company.id,
'comment': _("This invoice covers the following period: %s - %s") % (format_date(self.env, next_date), format_date(self.env, end_date)),
'user_id': self.user_id.id,
'sent_by_mail': True if self.sent_by_mail else False,
'subscription_id' : self.id,
}
def get_date_range_str(self, lang_code=False):
self.ensure_one()
today = fields.Datetime.now()
event_date = self.event_begin_date
diff = (event_date.date() - today.date())
if diff.days <= 0:
return _('today')
elif diff.days == 1:
return _('tomorrow')
elif (diff.days < 7):
return _('in %d days') % (diff.days, )
elif (diff.days < 14):
return _('next week')
elif event_date.month == (today + relativedelta(months=+1)).month:
return _('next month')
else:
return _('on %(date)s',
date=format_date(self.env,
self.event_begin_date,
lang_code=lang_code,
date_format='medium'))
def value_to_html(self, value, options):
return format_date(self.env, value, date_format=options.get('format'))
