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 _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'))