class OpenRegion(Wizard): "Open Region" __name__ = 'sale.reporting.region.open' start = StateTransition() country = StateAction('sale.act_reporting_country_time_series') subdivision = StateAction( 'sale.act_reporting_country_subdivision_time_series') def transition_start(self): pool = Pool() Region = pool.get('sale.reporting.region') Country = pool.get('sale.reporting.country') Subdivision = pool.get('sale.reporting.country.subdivision') region = Region(Transaction().context['active_id']) record = Region.union_unshard(region.id) if isinstance(record, Country): return 'country' elif isinstance(record, Subdivision): return 'subdivision' def _do_action(self, action): pool = Pool() Region = pool.get('sale.reporting.region') region = Region(Transaction().context['active_id']) record = Region.union_unshard(region.id) data = { 'id': record.id, 'ids': [record.id], } action['name'] += ' (%s)' % record.rec_name return action, data do_country = _do_action do_subdivision = _do_action
def do_print_(self, action): fiscalyear = (self.start.fiscalyear.id if self.start.fiscalyear else None) if self.start.start_date: fiscalyear = None data = { 'company': self.start.company.id, 'fiscalyear': fiscalyear, 'start_date': self.start.start_date, 'end_date': self.start.end_date, 'periods': [x.id for x in self.start.periods], 'parties': [x.id for x in self.start.parties], 'output_format': self.start.output_format, 'partner_type': self.start.partner_type, 'totals_only': self.start.totals_only, 'grouping': self.start.grouping, 'tax_type': self.start.tax_type, } if data['grouping'] == 'invoice': state_action = StateAction('account_jasper_reports.' 'report_taxes_by_invoice_and_period') action = state_action.get_action() return action, data
class OpenEvaluations(Wizard): 'Open Evaluations' __name__ = 'gnuhealth.evaluations.open' start = StateView('gnuhealth.evaluations.open.start', 'health_reporting.evaluations_open_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Open', 'select', 'tryton-ok', default=True), ]) select = StateTransition() open_doctor = StateAction('health_reporting.act_evaluations_doctor') open_specialty = StateAction('health_reporting.act_evaluations_specialty') open_sector = StateAction('health_reporting.act_evaluations_sector') def transition_select(self): return 'open_' + self.start.group_by def do_open_doctor(self, action): action['pyson_context'] = PYSONEncoder().encode({ 'start_date': self.start.start_date, 'end_date': self.start.end_date, }) return action, {} def do_open_specialty(self, action): action['pyson_context'] = PYSONEncoder().encode({ 'start_date': self.start.start_date, 'end_date': self.start.end_date, }) return action, {} def do_open_sector(self, action): action['pyson_context'] = PYSONEncoder().encode({ 'start_date': self.start.start_date, 'end_date': self.start.end_date, }) return action, {} def transition_open_doctor(self): return 'end' def transition_open_specialty(self): return 'end' def transition_open_sector(self): return 'end'
class ExportShipmentStatus(Wizard): """ Export Shipment Status Wizard Exports shipment status for sale orders related to current store view """ __name__ = 'magento.wizard_export_shipment_status' start = StateView( 'magento.wizard_export_shipment_status.start', 'magento.wizard_export_shipment_status_view_start_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Continue', 'export_', 'tryton-ok', default=True), ]) export_ = StateAction('sale.act_sale_form') def do_export_(self, action): """Handles the transition""" StoreView = Pool().get('magento.store.store_view') storeview = StoreView(Transaction().context.get('active_id')) sales = storeview.export_shipment_status_to_magento() action['pyson_domain'] = PYSONEncoder().encode([('id', 'in', map(int, sales))]) return action, {} def transition_export_(self): return 'end'
class PrintReportTransfer(Wizard): 'Print Report Transfer ' __name__ = 'print_report_transfer' start = StateView( 'print_report_transfer.start', 'nodux_purchase_product_stock_one.print_transfer_report_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Print', 'print_', 'tryton-print', default=True), ]) print_ = StateAction('nodux_purchase_product_stock_one.report_transfer') def do_print_(self, action): if self.start.product: data = { 'company': self.start.company.id, 'all_products': self.start.all_products, 'product': self.start.product.id, 'date': self.start.date, 'date_end': self.start.date_end, } else: data = { 'company': self.start.company.id, 'all_products': self.start.all_products, 'product': None, 'date': self.start.date, 'date_end': self.start.date_end, } return action, data def transition_print_(self): return 'end'
class OpenTotal(Wizard): 'Open Total' __name__ = 'nodux_electronic_invoice_auth.print_total' start = StateView('nodux_electronic_invoice_auth.print_total_voucher.start', 'nodux_electronic_invoice_auth.print_total_voucher_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Print', 'print_', 'tryton-ok', default=True), ]) print_ = StateAction('nodux_electronic_invoice_auth.report_total_voucher') def do_print_(self, action): if self.start.start_period: start_period = self.start.start_period.id else: start_period = None if self.start.end_period: end_period = self.start.end_period.id else: end_period = None if self.start.party: start_party = self.start.party.id else: start_party = None data = { 'party': start_party, 'fiscalyear': self.start.fiscalyear.id, 'start_period': start_period, 'end_period': end_period, } return action, data def transition_print_(self): return 'end'
class OpenSamplesComparator(Wizard): 'Samples Comparator' __name__ = 'lims.samples_comparator.open' start = StateTransition() ask = StateView('lims.samples_comparator.ask', 'lims_diagnosis.samples_comparator_ask_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Open', 'open_', 'tryton-ok', default=True), ]) open_ = StateAction('lims_diagnosis.act_samples_comparator') def transition_start(self): ResultsSample = Pool().get('lims.results_report.version.detail.sample') active_model = Transaction().context['active_model'] if active_model == 'lims.results_report.version.detail.sample': sample = ResultsSample(Transaction().context['active_id']) self.ask.notebook = sample.notebook.id return 'open_' return 'ask' def do_open_(self, action): SamplesComparator = Pool().get('lims.samples_comparator') notebook = self.ask.notebook lines = [{'notebook_line': l.id} for l in notebook.lines] comparison = SamplesComparator.create([{ 'notebook': notebook.id, 'lines': [('create', lines)], }])[0] action['res_id'] = [comparison.id] return action, {} def transition_open_(self): return 'end'
class LabDeviceGenerateMaintenance(Wizard): 'Generate Device Maintenance Calendar' __name__ = 'lims.lab.device.maintenance.generate' start_state = 'open' open = StateAction( 'lims_device_maintenance.act_lab_device_maintenance_calendar_related') def do_open(self, action): pool = Pool() MaintenanceProgram = pool.get('lims.lab.device.maintenance.program') Maintenance = pool.get('lims.lab.device.maintenance') programs = MaintenanceProgram.browse( Transaction().context['active_ids']) maintenances = MaintenanceProgram.create_events( programs, MaintenanceProgram._create_maintenances) if maintenances: Maintenance.save(maintenances) Maintenance.pending(maintenances) action['pyson_domain'] = PYSONEncoder().encode([ ('id', 'in', [m.id for m in maintenances]), ]) return action, {} def transition_open(self): return 'end'
class TestWizard(Wizard): 'Test Wizard' __name__ = 'test.test_wizard' start = StateView('test.test_wizard.start', 'tests.test_wizard_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Next', 'next_', 'tryton-next', default=True), ]) next_ = StateTransition() action = StateAction('ir.act_menu_tree') @staticmethod def default_start(fields): return { 'name': 'Test wizard', } @staticmethod def transition_next_(): return 'action' @staticmethod def do_action(action): return action, {} @staticmethod def transition_action(): return 'end'
class WithholdingOut(Wizard): 'Withholding Out' __name__ = 'nodux_account_withholding_ec.out_withholding' #crear referencias: start = StateView('nodux_account_withholding_ec.out_withholding.start', 'nodux_account_withholding_out_ec.out_withholding_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Withholding', 'withholdingOut', 'tryton-ok', default=True), ]) withholdingOut = StateAction('nodux_account_withholding_out_ec.act_withholding_form') @classmethod def __setup__(cls): super(WithholdingOut, cls).__setup__() def do_withholdingOut(self, action): pool = Pool() Invoice = pool.get('account.invoice') invoices = Invoice.browse(Transaction().context['active_ids']) for invoice in invoices: if invoice.type != 'out': self.raise_user_error('No puede generar un comprobante de retencion de cliente desde Factura de Proveedor') out_withholding = Invoice.withholdingOut(invoices) data = {'res_id': [i.id for i in out_withholding]} if len(out_withholding) == 1: action['views'].reverse() return action, data
class OpenJournalCash(Wizard): 'Open Journal Cash' __name__ = 'account.journal.open_cash' start = StateView('account.journal.open_cash.start', 'account.journal_open_cash_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Open', 'open_', 'tryton-ok', default=True), ]) open_ = StateAction('account.act_journal_open_cash') def do_open_(self, action): pool = Pool() Lang = pool.get('ir.lang') lang, = Lang.search([ ('code', '=', Transaction().language), ]) action['pyson_context'] = PYSONEncoder().encode({ 'start_date': self.start.start_date, 'end_date': self.start.end_date, }) action['name'] += ' %s - %s' % ( Lang.strftime(self.start.start_date, lang.code, lang.date), Lang.strftime(self.start.end_date, lang.code, lang.date)) return action, {}
class OpenMoveLineBalance(Wizard): 'Open Type' __name__ = 'account.move.line.balance' start_state = 'open_' open_ = StateAction('current_account.act_move_line_balance') def do_open_(self, action): Party = Pool().get('party.party') party = Party(Transaction().context['active_id']) action['pyson_domain'] = PYSONEncoder().encode([ ('party', '=', Transaction().context['active_id']), [ 'OR', ('account.type.payable', '=', True), ('account.type.receivable', '=', True) ], ]) action['pyson_context'] = PYSONEncoder().encode({ 'party': Transaction().context['active_id'], 'account_kind': ['payable', 'receivable'], }) action['name'] = 'Cuenta corriente - %s' % (party.name) return action, {}
class CreateInventories(Wizard): 'Create Inventories' __name__ = 'stock.inventory.create' start = StateView( 'stock.inventory.create.start', 'stock_inventory_location.inventory_create_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Create', 'create_', 'tryton-ok', default=True), ]) create_ = StateAction('stock.act_inventory_form') def get_inventory(self, location, Inventory): return Inventory(location=location, date=self.start.date, company=self.start.company, empty_quantity=self.start.empty_quantity) def do_create_(self, action): pool = Pool() Inventory = pool.get('stock.inventory') inventories = [ self.get_inventory(location, Inventory) for location in self.start.locations ] Inventory.save(inventories) if self.start.complete_lines: Inventory.complete_lines(inventories) data = {'res_id': [i.id for i in inventories]} return action, data
class OpenSheetSample(Wizard): 'Open Sheet Sample' __name__ = 'lims.planification.professional.open_sheet_sample' start_state = 'open_' open_ = StateAction('lims.act_lims_sample_list') def do_open_(self, action): pool = Pool() Sheet = pool.get('lims.analysis_sheet') Data = pool.get('lims.interface.data') sheet = Sheet(Transaction().context['active_id']) with Transaction().set_context( lims_interface_table=sheet.compilation.table.id): lines = Data.search([('compilation', '=', sheet.compilation.id)]) samples = [] for line in lines: nl = line.notebook_line if not nl: continue if nl.sample.id not in samples: samples.append(nl.sample.id) action['pyson_domain'] = [ ('id', 'in', samples), ] action['pyson_domain'] = PYSONEncoder().encode(action['pyson_domain']) return action, {}
class GenerateAdministrativeTask(Wizard): 'Generate Administrative Tasks Calendar' __name__ = 'lims.administrative.task.generate' start_state = 'open' open = StateAction('lims_administrative_task.act_task') def do_open(self, action): pool = Pool() TaskProgram = pool.get('lims.administrative.task.program') AdministrativeTask = pool.get('lims.administrative.task') programs = TaskProgram.browse(Transaction().context['active_ids']) tasks = TaskProgram.create_events(programs, TaskProgram._create_tasks) if tasks: AdministrativeTask.save(tasks) AdministrativeTask.pending(tasks) action['pyson_domain'] = PYSONEncoder().encode([ ('id', 'in', [t.id for t in tasks]), ]) return action, {} def transition_open(self): return 'end'
class PrintSalesmanReport(Wizard): 'Print Sale Report' __name__ = 'nodux_sale_pos_salesman.print_sale_report' start = StateView( 'nodux_sale_pos_salesman.print_sale_report.start', 'nodux_sale_pos_salesman.print_sale_report_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Print', 'print_', 'tryton-print', default=True), ]) print_ = StateAction('nodux_sale_pos_salesman.report_sale_report') def do_print_(self, action): if self.start.employee: data = { 'company': self.start.company.id, 'date': self.start.date, 'date_end': self.start.date_end, 'employee': self.start.employee.id, 'paid': self.start.paid } else: data = { 'company': self.start.company.id, 'date': self.start.date, 'employee': None, 'date_end': self.start.date_end, 'paid': self.start.paid } return action, data def transition_print_(self): return 'end'
class OpenInvoice(Wizard): 'Open Invoice' __name__ = 'project.open_invoice' start_state = 'open_' open_ = StateAction('account_invoice.act_invoice_form') def do_open_(self, action): pool = Pool() Work = pool.get('project.work') works = Work.search([ ('parent', 'child_of', Transaction().context['active_ids']), ]) invoice_ids = set() for work in works: if work.invoice_line and work.invoice_line.invoice: invoice_ids.add(work.invoice_line.invoice.id) for twork in work.timesheet_works: for timesheet_line in twork.timesheet_lines: if (timesheet_line.invoice_line and timesheet_line.invoice_line.invoice): invoice_ids.add(timesheet_line.invoice_line.invoice.id) if work.invoiced_progress: for progress in work.invoiced_progress: invoice_ids.add(progress.invoice_line.invoice.id) encoder = PYSONEncoder() action['pyson_domain'] = encoder.encode( [('id', 'in', list(invoice_ids))]) action['pyson_search_value'] = encoder.encode([]) return action, {}
class ServiceUtilisationWizard(Wizard): '''Service Utilisation Report Wizard''' __name__ = 'healthjm_primarycare.report.service_utilisation.wizard' start = StateView( 'healthjm_primarycare.report.service_utilisation.start', 'health_jamaica_primarycare.report_service_utilisation_start', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Generate report', 'generate_report', 'tryton-ok', default=True) ]) generate_report = StateAction( 'health_jamaica_primarycare.jmreport_service_utilisation') def transition_generate_report(self): return 'end' def do_generate_report(self, action): data = { 'start_date': self.start.on_or_after, 'end_date': self.start.on_or_after } if self.start.on_or_before: data['end_date'] = self.start.on_or_before if self.start.institution: data['institution'] = self.start.institution.id else: self.start.raise_user_error('required_institution') return 'start' return action, data
class ExportMagentoInventory(Wizard): """ Export Inventory Wizard Export product stock information to magento for the current website """ __name__ = 'magento.wizard_export_inventory' start = StateView( 'magento.wizard_export_inventory.start', 'magento.wizard_export_magento_inventory_view_start_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Continue', 'export_', 'tryton-ok', default=True), ]) export_ = StateAction('product.act_template_form') def do_export_(self, action): """ Handles the transition """ Channel = Pool().get('sale.channel') channel = Channel.get_current_magento_channel() product_templates = channel.export_inventory_to_magento() action['pyson_domain'] = PYSONEncoder().encode([ ('id', 'in', map(int, product_templates)) ]) return action, {} def transition_export_(self): return 'end'
class CheckImmunizationStatus(Wizard): 'Check Immunization Status' __name__ = 'gnuhealth.check_immunization_status' start = StateView( 'gnuhealth.check_immunization_status.init', 'health.view_check_immunization_status', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Immunization Status', 'check_immunization_status', 'tryton-ok', True), ]) check_immunization_status = StateAction( 'health.report_immunization_status') def do_check_immunization_status(self, action): return action, self.get_info() def get_info(self): return { 'patient_id': Transaction().context.get('active_id'), 'immunization_schedule_id': self.start.immunization_schedule.id } def transition_check_immunization_status(self): return 'end'
class CreateInvoice(Wizard): 'Create Commission Invoice' __name__ = 'commission.create_invoice' start_state = 'ask' ask = StateView('commission.create_invoice.ask', 'commission.commission_create_invoice_ask_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('OK', 'create_', 'tryton-ok', default=True), ]) create_ = StateAction('account_invoice.act_invoice_form') def get_domain(self): domain = [('invoice_line', '=', None)] if self.ask.from_: domain.append(('date', '>=', self.ask.from_)) if self.ask.to: domain.append(('date', '<=', self.ask.to)) if self.ask.type_ == 'in': domain.append(('agent.type_', '=', 'principal')) elif self.ask.type_ == 'out': domain.append(('agent.type_', '=', 'agent')) return domain def do_create_(self, action): pool = Pool() Commission = pool.get('commission') commissions = Commission.search(self.get_domain(), order=[('agent', 'DESC'), ('date', 'DESC')]) Commission.invoice(commissions) invoice_ids = list({c.invoice_line.invoice.id for c in commissions}) encoder = PYSONEncoder() action['pyson_domain'] = encoder.encode([('id', 'in', invoice_ids)]) action['pyson_search_value'] = encoder.encode([]) return action, {}
class CreateInventories(Wizard): 'Create Inventories' __name__ = 'stock.inventory.create' start = StateView( 'stock.inventory.create.start', 'stock_inventory_location.inventory_create_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Create', 'create_', 'tryton-ok', default=True), ]) create_ = StateAction('stock.act_inventory_form') def do_create_(self, action): Inventory = Pool().get('stock.inventory') to_create = [] for location in self.start.locations: to_create.append({ 'location': location.id, 'date': self.start.date, 'lost_found': self.start.lost_found.id, 'company': self.start.company.id, }) if to_create: inventories = Inventory.create(to_create) Inventory.complete_lines(inventories) data = {'res_id': [i.id for i in inventories]} return action, data
class WizardGenerateResult(Wizard): 'Generate Results' __name__ = 'wizard.generate.result' start_state = 'open_' open_ = StateAction('health_imaging.act_imaging_test_result_view') def do_open_(self, action): pool = Pool() Request = pool.get('gnuhealth.imaging.test.request') Result = pool.get('gnuhealth.imaging.test.result') request_data = [] requests = Request.browse(Transaction().context.get('active_ids')) for request in requests: request_data.append({ 'patient': request.patient.id, 'date': datetime.now(), 'request_date': request.date, 'requested_test': request.requested_test, 'request': request.id, 'doctor': request.doctor }) results = Result.create(request_data) action['pyson_domain'] = PYSONEncoder().encode([ ('id', 'in', [r.id for r in results]) ]) Request.requested(requests) Request.done(requests) return action, {}
class CaseCountWizard(Wizard): __name__ = 'health_disease_notification.case_count_wizard' start = StateView( 'gnuhealth.disease_notification.report.case_count_start', 'health_disease_notification.view_form-case_count_start', [Button('Cancel', 'end', 'tryton-cancel'), Button('Generate report', 'generate_report', 'tryton-ok', default=True)]) generate_report = StateAction( 'health_disease_notification.reptnotif_case_count') def transition_generate_report(self): return 'end' def do_generate_report(self, action): data = {'start_date': self.start.on_or_after, 'end_date': self.start.on_or_after, 'state': self.start.state} if self.start.on_or_before: data['end_date'] = self.start.on_or_before # if self.start.institution: # data['institution'] = self.start.institution.id # else: # self.start.raise_user_error('required_institution') # return 'start' return action, data
class OpenTopDiseases(Wizard): 'Open Top Diseases' __name__ = 'gnuhealth.top_diseases.open' start = StateView('gnuhealth.top_diseases.open.start', 'health_reporting.top_diseases_open_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Open', 'open_', 'tryton-ok', default=True), ]) open_ = StateAction('health_reporting.act_top_diseases_form') def do_open_(self, action): action['pyson_context'] = PYSONEncoder().encode({ 'start_date': self.start.start_date, 'end_date': self.start.end_date, 'group': self.start.group.id if self.start.group else None, 'number_records': self.start.number_records, }) return action, {} def transition_open_(self): return 'end'
class GetRenumerationBill(Wizard): '''Get TA/DA Bill for employee''' __name__ = 'exam.get_renumeration_bill' start_state = 'details' details = StateView( 'exam.get_renumeration_bill.view', 'exam_section.form_get_renumeration_bill', [ Button('Cancel', 'end', 'tryton-cancel'), Button('OK', 'save_details', 'tryton-go-next', default=True) ] ) save_details = StateTransition() fill = StateAction('exam_section.act_renumeration_bill') def transition_save_details(self): Employee = Pool().get('exam.employees') current_employee = Employee.search([ ('employee', '=', self.details.employee), ('exam', '=', self.details.exam) ])[0] self.details.renumeration_bill = \ current_employee.renumeration_bill return 'fill' def do_fill(self, action): action['pyson_domain'] = PYSONEncoder().encode([ ('id', '=', self.details.renumeration_bill.id) ]) return action, {}
class EnterLines(Wizard): 'Enter Lines' __name__ = 'timesheet.line.enter' start = StateView('timesheet.line.enter.start', 'timesheet.line_enter_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Enter', 'enter', 'tryton-ok', default=True), ]) enter = StateAction('timesheet.act_line_form') def do_enter(self, action): date = self.start.date date = Date(date.year, date.month, date.day) action['pyson_domain'] = PYSONEncoder().encode([ ('employee', '=', self.start.employee.id), ('company', '=', self.start.employee.company.id), ('date', '=', date), ]) action['pyson_context'] = PYSONEncoder().encode({ 'employee': self.start.employee.id, 'company': self.start.employee.company.id, 'date': date, }) action['name'] += " - " + self.start.employee.rec_name return action, {} def transition_enter(self): return 'end'
class Checkout(Wizard): "Stripe Checkout" __name__ = 'account.payment.stripe.checkout' start_state = 'checkout' checkout = StateAction('account_payment_stripe.url_checkout') def do_checkout(self, action): pool = Pool() Payment = pool.get('account.payment') Customer = pool.get('account.payment.stripe.customer') context = Transaction().context active_model = context['active_model'] active_id = context['active_id'] if active_model == Payment.__name__: Model = Payment elif active_model == Customer.__name__: Model = Customer else: raise ValueError("Invalid active_model: %s" % active_model) record = Model(active_id) database = Transaction().database.name action['url'] = action['url'] % { 'hostname': HOSTNAME, 'database': database, 'model': active_model, 'id': record.stripe_checkout_id, } return action, {}
class SummaryReport(Wizard): 'Open Institution Summary Report' __name__ = 'gnuhealth.summary.report.open' start = StateView('gnuhealth.summary.report.open.start', 'health_reporting.summary_report_open_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Open', 'open_', 'tryton-ok', default=True), ]) open_ = StateAction('health_reporting.report_summary_information') def fill_data(self): return { 'institution': (self.start.institution.id if self.start.institution else None), 'start_date': self.start.start_date, 'end_date': self.start.end_date, 'demographics': self.start.demographics, 'patient_evaluations': self.start.patient_evaluations, } def do_open_(self, action): return action, self.fill_data() def transition_open_(self): return 'end'
class ProductsByLocations(Wizard): 'Products by Locations' __name__ = 'stock.products_by_locations' start = StateView('stock.products_by_locations.start', 'stock.products_by_locations_start_view_form', [ Button('Cancel', 'end', 'tryton-cancel'), Button('Open', 'open', 'tryton-ok', True), ]) open = StateAction('stock.act_products_by_locations') def do_open(self, action): pool = Pool() Location = pool.get('stock.location') Lang = pool.get('ir.lang') context = {} context['locations'] = Transaction().context.get('active_ids') date = self.start.forecast_date or datetime.date.max context['stock_date_end'] = Date(date.year, date.month, date.day) action['pyson_context'] = PYSONEncoder().encode(context) locations = Location.browse(context['locations']) for code in [Transaction().language, 'en_US']: langs = Lang.search([ ('code', '=', code), ]) if langs: break lang = langs[0] date = Lang.strftime(date, lang.code, lang.date) action['name'] += ' - (%s) @ %s' % (','.join(l.name for l in locations), date) return action, {}
def __init__(self): StateAction.__init__(self, None)