class stock_location(osv.osv): _inherit = "stock.location" _columns = \ { 'blueprint' : fields.binary ('Blueprint') , 'image' : fields.binary ('Image') }
class buildbot_test_step(osv.osv): _name = "buildbot.test.step" _columns = { 'name': fields.char('Name of Step', size=128, help="Name of the Test step"), 'test_id': fields.many2one('buildbot.test', 'Test', ondelete='cascade', help="Name of the Test"), 'blame_log': fields.text("Summary", help="Quick blame info of thing(s) that failed"), 'log': fields.binary('General Log', help="Log File"), 'quality_log': fields.binary("Module's Quality Log", help="Module's Quality Log File"), # 'warning_log': fields.text('Warning Log',help="Warning Log"), #'error_log': fields.text('Error Log',help="Error Log"), #'critical_log': fields.text('Critical Log',help="Critical Log"), #'info_log': fields.text('Info Log',help="Information Log"), #'yml_log': fields.text('YML-Test Log',help="YML Log"), #'traceback_detail': fields.text('Traceback',help="Traceback Detail"), 'state': fields.selection([('unknown', 'Unknown'), ('fail', 'Failed'), ('pass', 'Passed'), ('skip', 'Skipped'), ('debug', 'Debug')], "Test Result", readonly=True, required=True, help="Final State of the Test Step"), } _defaults = {'state': 'unknown'} _order = 'id'
class product_images(osv.osv): _inherit = "product.images" def get_image(self, cr, uid, id): print"get_image" img = '' each = self.read(cr, uid, id, ['link', 'filename', 'image','full_url','chk_ebay_link']) if each['link'] == True: if each['link']: (filename, header) = urllib.urlretrieve(each['filename']) f = open(filename , 'rb') img = base64.encodestring(f.read()) f.close() if each['full_url']: if each['full_url']: (filename, header) = urllib.urlretrieve(each['full_url']) f = open(filename , 'rb') img_ebay = base64.encodestring(f.read()) f.close() if img_ebay: cr.execute("UPDATE product_images SET preview_ebay='%s' where id=%d"%(img_ebay,id,)) f.close() else: img = each['image'] return img def write(self,cr,uid,ids,vals,context={}): if ids: filename = vals.get('filename_ebay',False) filename_database = self.browse(cr,uid,ids[0]).filename_ebay if filename == filename_database: vals.update({'change_or_no_change': 'no_change'}) else: vals.update({'change_or_no_change': 'change','last_updated_changes':time.strftime('%Y-%m-%d %H:%M:%S')}) id = super(product_images, self).write(cr, uid, ids,vals, context) return id def create(self,cr,uid,vals,context={}): id = super(product_images, self).create(cr, uid, vals, context) filename = vals.get('filename_ebay',False) vals.update({'change_or_no_change': 'change','last_updated_changes':time.strftime('%Y-%m-%d %H:%M:%S')}) return id _columns = { 'chk_ebay_link' : fields.boolean('Ebay'), 'chk_mag' : fields.boolean('Magento'), 'link':fields.boolean('Magento Link?', help="Images can be linked from files on your file system or remote (Preferred)"), 'filename_ebay':fields.binary('Main Image', filters='*.png,*.jpg,*.gif'), 'filename':fields.char('Magento File Location', size=250), 'change_or_no_change':fields.selection([('change', 'Change'),('no_change', 'No Change')],'Changes'), 'last_updated_changes': fields.datetime('Last Updated'), 'full_url':fields.char('Full URL', size=256), 'preview_ebay':fields.binary('Preview of Ebay Image'), } _defaults = { 'link': lambda *a: False, 'change_or_no_change': 'change', }
class congreso_noticiasgen(osv.osv): _name = 'congreso.noticiasgen' _description = 'Noticias generadas' _columns = { 'fecha': fields.date('Fecha'), 'medio': fields.many2one('congreso.medios', 'Medio'), 'enlace': fields.char('Enlace', size=200, required=False), 'image1': fields.binary("Imagen", help="Seleccionar imagen aqui"), 'image2': fields.binary("Imagen", help="Seleccionar imagen aqui"), 'image3': fields.binary("Imagen", help="Seleccionar imagen aqui"), 'informacion': fields.text('Información', required=False), }
class congreso_publicidad(osv.osv): _name = 'congreso.publicidad' _description = 'Publicidad' _columns = { 'fecha': fields.date('Fecha'), 'medio': fields.many2one('congreso.medios', 'Medio'), 'enlace': fields.char('Enlace', size=200, required=False), 'image1': fields.binary("Imagen", help="Seleccionar imagen aqui"), 'image2': fields.binary("Imagen", help="Seleccionar imagen aqui"), 'image3': fields.binary("Imagen", help="Seleccionar imagen aqui"), 'presupuesto': fields.text('Presupuesto', required=False), 'informacion': fields.text('Información', required=False), }
class res_company (osv.osv): _inherit = 'res.company' _columns = { 'tire_stock': fields.many2one ('stock.location','Tire Stock'), 'retread': fields.many2one ('stock.location','Retread'), 'scratch': fields.many2one ('stock.location','Scratch'), 'waste': fields.many2one ('stock.location','Waste'), 'flatire': fields.many2one ('stock.location','Flat Tire'), 'schema4' : fields.binary('4 Tire Schema'), 'schema6' : fields.binary('6 Tire Schema'), 'schema8' : fields.binary('8 Tire Schema') }
class photo_security(osv.osv): _name = "photo.security" _description = "Photo" _columns = { 'name': fields.char('Photo Description', size=128, required=True, select=True), 'date': fields.datetime("Date of Photo"), 'photo': fields.binary('Photo'), 'photo_card': fields.binary('Photo card'), 'photo_car': fields.binary('Photo car'), }
class report_xml_file(osv.osv): _name = 'ir.actions.report.xml.file' _columns = { 'file': fields.binary('File', required=True, filters="*.jrxml,*.properties,*.ttf", help=''), 'filename': fields.char('File Name', size=256, required=False, help=''), 'report_id': fields.many2one('ir.actions.report.xml', 'Report', required=True, ondelete='cascade', help=''), 'default': fields.boolean('Default', help=''), } def create(self, cr, uid, vals, context=None): result = super(report_xml_file, self).create(cr, uid, vals, context) self.pool.get('ir.actions.report.xml').update(cr, uid, [vals['report_id']], context) return result def write(self, cr, uid, ids, vals, context=None): result = super(report_xml_file, self).write(cr, uid, ids, vals, context) for attachment in self.browse(cr, uid, ids, context): self.pool.get('ir.actions.report.xml').update( cr, uid, [attachment.report_id.id], context) return result
class account_report_print_indicators_with_pdf(osv.osv_memory): _name = "account.report.print.indicators.with.pdf" _description = "Print Indicators" _columns = { 'file': fields.binary('Select a PDF File', filters='*.pdf', required=True), } def check_report(self, cr, uid, ids, context=None): datas = {} if context is None: context = {} data = self.read(cr, uid, ids)[0] datas = { 'ids': context.get('active_ids', []), 'model': 'account.report.report', 'form': data } return { 'type': 'ir.actions.report.xml', 'report_name': 'print.indicator.pdf', 'datas': datas, }
class res_user(osv.osv): _name = 'res.users' _inherit = 'res.users' _columns = { 'photo_signature': fields.binary('Signature'), }
class FileFormatLoader(osv.osv_memory): _name = 'cnab.wizard.file_format_loader' def load(self, cr, uid, ids, context=None): pool = self.pool.get('cnab.file_format') parser = Parser() wizard, = self.browse(cr, uid, ids) xml = base64.b64decode(wizard.file) data = parser.parse_schema(xml) data['type'] = wizard.type if wizard.replace: old_ids = pool.search(cr, uid, [('name', '=', data['name'])]) pool.unlink(cr, uid, old_ids) new_id = pool.create(cr, uid, data) return { 'type': 'ir.actions.act_window', 'res_model': 'cnab.file_format', 'view_mode': 'form', 'view_type': 'form', 'res_id': new_id } _columns = { 'file': fields.binary('File', required=True), 'type': fields.selection([('remessa', 'Arquivo de Remessa Bancária'), ('retorno', 'Arquivo de Retorno Bancário'), ('extrato', 'Arquivo de Extrato Bancário')], 'File Type', required=True), 'replace': fields.boolean('Replace any entries with the same name') }
class quality_save_report(osv.osv_memory): _name = "save.report" _description = "Save Report of Quality" def default_get(self, cr, uid, fields, context=None): res = super(quality_save_report, self).default_get(cr, uid, fields, context=context) active_ids = context.get('active_ids') data = self.pool.get('module.quality.detail').browse( cr, uid, active_ids, context=context)[0] if not data.detail: raise osv.except_osv(_('Warning'), _('No report to save!')) buf = cStringIO.StringIO(data.detail) out = base64.encodestring(buf.getvalue()) buf.close() return {'module_file': out, 'name': data.name + '.html'} _columns = { 'name': fields.char('File Name', required=True, size=32, help="Save report as .html format"), 'module_file': fields.binary('Save report', required=True), }
class vit_master_type(osv.osv): _name = "vit.master.type" _description = 'Master Type' _rec_name = 'model_product' _columns = { 'model_product': fields.char( 'Model/Type', required=True, ), 'product_id': fields.many2one( 'product.product', 'Sample Product', domain= "['|',('categ_id.name','=','Mutif'),('categ_id.name','=','Little Mutif')]" ), 'main_qty': fields.integer('Body'), 'variation_qty': fields.integer('Variation'), 'categ_id': fields.char('Category'), 'cost_model': fields.float('Makloon Price'), 'cost_model_cut': fields.float('Cutting Price'), 'image': fields.binary('image', type="binary"), } _sql_constraints = [ ('model_product_uniq', 'unique(model_product)', 'Model Ini Sudah Tersedia, Silahkan Buat Model lain dengan Product Sample Lain!' ), ] def on_change_categ_id(self, cr, uid, ids, categ_id, context=None): categ_id_obj = self.pool.get('product.category') categ_id = categ_id_obj.browse(cr, uid, categ_id, context=context) def on_change_product_id(self, cr, uid, ids, product_id, context=None): product_obj = self.pool.get('product.product') product = product_obj.browse(cr, uid, product_id, context=context) if product_id != False: return { 'value': { 'model_product': product.type_model, 'categ_id': product.categ_id.name, } } else: return { 'value': { 'model_product': '', 'categ_id': '', } }
class certificate(osv.Model): _inherit = "crypto.certificate" def _get_cert_selection(self, cursor, user_id, context=None): return (('fina_demo', 'Fina Demo Certifiacte'), ('fina_prod', 'Fina Production Certificate'), ('personal', 'Personal Certificate'), ('other', 'Other types')) _columns = { 'company_id': fields.many2one('res.company', 'Tvrtka', help='Cerificate is used for this company only.'), 'group_id': fields.many2one('res.groups', 'User group', select=True, help='Users who use the certificate.'), 'cert_type': fields.selection(_get_cert_selection, 'Certificate Use'), 'pfx_certificate': fields.binary('Certificate', help='Original Pfx File.') } _defaults = { 'state': 'draft', 'company_id': lambda self, cr, uid, c: self.pool.get('res.company'). _company_default_get(cr, uid, 'crypto.certificate', context=c), }
class account_pay(osv.osv): _name = "account.pay" _description = "Payment Export History" _rec_name = 'payment_order_id' _columns = { 'payment_order_id': fields.many2one('payment.order', 'Payment Order Reference', readonly=True), 'state': fields.selection([('failed', 'Failed'), ('succeeded', 'Succeeded')], 'Status', readonly=True), 'file': fields.binary('Saved File', readonly=True), 'note': fields.text('Creation Log', readonly=True), 'create_date': fields.datetime('Creation Date', required=True, readonly=True), 'create_uid': fields.many2one('res.users', 'Creation User', required=True, readonly=True), }
class upoflix_user(osv.Model): _name = 'upoflix.user' _description = 'This is an UPOFLIX user' _columns = { 'name': fields.char('Name', size=64, required=False, readonly=False), 'surname': fields.char('Surname', size=64, required=True), 'mail': fields.char('Email', size=120, required=True), 'password': fields.char('Password', size=64, required=True), 'registration_date': fields.date("Registration Date", readonly=True), 'image': fields.binary("Image"), 'user_film_favs': fields.many2many('film', 'user_film_fav', 'user_id', 'film_id', 'Favorite Films'), 'user_serie_favs': fields.many2many('serie', 'user_serie_fav', 'user_id', 'serie_id', 'Favorite Series'), } _defaults = { 'registration_date': datetime.now().strftime('%Y-%m-%d'), } _sql_constraints = [ ('name_uniq', 'unique (name)', 'The Name of the User must be unique !'), ('mail_uniq', 'unique (mail)', 'The Mail of the User must be unique !'), ]
class partaker(osv.osv): _name = 'partaker' _description = 'this is a partaker from a resource.' _columns = { 'name': fields.char('Name', size=64, required=True, readonly=False), 'country': fields.many2one("res.country", "Country", required=True), 'birth': fields.date('Birth'), 'image': fields.binary("Image"), 'series_actor': fields.many2many('serie', 'serie_partaker_rel', 'partaker_id', 'serie_id', 'Series'), 'films_actor': fields.many2many('film', 'film_partaker_rel', 'partaker_id', 'film_id', 'Films'), 'series_director': fields.one2many("serie", "director", "Series Director"), 'films_director': fields.one2many("film", "director", "Films Director"), } _sql_constraints = [ ('name_uniq', 'unique (name)', 'The Name of the Partaker must be unique !'), ]
class universidad(osv.Model): _name = 'gid.cursos.universidad' _columns = { 'name': fields.char('Nombre', required=True, size=200), 'codigo_entidad': fields.char(u'Código', required=True), 'direccion': fields.char('Dirección', required=True, size=100), 'telefono': fields.char('Teléfono', required=True, size=100), 'ciudad': fields.selection([('tulua', 'Tuluá'), ('cali', 'Cali'), ('buga', 'Buga'), ('sevilla', 'Sevilla')], string="Ciudad"), 'email': fields.char('E-mail', required=True, size=100), 'logo': fields.binary(string='Logo', filters='*.png, *.jpeg'), 'active': fields.boolean('Active'), } _defaults = { 'active': True, }
class act_client(osv.osv): _name = 'ir.actions.client' _inherit = 'ir.actions.actions' _table = 'ir_act_client' _sequence = 'ir_actions_id_seq' _order = 'name' def _get_params(self, cr, uid, ids, field_name, arg, context): return dict([ ((record.id, ast.literal_eval(record.params_store)) if record.params_store else (record.id, False)) for record in self.browse(cr, uid, ids, context=context) ]) def _set_params(self, cr, uid, id, field_name, field_value, arg, context): assert isinstance(field_value, dict), "params can only be dictionaries" self.write(cr, uid, id, {'params_store': repr(field_value)}, context=context) _columns = { 'tag': fields.char('Client action tag', size=64, required=True, help="An arbitrary string, interpreted by the client" " according to its own needs and wishes. There " "is no central tag repository across clients."), 'params': fields.function(_get_params, fnct_inv=_set_params, type='binary', string="Supplementary arguments", help="Arguments sent to the client along with" "the view tag"), 'params_store': fields.binary("Params storage", readonly=True) } _defaults = { 'type': 'ir.actions.client', }
class MutasiStock(osv.osv_memory): _name = "mutasi.stock" _columns = { 'date_from' : fields.date('From'), 'date_to' : fields.date('To'), 'data_eksport': fields.binary('File', readonly=True), 'name': fields.char('File Name', 16), 'report': fields.selection((('del','Delivery Order'), ('inc','Incoming Shipment'), (('int','Internal Move'))), 'Report'), } _defaults = { 'report': 'del', 'date_from': time.strftime('%Y-%m-%d'), 'date_to': time.strftime('%Y-%m-%d'), } def eksport_excel(self,cr,uid,ids,context=None): searchConf = self.pool.get('ir.config_parameter').search(cr, uid, [('key', '=', 'base.print')], context=context) browseConf = self.pool.get('ir.config_parameter').browse(cr,uid,searchConf,context=context)[0] val = self.browse(cr, uid, ids)[0] # print '=====================================',val.report urlTo = str(browseConf.value)+"report-accounting/stock-move&jenis="+val.report+"&from="+val.date_from+"&to="+val.date_to return { 'type' : 'ir.actions.client', 'target': 'new', 'tag' : 'print.out.stockmove', 'params': { # 'id' : ids[0], 'redir' : urlTo, 'uid':uid }, }
class resource(osv.osv): _name = 'resource' _description = 'This is a resource, can be a Film or a serie' def _media(self, cr, uid, ids, field, args, context=None): res = {} for r in self.browse(cr, uid, ids): if len(r.scores) != 0: suma = sum(s.score for s in r.scores) res[r.id] = suma / float(len(r.scores)) else: res[r.id] = 0.0 return res _columns = { 'name': fields.char('Name', size=64, required=True, readonly=False), 'year': fields.date('Year', required=True), 'image': fields.binary("Image"), 'osd': fields.many2one("osd", "OSD", required=True), 'director': fields.many2one('partaker', 'Director', required=True), 'total_score': fields.function(_media, type="float", string="Score Average", store=True) }
class download_carrier_file_wizard(osv.osv_memory): _name = 'download.carrier.file.wizard' _columns = { 'format_id': fields.many2one('file.format', 'Carrier File Format', required=True), 'carrier_file': fields.binary('Carrier File', readonly=True), 'carrier_file_name': fields.char('Carrier File Name', size=255), 'state': fields.selection((('init','Init'),('download','Download')), 'State') } _defaults = { 'state': 'init' } def download_file(self, cr, uid, ids, context=None): if context is None: context = {} for obj in self.browse(cr, uid, ids, context=context): file_name = obj.format_id.file_name file_path = obj.format_id.path + "/" + file_name if not os.path.isfile(file_path): raise osv.except_osv(_("Error"), _("File %s does not exist" % (file_path))) carrier_file = open( file_path, 'rb' ) carrier_file_b64 = base64.b64encode(carrier_file.read()) carrier_file.close() carrier_file = open(file_path, 'w') carrier_file.write('') carrier_file.close() return self.write(cr, uid, ids, { 'carrier_file': carrier_file_b64, 'state': 'download', 'carrier_file_name': file_name})
class stock_picking(osv.Model): _inherit = 'stock.picking' _columns = { 'filename': fields.char('File Name', size=255, readonly=True), 'data': fields.binary('File', readonly=True), }
class create_data_template(osv.osv_memory): _name = 'jasper.create.data.template' _description = 'Create data template' def action_create_xml(self, cr, uid, ids, context=None): for data in self.read(cr, uid, ids, context=context): model = self.pool.get('ir.model').browse(cr, uid, data['model'][0], context=context) xml = self.pool.get('ir.actions.report.xml').create_xml( cr, uid, model.model, data['depth'], context) self.write(cr, uid, ids, { 'data': base64.encodestring(xml), 'filename': 'template.xml' }) return { 'view_type': 'form,tree', 'view_mode': 'form', 'res_model': 'jasper.create.data.template', 'res_id': ids[0], 'targer': 'new', 'type': 'ir.actions.act_window', } _columns = { 'model': fields.many2one('ir.model', 'Model', required=True), 'depth': fields.integer("Depth", required=True), 'filename': fields.char('File Name', size=32), 'data': fields.binary('XML') } _defaults = {'depth': 1}
class res_company(osv.osv): _inherit = "res.company" _columns = { 'signature': fields.binary('Signature'), 'accredetion': fields.text('Accredetion'), 'approval_authority': fields.text('Approval Authority'), }
class ea_import_chain_result(osv.osv): _name = 'ea_import.chain.result' _order = 'import_time desc' _columns = { 'name': fields.char('Model', size=256, required=True), 'chain_id': fields.many2one('ea_import.chain',), # to be removed 'log_id': fields.many2one('ea_import.log',), 'result_ids_file': fields.binary('Result Ids',), 'import_time': fields.datetime('Import Time',), 'scheduler_log_id': fields.many2one('ea_import.scheduler.log', 'Scheduler Log'), } _defaults = { } def show_result(self, cr, uid, ids, context={}): for result in self.browse(cr, uid, ids, context=context): result_ids = eval(base64.b64decode(result.result_ids_file)) return { 'name': 'Result', 'view_mode': 'tree,form', 'view_type': 'form', 'view_id': False, 'res_model': result.name, 'domain': [('id', 'in', result_ids)], 'type': 'ir.actions.act_window', 'nodestroy': True, 'target': 'current', }
class wizard_import(osv.osv_memory): _name = 'wizard.import' _columns = { 'name': fields.binary('File'), 'msg': fields.text('Messages', readonly=True), 'validate': fields.boolean('Validate?') } def send_lines(self, cr, uid, ids, context=None): if context is None: context = {} form = self.read(cr, uid, ids, []) order_id = context.get('res_id', False) fdata = form and base64.decodestring(form[0]['name']) or False fvalidate = form and form[0]['validate'] or False msg = self.pool.get('sale.order').import_data_line(cr, uid, order_id, fdata, fvalidate, context=context) if msg: self.write(cr, uid, ids, {'msg': msg}) return True return {}
class material(osv.Model): _name = 'material' _description = 'UPOKid material' _columns = { 'name': fields.char('Name', size=64, required=True, readonly=False), 'units': fields.integer('Units', required=True), 'description': fields.text('Description', required=False), 'photo': fields.binary('Photo', required=False), 'upokidsclass_ids': fields.many2many('upokidsclass', 'material_class_rel', 'material_id', 'class_id', 'Classes'), 'tournament_ids': fields.many2many('tournament', 'tournament_material_rel', 'material_id', 'tournament_id', 'Tournaments'), } def _check_stock(self, cr, uid, ids): return self.browse(cr, uid, ids)[0].units >= 0 _constraints = [ (_check_stock, 'Wrong Stock', ['units']), ]
class import_wizard(osv.osv_memory): _name = 'import_wizard' _description = 'Simple import wizard' _columns = { 'chain_id': fields.many2one('ea_import.chain', 'Import Chain', ), 'import_file': fields.binary('Importing file', ), 'type': fields.selection([ ('csv', 'CSV Import'), ('ftp', 'Import from ftp server'), ('mysql', 'MySql Import'), ], 'Import Type', required=True, readonly=True, help="Type of connection import will be done from"), } _defaults = { 'chain_id': lambda cr, uid, ids, context: context.get('import_chain_id'), 'type': lambda self, cr, uid, ctx={}: ctx.get('import_chain_id') and self.pool.get('ea_import.chain').browse(cr, uid, ctx['import_chain_id'], context=ctx).type, } def do_import(self, cr, uid, ids, context={}): for wizard in self.browse(cr, uid, ids, context=context): wizard.chain_id.write({'input_file': wizard.import_file}) cr.commit() wizard.chain_id.import_to_db() return {'type': 'ir.actions.act_window_close'}
class company(osv.osv): _inherit = 'res.company' _columns = { 'logo_web': fields.binary( 'Logo Header', filters='*.png,*.gif,*.jpg,*.jpeg', help= "Image file for company logo at header of web client. Ideally, a 200x55 png with transparent background." ), 'color_set': fields.many2one('res.company.color', string='Color schema', help="Set of colors to display on Web client"), 'color_top': fields.related('color_set', 'color_top', readonly=True, type='char'), 'color_mid': fields.related('color_set', 'color_mid', readonly=True, type='char'), 'color_low': fields.related('color_set', 'color_low', readonly=True, type='char'), 'button_top': fields.related('color_set', 'button_top', readonly=True, type='char'), 'button_mid': fields.related('color_set', 'button_mid', readonly=True, type='char'), 'link_top': fields.related('color_set', 'link_top', readonly=True, type='char'), }
# statement_facade.write(cr, uid, [statement_id], { 'date': st_data['fecha_fin'], 'balance_start': st_data['saldo_ini'], 'balance_end_real': st_data['saldo_fin'], }, context=context) # Attach the C43 file to the current statement data = base64.encodestring( c43_wizard.file ) res = statement_facade._attach_file_to_statement(cr, uid, data, statement_id, _('Bank Statement'), _('bank-statement.txt') ) return {} _name = 'l10n.es.bank.statement.import.c43.wizard' _columns = { 'file': fields.binary('Bank Statements File', required=True, filename='file_name'), 'file_name': fields.char('Bank Statements File', size=64, readonly=True), 'reco_reference_and_amount': fields.boolean('Reconcile by reference and amount'), 'reco_vat_and_amount' : fields.boolean('Reconcile by VAT number and amount'), 'reco_amount' : fields.boolean('Reconcile by amount'), 'reco_rules' : fields.boolean('Statement Line Rules'), 'reco_payment_order': fields.boolean('Reconcile payment orders by total amount'), 'reco_max_days' : fields.integer('Max. days from statement date',help='Maximum difference in days, between the maturity date of the entry to reconcile and the bank statement entry') } l10n_es_bank_statement_import_c43_wizard() # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
if transport: transport.close() except Exception: # ignored, just a consequence of the previous exception pass raise osv.except_osv("Connection Test Succeeded!", "Everything seems properly set up!") _name = 'vehicle.config' _description = 'Configuration for Vehicle Fits ftp link' _table = 'vehiclefits_config' _columns = { 'name': fields.char('Name', size=20), 'vf_url': fields.char('Url', size=30, help="Url to Magento Web"), 'sftp_user': fields.char('Ftp user', size=20, required=True), 'sftp_password': fields.char('Ftp password', size=20, required=False), 'sftp_pem': fields.binary('RSA Key', required=True), 'sftp_host': fields.char('FTP IP host', size=15, required=True), 'sftp_port': fields.integer('Ftp Port', help='Port of the connection'), 'sftp_local_file': fields.char('Full path to local csv file'), 'sftp_remote_file': fields.char('Name of remote file', help="Default name for import is" " product-fitments-import.csv"), 'sftp_remote_dir': fields.char('Full remote path'), 'erp_host': fields.char('Erp host', size=20, required=True), 'erp_user': fields.char('Erp DB user', size=15, required=True), 'erp_password': fields.char('Erp password', size=20, required=True), 'erp_db': fields.char('Erp DB', size=20, required=True) } vehicle_config()
def _is_remotewarehouse(self, cr, uid, context=None): try: entity = self.pool.get('sync.client.entity').get_entity(cr, uid) if entity.usb_instance_type == 'remote_warehouse': return True except Exception, e: pass return False _columns = { 'message' : fields.text("Caption", readonly=True), 'state' : fields.selection([ ('need-provide-manually','Need To Provide Manually The Files'), ('need-download','Need Download'), ('up-to-date','Up-To-Date'), ('need-install','Need Install'), ('need-restart','Need Restart'), ('blocked','Blocked') ], string="Status"), 'patch' : fields.binary("Patch"), 'error': fields.text('Error', readonly="1"), } _defaults = { 'message' : _generate, 'state' : _get_state, 'error': _get_error, } upgrade()
'saturday_delivery': fields.boolean('Saturday Delivery?'), 'description': fields.text('Description'), 'state':fields.selection(STATE_SELECTION, 'Status', readonly=True,), # The following are UPS filled information 'billed_weight':fields.float('Billed Weight', digits=(10, 4), readonly=True, help=( 'The billed weght may be different from the actual weight.' 'This is computed by UPS.')), 'billed_weight_uom':fields.many2one('product.uom', 'Billed Weight UOM', readonly=True), 'total_amount':fields.float('Total Amount', digits=(14, 4), select="1", readonly=True), 'total_amount_currency':fields.many2one('res.currency', 'Total Amount Currency', select="2", readonly=True,), 'digest': fields.binary('Information digest for DIGEST'), 'notificationemailaddr': fields.char('Notification eMail Addresses', size=255, help='Separated by commas(,).'), } _defaults = { 'name': lambda *a: 'Not Processed', 'state': lambda *a: 'draft' } UpsShippingRegister() class UpsShippingRegisterPackage(osv.osv): """ Model to record all packages corresponding
"path": fields.function(_get_module_path, method=True, string="Path", type="char", size=512, readonly=True), "technical_certificate": fields.selection( [("not_started", "Not Started"), ("failed", "Failed"), ("succeeded", "Succeeded"), ("skipped", "Skipped")], "Technical Certification", ), "functional_certificate": fields.selection( [("not_started", "Not Started"), ("failed", "Failed"), ("succeeded", "Succeeded"), ("skipped", "Skipped")], "Functional Certification", ), "sale_ids": fields.many2many( "sale.order", "maintenance_module_sale_rel", "module_id", "sale_id", "Sale orders" ), "nbr_source_line": fields.integer( "Source Line of Code", help="number of source line of code of uploaded module" ), "module_zip": fields.binary("Module Zip File"), "state": fields.selection( [("draft", "Draft"), ("open", "Open"), ("failed", "Failed"), ("done", "Done"), ("cancel", "Cancel")], "State", readonly=True, ), "test_ids": fields.one2many("test", "module_id", "Tests"), "test_tech_ids": one2many_mod_advert("test", "id", "Tests"), "test_func_ids": one2many_mod_advert("test", "id", "Tests"), "tech_certificate": fields.boolean("Technicle certificate", help="tick if you want technicle certificate"), "func_certificate": fields.boolean("Functional certificate", help="tick if you want functional certificate"), "tech_user_id": fields.many2one("res.users", "Technicle User", help="User for Technicle tests"), "func_user_id": fields.many2one("res.users", "Functional User", help="User for Functional tests"), } _defaults = {
finally: ofile.close() return True def _set_image(self, cr, uid, id, name, value, arg, context=None): local_media_repository = self.pool.get('res.company').get_local_media_repository(cr, uid, context=context) if local_media_repository: image = self.browse(cr, uid, id, context=context) return self._save_file(os.path.join(local_media_repository, image.product_id.default_code), '%s%s'%(image.name, image.extention), value) return self.write(cr, uid, id, {'file_db_store' : value}, context=context) _columns = { 'name':fields.char('Image Title', size=100, required=True), 'extention': fields.char('file extention', size=6), 'link':fields.boolean('Link?', help="Images can be linked from files on your file system or remote (Preferred)"), 'file_db_store':fields.binary('Image stored in database'), 'file':fields.function(_get_image, fnct_inv=_set_image, type="binary", method=True, filters='*.png,*.jpg,*.gif'), 'url':fields.char('File Location', size=250), 'comments':fields.text('Comments'), 'product_id':fields.many2one('product.product', 'Product') } _defaults = { 'link': lambda *a: False, } _sql_constraints = [('uniq_name_product_id', 'UNIQUE(product_id, name)', _('A product can have only one image with the same name'))] product_images()
input_model[ir_model_field.name] record_dict['fields'] = field_dict data_json.append(record_dict) out = base64.encodestring(json.dumps(data_json, indent=4)) return self.write(cr, uid, ids, { 'state': 'done', 'dm_export_data_wizard_data': out, 'name': json_exported_file_name }, context=context) EXPORT_TYPE = (('a', 'based on model'), ('b', 'based on module')) _columns = { 'name': fields.char('Filename', size=128, readonly=True), 'dm_export_data_wizard_type': fields.selection(EXPORT_TYPE, 'DM Export Data Wizard Type'), 'ir_model_id': fields.many2one('ir.model', 'IR Model'), 'ir_module_module_id': fields.many2one('ir.module.module', 'IR Module Module'), 'dm_export_data_wizard_data': fields.binary('Export Data Wizard Data', readonly=True), 'state': fields.selection([('init', 'init'), ('done', 'done')], 'state', readonly=True), } _defaults = {'state': 'init', 'dm_export_data_wizard_type': 'a'} DmExportDataWizard()
} _defaults = { 'active': lambda *a, 1, } _sql_constraints = [('name_uniq', 'unique(name)', 'Pallet names must be unique!')] pallet_types() class pallet_stack_layout(osv.osv): _name = 'pallet.stack.layout' _columns = { 'name': fields.char('Description', size=128, required=True), 'active': fields.boolean('Active'), 'program': fields.integer('Program Number', help='If this is stacked on a palletiser, this is the palletiser program number'), 'pallet_type_id': fields.many2one('pallet.types','Pallet Type', ondelete='set null'), 'layout_diagram': fields.binary('Layout diagram', filters='*.bmp,*.jpg,*.gif') 'slipsheeted': fields.boolean('Slipsheeted', help='If product is stacked onto slipsheets, this box should be ticked.'), 'layer_qty': fields.integer('Packages per layer'), 'layer_height': fields.integer('Height per layer (mm)'), 'layer_ids': fields.one2many('pallet_stack_layers', 'layout_id','Layer options'), } _defaults = { 'active': lambda *a, 1, } pallet_stack_layout() class pallet_stack_layers(osv.osv): _name = 'pallet.stack.layers' #TODO This needs to calculate sum height of each layer and add the pallet height to come up with an overall height. #def _calc_total_height(self, cr, uid, ids, field_name, arg, context=None)
return True def _set_image(self, cr, uid, id, name, value, arg, context=None): image = self.browse(cr, uid, id, context=context) full_path = self._image_path(cr, uid, image, context=context) if full_path: return self._save_file(full_path, value) return self.write(cr, uid, id, {"file_db_store": value}, context=context) _columns = { "name": fields.char("Image Title", translate=True, size=100, required=True), "extention": fields.char("file extention", size=6), "link": fields.boolean( "Link?", help="Images can be linked from files on your file system or remote (Preferred)" ), "file_db_store": fields.binary("Image stored in database"), "file": fields.function( _get_image, fnct_inv=_set_image, type="binary", method=True, filters="*.png,*.jpg,*.gif" ), "url": fields.char("File Location", size=128), "comments": fields.text("Comments", translate=True), "product_id": fields.many2one("product.product", "Product"), } _defaults = {"link": lambda *a: False} _sql_constraints = [ ("uniq_name_product_id", "UNIQUE(product_id, name)", _("A product can have only one image with the same name")) ]