コード例 #1
0
    def __new__(cls, name, bases, nmspc):

        columns = nmspc['_columns']
        size = int(config.get_misc('analytic', 'analytic_size', 5))
        for n in xrange(1, size + 1):
            columns['ns{}_id'.format(n)] = fields.one2many(
                'analytic.structure',
                'nd_id',
                "Generated Subset of Structures",
                domain=[('ordering', '=', n)],
                auto_join=True,
            )
        return super(_dimension_meta, cls).__new__(cls, name, bases, nmspc)
コード例 #2
0
ファイル: module.py プロジェクト: xiaoyun102/odoo
class module(osv.osv):
    _name = "ir.module.module"
    _rec_name = "shortdesc"
    _description = "Module"

    def fields_view_get(self,
                        cr,
                        uid,
                        view_id=None,
                        view_type='form',
                        context=None,
                        toolbar=False,
                        submenu=False):
        res = super(module, self).fields_view_get(cr,
                                                  uid,
                                                  view_id=view_id,
                                                  view_type=view_type,
                                                  context=context,
                                                  toolbar=toolbar,
                                                  submenu=False)
        result = self.pool.get('ir.model.data').get_object_reference(
            cr, uid, 'base', 'action_server_module_immediate_install')[1]
        if view_type == 'form':
            if res.get('toolbar', False):
                list = [
                    rec for rec in res['toolbar']['action']
                    if rec.get('id', False) != result
                ]
                res['toolbar'] = {'action': list}
        return res

    @classmethod
    def get_module_info(cls, name):
        info = {}
        try:
            info = modules.load_information_from_description_file(name)
        except Exception:
            _logger.debug(
                'Error when trying to fetch informations for '
                'module %s',
                name,
                exc_info=True)
        return info

    def _get_desc(self, cr, uid, ids, field_name=None, arg=None, context=None):
        res = dict.fromkeys(ids, '')
        for module in self.browse(cr, uid, ids, context=context):
            path = get_module_resource(module.name,
                                       'static/description/index.html')
            if path:
                with tools.file_open(path, 'rb') as desc_file:
                    doc = desc_file.read()
                    html = lxml.html.document_fromstring(doc)
                    for element, attribute, link, pos in html.iterlinks():
                        if element.get('src') and not '//' in element.get(
                                'src') and not 'static/' in element.get('src'):
                            element.set(
                                'src', "/%s/static/description/%s" %
                                (module.name, element.get('src')))
                    res[module.id] = lxml.html.tostring(html)
            else:
                overrides = {
                    'embed_stylesheet': False,
                    'doctitle_xform': False,
                    'output_encoding': 'unicode',
                    'xml_declaration': False,
                }
                output = publish_string(source=module.description or '',
                                        settings_overrides=overrides,
                                        writer=MyWriter())
                res[module.id] = output
        return res

    def _get_latest_version(self,
                            cr,
                            uid,
                            ids,
                            field_name=None,
                            arg=None,
                            context=None):
        default_version = modules.adapt_version('1.0')
        res = dict.fromkeys(ids, default_version)
        for m in self.browse(cr, uid, ids):
            res[m.id] = self.get_module_info(m.name).get(
                'version', default_version)
        return res

    def _get_views(self,
                   cr,
                   uid,
                   ids,
                   field_name=None,
                   arg=None,
                   context=None):
        res = {}
        model_data_obj = self.pool.get('ir.model.data')

        dmodels = []
        if field_name is None or 'views_by_module' in field_name:
            dmodels.append('ir.ui.view')
        if field_name is None or 'reports_by_module' in field_name:
            dmodels.append('ir.actions.report.xml')
        if field_name is None or 'menus_by_module' in field_name:
            dmodels.append('ir.ui.menu')
        assert dmodels, "no models for %s" % field_name

        for module_rec in self.browse(cr, uid, ids, context=context):
            res_mod_dic = res[module_rec.id] = {
                'menus_by_module': [],
                'reports_by_module': [],
                'views_by_module': []
            }

            # Skip uninstalled modules below, no data to find anyway.
            if module_rec.state not in ('installed', 'to upgrade',
                                        'to remove'):
                continue

            # then, search and group ir.model.data records
            imd_models = dict([(m, []) for m in dmodels])
            imd_ids = model_data_obj.search(cr, uid,
                                            [('module', '=', module_rec.name),
                                             ('model', 'in', tuple(dmodels))])

            for imd_res in model_data_obj.read(cr,
                                               uid,
                                               imd_ids, ['model', 'res_id'],
                                               context=context):
                imd_models[imd_res['model']].append(imd_res['res_id'])

            def browse(model):
                M = self.pool[model]
                # as this method is called before the module update, some xmlid may be invalid at this stage
                # explictly filter records before reading them
                ids = M.exists(cr, uid, imd_models.get(model, []), context)
                return M.browse(cr, uid, ids, context)

            def format_view(v):
                aa = v.inherit_id and '* INHERIT ' or ''
                return '%s%s (%s)' % (aa, v.name, v.type)

            res_mod_dic['views_by_module'] = map(format_view,
                                                 browse('ir.ui.view'))
            res_mod_dic['reports_by_module'] = map(
                attrgetter('name'), browse('ir.actions.report.xml'))
            res_mod_dic['menus_by_module'] = map(attrgetter('complete_name'),
                                                 browse('ir.ui.menu'))

        for key in res.iterkeys():
            for k, v in res[key].iteritems():
                res[key][k] = "\n".join(sorted(v))
        return res

    def _get_icon_image(self,
                        cr,
                        uid,
                        ids,
                        field_name=None,
                        arg=None,
                        context=None):
        res = dict.fromkeys(ids, '')
        for module in self.browse(cr, uid, ids, context=context):
            path = get_module_resource(module.name, 'static', 'description',
                                       'icon.png')
            if path:
                image_file = tools.file_open(path, 'rb')
                try:
                    res[module.id] = image_file.read().encode('base64')
                finally:
                    image_file.close()
        return res

    _columns = {
        'name':
        fields.char("Technical Name",
                    readonly=True,
                    required=True,
                    select=True),
        'category_id':
        fields.many2one('ir.module.category',
                        'Category',
                        readonly=True,
                        select=True),
        'shortdesc':
        fields.char('Module Name', readonly=True, translate=True),
        'summary':
        fields.char('Summary', readonly=True, translate=True),
        'description':
        fields.text("Description", readonly=True, translate=True),
        'description_html':
        fields.function(_get_desc,
                        string='Description HTML',
                        type='html',
                        method=True,
                        readonly=True),
        'author':
        fields.char("Author", readonly=True),
        'maintainer':
        fields.char('Maintainer', readonly=True),
        'contributors':
        fields.text('Contributors', readonly=True),
        'website':
        fields.char("Website", readonly=True),

        # attention: Incorrect field names !!
        #   installed_version refers the latest version (the one on disk)
        #   latest_version refers the installed version (the one in database)
        #   published_version refers the version available on the repository
        'installed_version':
        fields.function(_get_latest_version,
                        string='Latest Version',
                        type='char'),
        'latest_version':
        fields.char('Installed Version', readonly=True),
        'published_version':
        fields.char('Published Version', readonly=True),
        'url':
        fields.char('URL', readonly=True),
        'sequence':
        fields.integer('Sequence'),
        'dependencies_id':
        fields.one2many('ir.module.module.dependency',
                        'module_id',
                        'Dependencies',
                        readonly=True),
        'auto_install':
        fields.boolean(
            'Automatic Installation',
            help='An auto-installable module is automatically installed by the '
            'system when all its dependencies are satisfied. '
            'If the module has no dependency, it is always installed.'),
        'state':
        fields.selection([('uninstallable', 'Not Installable'),
                          ('uninstalled', 'Not Installed'),
                          ('installed', 'Installed'),
                          ('to upgrade', 'To be upgraded'),
                          ('to remove', 'To be removed'),
                          ('to install', 'To be installed')],
                         string='Status',
                         readonly=True,
                         select=True),
        'demo':
        fields.boolean('Demo Data', readonly=True),
        'license':
        fields.selection(
            [('GPL-2', 'GPL Version 2'),
             ('GPL-2 or any later version', 'GPL-2 or later version'),
             ('GPL-3', 'GPL Version 3'),
             ('GPL-3 or any later version', 'GPL-3 or later version'),
             ('AGPL-3', 'Affero GPL-3'), ('LGPL-3', 'LGPL Version 3'),
             ('Other OSI approved licence', 'Other OSI Approved Licence'),
             ('Other proprietary', 'Other Proprietary')],
            string='License',
            readonly=True),
        'menus_by_module':
        fields.function(_get_views,
                        string='Menus',
                        type='text',
                        multi="meta",
                        store=True),
        'reports_by_module':
        fields.function(_get_views,
                        string='Reports',
                        type='text',
                        multi="meta",
                        store=True),
        'views_by_module':
        fields.function(_get_views,
                        string='Views',
                        type='text',
                        multi="meta",
                        store=True),
        'application':
        fields.boolean('Application', readonly=True),
        'icon':
        fields.char('Icon URL'),
        'icon_image':
        fields.function(_get_icon_image, string='Icon', type="binary"),
    }

    _defaults = {
        'state': 'uninstalled',
        'sequence': 100,
        'demo': False,
        'license': 'AGPL-3',
    }
    _order = 'sequence,name'

    def _name_uniq_msg(self, cr, uid, ids, context=None):
        return _('The name of the module must be unique !')

    _sql_constraints = [
        ('name_uniq', 'UNIQUE (name)', _name_uniq_msg),
    ]

    def unlink(self, cr, uid, ids, context=None):
        if not ids:
            return True
        if isinstance(ids, (int, long)):
            ids = [ids]
        mod_names = []
        for mod in self.read(cr, uid, ids, ['state', 'name'], context):
            if mod['state'] in ('installed', 'to upgrade', 'to remove',
                                'to install'):
                raise UserError(
                    _('You try to remove a module that is installed or will be installed'
                      ))
            mod_names.append(mod['name'])
        #Removing the entry from ir_model_data
        #ids_meta = self.pool.get('ir.model.data').search(cr, uid, [('name', '=', 'module_meta_information'), ('module', 'in', mod_names)])

        #if ids_meta:
        #    self.pool.get('ir.model.data').unlink(cr, uid, ids_meta, context)

        return super(module, self).unlink(cr, uid, ids, context=context)

    @staticmethod
    def _check_external_dependencies(terp):
        depends = terp.get('external_dependencies')
        if not depends:
            return
        for pydep in depends.get('python', []):
            try:
                importlib.import_module(pydep)
            except ImportError:
                raise ImportError('No module named %s' % (pydep, ))

        for binary in depends.get('bin', []):
            try:
                tools.find_in_path(binary)
            except IOError:
                raise Exception('Unable to find %r in path' % (binary, ))

    @classmethod
    def check_external_dependencies(cls, module_name, newstate='to install'):
        terp = cls.get_module_info(module_name)
        try:
            cls._check_external_dependencies(terp)
        except Exception, e:
            if newstate == 'to install':
                msg = _(
                    'Unable to install module "%s" because an external dependency is not met: %s'
                )
            elif newstate == 'to upgrade':
                msg = _(
                    'Unable to upgrade module "%s" because an external dependency is not met: %s'
                )
            else:
                msg = _(
                    'Unable to process module "%s" because an external dependency is not met: %s'
                )
            raise UserError(msg % (module_name, e.args[0]))
コード例 #3
0
ファイル: tms_mini_esqueleto.py プロジェクト: sc4you/tmsv8
class tms_maintenance_order(osv.Model):
    _inherit = ['mail.thread', 'ir.needaction_mixin']
    _name = 'tms.maintenance.order'
    _description = 'Order Maintenace'

    ########################### Columnas : Atributos #######################################################################
    _columns = {
        'name':
        fields.char('Order Maintenance'),
        'description':
        fields.char('Description'),
        'notes':
        fields.text('Notes'),
        'state':
        fields.selection([('draft', 'Draft'), ('confirmed', 'Confirmed'),
                          ('done', 'Done'), ('cancel', 'Cancelled')],
                         'Estados'),
        'cheduled_start':
        fields.datetime('Cheduled Start'),
        'cheduled_end':
        fields.datetime('Cheduled End'),
        'cheduled_start_real':
        fields.datetime('Cheduled Start Real'),
        'cheduled_end_real':
        fields.datetime('Cheduled End Real'),

        ########Many2One###########
        'unit_id':
        fields.many2one('tms.unit', 'Unit'),
        'concept_id':
        fields.many2one('product.product', 'Concept Maintenance'),
        'supervisor_id':
        fields.many2one('hr.employee', 'Supervisor'),
        'driver_report_id':
        fields.many2one('hr.employee', 'Driver Report'),
        'user_register_order_id':
        fields.many2one('hr.employee', 'User Register Report'),

        ########One2Many###########
        'activities_ids':
        fields.one2many('tms.maintenance.order.activity',
                        'maintenance_order_id', 'Activities'),
    }

    ########################### Metodos ####################################################################################

    ########## Metodos para el 'state' ##########
    def action_draft(self, cr, uid, ids, context={}):
        self.write(cr, uid, ids, {'state': 'draft'})
        return True

    def action_confirmed(self, cr, uid, ids, context=None):
        self.write(cr, uid, ids, {'state': 'confirmed'})
        return True

    def action_done(self, cr, uid, ids, context={}):
        self.write(cr, uid, ids, {'state': 'done'})
        return True

    def action_cancel(self, cr, uid, ids, context=None):
        self.write(cr, uid, ids, {'state': 'cancel'})
        return True

########################### Valores por Defecto ########################################################################

    _defaults = {
        'state': lambda *a: 'draft',
    }

    ########################### Criterio de ordenamiento ###################################################################
    _order = 'name'
コード例 #4
0
        'author': fields.char("Author", size=128, readonly=True),
        'maintainer': fields.char('Maintainer', size=128, readonly=True),
        'contributors': fields.text('Contributors', readonly=True),
        'website': fields.char("Website", size=256, readonly=True),

        # attention: Incorrect field names !!
        #   installed_version refers the latest version (the one on disk)
        #   latest_version refers the installed version (the one in database)
        #   published_version refers the version available on the repository
        'installed_version': fields.function(_get_latest_version, string='Latest Version', type='char'),
        'latest_version': fields.char('Installed Version', size=64, readonly=True),
        'published_version': fields.char('Published Version', size=64, readonly=True),

        'url': fields.char('URL', size=128, readonly=True),
        'sequence': fields.integer('Sequence'),
        'dependencies_id': fields.one2many('ir.module.module.dependency', 'module_id', 'Dependencies', readonly=True),
        'auto_install': fields.boolean('Automatic Installation',
                                       help='An auto-installable module is automatically installed by the '
                                            'system when all its dependencies are satisfied. '
                                            'If the module has no dependency, it is always installed.'),
        'state': fields.selection([
            ('uninstallable', 'Not Installable'),
            ('uninstalled', 'Not Installed'),
            ('installed', 'Installed'),
            ('to upgrade', 'To be upgraded'),
            ('to remove', 'To be removed'),
            ('to install', 'To be installed')
        ], string='Status', readonly=True, select=True),
        'demo': fields.boolean('Demo Data', readonly=True),
        'license': fields.selection([
            ('GPL-2', 'GPL Version 2'),
コード例 #5
0
ファイル: delivery.py プロジェクト: rafasis1986/odoo
                    except osv.except_osv, e:
                        # no suitable delivery method found, probably configuration error
                        _logger.error("Carrier %s: %s\n%s" % (carrier.name, e.name, e.value))
                        price = 0.0
                else:
                    price = 0.0
            res[carrier.id] = {"price": price, "available": available}
        return res

    _columns = {
        "name": fields.char("Delivery Method", required=True),
        "partner_id": fields.many2one(
            "res.partner", "Transport Company", required=True, help="The partner that is doing the delivery service."
        ),
        "product_id": fields.many2one("product.product", "Delivery Product", required=True),
        "grids_id": fields.one2many("delivery.grid", "carrier_id", "Delivery Grids"),
        "available": fields.function(
            get_price,
            string="Available",
            type="boolean",
            multi="price",
            help="Is the carrier method possible with the current order.",
        ),
        "price": fields.function(get_price, string="Price", multi="price"),
        "active": fields.boolean(
            "Active",
            help="If the active field is set to False, it will allow you to hide the delivery carrier without removing it.",
        ),
        "normal_price": fields.float(
            "Normal Price", help="Keep empty if the pricing depends on the advanced pricing per destination"
        ),
コード例 #6
0
ファイル: sale.py プロジェクト: GoContractPro/Odoo-GCP
        'ups_shipper_id': fields.many2one('ups.account.shipping', 'Shipping Account'),
=======
        'ups_shipper_id': fields.many2one('ups.account.shipping', 'Shipper'),
>>>>>>> c1979f64b3360c86d60e00c92be0271d89f97f2d
        'ups_service_id': fields.many2one('ups.shipping.service.type', 'Service Type'),
        'ups_pickup_type': fields.selection([
            ('01', 'Daily Pickup'),
            ('03', 'Customer Counter'),
            ('06', 'One Time Pickup'),
            ('07', 'On Call Air'),
            ('11', 'Suggested Retail Rates'),
            ('19', 'Letter Center'),
            ('20', 'Air Service Center'),
            ], 'Pickup Type'),
        'ups_packaging_type': fields.many2one('shipping.package.type', 'Packaging Type'),
        'shipping_rates': fields.one2many('shipping.rates.sales', 'sales_id', 'Rate Quotes'),
        'status_message': fields.char('Status', size=128, readonly=True),
        # From partner address validation
        'address_validation_method': fields.selection(_method_get, 'Address Validation Method', size=32),
        
    }

    def _get_sale_account(self, cr, uid, context=None):
        if context is None:
            context = {}
        logsitic_obj = self.pool.get('logistic.company')
        user_rec = self.pool.get('res.users').browse(cr , uid, uid, context)
        logis_company = logsitic_obj.search(cr, uid, [])
        if not logis_company:
            return False
        return logsitic_obj.browse(cr, uid, logis_company[0], context).ship_account_id.id
コード例 #7
0
FISCAL_RULE_COLUMNS = {
    "partner_fiscal_type_id": fields.many2one("l10n_br_account.partner.fiscal.type", "Tipo Fiscal do Parceiro"),
    "fiscal_category_id": fields.many2one("l10n_br_account.fiscal.category", "Categoria"),
    "fiscal_type": fields.selection(COMPANY_FISCAL_TYPE, u"Regime Tributário", required=True),
    "revenue_start": fields.float(
        "Faturamento Inicial", digits_compute=dp.get_precision("Account"), help="Faixa inicial de faturamento bruto"
    ),
    "revenue_end": fields.float(
        "Faturamento Final", digits_compute=dp.get_precision("Account"), help="Faixa inicial de faturamento bruto"
    ),
}

OTHERS_FISCAL_RULE_COLUMNS_TEMPLATE = {
    "parent_id": fields.many2one("account.fiscal.position.rule.template", "Regra Pai"),
    "child_ids": fields.one2many("account.fiscal.position.rule.template", "parent_id", "Regras Filhas"),
}

OTHERS_FISCAL_RULE_COLUMNS = {
    "parent_id": fields.many2one("account.fiscal.position.rule", "Regra Pai"),
    "child_ids": fields.one2many("account.fiscal.position.rule", "parent_id", "Regras Filhas"),
}

FISCAL_RULE_DEFAULTS = {"fiscal_type": COMPANY_FISCAL_TYPE_DEFAULT, "revenue_start": 0.00, "revenue_end": 0.00}


class AccountFiscalPositionRuleTemplate(orm.Model):
    _inherit = "account.fiscal.position.rule.template"
    _columns = dict(FISCAL_RULE_COLUMNS.items() + OTHERS_FISCAL_RULE_COLUMNS_TEMPLATE.items())
    _defaults = FISCAL_RULE_DEFAULTS
コード例 #8
0
ファイル: product.py プロジェクト: akhdaniel/addons
	_columns = {
		'name' : fields.char('Name', required=True),
		'partner_id' : fields.many2one('res.partner','Principle',domain=[('supplier','=',True)],required=True),
		'product_id' : fields.many2one('product.product','Bonus Product'),
		'qty_2' : fields.float('Bonus Qty2', digits_compute=dp.get_precision('Product Unit of Measure')),
		'qty' : fields.function(_qty_all_1,type="float",string='Bonus Qty',digits_compute=dp.get_precision('Product Unit of Measure')),
		'uom_id' : fields.many2one('product.uom','UoM',required=True),
		'uom_id2' : fields.many2one('product.uom','UoM',required=True),
		'value' : fields.float('Price Value',domain=[('is_percent','=',False)]),
		'per_product' : fields.boolean('Per Product'),
		'persentase' : fields.float('Percent Value', digits_compute= dp.get_precision('Discount'),domain=[('is_percent','=',True)]),
		'multi' : fields.boolean('Multiples'),
		'is_active' : fields.boolean('Active?'),
		'date_from' : fields.date('Start Date', required=True),
		'date_to' : fields.date('End Date', required=True),
		'condition_ids' : fields.one2many('master.condition','discount_id','Value Condition'),
		'condition2_ids' : fields.one2many('master.condition2','discount_id','Product Condition'),
		'condition3_ids' : fields.one2many('master.condition3','discount_id','Product Condition 2'),
		'condition4_ids' : fields.one2many('master.condition4','discount_id','Product Condition 3'),
		'condition5_ids' : fields.one2many('master.condition5','discount_id','Product Condition 4'),
		'group_price_ids' : fields.many2many('res.partner.category', id1='discount_id', id2='category_id', string='Group Price Category'),
		'is_percent' : fields.boolean('Is Percent'),
		'is_flat' : fields.boolean('Flat'),
		'type' :fields.selection([('regular','Regular Discount'),('promo','Promo Discount'),('extra','Extra Discount'),('cash','Cash Discount'),('mix','Mix Discount')],string='Type Discount',required=True),
		'min_qty_product' : fields.float('Min. Product Item',digits_compute=dp.get_precision('Product Unit of Measure')),
		'multi2' : fields.boolean('Value Condition'),
		'multi3' : fields.boolean('Multiples for New Product'),
		# 'multi_sel' : fields.selection([('general','General Multiples'),('specific','Specific Multiples for New Product')],string="Multiples"),
		'product_id2' : fields.many2one('product.product','Bonus New Product'),
		'qty2_2' : fields.float('Bonus Qty', digits_compute=dp.get_precision('Product Unit of Measure')),
		'qty2' : fields.function(_qty_all_2,type="float",string='Bonus Qty',digits_compute=dp.get_precision('Product Unit of Measure')),
コード例 #9
0
class MergePartnerAutomatic(osv.TransientModel):
    """
        The idea behind this wizard is to create a list of potential partners to
        merge. We use two objects, the first one is the wizard for the end-user.
        And the second will contain the partner list to merge.
    """
    _name = 'base.partner.merge.automatic.wizard'

    _columns = {
        # Group by
        'group_by_email':
        fields.boolean('Email'),
        'group_by_name':
        fields.boolean('Name'),
        'group_by_is_company':
        fields.boolean('Is Company'),
        'group_by_vat':
        fields.boolean('VAT'),
        'group_by_parent_id':
        fields.boolean('Parent Company'),
        'state':
        fields.selection([('option', 'Option'), ('selection', 'Selection'),
                          ('finished', 'Finished')],
                         'State',
                         readonly=True,
                         required=True),
        'number_group':
        fields.integer("Group of Contacts", readonly=True),
        'current_line_id':
        fields.many2one('base.partner.merge.line', 'Current Line'),
        'line_ids':
        fields.one2many('base.partner.merge.line', 'wizard_id', 'Lines'),
        'partner_ids':
        fields.many2many('res.partner', string='Contacts'),
        'dst_partner_id':
        fields.many2one('res.partner', string='Destination Contact'),
        'exclude_contact':
        fields.boolean('A user associated to the contact'),
        'exclude_journal_item':
        fields.boolean('Journal Items associated to the contact'),
        'maximum_group':
        fields.integer("Maximum of Group of Contacts"),
    }

    def default_get(self, cr, uid, fields, context=None):
        if context is None:
            context = {}
        res = super(MergePartnerAutomatic,
                    self).default_get(cr, uid, fields, context)
        if context.get('active_model') == 'res.partner' and context.get(
                'active_ids'):
            partner_ids = context['active_ids']
            res['state'] = 'selection'
            res['partner_ids'] = partner_ids
            res['dst_partner_id'] = self._get_ordered_partner(
                cr, uid, partner_ids, context=context)[-1].id
        return res

    _defaults = {'state': 'option'}

    def get_fk_on(self, cr, table):
        q = """  SELECT cl1.relname as table,
                        att1.attname as column
                   FROM pg_constraint as con, pg_class as cl1, pg_class as cl2,
                        pg_attribute as att1, pg_attribute as att2
                  WHERE con.conrelid = cl1.oid
                    AND con.confrelid = cl2.oid
                    AND array_lower(con.conkey, 1) = 1
                    AND con.conkey[1] = att1.attnum
                    AND att1.attrelid = cl1.oid
                    AND cl2.relname = %s
                    AND att2.attname = 'id'
                    AND array_lower(con.confkey, 1) = 1
                    AND con.confkey[1] = att2.attnum
                    AND att2.attrelid = cl2.oid
                    AND con.contype = 'f'
        """
        return cr.execute(q, (table, ))

    def _update_foreign_keys(self,
                             cr,
                             uid,
                             src_partners,
                             dst_partner,
                             context=None):
        _logger.debug(
            '_update_foreign_keys for dst_partner: %s for src_partners: %r',
            dst_partner.id, list(map(operator.attrgetter('id'), src_partners)))

        # find the many2one relation to a partner
        proxy = self.pool.get('res.partner')
        self.get_fk_on(cr, 'res_partner')

        # ignore two tables

        for table, column in cr.fetchall():
            if 'base_partner_merge_' in table:
                continue
            partner_ids = tuple(map(int, src_partners))

            query = "SELECT column_name FROM information_schema.columns WHERE table_name LIKE '%s'" % (
                table)
            cr.execute(query, ())
            columns = []
            for data in cr.fetchall():
                if data[0] != column:
                    columns.append(data[0])

            query_dic = {
                'table': table,
                'column': column,
                'value': columns[0],
            }
            if len(columns) <= 1:
                # unique key treated
                query = """
                    UPDATE "%(table)s" as ___tu
                    SET %(column)s = %%s
                    WHERE
                        %(column)s = %%s AND
                        NOT EXISTS (
                            SELECT 1
                            FROM "%(table)s" as ___tw
                            WHERE
                                %(column)s = %%s AND
                                ___tu.%(value)s = ___tw.%(value)s
                        )""" % query_dic
                for partner_id in partner_ids:
                    cr.execute(query,
                               (dst_partner.id, partner_id, dst_partner.id))
            else:
                try:
                    with mute_logger('openerp.sql_db'), cr.savepoint():
                        query = 'UPDATE "%(table)s" SET %(column)s = %%s WHERE %(column)s IN %%s' % query_dic
                        cr.execute(query, (
                            dst_partner.id,
                            partner_ids,
                        ))

                        if column == proxy._parent_name and table == 'res_partner':
                            query = """
                                WITH RECURSIVE cycle(id, parent_id) AS (
                                        SELECT id, parent_id FROM res_partner
                                    UNION
                                        SELECT  cycle.id, res_partner.parent_id
                                        FROM    res_partner, cycle
                                        WHERE   res_partner.id = cycle.parent_id AND
                                                cycle.id != cycle.parent_id
                                )
                                SELECT id FROM cycle WHERE id = parent_id AND id = %s
                            """
                            cr.execute(query, (dst_partner.id, ))
                except psycopg2.Error:
                    # updating fails, most likely due to a violated unique constraint
                    # keeping record with nonexistent partner_id is useless, better delete it
                    query = 'DELETE FROM %(table)s WHERE %(column)s = %%s' % query_dic
                    cr.execute(query, (partner_id, ))

    def _update_reference_fields(self,
                                 cr,
                                 uid,
                                 src_partners,
                                 dst_partner,
                                 context=None):
        _logger.debug(
            '_update_reference_fields for dst_partner: %s for src_partners: %r',
            dst_partner.id, list(map(operator.attrgetter('id'), src_partners)))

        def update_records(model,
                           src,
                           field_model='model',
                           field_id='res_id',
                           context=None):
            proxy = self.pool.get(model)
            if proxy is None:
                return
            domain = [(field_model, '=', 'res.partner'),
                      (field_id, '=', src.id)]
            ids = proxy.search(cr,
                               openerp.SUPERUSER_ID,
                               domain,
                               context=context)
            try:
                with mute_logger('openerp.sql_db'), cr.savepoint():
                    return proxy.write(cr,
                                       openerp.SUPERUSER_ID,
                                       ids, {field_id: dst_partner.id},
                                       context=context)
            except psycopg2.Error:
                # updating fails, most likely due to a violated unique constraint
                # keeping record with nonexistent partner_id is useless, better delete it
                return proxy.unlink(cr,
                                    openerp.SUPERUSER_ID,
                                    ids,
                                    context=context)

        update_records = functools.partial(update_records, context=context)

        for partner in src_partners:
            update_records('calendar',
                           src=partner,
                           field_model='model_id.model')
            update_records('ir.attachment',
                           src=partner,
                           field_model='res_model')
            update_records('mail.followers',
                           src=partner,
                           field_model='res_model')
            update_records('mail.message', src=partner)
            update_records('marketing.campaign.workitem',
                           src=partner,
                           field_model='object_id.model')
            update_records('ir.model.data', src=partner)

        proxy = self.pool['ir.model.fields']
        domain = [('ttype', '=', 'reference')]
        record_ids = proxy.search(cr,
                                  openerp.SUPERUSER_ID,
                                  domain,
                                  context=context)

        for record in proxy.browse(cr,
                                   openerp.SUPERUSER_ID,
                                   record_ids,
                                   context=context):
            try:
                proxy_model = self.pool[record.model]
                field_type = proxy_model._columns[record.name].__class__._type
            except KeyError:
                # unknown model or field => skip
                continue

            if field_type == 'function':
                continue

            for partner in src_partners:
                domain = [(record.name, '=', 'res.partner,%d' % partner.id)]
                model_ids = proxy_model.search(cr,
                                               openerp.SUPERUSER_ID,
                                               domain,
                                               context=context)
                values = {
                    record.name: 'res.partner,%d' % dst_partner.id,
                }
                proxy_model.write(cr,
                                  openerp.SUPERUSER_ID,
                                  model_ids,
                                  values,
                                  context=context)

    def _update_values(self, cr, uid, src_partners, dst_partner, context=None):
        _logger.debug(
            '_update_values for dst_partner: %s for src_partners: %r',
            dst_partner.id, list(map(operator.attrgetter('id'), src_partners)))

        columns = dst_partner._columns

        def write_serializer(column, item):
            if isinstance(item, browse_record):
                return item.id
            else:
                return item

        values = dict()
        for column, field in columns.iteritems():
            if field._type not in ('many2many', 'one2many') and not isinstance(
                    field, fields.function):
                for item in itertools.chain(src_partners, [dst_partner]):
                    if item[column]:
                        values[column] = write_serializer(column, item[column])

        values.pop('id', None)
        parent_id = values.pop('parent_id', None)
        dst_partner.write(values)
        if parent_id and parent_id != dst_partner.id:
            try:
                dst_partner.write({'parent_id': parent_id})
            except (osv.except_osv, orm.except_orm):
                _logger.info(
                    'Skip recursive partner hierarchies for parent_id %s of partner: %s',
                    parent_id, dst_partner.id)

    @mute_logger('openerp.osv.expression', 'openerp.models')
    def _merge(self, cr, uid, partner_ids, dst_partner=None, context=None):
        proxy = self.pool.get('res.partner')

        partner_ids = proxy.exists(cr, uid, list(partner_ids), context=context)
        if len(partner_ids) < 2:
            return

        if len(partner_ids) > 3:
            raise osv.except_osv(
                _('Error'),
                _("For safety reasons, you cannot merge more than 3 contacts together. You can re-open the wizard several times if needed."
                  ))

        if openerp.SUPERUSER_ID != uid and len(
                set(partner.email for partner in proxy.browse(
                    cr, uid, partner_ids, context=context))) > 1:
            raise osv.except_osv(
                _('Error'),
                _("All contacts must have the same email. Only the Administrator can merge contacts with different emails."
                  ))

        if dst_partner and dst_partner.id in partner_ids:
            src_partners = proxy.browse(
                cr,
                uid, [id for id in partner_ids if id != dst_partner.id],
                context=context)
        else:
            ordered_partners = self._get_ordered_partner(
                cr, uid, partner_ids, context)
            dst_partner = ordered_partners[-1]
            src_partners = ordered_partners[:-1]
        _logger.info("dst_partner: %s", dst_partner.id)

        if openerp.SUPERUSER_ID != uid and self._model_is_installed(cr, uid, 'account.move.line', context=context) and \
                self.pool.get('account.move.line').search(cr, openerp.SUPERUSER_ID, [('partner_id', 'in', [partner.id for partner in src_partners])], context=context):
            raise osv.except_osv(
                _('Error'),
                _("Only the destination contact may be linked to existing Journal Items. Please ask the Administrator if you need to merge several contacts linked to existing Journal Items."
                  ))

        call_it = lambda function: function(
            cr, uid, src_partners, dst_partner, context=context)

        call_it(self._update_foreign_keys)
        call_it(self._update_reference_fields)
        call_it(self._update_values)

        _logger.info('(uid = %s) merged the partners %r with %s', uid,
                     list(map(operator.attrgetter('id'), src_partners)),
                     dst_partner.id)
        dst_partner.message_post(body='%s %s' %
                                 (_("Merged with the following partners:"),
                                  ", ".join('%s<%s>(ID %s)' %
                                            (p.name, p.email or 'n/a', p.id)
                                            for p in src_partners)))

        for partner in src_partners:
            partner.unlink()

    def clean_emails(self, cr, uid, context=None):
        """
        Clean the email address of the partner, if there is an email field with
        a mimum of two addresses, the system will create a new partner, with the
        information of the previous one and will copy the new cleaned email into
        the email field.
        """
        context = dict(context or {})

        proxy_model = self.pool['ir.model.fields']
        field_ids = proxy_model.search(cr,
                                       uid, [('model', '=', 'res.partner'),
                                             ('ttype', 'like', '%2many')],
                                       context=context)
        fields = proxy_model.read(cr, uid, field_ids, context=context)
        reset_fields = dict((field['name'], []) for field in fields)

        proxy_partner = self.pool['res.partner']
        context['active_test'] = False
        ids = proxy_partner.search(cr, uid, [], context=context)

        fields = ['name', 'var' 'partner_id' 'is_company', 'email']
        partners = proxy_partner.read(cr, uid, ids, fields, context=context)

        partners.sort(key=operator.itemgetter('id'))
        partners_len = len(partners)

        _logger.info('partner_len: %r', partners_len)

        for idx, partner in enumerate(partners):
            if not partner['email']:
                continue

            percent = (idx / float(partners_len)) * 100.0
            _logger.info('idx: %r', idx)
            _logger.info('percent: %r', percent)
            try:
                emails = sanitize_email(partner['email'])
                head, tail = emails[:1], emails[1:]
                email = head[0] if head else False

                proxy_partner.write(cr,
                                    uid, [partner['id']], {'email': email},
                                    context=context)

                for email in tail:
                    values = dict(reset_fields, email=email)
                    proxy_partner.copy(cr,
                                       uid,
                                       partner['id'],
                                       values,
                                       context=context)

            except Exception:
                _logger.exception("There is a problem with this partner: %r",
                                  partner)
                raise
        return True

    def close_cb(self, cr, uid, ids, context=None):
        return {'type': 'ir.actions.act_window_close'}

    def _generate_query(self, fields, maximum_group=100):
        sql_fields = []
        for field in fields:
            if field in ['email', 'name']:
                sql_fields.append('lower(%s)' % field)
            elif field in ['vat']:
                sql_fields.append("replace(%s, ' ', '')" % field)
            else:
                sql_fields.append(field)

        group_fields = ', '.join(sql_fields)

        filters = []
        for field in fields:
            if field in ['email', 'name', 'vat']:
                filters.append((field, 'IS NOT', 'NULL'))

        criteria = ' AND '.join('%s %s %s' % (field, operator, value)
                                for field, operator, value in filters)

        text = [
            "SELECT min(id), array_agg(id)",
            "FROM res_partner",
        ]

        if criteria:
            text.append('WHERE %s' % criteria)

        text.extend([
            "GROUP BY %s" % group_fields,
            "HAVING COUNT(*) >= 2",
            "ORDER BY min(id)",
        ])

        if maximum_group:
            text.extend([
                "LIMIT %s" % maximum_group,
            ])

        return ' '.join(text)

    def _compute_selected_groupby(self, this):
        group_by_str = 'group_by_'
        group_by_len = len(group_by_str)

        fields = [
            key[group_by_len:] for key in self._columns.keys()
            if key.startswith(group_by_str)
        ]

        groups = [
            field for field in fields
            if getattr(this, '%s%s' % (group_by_str, field), False)
        ]

        if not groups:
            raise osv.except_osv(
                _('Error'),
                _("You have to specify a filter for your selection"))

        return groups

    def next_cb(self, cr, uid, ids, context=None):
        """
        Don't compute any thing
        """
        context = dict(context or {}, active_test=False)
        this = self.browse(cr, uid, ids[0], context=context)
        if this.current_line_id:
            this.current_line_id.unlink()
        return self._next_screen(cr, uid, this, context)

    def _get_ordered_partner(self, cr, uid, partner_ids, context=None):
        partners = self.pool.get('res.partner').browse(cr,
                                                       uid,
                                                       list(partner_ids),
                                                       context=context)
        ordered_partners = sorted(sorted(
            partners, key=operator.attrgetter('create_date'), reverse=True),
                                  key=operator.attrgetter('active'),
                                  reverse=True)
        return ordered_partners

    def _next_screen(self, cr, uid, this, context=None):
        this.refresh()
        values = {}
        if this.line_ids:
            # in this case, we try to find the next record.
            current_line = this.line_ids[0]
            current_partner_ids = literal_eval(current_line.aggr_ids)
            values.update({
                'current_line_id':
                current_line.id,
                'partner_ids': [(6, 0, current_partner_ids)],
                'dst_partner_id':
                self._get_ordered_partner(cr, uid, current_partner_ids,
                                          context)[-1].id,
                'state':
                'selection',
            })
        else:
            values.update({
                'current_line_id': False,
                'partner_ids': [],
                'state': 'finished',
            })

        this.write(values)

        return {
            'type': 'ir.actions.act_window',
            'res_model': this._name,
            'res_id': this.id,
            'view_mode': 'form',
            'target': 'new',
        }

    def _model_is_installed(self, cr, uid, model, context=None):
        proxy = self.pool.get('ir.model')
        domain = [('model', '=', model)]
        return proxy.search_count(cr, uid, domain, context=context) > 0

    def _partner_use_in(self, cr, uid, aggr_ids, models, context=None):
        """
        Check if there is no occurence of this group of partner in the selected
        model
        """
        for model, field in models.iteritems():
            proxy = self.pool.get(model)
            domain = [(field, 'in', aggr_ids)]
            if proxy.search_count(cr, uid, domain, context=context):
                return True
        return False

    def compute_models(self, cr, uid, ids, context=None):
        """
        Compute the different models needed by the system if you want to exclude
        some partners.
        """
        assert is_integer_list(ids)

        this = self.browse(cr, uid, ids[0], context=context)

        models = {}
        if this.exclude_contact:
            models['res.users'] = 'partner_id'

        if self._model_is_installed(
                cr, uid, 'account.move.line',
                context=context) and this.exclude_journal_item:
            models['account.move.line'] = 'partner_id'

        return models

    def _process_query(self, cr, uid, ids, query, context=None):
        """
        Execute the select request and write the result in this wizard
        """
        proxy = self.pool.get('base.partner.merge.line')
        this = self.browse(cr, uid, ids[0], context=context)
        models = self.compute_models(cr, uid, ids, context=context)
        cr.execute(query)

        counter = 0
        for min_id, aggr_ids in cr.fetchall():
            if models and self._partner_use_in(
                    cr, uid, aggr_ids, models, context=context):
                continue
            values = {
                'wizard_id': this.id,
                'min_id': min_id,
                'aggr_ids': aggr_ids,
            }

            proxy.create(cr, uid, values, context=context)
            counter += 1

        values = {
            'state': 'selection',
            'number_group': counter,
        }

        this.write(values)

        _logger.info("counter: %s", counter)

    def start_process_cb(self, cr, uid, ids, context=None):
        """
        Start the process.
        * Compute the selected groups (with duplication)
        * If the user has selected the 'exclude_XXX' fields, avoid the partners.
        """
        assert is_integer_list(ids)

        context = dict(context or {}, active_test=False)
        this = self.browse(cr, uid, ids[0], context=context)
        groups = self._compute_selected_groupby(this)
        query = self._generate_query(groups, this.maximum_group)
        self._process_query(cr, uid, ids, query, context=context)

        return self._next_screen(cr, uid, this, context)

    def automatic_process_cb(self, cr, uid, ids, context=None):
        assert is_integer_list(ids)
        this = self.browse(cr, uid, ids[0], context=context)
        this.start_process_cb()
        this.refresh()

        for line in this.line_ids:
            partner_ids = literal_eval(line.aggr_ids)
            self._merge(cr, uid, partner_ids, context=context)
            line.unlink()
            cr.commit()

        this.write({'state': 'finished'})
        return {
            'type': 'ir.actions.act_window',
            'res_model': this._name,
            'res_id': this.id,
            'view_mode': 'form',
            'target': 'new',
        }

    def parent_migration_process_cb(self, cr, uid, ids, context=None):
        assert is_integer_list(ids)

        context = dict(context or {}, active_test=False)
        this = self.browse(cr, uid, ids[0], context=context)

        query = """
            SELECT
                min(p1.id),
                array_agg(DISTINCT p1.id)
            FROM
                res_partner as p1
            INNER join
                res_partner as p2
            ON
                p1.email = p2.email AND
                p1.name = p2.name AND
                (p1.parent_id = p2.id OR p1.id = p2.parent_id)
            WHERE
                p2.id IS NOT NULL
            GROUP BY
                p1.email,
                p1.name,
                CASE WHEN p1.parent_id = p2.id THEN p2.id
                    ELSE p1.id
                END
            HAVING COUNT(*) >= 2
            ORDER BY
                min(p1.id)
        """

        self._process_query(cr, uid, ids, query, context=context)

        for line in this.line_ids:
            partner_ids = literal_eval(line.aggr_ids)
            self._merge(cr, uid, partner_ids, context=context)
            line.unlink()
            cr.commit()

        this.write({'state': 'finished'})

        cr.execute("""
            UPDATE
                res_partner
            SET
                is_company = NULL,
                parent_id = NULL
            WHERE
                parent_id = id
        """)

        return {
            'type': 'ir.actions.act_window',
            'res_model': this._name,
            'res_id': this.id,
            'view_mode': 'form',
            'target': 'new',
        }

    def update_all_process_cb(self, cr, uid, ids, context=None):
        assert is_integer_list(ids)

        # WITH RECURSIVE cycle(id, parent_id) AS (
        #     SELECT id, parent_id FROM res_partner
        #   UNION
        #     SELECT  cycle.id, res_partner.parent_id
        #     FROM    res_partner, cycle
        #     WHERE   res_partner.id = cycle.parent_id AND
        #             cycle.id != cycle.parent_id
        # )
        # UPDATE  res_partner
        # SET     parent_id = NULL
        # WHERE   id in (SELECT id FROM cycle WHERE id = parent_id);

        this = self.browse(cr, uid, ids[0], context=context)

        self.parent_migration_process_cb(cr, uid, ids, context=None)

        list_merge = [
            {
                'group_by_vat': True,
                'group_by_email': True,
                'group_by_name': True
            },
            # {'group_by_name': True, 'group_by_is_company': True, 'group_by_parent_id': True},
            # {'group_by_email': True, 'group_by_is_company': True, 'group_by_parent_id': True},
            # {'group_by_name': True, 'group_by_vat': True, 'group_by_is_company': True, 'exclude_journal_item': True},
            # {'group_by_email': True, 'group_by_vat': True, 'group_by_is_company': True, 'exclude_journal_item': True},
            # {'group_by_email': True, 'group_by_is_company': True, 'exclude_contact': True, 'exclude_journal_item': True},
            # {'group_by_name': True, 'group_by_is_company': True, 'exclude_contact': True, 'exclude_journal_item': True}
        ]

        for merge_value in list_merge:
            id = self.create(cr, uid, merge_value, context=context)
            self.automatic_process_cb(cr, uid, [id], context=context)

        cr.execute("""
            UPDATE
                res_partner
            SET
                is_company = NULL
            WHERE
                parent_id IS NOT NULL AND
                is_company IS NOT NULL
        """)

        # cr.execute("""
        #     UPDATE
        #         res_partner as p1
        #     SET
        #         is_company = NULL,
        #         parent_id = (
        #             SELECT  p2.id
        #             FROM    res_partner as p2
        #             WHERE   p2.email = p1.email AND
        #                     p2.parent_id != p2.id
        #             LIMIT 1
        #         )
        #     WHERE
        #         p1.parent_id = p1.id
        # """)

        return self._next_screen(cr, uid, this, context)

    def merge_cb(self, cr, uid, ids, context=None):
        assert is_integer_list(ids)

        context = dict(context or {}, active_test=False)
        this = self.browse(cr, uid, ids[0], context=context)

        partner_ids = set(map(int, this.partner_ids))
        if not partner_ids:
            this.write({'state': 'finished'})
            return {
                'type': 'ir.actions.act_window',
                'res_model': this._name,
                'res_id': this.id,
                'view_mode': 'form',
                'target': 'new',
            }

        self._merge(cr, uid, partner_ids, this.dst_partner_id, context=context)

        if this.current_line_id:
            this.current_line_id.unlink()

        return self._next_screen(cr, uid, this, context)

    def auto_set_parent_id(self, cr, uid, ids, context=None):
        assert is_integer_list(ids)

        # select partner who have one least invoice
        partner_treated = ['@gmail.com']
        cr.execute("""  SELECT p.id, p.email
                        FROM res_partner as p 
                        LEFT JOIN account_invoice as a 
                        ON p.id = a.partner_id AND a.state in ('open','paid')
                        WHERE p.grade_id is NOT NULL
                        GROUP BY p.id
                        ORDER BY COUNT(a.id) DESC
                """)
        re_email = re.compile(r".*@")
        for id, email in cr.fetchall():
            # check email domain
            email = re_email.sub("@", email or "")
            if not email or email in partner_treated:
                continue
            partner_treated.append(email)

            # don't update the partners if they are more of one who have invoice
            cr.execute("""  SELECT *
                            FROM res_partner as p
                            WHERE p.id != %s AND p.email LIKE '%%%s' AND
                                EXISTS (SELECT * FROM account_invoice as a WHERE p.id = a.partner_id AND a.state in ('open','paid'))
                    """ % (id, email))

            if len(cr.fetchall()) > 1:
                _logger.info("%s MORE OF ONE COMPANY", email)
                continue

            # to display changed values
            cr.execute("""  SELECT id,email
                            FROM res_partner
                            WHERE parent_id != %s AND id != %s AND email LIKE '%%%s'
                    """ % (id, id, email))
            _logger.info("%r", cr.fetchall())

            # upgrade
            cr.execute("""  UPDATE res_partner
                            SET parent_id = %s
                            WHERE id != %s AND email LIKE '%%%s'
                    """ % (id, id, email))
        return False
class hr_rpt_attend_emp_day(osv.osv_memory):
    _name = "hr.rpt.attend.emp.day"
    _inherit = "rpt.base"
    _description = "HR Attendance Employee Day Report"
    _columns = {
        #report data lines
        'rpt_lines':
        fields.one2many('hr.rpt.attend.emp.day.line',
                        'rpt_id',
                        string='Report Line'),
        'date_from':
        fields.datetime("Start Date", required=True),
        'date_to':
        fields.datetime("End Date", required=True),
        'emp_ids':
        fields.many2many('hr.employee', string='Employees'),
    }

    _defaults = {
        'type': 'attend_emp_day',
        #        'emp_ids':[342,171]
    }

    def default_get(self, cr, uid, fields, context=None):
        vals = super(hr_rpt_attend_emp_day, self).default_get(cr,
                                                              uid,
                                                              fields,
                                                              context=context)
        if 'date_from' in fields:
            #For the datetime value in defaults, need convert the local time to UTC, the web framework will convert them back to local time on GUI
            date_from = datetime.strptime(time.strftime('%Y-%m-01 00:00:00'),
                                          '%Y-%m-%d %H:%M:%S')
            date_from_utc = utils.utc_timestamp(cr, uid, date_from, context)
            vals.update({
                'date_from':
                date_from_utc.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
            })

        if 'date_to' in fields:
            date_to = datetime.strptime(time.strftime('%Y-%m-%d 23:59:59'),
                                        '%Y-%m-%d %H:%M:%S')
            date_to_utc = utils.utc_timestamp(cr, uid, date_to, context)
            vals.update({
                'date_to':
                date_to_utc.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
            })

        return vals

    def _check_dates(self, cr, uid, ids, context=None):
        for wiz in self.browse(cr, uid, ids, context=context):
            if wiz.date_from and wiz.date_to and wiz.date_from > wiz.date_to:
                return False
        return True

    _constraints = [
        (_check_dates, 'The date end must be after the date start.',
         ['date_from', 'date_to']),
    ]

    def get_report_name(self, cr, uid, id, rpt_name, context=None):
        return "Attendance Employee Day Report"

    def name_get(self, cr, uid, ids, context=None):
        if not ids:
            return []
        res = []
        for id in ids:
            res.append((id, '%s' % (id, )))
        return res

    def _convert_save_dates(self, cr, uid, vals, context):
        #convert to the date like '2013-01-01' to UTC datetime to store
        if 'date_from' in vals and len(vals['date_from']) == 10:
            date_from = vals['date_from']
            date_from = utils.utc_timestamp(
                cr,
                uid,
                datetime.strptime(date_from + ' 00:00:00',
                                  DEFAULT_SERVER_DATETIME_FORMAT),
                context=context)
            date_from = date_from.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
            vals['date_from'] = date_from
        if 'date_to' in vals and len(vals['date_to']) == 10:
            date_to = vals['date_to']
            date_to = utils.utc_timestamp(cr,
                                          uid,
                                          datetime.strptime(
                                              date_to + ' 23:59:59',
                                              DEFAULT_SERVER_DATETIME_FORMAT),
                                          context=context)
            date_to = date_to.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
            vals['date_to'] = date_to

    def create(self, cr, uid, vals, context=None):
        self._convert_save_dates(cr, uid, vals, context)
        id_new = super(hr_rpt_attend_emp_day, self).create(cr,
                                                           uid,
                                                           vals,
                                                           context=context)
        return id_new

    def write(self, cr, uid, ids, vals, context=None):
        self._convert_save_dates(cr, uid, vals, context)
        resu = super(hr_rpt_attend_emp_day, self).write(cr,
                                                        uid,
                                                        ids,
                                                        vals,
                                                        context=context)
        return resu

    def _attend_hours(self, hours_valid, period):
        '''
        if hours_valid > period.hours_work_normal:
            hours_normal = period.hours_work_normal
        else:
            hours_normal = hours_valid
        hours_ot = hours_valid - hours_normal
        if hours_ot > period.hours_work_ot:
            hours_ot = period.hours_work_ot
        #the second time group                        
        if hours_valid > period.hours_work_normal2:
            hours_normal2 = period.hours_work_normal2
        else:
            hours_normal2 = hours_valid
        hours_ot2 = hours_valid - hours_normal2
        if hours_ot2 > period.hours_work_ot2:
            hours_ot2 = period.hours_work_ot2
        '''
        if hours_valid > period.hours_work_normal:
            hours_normal = period.hours_work_normal
        else:
            hours_normal = hours_valid
        hours_ot = hours_valid - hours_normal
        if hours_ot > period.hours_work_ot:
            hours_ot = period.hours_work_ot
        #the second time group
        if hours_valid > period.hours_work_normal2:
            hours_normal2 = period.hours_work_normal2
        else:
            hours_normal2 = hours_valid
        hours_ot2 = hours_valid - hours_normal2
        if hours_ot2 > period.hours_work_ot2:
            hours_ot2 = period.hours_work_ot2
        return hours_normal, hours_ot, hours_normal2, hours_ot2

    def run_attend_emp_day(self, cr, uid, ids, context=None):
        '''
        1.Query all data with both in/out by date range, store the result in attends_normal
        2.Loop on by days and employees
        '''
        emp_obj = self.pool.get('hr.employee')
        attend_obj = self.pool.get('hr.attendance')

        if context is None: context = {}
        rpt = self.browse(cr, uid, ids, context=context)[0]
        date_from = datetime.strptime(rpt.date_from,
                                      DEFAULT_SERVER_DATETIME_FORMAT)
        date_to = datetime.strptime(rpt.date_to,
                                    DEFAULT_SERVER_DATETIME_FORMAT)
        #report data line
        rpt_lns = []
        #context for the query
        c = context.copy()
        #get the employees
        emp_ids = [emp.id for emp in rpt.emp_ids]
        if not emp_ids:
            emp_ids = emp_obj.search(cr, uid, [], context=context)
        '''
        1.Query all data with both in/out by date range, store the result in attends_normal
        '''
        sql = '''
                select emp.id as emp_id, 
                period.id as period_id, 
                sign_in.day,
                sign_in.action as in_action, sign_in.name as in_time, sign_out.action out_action, sign_out.name out_time
                from hr_employee emp
                left join 
                    (select name,employee_id,cale_period_id,action,day from hr_attendance where name between %s and %s and action in('sign_in','sign_in_late')) as sign_in
                    on emp.id = sign_in.employee_id
                left join 
                    (select name,employee_id,cale_period_id,action,day from hr_attendance where name between %s and %s and action in('sign_out','sign_out_early')) as sign_out
                    on emp.id = sign_out.employee_id and sign_in.day = sign_out.day and sign_in.cale_period_id = sign_out.cale_period_id
                join resource_calendar_attendance period on sign_in.cale_period_id = period.id and sign_out.cale_period_id = period.id
                where emp.id = ANY(%s)
                '''
        cr.execute(sql, (date_from, date_to, date_from, date_to, (emp_ids, )))
        attends = cr.dictfetchall()
        #use the emp_id-day-period_id as the key to store the normal attendance
        #        attends_normal = dict(('%s-%s-%s'%(attend['emp_id'], attend['day'], attend['period_id']), attend) for attend in attends)
        attends_normal = {}
        for attend in attends:
            key = '%s-%s-%s' % (attend['emp_id'], attend['day'],
                                attend['period_id'])
            in_time = fields.datetime.context_timestamp(
                cr,
                uid,
                datetime.strptime(attend['in_time'],
                                  DEFAULT_SERVER_DATETIME_FORMAT),
                context=context)
            out_time = fields.datetime.context_timestamp(
                cr,
                uid,
                datetime.strptime(attend['out_time'],
                                  DEFAULT_SERVER_DATETIME_FORMAT),
                context=context)
            attend['in_time'] = in_time
            attend['out_time'] = out_time
            attends_normal[key] = attend
        '''
        2.Loop on by days and employees
        '''
        date_from_local = fields.datetime.context_timestamp(
            cr, uid, date_from, context)
        date_to_local = fields.datetime.context_timestamp(
            cr, uid, date_to, context)
        days = rrule.rrule(rrule.DAILY,
                           dtstart=date_from_local,
                           until=date_to_local)
        emps = emp_obj.browse(cr, uid, emp_ids, context)
        seq = 0
        for emp in emps:
            for day_dt in days:
                day = day_dt.strftime('%Y-%m-%d')
                #if there is no working time defined to employee then continue to next employee directly
                if not emp.calendar_id or not emp.calendar_id.attendance_ids:
                    seq += 1
                    '''
                    init a new empty line by employee/day without period info
                    '''
                    rpt_line = {
                        'seq': seq,
                        'emp_id': emp.id,
                        'day': day,
                        'period_id': None,
                        'sign_in': None,
                        'sign_out': None,
                        'hours_normal': None,
                        'hours_ot': None,
                        'is_late': False,
                        'is_early': False,
                        'is_absent': False,
                        'hours_normal2': None,
                        'hours_ot2': None,
                    }
                    rpt_lns.append(rpt_line)
                    continue
                for period in emp.calendar_id.attendance_ids:
                    if day_dt.isoweekday() != (int(period.dayofweek) + 1):
                        continue
                    '''
                    init a new empty line by employee/day/period
                    '''
                    seq += 1
                    rpt_line = {
                        'seq': seq,
                        'emp_id': emp.id,
                        'day': day,
                        'period_id': period.id,
                        'sign_in': None,
                        'sign_out': None,
                        'hours_normal': None,
                        'hours_ot': None,
                        'is_late': False,
                        'is_early': False,
                        'is_absent': False,
                        'hours_normal2': None,
                        'hours_ot2': None,
                    }
                    rpt_lns.append(rpt_line)
                    #find the normal attendance by employee/day/period
                    attend_key = '%s-%s-%s' % (emp.id, day, period.id)
                    attend = attends_normal.get(attend_key, False)
                    if attend:
                        #found the normal attendance, with sign in and out record, put the data directly
                        hour_in = attend[
                            'in_time'].hour + attend['in_time'].minute / 60.0
                        hour_out = attend[
                            'out_time'].hour + attend['out_time'].minute / 60.0
                        hours_valid = hour_out - hour_in - period.hours_non_work
                        attend_hours = self._attend_hours(hours_valid, period)
                        rpt_line.update({
                            'period_id': period.id,
                            'sign_in': hour_in,
                            'sign_out': hour_out,
                            'hours_normal': attend_hours[0],
                            'hours_ot': attend_hours[1],
                            'is_late': attend['in_action'] == 'sign_in_late',
                            'is_early':
                            attend['out_action'] == 'sign_out_early',
                            'hours_normal2': attend_hours[2],
                            'hours_ot2': attend_hours[3],
                        })
                        continue
                    #the abnormal attendance, with sign in or out record only, or without any attendance
                    attend_ids = attend_obj.search(
                        cr,
                        uid,
                        [('employee_id', '=', emp.id), ('day', '=', day),
                         ('cale_period_id', '=', period.id),
                         ('action', 'in', ('sign_in', 'sign_in_late',
                                           'sign_out', 'sign_out_early'))],
                        context=context)
                    if attend_ids:
                        #found sign in or sign out data, there shoule be only one record, so use the first ID to get data
                        attend = attend_obj.browse(cr,
                                                   uid,
                                                   attend_ids[0],
                                                   context=context)
                        attend_time = fields.datetime.context_timestamp(
                            cr, uid,
                            datetime.strptime(attend.name,
                                              DEFAULT_SERVER_DATETIME_FORMAT),
                            context)
                        hour_in = None
                        hour_out = None
                        hours_valid = None
                        hours_normal = None
                        hours_ot = None
                        is_late = False
                        is_early = False
                        is_absent = False
                        hours_normal2 = None
                        hours_ot2 = None
                        #Only have sign in record
                        if attend.action in ('sign_in', 'sign_in_late'):
                            hour_in = attend_time.hour + attend_time.minute / 60.0
                            if emp.calendar_id.no_out_option == 'early':
                                #treat as leave early
                                if not period.is_full_ot:
                                    is_early = True
                                hours_valid = period.hour_to - hour_in - period.hours_non_work - emp.calendar_id.no_out_time / 60.0
                            else:
                                #treat as absent
                                if not period.is_full_ot:
                                    is_absent = True
                                hours_valid = 0.0
                        #Only have sign out record
                        if attend.action in ('sign_out', 'sign_out_early'):
                            hour_out = attend_time.hour + attend_time.minute / 60.0
                            if emp.calendar_id.no_in_option == 'late':
                                #treat as leave early
                                if not period.is_full_ot:
                                    is_late = True
                                hours_valid = hour_out - period.hour_from - period.hours_non_work - emp.calendar_id.no_in_time / 60.0
                            else:
                                #treat as absent
                                if not period.is_full_ot:
                                    is_absent = True
                                hours_valid = 0.0
                        if hours_valid:
                            hours_normal, hours_ot, hours_normal2, hours_ot2 = self._attend_hours(
                                hours_valid, period)

                        rpt_line.update({
                            'period_id': period.id,
                            'sign_in': hour_in,
                            'sign_out': hour_out,
                            'hours_normal': hours_normal,
                            'hours_ot': hours_ot,
                            'is_late': is_late,
                            'is_early': is_early,
                            'is_absent': is_absent,
                            'hours_normal2': hours_normal2,
                            'hours_ot2': hours_ot2,
                        })
                    else:
                        if not period.is_full_ot:
                            rpt_line.update({'is_absent': True})
        '''========return data to rpt_base.run_report()========='''
        return self.pool.get('hr.rpt.attend.emp.day.line'), rpt_lns

    def _pdf_data(self, cr, uid, ids, form_data, context=None):
        return {'xmlrpt_name': 'hr.rpt.attend.emp.day'}
コード例 #11
0
ファイル: forum.py プロジェクト: wajidksa/odoo
class Post(osv.Model):
    _name = 'forum.post'
    _description = 'Forum Post'
    _inherit = ['mail.thread', 'website.seo.metadata']
    _order = "is_correct DESC, vote_count DESC, write_date DESC"

    def _get_user_vote(self, cr, uid, ids, field_name, arg, context):
        res = dict.fromkeys(ids, 0)
        vote_ids = self.pool['forum.post.vote'].search(cr,
                                                       uid,
                                                       [('post_id', 'in', ids),
                                                        ('user_id', '=', uid)],
                                                       context=context)
        for vote in self.pool['forum.post.vote'].browse(cr,
                                                        uid,
                                                        vote_ids,
                                                        context=context):
            res[vote.post_id.id] = vote.vote
        return res

    def _get_vote_count(self, cr, uid, ids, field_name, arg, context):
        res = dict.fromkeys(ids, 0)
        for post in self.browse(cr, uid, ids, context=context):
            for vote in post.vote_ids:
                res[post.id] += int(vote.vote)
        return res

    def _get_post_from_vote(self, cr, uid, ids, context=None):
        result = {}
        for vote in self.pool['forum.post.vote'].browse(cr,
                                                        uid,
                                                        ids,
                                                        context=context):
            result[vote.post_id.id] = True
        return result.keys()

    def _get_user_favourite(self, cr, uid, ids, field_name, arg, context):
        res = dict.fromkeys(ids, False)
        for post in self.browse(cr, uid, ids, context=context):
            if uid in [f.id for f in post.favourite_ids]:
                res[post.id] = True
        return res

    def _get_favorite_count(self, cr, uid, ids, field_name, arg, context):
        res = dict.fromkeys(ids, 0)
        for post in self.browse(cr, uid, ids, context=context):
            res[post.id] += len(post.favourite_ids)
        return res

    def _get_post_from_hierarchy(self, cr, uid, ids, context=None):
        post_ids = set(ids)
        for post in self.browse(cr, SUPERUSER_ID, ids, context=context):
            if post.parent_id:
                post_ids.add(post.parent_id.id)
        return list(post_ids)

    def _get_child_count(self,
                         cr,
                         uid,
                         ids,
                         field_name=False,
                         arg={},
                         context=None):
        res = dict.fromkeys(ids, 0)
        for post in self.browse(cr, uid, ids, context=context):
            if post.parent_id:
                res[post.parent_id.id] = len(post.parent_id.child_ids)
            else:
                res[post.id] = len(post.child_ids)
        return res

    def _get_uid_answered(self, cr, uid, ids, field_name, arg, context=None):
        res = dict.fromkeys(ids, False)
        for post in self.browse(cr, uid, ids, context=context):
            res[post.id] = any(answer.create_uid.id == uid
                               for answer in post.child_ids)
        return res

    def _get_has_validated_answer(self,
                                  cr,
                                  uid,
                                  ids,
                                  field_name,
                                  arg,
                                  context=None):
        res = dict.fromkeys(ids, False)
        ans_ids = self.search(cr,
                              uid, [('parent_id', 'in', ids),
                                    ('is_correct', '=', True)],
                              context=context)
        for answer in self.browse(cr, uid, ans_ids, context=context):
            res[answer.parent_id.id] = True
        return res

    def _is_self_reply(self, cr, uid, ids, field_name, arg, context=None):
        res = dict.fromkeys(ids, False)
        for post in self.browse(cr, uid, ids, context=context):
            res[post.
                id] = post.parent_id and post.parent_id.create_uid == post.create_uid or False
        return res

    def _get_post_karma_rights(self,
                               cr,
                               uid,
                               ids,
                               field_name,
                               arg,
                               context=None):
        user = self.pool['res.users'].browse(cr, uid, uid, context=context)
        res = dict.fromkeys(ids, False)
        for post in self.browse(cr, uid, ids, context=context):
            res[post.id] = {
                'karma_ask':
                post.forum_id.karma_ask,
                'karma_answer':
                post.forum_id.karma_answer,
                'karma_accept':
                post.parent_id and post.parent_id.create_uid.id == uid
                and post.forum_id.karma_answer_accept_own
                or post.forum_id.karma_answer_accept_all,
                'karma_edit':
                post.create_uid.id == uid and post.forum_id.karma_edit_own
                or post.forum_id.karma_edit_all,
                'karma_close':
                post.create_uid.id == uid and post.forum_id.karma_close_own
                or post.forum_id.karma_close_all,
                'karma_unlink':
                post.create_uid.id == uid and post.forum_id.karma_unlink_own
                or post.forum_id.karma_unlink_all,
                'karma_upvote':
                post.forum_id.karma_upvote,
                'karma_downvote':
                post.forum_id.karma_downvote,
                'karma_comment':
                post.create_uid.id == uid and post.forum_id.karma_comment_own
                or post.forum_id.karma_comment_all,
                'karma_comment_convert':
                post.create_uid.id == uid
                and post.forum_id.karma_comment_convert_own
                or post.forum_id.karma_comment_convert_all,
            }
            res[post.id].update({
                'can_ask':
                uid == SUPERUSER_ID or user.karma >= res[post.id]['karma_ask'],
                'can_answer':
                uid == SUPERUSER_ID
                or user.karma >= res[post.id]['karma_answer'],
                'can_accept':
                uid == SUPERUSER_ID
                or user.karma >= res[post.id]['karma_accept'],
                'can_edit':
                uid == SUPERUSER_ID
                or user.karma >= res[post.id]['karma_edit'],
                'can_close':
                uid == SUPERUSER_ID
                or user.karma >= res[post.id]['karma_close'],
                'can_unlink':
                uid == SUPERUSER_ID
                or user.karma >= res[post.id]['karma_unlink'],
                'can_upvote':
                uid == SUPERUSER_ID
                or user.karma >= res[post.id]['karma_upvote'],
                'can_downvote':
                uid == SUPERUSER_ID
                or user.karma >= res[post.id]['karma_downvote'],
                'can_comment':
                uid == SUPERUSER_ID
                or user.karma >= res[post.id]['karma_comment'],
                'can_comment_convert':
                uid == SUPERUSER_ID
                or user.karma >= res[post.id]['karma_comment_convert'],
            })
        return res

    _columns = {
        'name':
        fields.char('Title'),
        'forum_id':
        fields.many2one('forum.forum', 'Forum', required=True),
        'content':
        fields.html('Content'),
        'tag_ids':
        fields.many2many('forum.tag', 'forum_tag_rel', 'forum_id',
                         'forum_tag_id', 'Tags'),
        'state':
        fields.selection([('active', 'Active'), ('close', 'Close'),
                          ('offensive', 'Offensive')], 'Status'),
        'views':
        fields.integer('Number of Views'),
        'active':
        fields.boolean('Active'),
        'is_correct':
        fields.boolean(
            'Valid Answer',
            help='Correct Answer or Answer on this question accepted.'),
        'website_message_ids':
        fields.one2many(
            'mail.message',
            'res_id',
            domain=lambda self: [
                '&', ('model', '=', self._name),
                ('type', 'in', ['email', 'comment'])
            ],
            string='Post Messages',
            help="Comments on forum post",
        ),
        # history
        'create_date':
        fields.datetime('Asked on', select=True, readonly=True),
        'create_uid':
        fields.many2one('res.users', 'Created by', select=True, readonly=True),
        'write_date':
        fields.datetime('Update on', select=True, readonly=True),
        'write_uid':
        fields.many2one('res.users', 'Updated by', select=True, readonly=True),
        # vote fields
        'vote_ids':
        fields.one2many('forum.post.vote', 'post_id', 'Votes'),
        'user_vote':
        fields.function(_get_user_vote, string='My Vote', type='integer'),
        'vote_count':
        fields.function(_get_vote_count,
                        string="Votes",
                        type='integer',
                        store={
                            'forum.post':
                            (lambda self, cr, uid, ids, c={}: ids,
                             ['vote_ids'], 10),
                            'forum.post.vote': (_get_post_from_vote, [], 10),
                        }),
        # favorite fields
        'favourite_ids':
        fields.many2many('res.users', string='Favourite'),
        'user_favourite':
        fields.function(_get_user_favourite,
                        string="My Favourite",
                        type='boolean'),
        'favourite_count':
        fields.function(_get_favorite_count,
                        string='Favorite Count',
                        type='integer',
                        store={
                            'forum.post':
                            (lambda self, cr, uid, ids, c={}: ids,
                             ['favourite_ids'], 10),
                        }),
        # hierarchy
        'parent_id':
        fields.many2one('forum.post', 'Question', ondelete='cascade'),
        'self_reply':
        fields.function(_is_self_reply,
                        'Reply to own question',
                        type='boolean',
                        store={
                            'forum.post':
                            (lambda self, cr, uid, ids, c={}: ids,
                             ['parent_id', 'create_uid'], 10),
                        }),
        'child_ids':
        fields.one2many('forum.post', 'parent_id', 'Answers'),
        'child_count':
        fields.function(_get_child_count,
                        string="Answers",
                        type='integer',
                        store={
                            'forum.post': (_get_post_from_hierarchy,
                                           ['parent_id', 'child_ids'], 10),
                        }),
        'uid_has_answered':
        fields.function(
            _get_uid_answered,
            string='Has Answered',
            type='boolean',
        ),
        'has_validated_answer':
        fields.function(_get_has_validated_answer,
                        string='Has a Validated Answered',
                        type='boolean',
                        store={
                            'forum.post':
                            (_get_post_from_hierarchy,
                             ['parent_id', 'child_ids', 'is_correct'], 10),
                        }),
        # closing
        'closed_reason_id':
        fields.many2one('forum.post.reason', 'Reason'),
        'closed_uid':
        fields.many2one('res.users', 'Closed by', select=1),
        'closed_date':
        fields.datetime('Closed on', readonly=True),
        # karma
        'karma_ask':
        fields.function(_get_post_karma_rights,
                        string='Karma to ask',
                        type='integer',
                        multi='_get_post_karma_rights'),
        'karma_answer':
        fields.function(_get_post_karma_rights,
                        string='Karma to answer',
                        type='integer',
                        multi='_get_post_karma_rights'),
        'karma_accept':
        fields.function(_get_post_karma_rights,
                        string='Karma to accept this answer',
                        type='integer',
                        multi='_get_post_karma_rights'),
        'karma_edit':
        fields.function(_get_post_karma_rights,
                        string='Karma to edit',
                        type='integer',
                        multi='_get_post_karma_rights'),
        'karma_close':
        fields.function(_get_post_karma_rights,
                        string='Karma to close',
                        type='integer',
                        multi='_get_post_karma_rights'),
        'karma_unlink':
        fields.function(_get_post_karma_rights,
                        string='Karma to unlink',
                        type='integer',
                        multi='_get_post_karma_rights'),
        'karma_upvote':
        fields.function(_get_post_karma_rights,
                        string='Karma to upvote',
                        type='integer',
                        multi='_get_post_karma_rights'),
        'karma_downvote':
        fields.function(_get_post_karma_rights,
                        string='Karma to downvote',
                        type='integer',
                        multi='_get_post_karma_rights'),
        'karma_comment':
        fields.function(_get_post_karma_rights,
                        string='Karma to comment',
                        type='integer',
                        multi='_get_post_karma_rights'),
        'karma_comment_convert':
        fields.function(_get_post_karma_rights,
                        string='karma to convert as a comment',
                        type='integer',
                        multi='_get_post_karma_rights'),
        # access rights
        'can_ask':
        fields.function(_get_post_karma_rights,
                        string='Can Ask',
                        type='boolean',
                        multi='_get_post_karma_rights'),
        'can_answer':
        fields.function(_get_post_karma_rights,
                        string='Can Answer',
                        type='boolean',
                        multi='_get_post_karma_rights'),
        'can_accept':
        fields.function(_get_post_karma_rights,
                        string='Can Accept',
                        type='boolean',
                        multi='_get_post_karma_rights'),
        'can_edit':
        fields.function(_get_post_karma_rights,
                        string='Can Edit',
                        type='boolean',
                        multi='_get_post_karma_rights'),
        'can_close':
        fields.function(_get_post_karma_rights,
                        string='Can Close',
                        type='boolean',
                        multi='_get_post_karma_rights'),
        'can_unlink':
        fields.function(_get_post_karma_rights,
                        string='Can Unlink',
                        type='boolean',
                        multi='_get_post_karma_rights'),
        'can_upvote':
        fields.function(_get_post_karma_rights,
                        string='Can Upvote',
                        type='boolean',
                        multi='_get_post_karma_rights'),
        'can_downvote':
        fields.function(_get_post_karma_rights,
                        string='Can Downvote',
                        type='boolean',
                        multi='_get_post_karma_rights'),
        'can_comment':
        fields.function(_get_post_karma_rights,
                        string='Can Comment',
                        type='boolean',
                        multi='_get_post_karma_rights'),
        'can_comment_convert':
        fields.function(_get_post_karma_rights,
                        string='Can Convert to Comment',
                        type='boolean',
                        multi='_get_post_karma_rights'),
    }

    _defaults = {
        'state': 'active',
        'views': 0,
        'active': True,
        'vote_ids': list(),
        'favourite_ids': list(),
        'child_ids': list(),
    }

    def create(self, cr, uid, vals, context=None):
        if context is None:
            context = {}
        create_context = dict(context, mail_create_nolog=True)
        post_id = super(Post, self).create(cr,
                                           uid,
                                           vals,
                                           context=create_context)
        post = self.browse(
            cr, SUPERUSER_ID, post_id, context=context
        )  # SUPERUSER_ID to avoid read access rights issues when creating
        # karma-based access
        if post.parent_id and not post.can_ask:
            raise KarmaError('Not enough karma to create a new question')
        elif not post.parent_id and not post.can_answer:
            raise KarmaError('Not enough karma to answer to a question')
        # messaging and chatter
        base_url = self.pool['ir.config_parameter'].get_param(
            cr, uid, 'web.base.url')
        if post.parent_id:
            body = _(
                '<p>A new answer for <i>%s</i> has been posted. <a href="%s/forum/%s/question/%s">Click here to access the post.</a></p>'
                % (post.parent_id.name, base_url, slug(
                    post.parent_id.forum_id), slug(post.parent_id)))
            self.message_post(cr,
                              uid,
                              post.parent_id.id,
                              subject=_('Re: %s') % post.parent_id.name,
                              body=body,
                              subtype='website_forum.mt_answer_new',
                              context=context)
        else:
            body = _(
                '<p>A new question <i>%s</i> has been asked on %s. <a href="%s/forum/%s/question/%s">Click here to access the question.</a></p>'
                % (post.name, post.forum_id.name, base_url, slug(
                    post.forum_id), slug(post)))
            self.message_post(cr,
                              uid,
                              post_id,
                              subject=post.name,
                              body=body,
                              subtype='website_forum.mt_question_new',
                              context=context)
            self.pool['res.users'].add_karma(
                cr,
                SUPERUSER_ID, [uid],
                post.forum_id.karma_gen_question_new,
                context=context)
        return post_id

    def write(self, cr, uid, ids, vals, context=None):
        posts = self.browse(cr, uid, ids, context=context)
        if 'state' in vals:
            if vals['state'] in ['active', 'close'] and any(not post.can_close
                                                            for post in posts):
                raise KarmaError('Not enough karma to close or reopen a post.')
        if 'active' in vals:
            if any(not post.can_unlink for post in posts):
                raise KarmaError(
                    'Not enough karma to delete or reactivate a post')
        if 'is_correct' in vals:
            if any(not post.can_accept for post in posts):
                raise KarmaError(
                    'Not enough karma to accept or refuse an answer')
            # update karma except for self-acceptance
            mult = 1 if vals['is_correct'] else -1
            for post in self.browse(cr, uid, ids, context=context):
                if vals['is_correct'] != post.is_correct and post.create_uid.id != uid:
                    self.pool['res.users'].add_karma(
                        cr,
                        SUPERUSER_ID, [post.create_uid.id],
                        post.forum_id.karma_gen_answer_accepted * mult,
                        context=context)
                    self.pool['res.users'].add_karma(
                        cr,
                        SUPERUSER_ID, [uid],
                        post.forum_id.karma_gen_answer_accept * mult,
                        context=context)
        if any(key not in [
                'state', 'active', 'is_correct', 'closed_uid', 'closed_date',
                'closed_reason_id'
        ] for key in vals.keys()) and any(not post.can_edit for post in posts):
            raise KarmaError('Not enough karma to edit a post.')

        res = super(Post, self).write(cr, uid, ids, vals, context=context)
        # if post content modify, notify followers
        if 'content' in vals or 'name' in vals:
            for post in posts:
                if post.parent_id:
                    body, subtype = _(
                        'Answer Edited'), 'website_forum.mt_answer_edit'
                    obj_id = post.parent_id.id
                else:
                    body, subtype = _(
                        'Question Edited'), 'website_forum.mt_question_edit'
                    obj_id = post.id
                self.message_post(cr,
                                  uid,
                                  obj_id,
                                  body=body,
                                  subtype=subtype,
                                  context=context)
        return res

    def close(self, cr, uid, ids, reason_id, context=None):
        if any(post.parent_id
               for post in self.browse(cr, uid, ids, context=context)):
            return False
        return self.pool['forum.post'].write(
            cr,
            uid,
            ids, {
                'state':
                'close',
                'closed_uid':
                uid,
                'closed_date':
                datetime.today().strftime(
                    tools.DEFAULT_SERVER_DATETIME_FORMAT),
                'closed_reason_id':
                reason_id,
            },
            context=context)

    def unlink(self, cr, uid, ids, context=None):
        posts = self.browse(cr, uid, ids, context=context)
        if any(not post.can_unlink for post in posts):
            raise KarmaError('Not enough karma to unlink a post')
        # if unlinking an answer with accepted answer: remove provided karma
        for post in posts:
            if post.is_correct:
                self.pool['res.users'].add_karma(
                    cr,
                    SUPERUSER_ID, [post.create_uid.id],
                    post.forum_id.karma_gen_answer_accepted * -1,
                    context=context)
                self.pool['res.users'].add_karma(
                    cr,
                    SUPERUSER_ID, [uid],
                    post.forum_id.karma_gen_answer_accept * -1,
                    context=context)
        return super(Post, self).unlink(cr, uid, ids, context=context)

    def vote(self, cr, uid, ids, upvote=True, context=None):
        posts = self.browse(cr, uid, ids, context=context)

        if upvote and any(not post.can_upvote for post in posts):
            raise KarmaError('Not enough karma to upvote.')
        elif not upvote and any(not post.can_downvote for post in posts):
            raise KarmaError('Not enough karma to downvote.')

        Vote = self.pool['forum.post.vote']
        vote_ids = Vote.search(cr,
                               uid, [('post_id', 'in', ids),
                                     ('user_id', '=', uid)],
                               context=context)
        new_vote = '1' if upvote else '-1'
        voted_forum_ids = set()
        if vote_ids:
            for vote in Vote.browse(cr, uid, vote_ids, context=context):
                if upvote:
                    new_vote = '0' if vote.vote == '-1' else '1'
                else:
                    new_vote = '0' if vote.vote == '1' else '-1'
                Vote.write(cr,
                           uid,
                           vote_ids, {'vote': new_vote},
                           context=context)
                voted_forum_ids.add(vote.post_id.id)
        for post_id in set(ids) - voted_forum_ids:
            for post_id in ids:
                Vote.create(cr,
                            uid, {
                                'post_id': post_id,
                                'vote': new_vote
                            },
                            context=context)
        return {
            'vote_count':
            self._get_vote_count(cr, uid, ids, None, None,
                                 context=context)[ids[0]],
            'user_vote':
            new_vote
        }

    def convert_answer_to_comment(self, cr, uid, id, context=None):
        """ Tools to convert an answer (forum.post) to a comment (mail.message).
        The original post is unlinked and a new comment is posted on the question
        using the post create_uid as the comment's author. """
        post = self.browse(cr, SUPERUSER_ID, id, context=context)
        if not post.parent_id:
            return False

        # karma-based action check: use the post field that computed own/all value
        if not post.can_comment_convert:
            raise KarmaError(
                'Not enough karma to convert an answer to a comment')

        # post the message
        question = post.parent_id
        values = {
            'author_id': post.create_uid.partner_id.id,
            'body': html2plaintext(post.content),
            'type': 'comment',
            'subtype': 'mail.mt_comment',
            'date': post.create_date,
        }
        message_id = self.pool['forum.post'].message_post(
            cr,
            uid,
            question.id,
            context=dict(context, mail_create_nosubcribe=True),
            **values)

        # unlink the original answer, using SUPERUSER_ID to avoid karma issues
        self.pool['forum.post'].unlink(cr,
                                       SUPERUSER_ID, [post.id],
                                       context=context)

        return message_id

    def convert_comment_to_answer(self,
                                  cr,
                                  uid,
                                  message_id,
                                  default=None,
                                  context=None):
        """ Tool to convert a comment (mail.message) into an answer (forum.post).
        The original comment is unlinked and a new answer from the comment's author
        is created. Nothing is done if the comment's author already answered the
        question. """
        comment = self.pool['mail.message'].browse(cr,
                                                   SUPERUSER_ID,
                                                   message_id,
                                                   context=context)
        post = self.pool['forum.post'].browse(cr,
                                              uid,
                                              comment.res_id,
                                              context=context)
        user = self.pool['res.users'].browse(cr, uid, uid, context=context)
        if not comment.author_id or not comment.author_id.user_ids:  # only comment posted by users can be converted
            return False

        # karma-based action check: must check the message's author to know if own / all
        karma_convert = comment.author_id.id == user.partner_id.id and post.forum_id.karma_comment_convert_own or post.forum_id.karma_comment_convert_all
        can_convert = uid == SUPERUSER_ID or user.karma >= karma_convert
        if not can_convert:
            raise KarmaError(
                'Not enough karma to convert a comment to an answer')

        # check the message's author has not already an answer
        question = post.parent_id if post.parent_id else post
        post_create_uid = comment.author_id.user_ids[0]
        if any(answer.create_uid.id == post_create_uid.id
               for answer in question.child_ids):
            return False

        # create the new post
        post_values = {
            'forum_id': question.forum_id.id,
            'content': comment.body,
            'parent_id': question.id,
        }
        # done with the author user to have create_uid correctly set
        new_post_id = self.pool['forum.post'].create(cr,
                                                     post_create_uid.id,
                                                     post_values,
                                                     context=context)

        # delete comment
        self.pool['mail.message'].unlink(cr,
                                         SUPERUSER_ID, [comment.id],
                                         context=context)

        return new_post_id

    def unlink_comment(self, cr, uid, id, message_id, context=None):
        comment = self.pool['mail.message'].browse(cr,
                                                   SUPERUSER_ID,
                                                   message_id,
                                                   context=context)
        post = self.pool['forum.post'].browse(cr, uid, id, context=context)
        user = self.pool['res.users'].browse(cr,
                                             SUPERUSER_ID,
                                             uid,
                                             context=context)
        if not comment.model == 'forum.post' or not comment.res_id == id:
            return False

        # karma-based action check: must check the message's author to know if own or all
        karma_unlink = comment.author_id.id == user.partner_id.id and post.forum_id.karma_comment_unlink_own or post.forum_id.karma_comment_unlink_all
        can_unlink = uid == SUPERUSER_ID or user.karma >= karma_unlink
        if not can_unlink:
            raise KarmaError('Not enough karma to unlink a comment')

        return self.pool['mail.message'].unlink(cr,
                                                SUPERUSER_ID, [message_id],
                                                context=context)

    def set_viewed(self, cr, uid, ids, context=None):
        cr.execute("""UPDATE forum_post SET views = views+1 WHERE id IN %s""",
                   (tuple(ids), ))
        return True

    def _get_access_link(self, cr, uid, mail, partner, context=None):
        post = self.pool['forum.post'].browse(cr,
                                              uid,
                                              mail.res_id,
                                              context=context)
        res_id = post.parent_id and "%s#answer-%s" % (post.parent_id.id,
                                                      post.id) or post.id
        return "/forum/%s/question/%s" % (post.forum_id.id, res_id)
コード例 #12
0
ファイル: mrp.py プロジェクト: OdooBulgaria/addons-2
class ProductionPlan(osv.osv):
    _inherit = 'production.plan'
    _columns = {
        'plan_list': fields.one2many('production.plan.list', 'plan_id', 'Production Plan List', readonly=True),
    }

    def compute(self, cr, uid, ids, context=None):
        val = self.browse(cr, uid, ids, context={})[0]
        product_obj = self.pool.get('product.product')
        def _create_list(ID,name,product,qty):
            self.pool.get('production.plan.list').create(cr,uid,{'plan_id':ID,'name':name,'product_id': product.id,'qty': qty,'ean13':product.ean13 or ''})
        if val.plan_line:
            for x in val.plan_line:
                plan = x.plan
                if x.real - x.total == 0 :
                    plan = x.max
                elif x.real - x.total <= 0 :
                    plan = abs(x.real - x.total) + x.max
                elif x.real - x.total < x.min:
                    plan = x.max - (x.real - x.total)
                self.pool.get('production.plan.line').write(cr, uid, [x.id], {'plan': plan, 'end': x.real - x.total + plan})
        else:
            product = []
            list_product = []
            for x in val.order_ids:
                for l in x.order_line:
                    product.append({'product_id': l.product_id.id, 'line': l, 'qty': l.product_uom_qty, 'uom': l.product_uom.id})
                    _create_list(val.id,x.name,l.product_id,l.product_uom_qty)
            for x in val.stock_ids:
                for l in x.stock_line:
                    product.append({'source':x.name,'product_id': l.product_id.id, 'line': l, 'qty': l.product_qty, 'uom': l.product_uom.id})
                    _create_list(val.id,x.name,l.product_id,l.product_qty)
            for x in val.stockw_ids:
                for l in x.stock_line:
                    product.append({'product_id': l.product_id.id, 'line': l, 'qty': l.product_qty, 'uom': l.product_uom.id})

            data = {}
            for p in product:
                data[p['product_id']] = {'qty': [], 'uom': p['uom'], 'line': []}
            for p in product:
                data[p['product_id']]['qty'].append(p['qty'])
                data[p['product_id']]['line'].append(p['line'])
            for i in data:
                order = sum(data[i]['qty'])
                brg = product_obj.browse(cr, uid, i)
                min = 0; max = 0; plan = order
                sid = self.pool.get('stock.warehouse.orderpoint').search(cr, uid, [('product_id', '=', i)])
                if sid:
                    sto = self.pool.get('stock.warehouse.orderpoint').browse(cr, uid, sid)[0]
                    min = sto.product_min_qty
                    max = sto.product_max_qty
                    plan = 0
                    if brg.qty_available - order == 0 :
                        plan = max
                    elif brg.qty_available - order <= 0 :
                        plan = abs(brg.qty_available - order) + max
                    elif brg.qty_available - order < min:
                        plan = max - (brg.qty_available - order)
                self.pool.get('production.plan.line').create(cr, uid, {
                                                                   'plan_id': val.id,
                                                                   'product_id': i,
                                                                   'product_uom': data[i]['uom'],
                                                                   'total': order,
                                                                   'name': product_obj.name_get(cr, uid, [i])[0][1],
                                                                   'real': brg.qty_available,
                                                                   'min': min,
                                                                   'max': max,
                                                                   'plan': plan,
                                                                   'end': brg.qty_available - order + plan 
                                                                   })
        return True 
コード例 #13
0
ファイル: mrp.py プロジェクト: OdooBulgaria/addons-2
class mrp_barcode_setting(osv.osv):
    _name = 'mrp.barcode.setting'

    def compose_barcode(self, cr, uid, ids, context=None):
        vals = self.browse(cr,uid,ids[0],)
        content1 = []    
        content2 =[]    
        content3 = []    
        Ap4 = {'1':12,'2':'16'}
        Y1=0
        Y23=0
        list_obj = self.pool.get('mrp.barcode.setting.list')
        ul = [i.id for i in vals.result_ids]
        if ul :
            list_obj.unlink(cr, uid, ul , context=context)
        def construct_label(A,X,Y,R):
            return "\n"+",".join([A+X,Y,R,'1,1,1,N,'])
        def construct_barcode(B,X,Y,R,T,H):
            return "\n"+",".join([B+X,Y,R,T,'2,2',H,'N,'])
        if vals.detail_ids:
            for l in vals.detail_ids:
                if l.type == "A":
                    Y1+=int(Ap4[l.size])
                    str1 = construct_label("A",str(vals.initX1),str(Y1),l.rotation)
                else :
                    Y1+=int(l.height)+4
                    str1 = construct_barcode("B",str(vals.initX1),str(Y1),l.rotation,l.barcode,str(l.height))
                list_obj.create(cr,uid,{'setting_id':ids[0],'type' :l.type,'kolom':1,'list':str1})
        if vals.detail_ids2:
            for l in vals.detail_ids2:
                if l.type == "A":
                    str2 = construct_label("A",str(vals.initX2),str(Y23),l.rotation)
                    str3 = construct_label("A",str(vals.initX3),str(Y23),l.rotation)
                    Y23+=int(Ap4[l.size])
                else :
                    str2 = construct_barcode("B",str(vals.initX2),str(Y23),l.rotation,l.barcode,str(l.height))
                    str3 = construct_barcode("B",str(vals.initX3),str(Y23),l.rotation,l.barcode,str(l.height))
                    Y23+=int(l.height)+4
                list_obj.create(cr,uid,{'setting_id':ids[0],'type' :l.type,'kolom':2,'list':str2})
                list_obj.create(cr,uid,{'setting_id':ids[0],'type' :l.type,'kolom':3,'list':str3})
        return True

    _columns = {
        'name'      : fields.char('Name',size=10),
        'detail_ids2': fields.one2many('mrp.barcode.setting.line2','setting_id',string='Setting'),
        'detail_ids': fields.one2many('mrp.barcode.setting.line','setting_id',string='Setting'),
        'deltaY'    : fields.integer('Delta Y',size=3),
        'initX1'    : fields.integer('X0 column 1',size=3),
        'initX2'    : fields.integer('X0 column 2',size=3),
        'initX3'    : fields.integer('X0 column 3',size=3),
        'result_ids':fields.one2many('mrp.barcode.setting.list','setting_id',string='Setting',readonly=True),
        'active'    :fields.boolean("Active"),
        'initRX'    : fields.integer('X0 Form',size=3),
        'initRY'    : fields.integer('Y0 Form',size=3),
    }

    _defaults = {
        'deltaY'   :145,
        'initX1'    : 240,
        'initX2'    : 270,
        'initX3'    : 550,
        'active'    : True,
        'initRX'    : 0,
        'initRY'    : 0,
    }
コード例 #14
0
class ebay_user(osv.osv):
    _name = "ebay.user"
    _description = "a registered eBay user"

    @staticmethod
    def get_shipping_service_type():
        return [
            ('cnam', _('China Post Normal Air Mail')),
            ('cnram', _('China Post Registered Air Mail')),
            ('hkam', _('HongKong Post Normal Air Mail')),
            ('hkram', _('HongKong Post Registered Air Mail')),
            ('sgam', _('Sing Post Normal Air Mail')),
            ('sgram', _('Sing Post Registered Air Mail')),
        ]

    def _get_shipping_service_type(self, cr, uid, context=None):
        return self.get_shipping_service_type()

    _columns = {
        'email':
        fields.char('Email', size=128, readonly=True),
        'feedback_rating_star':
        fields.selection(
            [('Blue', 'Blue Star'),
             ('CustomCode', 'Reserved for internal or future use.'),
             ('Green', 'Green Star'), ('GreenShooting', 'Green Shooting Star'),
             ('None', 'No graphic displayed'), ('Purple', 'Purple Star'),
             ('PurpleShooting', 'Purple Shooting Star'), ('Red', 'Red Star'),
             ('RedShooting', 'Red Shooting Star'),
             ('SilverShooting', 'Silver Shooting Star'),
             ('Turquoise', 'Turquoise Star'),
             ('TurquoiseShooting', 'Turquoise Shooting Star'),
             ('Yellow', 'Yellow Star'),
             ('YellowShooting', 'Yellow Shooting Star')],
            'Feedback Rating Star',
            readonly=True),
        'feedback_score':
        fields.integer('Feedback Score', readonly=True),
        'positive_feedback_percent':
        fields.float('Feedback Percent', readonly=True),
        'registration_date':
        fields.datetime('Registration Date', readonly=True),
        'store_owner':
        fields.boolean('Store Owner', readonly=True),
        'store_site':
        fields.char('Store Site', readonly=True),
        'store_url':
        fields.char('Store URL', readonly=True),
        'top_rated_seller':
        fields.boolean('Top-rated Seller', readonly=True),
        'site':
        fields.char('Site', readonly=True),
        'unique_negative_feedback_count':
        fields.integer('Negative', readonly=True),
        'unique_neutral_feedback_count':
        fields.integer('Neutral', readonly=True),
        'unique_positive_feedback_count':
        fields.integer('Positive', readonly=True),
        'name':
        fields.char('User ID', required=True, select=True),
        # Selleris
        'seller_list_ids':
        fields.one2many('ebay.seller.list',
                        'user_id',
                        'Seller Lists',
                        readonly=True),
        'last_updated':
        fields.datetime('Last Updated'),
        # Application keys for authorization
        'ownership':
        fields.boolean('Ownership', readonly=True),
        'sandbox':
        fields.boolean('Sandbox'),
        'sale_site':
        fields.selection([
            ('0', 'US'),
            ('2', 'Canada'),
            ('3', 'UK'),
            ('15', 'Australia'),
            ('201', 'HongKong'),
        ], 'Sale Site'),
        'app_id':
        fields.char('AppID', size=64),
        'dev_id':
        fields.char('DevID', size=64),
        'cert':
        fields.char('CERT', size=64),
        'ru_name':
        fields.char('RuName', size=64),
        # Auth info, get from FetchToken
        'ebay_auth_token':
        fields.char('eBayAuthToken', readonly=True),
        'hard_expiration_time':
        fields.datetime('HardExpirationTime', readonly=True),
        'rest_token':
        fields.char('RESTToken', readonly=True),
        # Sale status
        'monthly_sales':
        fields.float('Monthly Sales', readonly=True),
        'monthly_sales_volume':
        fields.integer('Monthly Sales Volume', readonly=True),
        # Additional Info
        'ebay_item_ids':
        fields.one2many('ebay.item', 'ebay_user_id', 'Items'),
        'paypal_email_address':
        fields.char('Paypal Email Address'),
        'country':
        fields.char('Country', size=2),
        'location':
        fields.char('Location'),
        'shipping_service':
        fields.selection(_get_shipping_service_type, 'Shipping service'),
        'after_service_7_template':
        fields.text('7 days template'),
        'after_service_15_template':
        fields.text('15 days template'),
        'after_service_25_template':
        fields.text('25 days template'),
        # User Preferences
        'exclude_ship_to_location':
        fields.text('Exclude Ship To Location', readonly=True),
    }

    _defaults = {
        'feedback_score':
        0,
        'store_owner':
        0,
        'ownership':
        0,
        'sandbox':
        0,
        'sale_site':
        '0',
        'country':
        'CN',
        'location':
        'ShenZhen',
        'shipping_service':
        'sgam',
        'after_service_7_template':
        '''
Hi friend.
  Your item has been shipped on {{ shipped_time }} by air mail,
  and it may take about 10~20 days to arrive,
  sometimes it may be delayed by unexpected reason like holiday,
  custom`s process, weather condition etc.
  It may be delayed up to 35 days to arrive.
  We will be very appreciated for your patience.
  If you have any question, feel free to contact us asap.
  Thanks for your purchase.
  
  Yours Sincerely
''',
        'after_service_15_template':
        '''
Hi friend.
  Your item has been shipped on {{ shipped_time }} by air mail.
  {{ elapse }} days have passed since your item was shipped,
  When you receive it, we sincerely hope that you will like it 
  and appreciate our customer services.
  If there is anything you feel unsatisfied with, please do tell us. 
  This will help us know what we should do to help you as well as how we should improve.
  If you are satisfied, we sincerely hope that you can leave us a positive comment, 
  which is of vital importance to the growth of our small company.
  PLEASE DO NOT leaves us negative feedback. If you are not satisfied in any regard,
  please tell us.
  Thanks once more for your purchase.
  
  Yours Sincerely
''',
        'after_service_25_template':
        '''
Hi friend.
  Your item has been shipped on {{ shipped_time }} by air mail.
  If you haven't received your item and this situation lasts to the 35th day,
  please do contact us. WE WILL DO OUR BEST TO SOLVE YOUR PROBLEM.
  We do not want to give you a bad buying experience even when the shipping is out of our control.
  But if you receive it, we sincerely hope you can leave us a positive comment if you like it and
  appreciate our customer services.
  Thanks once more for your purchase.

  Yours Sincerely
'''
    }

    _order = 'monthly_sales desc'

    _sql_constraints = [
        ('name_uniq', 'unique(name, sandbox)', 'User ID must be unique!'),
    ]

    def copy(self, cr, uid, id, default=None, context=None):
        if default is None:
            default = {}

        name = self.read(cr, uid, id, ['name'], context=context)['name']
        default = default.copy()
        default.update({
            'name': name + _(' (Copy)'),
            'session_id': '',
            'ebay_auth_token': '',
        })

        return super(ebay_user, self).copy(cr, uid, id, default, context)

    def action_get_user(self, cr, uid, ids, context=None):
        for user in self.browse(cr, uid, ids, context=context):
            call_data = dict()
            call_data['UserID'] = user.name
            error_msg = 'Get the data for the specified user %s' % user.name
            reply = self.pool.get('ebay.ebay').call(
                cr,
                uid,
                user,
                'GetUser',
                call_data,
                error_msg,
                context=context).response.reply
            vals = dict()
            user_dict = reply.User
            vals['email'] = user_dict.Email
            vals['feedback_rating_star'] = user_dict.FeedbackRatingStar
            vals['feedback_score'] = user_dict.FeedbackScore
            vals[
                'positive_feedback_percent'] = user_dict.PositiveFeedbackPercent
            vals['registration_date'] = user_dict.RegistrationDate
            seller_info = user_dict.SellerInfo
            vals['store_owner'] = seller_info.StoreOwner == "true"
            if vals['store_owner']:
                vals['store_site'] = seller_info.StoreSite
                vals['store_url'] = seller_info.StoreURL
            vals['top_rated_seller'] = seller_info.get('TopRatedSeller', False)
            vals['site'] = user_dict.Site
            vals[
                'unique_negative_feedback_count'] = user_dict.UniqueNegativeFeedbackCount
            vals[
                'unique_neutral_feedback_count'] = user_dict.UniqueNeutralFeedbackCount
            vals[
                'unique_positive_feedback_count'] = user_dict.UniquePositiveFeedbackCount

            call_data = dict()
            call_data['ShowSellerExcludeShipToLocationPreference'] = 'true'
            error_msg = 'Get the user perferences for the user %s' % user.name
            reply = self.pool.get('ebay.ebay').call(
                cr,
                uid,
                user,
                'GetUserPreferences',
                call_data,
                error_msg,
                context=context).response.reply
            exclude_ship_to_location = reply.SellerExcludeShipToLocationPreferences.ExcludeShipToLocation
            if type(exclude_ship_to_location) != list:
                vals['exclude_ship_to_location'] = exclude_ship_to_location
            else:
                vals['exclude_ship_to_location'] = '|'.join(
                    exclude_ship_to_location)

            user.write(vals)

    def action_get_seller_list(self, cr, uid, ids, context=None):
        ebay_seller_list_obj = self.pool.get('ebay.seller.list')

        try:
            for user in self.browse(cr, uid, ids, context=context):
                ebay_seller_list_obj.get_seller_list(cr,
                                                     uid,
                                                     user,
                                                     context=context)
        except (ConnectionError, ConnectionResponseError,
                RequestException) as e:
            return self.pool.get('ebay.ebay').exception(cr,
                                                        uid,
                                                        'GetSellerList',
                                                        e,
                                                        context=context)
        else:
            return True
コード例 #15
0
ファイル: stock.py プロジェクト: GoContractPro/Odoo-GCP
     ], 'Package Type', help='Indicates the type of package'),
 'bill_shipping': fields.selection([
     ('shipper', 'Shipper'),
     ('receiver', 'Receiver'),
     ('thirdparty', 'Third Party')
     ], 'Bill Shipping to', help='Shipper, Receiver, or Third Party.'),
 'with_ret_service': fields.boolean('With Return Services', help='Include Return Shipping Information in the package.'),
 'tot_ship_weight': fields.function(_total_weight_net, method=True, type='float', digits=(16, 3), string='Total Shipment Weight',
     store={
         'stock.picking': (lambda self, cr, uid, ids, c={}: ids, ['packages_ids'], -10),
         'stock.packages': (_get_order, ['weight'], -10),
         }, help="Adds the Total Weight of all the packages in the Packages Table.",
         ),
 'tot_del_order_weight': fields.function(_total_ord_weight_net, method=True, readonly=True, string='Total Order Weight', store=False,
                                          help="Adds the Total Weight of all the packages in the Packages Table."),
 'packages_ids': fields.one2many("stock.packages", 'pick_id', 'Packages Table'),
 'ship_state': fields.selection([
     ('draft', 'Draft'),
     ('in_process', 'In Process'),
     ('ready_pick', 'Ready for Pickup'),
     ('shipped', 'Shipped'),
     ('delivered', 'Delivered'),
     ('void', 'Void'),
     ('hold', 'Hold'),
     ('cancelled', 'Cancelled')
     ], 'Shipping Status', readonly=True, help='The current status of the shipment'),
 'trade_mark': fields.text('Trademarks AREA'),
 'ship_message': fields.text('Message'),
 'address_validate': fields.selection([
     ('validate', 'Validate'),
     ('nonvalidate', 'No Validation')
コード例 #16
0
ファイル: file_exchange.py プロジェクト: Sk1f161/ERP
    _columns = {
        'name': fields.char('Name', size=64, help="Exchange description like the name of the supplier, bank,...", require=True),
        'type': fields.selection([('in','IN'),('out','OUT'),('in-out', 'IN & OUT')], 'Type',help=("IN for files coming from the other system"
                                                                "and to be imported in the ERP ; OUT for files to be"
                                                                "generated from the ERP and send to the other system")),
        'mapping_id':fields.many2one('external.mapping', 'External Mapping', require="True", domain="[('referential_id', '=', referential_id)]"),
        'format' : fields.selection([('csv','CSV'),('csv_no_header','CSV WITHOUT HEADER'), ('xls', 'XLS')], 'File format'),
        'referential_id':fields.many2one('external.referential', 'Referential',help="Referential to use for connection and mapping", require=True),
        'scheduler':fields.many2one('ir.cron', 'Scheduler',help="Scheduler that will execute the cron task"),
        'search_filter':  fields.char('Search Filter', size=256),
        'filename': fields.char('Filename', size=128, help="Filename will be used to generate the output file name or to read the incoming file. It is possible to use variables (check in sequence for syntax)", require=True),
        'folder_path': fields.char('Folder Path', size=128, help="folder that containt the incomming or the outgoing file"),
        'archive_folder_path': fields.char('Archive Folder Path', size=128, help="if a path is set when a file is imported the file will be automatically moved to this folder"),
        'encoding': fields.selection(_get_encoding, 'Encoding', require=True),
        'field_ids': fields.one2many('file.fields', 'file_id', 'Fields'),
        'action_before_all': fields.text('Action Before All', help="This python code will executed after the import/export"),
        'action_after_all': fields.text('Action After All', help="This python code will executed after the import/export"),
        'action_before_each': fields.text('Action Before Each', help="This python code will executed after each element of the import/export"),
        'action_after_each': fields.text('Action After Each', help="This python code will executed after each element of the import/export"),
        'check_if_import': fields.text('Check If Import', help="This python code will be executed before each element of the import"),
        'delimiter':fields.char('Fields delimiter', size=64, help="Delimiter used in the CSV file"),
        'lang': fields.many2one('res.lang', 'Language'),
        'import_default_fields':fields.one2many('file.default.import.values', 'file_id', 'Default Field'),
        'do_not_update':fields.boolean('Do Not Update'),
        'pre_processing': fields.text('Pre-Processing', help="This python code will be executed before merge of elements of the import"),
        'mapping_template_id':fields.many2one('external.mapping.template', 'External Mapping Template', require="True"),
        'notes': fields.text('Notes'),
        'related_mapping_ids': fields.function(_get_related_mapping_ids, type="many2many", relation="external.mapping", string='Related Mappings'),
        'synchronize_from': fields.selection([('referential', 'Referential'), ('pop_up', 'Pop Up')], string='Synchronize From'),
        'linked_task': fields.many2one('file.exchange', 'Linked Task'),
コード例 #17
0
class mrp_servicemc(osv.osv):
    _name = 'mrp.servicemc'
    _inherit = 'mail.thread'
    _description = 'servicemc Order'

    def _amount_untaxed(self, cr, uid, ids, field_name, arg, context=None):
        """ Calculates untaxed amount.
        @param self: The object pointer
        @param cr: The current row, from the database cursor,
        @param uid: The current user ID for security checks
        @param ids: List of selected IDs
        @param field_name: Name of field.
        @param arg: Argument
        @param context: A standard dictionary for contextual values
        @return: Dictionary of values.
        """
        res = {}
        cur_obj = self.pool.get('res.currency')

        for servicemc in self.browse(cr, uid, ids, context=context):
            res[servicemc.id] = 0.0
            for line in servicemc.operations:
                res[servicemc.id] += line.price_subtotal
            for line in servicemc.fees_lines:
                res[servicemc.id] += line.price_subtotal
            cur = servicemc.pricelist_id.currency_id
            res[servicemc.id] = cur_obj.round(cr, uid, cur, res[servicemc.id])
        return res

    def _amount_tax(self, cr, uid, ids, field_name, arg, context=None):
        """ Calculates taxed amount.
        @param field_name: Name of field.
        @param arg: Argument
        @return: Dictionary of values.
        """
        res = {}
        #return {}.fromkeys(ids, 0)
        cur_obj = self.pool.get('res.currency')
        tax_obj = self.pool.get('account.tax')
        for servicemc in self.browse(cr, uid, ids, context=context):
            val = 0.0
            cur = servicemc.pricelist_id.currency_id
            for line in servicemc.operations:
                #manage prices with tax included use compute_all instead of compute
                if line.to_invoice:
                    tax_calculate = tax_obj.compute_all(cr, uid, line.tax_id, line.price_unit, line.product_uom_qty, line.product_id, servicemc.partner_id)
                    for c in tax_calculate['taxes']:
                        val += c['amount']
            for line in servicemc.fees_lines:
                if line.to_invoice:
                    tax_calculate = tax_obj.compute_all(cr, uid, line.tax_id, line.price_unit, line.product_uom_qty,  line.product_id, servicemc.partner_id)
                    for c in tax_calculate['taxes']:
                        val += c['amount']
            res[servicemc.id] = cur_obj.round(cr, uid, cur, val)
        return res

    def _amount_total(self, cr, uid, ids, field_name, arg, context=None):
        """ Calculates total amount.
        @param field_name: Name of field.
        @param arg: Argument
        @return: Dictionary of values.
        """
        res = {}
        untax = self._amount_untaxed(cr, uid, ids, field_name, arg, context=context)
        tax = self._amount_tax(cr, uid, ids, field_name, arg, context=context)
        cur_obj = self.pool.get('res.currency')
        for id in ids:
            servicemc = self.browse(cr, uid, id, context=context)
            cur = servicemc.pricelist_id.currency_id
            res[id] = cur_obj.round(cr, uid, cur, untax.get(id, 0.0) + tax.get(id, 0.0))
        return res

    def _get_default_address(self, cr, uid, ids, field_name, arg, context=None):
        res = {}
        partner_obj = self.pool.get('res.partner')
        for data in self.browse(cr, uid, ids, context=context):
            adr_id = False
            if data.partner_id:
                adr_id = partner_obj.address_get(cr, uid, [data.partner_id.id], ['default'])['default']
            res[data.id] = adr_id
        return res

    def _get_lines(self, cr, uid, ids, context=None):
        return self.pool['mrp.servicemc'].search(
            cr, uid, [('operations', 'in', ids)], context=context)

    def _get_fee_lines(self, cr, uid, ids, context=None):
        return self.pool['mrp.servicemc'].search(
            cr, uid, [('fees_lines', 'in', ids)], context=context)

    _columns = {
        'facproducto': fields.many2one('product.product','Producto'),   
        'facpreciounitario': fields.float('Precio unitario', help = 'Precio unitario',  required=True), 
        'facimpuestos': fields.many2many('account.tax', 'repair_operation_line_tax', 'repair_operation_line_id', 'tax_id', 'Impuesto'),
        'facafacturar':fields.boolean('A facturar'),
        'facsubtotal':fields.float('Subtotal'),
        'total': fields.float('Total'),
        'faccantidad': fields.float('Cantidad',help = 'Cantidad',required=True),
        'noeconomicomc':fields.char('Numero Economico',size=24),
        'noseriemc':fields.char('Numero de Serie',size=24),
        'name': fields.char('servicemc Reference',size=24, required=True, states={'confirmed':[('readonly',True)]}),
        'product_id': fields.many2one('product.product', string='Product to give service', required=True, readonly=True, states={'draft':[('readonly',False)]}),
        'partner_id' : fields.many2one('res.partner', 'Partner', select=True, help='Choose partner for whom the order will be invoiced and delivered.', states={'confirmed':[('readonly',True)]}),
        'address_id': fields.many2one('res.partner', 'Delivery Address', domain="[('parent_id','=',partner_id)]", states={'confirmed':[('readonly',True)]}),
        'default_address_id': fields.function(_get_default_address, type="many2one", relation="res.partner"),
        'prodlot_id': fields.many2one('stock.production.lot', 'Lot Number', select=True, states={'draft':[('readonly',False)]},domain="[('product_id','=',product_id)]"),
        'state': fields.selection([
            ('draft','Quotation'),
            ('cancel','Cancelled'),
            ('confirmed','Confirmed'),
            ('under_servicemc','Under servicio'),
            ('ready','listo para dar servicio'),
            ('2binvoiced','To be Invoiced'),
            ('invoice_except','Invoice Exception'),
            ('done','Hecho')
            ], 'Status', readonly=True, track_visibility='onchange',
            help=' * The \'Draft\' status is used when a user is encoding a new and unconfirmed servicemc order. \
            \n* The \'Confirmed\' status is used when a user confirms the servicemc order. \
            \n* The \'Ready to servicemc\' status is used to start to servicemcing, user can start servicemcing only after servicemc order is confirmed. \
            \n* The \'To be Invoiced\' status is used to generate the invoice before or after servicemcing done. \
            \n* The \'Done\' status is set when servicemcing is completed.\
            \n* The \'Cancelled\' status is used when user cancel servicemc order.'),
        'location_id': fields.many2one('stock.location', 'Current Location', select=True, readonly=True, states={'draft':[('readonly',False)], 'confirmed':[('readonly',True)]}),
        'location_dest_id': fields.many2one('stock.location', 'Delivery Location', readonly=True, states={'draft':[('readonly',False)], 'confirmed':[('readonly',True)]}),
        'move_id': fields.many2one('stock.move', 'Move',required=True, domain="[('product_id','=',product_id)]", readonly=True, states={'draft':[('readonly',False)]}),
        'guarantee_limit': fields.date('Warranty Expiration', help="The warranty expiration limit is computed as: last move date + warranty defined on selected product. If the current date is below the warranty expiration limit, each operation and fee you will add will be set as 'not to invoiced' by default. Note that you can change manually afterwards.", states={'confirmed':[('readonly',True)]}),
        'operations' : fields.one2many('mrp.servicemc.line', 'servicemc_id', 'Operation Lines', readonly=True, states={'draft':[('readonly',False)]}),
        'pricelist_id': fields.many2one('product.pricelist', 'Pricelist', help='Pricelist of the selected partner.'),
        'partner_invoice_id':fields.many2one('res.partner', 'Invoicing Address'),
        'invoice_method':fields.selection([
            ("none","No Invoice"),
            ("b4servicemc","Before servicemc"),
            ("after_servicemc","After servicemc")
           ], "Invoice Method",
            select=True, required=True, states={'draft':[('readonly',False)]}, readonly=True, help='Selecting \'Before servicemc\' or \'After servicemc\' will allow you to generate invoice before or after the servicemc is done respectively. \'No invoice\' means you don\'t want to generate invoice for this servicemc order.'),
        'invoice_id': fields.many2one('account.invoice', 'Invoice', readonly=True),
        'picking_id': fields.many2one('stock.picking', 'Picking',readonly=True),
        'fees_lines': fields.one2many('mrp.servicemc.fee', 'servicemc_id', 'Fees Lines', readonly=True, states={'draft':[('readonly',False)]}),
        'internal_notes': fields.text('Internal Notes'),
        'quotation_notes': fields.text('Quotation Notes'),
        'company_id': fields.many2one('res.company', 'Company'),
        'deliver_bool': fields.boolean('Deliver', help="Check this box if you want to manage the delivery once the product is servicemced and create a picking with selected product. Note that you can select the locations in the Info tab, if you have the extended view.", states={'confirmed':[('readonly',True)]}),
        'invoiced': fields.boolean('Invoiced', readonly=True),
        'servicemced': fields.boolean('Entregado', readonly=True),
        'amount_untaxed': fields.function(_amount_untaxed, string='Untaxed Amount',
            store={
                'mrp.servicemc': (lambda self, cr, uid, ids, c={}: ids, ['operations', 'fees_lines'], 10),
                'mrp.servicemc.line': (_get_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
                'mrp.servicemc.fee': (_get_fee_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
            }),
        'amount_tax': fields.function(_amount_tax, string='Taxes',
            store={
                'mrp.servicemc': (lambda self, cr, uid, ids, c={}: ids, ['operations', 'fees_lines'], 10),
                'mrp.servicemc.line': (_get_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
                'mrp.servicemc.fee': (_get_fee_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
            }),
        'amount_total': fields.function(_amount_total, string='Total',
            store={
                'mrp.servicemc': (lambda self, cr, uid, ids, c={}: ids, ['operations', 'fees_lines'], 10),
                'mrp.servicemc.line': (_get_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
                'mrp.servicemc.fee': (_get_fee_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
            }),
         'clienteNombre': fields.many2one('res.partner','Nombre del Cliente', required= True),   
        'clienteEntregaNombre': fields.many2one('res.partner','Nombre del Cliente'),    
        'empresaEntregaNombre': fields.many2one('hr.employee','Nombre'),    
        'empresaNombre': fields.many2one('hr.employee','Nombre Jefe de Area'),      
        'produccion_fecha_final':  fields.date('Fecha final', required = False),
        'produccion_notas': fields.text('Notas'),
        'produccion_re_ter_unidad': fields.many2one('hr.employee','Reporta Terminio de la Unidad', required=False), 
        'calidad_fecha_inicial':  fields.date('Fecha Inicial', required = False),
        'calidad_fecha_final':  fields.date('Fecha Final', required = False),
        'calidad_notas': fields.text('Notas'),
        'calidad_re_li_unidad': fields.many2one('hr.employee','Reporta Terminio de la Unidad', required=False), 
        'calidad_fecha_liberacion':  fields.date('Fecha de Liberacion', required = False),
        'calidad_pri_inpeccion': fields.boolean('Primera Inspeccion'),
        'calidad_liberada': fields.boolean('Liberada'),
        'fecha_alta': fields.date('Fecha de Alta', required = True),
        'modelo_id': fields.many2one('fleet.vehicle','Modelo',required = True),
    }

    _defaults = {
        'state': lambda *a: 'draft',
        'deliver_bool': lambda *a: True,
        'name': lambda obj, cr, uid, context: obj.pool.get('ir.sequence').get(cr, uid, 'mrp.servicemc'),
        'invoice_method': lambda *a: 'none',
        'company_id': lambda self, cr, uid, context: self.pool.get('res.company')._company_default_get(cr, uid, 'mrp.servicemc', context=context),
        'pricelist_id': lambda self, cr, uid,context : self.pool.get('product.pricelist').search(cr, uid, [('type','=','sale')])[0]
    }

    def copy(self, cr, uid, id, default=None, context=None):
        if not default:
            default = {}
        default.update({
            'state':'draft',
            'servicemced':False,
            'invoiced':False,
            'invoice_id': False,
            'picking_id': False,
            'name': self.pool.get('ir.sequence').get(cr, uid, 'mrp.servicemc'),
        })
        return super(mrp_servicemc, self).copy(cr, uid, id, default, context)

    def onchange_product_id(self, cr, uid, ids, product_id=None):
        """ On change of product sets some values.
        @param product_id: Changed product
        @return: Dictionary of values.
        """
        return {'value': {
                    'prodlot_id': False,
                    'move_id': False,
                    'guarantee_limit' :False,
                    'location_id':  False,
                    'location_dest_id': False,
                }
        }

    def onchange_move_id(self, cr, uid, ids, prod_id=False, move_id=False):
        """ On change of move id sets values of guarantee limit, source location,
        destination location, partner and partner address.
        @param prod_id: Id of product in current record.
        @param move_id: Changed move.
        @return: Dictionary of values.
        """
        data = {}
        data['value'] = {'guarantee_limit': False, 'location_id': False, 'prodlot_id': False, 'partner_id': False}
        if not prod_id:
            return data
        if move_id:
            move =  self.pool.get('stock.move').browse(cr, uid, move_id)
            product = self.pool.get('product.product').browse(cr, uid, prod_id)
            limit = datetime.strptime(move.date_expected, '%Y-%m-%d %H:%M:%S') + relativedelta(months=int(product.warranty))
            data['value']['guarantee_limit'] = limit.strftime('%Y-%m-%d')
            data['value']['location_id'] = move.location_dest_id.id
            data['value']['location_dest_id'] = move.location_dest_id.id
            data['value']['prodlot_id'] = move.prodlot_id.id
            if move.partner_id:
                data['value']['partner_id'] = move.partner_id.id
            else:
                data['value']['partner_id'] = False
            d = self.onchange_partner_id(cr, uid, ids, data['value']['partner_id'], data['value']['partner_id'])
            data['value'].update(d['value'])
        return data

    def button_dummy(self, cr, uid, ids, context=None):
        return True

    def onchange_partner_id(self, cr, uid, ids, part, address_id):
        """ On change of partner sets the values of partner address,
        partner invoice address and pricelist.
        @param part: Changed id of partner.
        @param address_id: Address id from current record.
        @return: Dictionary of values.
        """
        part_obj = self.pool.get('res.partner')
        pricelist_obj = self.pool.get('product.pricelist')
        if not part:
            return {'value': {
                        'address_id': False,
                        'partner_invoice_id': False,
                        'pricelist_id': pricelist_obj.search(cr, uid, [('type','=','sale')])[0]
                    }
            }
        addr = part_obj.address_get(cr, uid, [part], ['delivery', 'invoice', 'default'])
        partner = part_obj.browse(cr, uid, part)
        pricelist = partner.property_product_pricelist and partner.property_product_pricelist.id or False
        return {'value': {
                    'address_id': addr['delivery'] or addr['default'],
                    'partner_invoice_id': addr['invoice'],
                    'pricelist_id': pricelist
                }
        }

    def onchange_lot_id(self, cr, uid, ids, lot, product_id):
        """ On change of Serial Number sets the values of source location,
        destination location, move and guarantee limit.
        @param lot: Changed id of Serial Number.
        @param product_id: Product id from current record.
        @return: Dictionary of values.
        """
        move_obj = self.pool.get('stock.move')
        data = {}
        data['value'] = {
            'location_id': False,
            'location_dest_id': False,
            'move_id': False,
            'guarantee_limit': False
        }

        if not lot:
            return data
        move_ids = move_obj.search(cr, uid, [('prodlot_id', '=', lot)])

        if not len(move_ids):
            return data

        def get_last_move(lst_move):
            while lst_move.move_dest_id and lst_move.move_dest_id.state == 'done':
                lst_move = lst_move.move_dest_id
            return lst_move

        move_id = move_ids[0]
        move = get_last_move(move_obj.browse(cr, uid, move_id))
        data['value']['move_id'] = move.id
        d = self.onchange_move_id(cr, uid, ids, product_id, move.id)
        data['value'].update(d['value'])
        return data

    def action_cancel_draft(self, cr, uid, ids, *args):
        """ Cancels servicemc order when it is in 'Draft' state.
        @param *arg: Arguments
        @return: True
        """
        if not len(ids):
            return False
        mrp_line_obj = self.pool.get('mrp.servicemc.line')
        for servicemc in self.browse(cr, uid, ids):
            mrp_line_obj.write(cr, uid, [l.id for l in servicemc.operations], {'state': 'draft'})
        self.write(cr, uid, ids, {'state':'draft'})
        wf_service = netsvc.LocalService("workflow")
        for id in ids:
            wf_service.trg_create(uid, 'mrp.servicemc', id, cr)
        return True

    def action_confirm(self, cr, uid, ids, *args):
        """ servicemc order state is set to 'To be invoiced' when invoice method
        is 'Before servicemc' else state becomes 'Confirmed'.
        @param *arg: Arguments
        @return: True
        """
        mrp_line_obj = self.pool.get('mrp.servicemc.line')
        for o in self.browse(cr, uid, ids):
            if (o.invoice_method == 'b4servicemc'):
                self.write(cr, uid, [o.id], {'state': '2binvoiced'})
            else:
                self.write(cr, uid, [o.id], {'state': 'confirmed'})
                for line in o.operations:
                    if line.product_id.track_production and not line.prodlot_id:
                        raise osv.except_osv(_('Warning!'), _("Serial number is required for operation line with product '%s'") % (line.product_id.name))
                mrp_line_obj.write(cr, uid, [l.id for l in o.operations], {'state': 'confirmed'})
        return True

    def action_cancel(self, cr, uid, ids, context=None):
        """ Cancels servicemc order.
        @return: True
        """
        mrp_line_obj = self.pool.get('mrp.servicemc.line')
        for servicemc in self.browse(cr, uid, ids, context=context):
            if not servicemc.invoiced:
                mrp_line_obj.write(cr, uid, [l.id for l in servicemc.operations], {'state': 'cancel'}, context=context)
            else:
                raise osv.except_osv(_('Warning!'),_('servicemc order is already invoiced.'))
        return self.write(cr,uid,ids,{'state':'cancel'})

    def wkf_invoice_create(self, cr, uid, ids, *args):
        self.action_invoice_create(cr, uid, ids)
        return True

    def action_invoice_create(self, cr, uid, ids, group=False, context=None):
        """ Creates invoice(s) for servicemc order.
        @param group: It is set to true when group invoice is to be generated.
        @return: Invoice Ids.
        """
        res = {}
        invoices_group = {}
        inv_line_obj = self.pool.get('account.invoice.line')
        inv_obj = self.pool.get('account.invoice')
        servicemc_line_obj = self.pool.get('mrp.servicemc.line')
        servicemc_fee_obj = self.pool.get('mrp.servicemc.fee')
        for servicemc in self.browse(cr, uid, ids, context=context):
            res[servicemc.id] = False
            if servicemc.state in ('draft','cancel') or servicemc.invoice_id:
                continue
            if not (servicemc.partner_id.id and servicemc.partner_invoice_id.id):
                raise osv.except_osv(_('No partner!'),_('You have to select a Partner Invoice Address in the servicemc form!'))
            comment = servicemc.quotation_notes
            if (servicemc.invoice_method != 'none'):
                if group and servicemc.partner_invoice_id.id in invoices_group:
                    inv_id = invoices_group[servicemc.partner_invoice_id.id]
                    invoice = inv_obj.browse(cr, uid, inv_id)
                    invoice_vals = {
                        'name': invoice.name +', '+servicemc.name,
                        'origin': invoice.origin+', '+servicemc.name,
                        'comment':(comment and (invoice.comment and invoice.comment+"\n"+comment or comment)) or (invoice.comment and invoice.comment or ''),
                    }
                    inv_obj.write(cr, uid, [inv_id], invoice_vals, context=context)
                else:
                    if not servicemc.partner_id.property_account_receivable:
                        raise osv.except_osv(_('Error!'), _('No account defined for partner "%s".') % servicemc.partner_id.name )
                    account_id = servicemc.partner_id.property_account_receivable.id
                    inv = {
                        'name': servicemc.name,
                        'origin':servicemc.name,
                        'type': 'out_invoice',
                        'account_id': account_id,
                        'partner_id': servicemc.partner_id.id,
                        'currency_id': servicemc.pricelist_id.currency_id.id,
                        'comment': servicemc.quotation_notes,
                        'fiscal_position': servicemc.partner_id.property_account_position.id
                    }
                    inv_id = inv_obj.create(cr, uid, inv)
                    invoices_group[servicemc.partner_invoice_id.id] = inv_id
                self.write(cr, uid, servicemc.id, {'invoiced': True, 'invoice_id': inv_id})

                for operation in servicemc.operations:
                    if operation.to_invoice == True:
                        if group:
                            name = servicemc.name + '-' + operation.name
                        else:
                            name = operation.name

                        if operation.product_id.property_account_income:
                            account_id = operation.product_id.property_account_income.id
                        elif operation.product_id.categ_id.property_account_income_categ:
                            account_id = operation.product_id.categ_id.property_account_income_categ.id
                        else:
                            raise osv.except_osv(_('Error!'), _('No account defined for product "%s".') % operation.product_id.name )

                        invoice_line_id = inv_line_obj.create(cr, uid, {
                            'invoice_id': inv_id,
                            'name': name,
                            'origin': servicemc.name,
                            'account_id': account_id,
                            'quantity': operation.product_uom_qty,
                            'invoice_line_tax_id': [(6,0,[x.id for x in operation.tax_id])],
                            'uos_id': operation.product_uom.id,
                            'price_unit': operation.price_unit,
                            'price_subtotal': operation.product_uom_qty*operation.price_unit,
                            'product_id': operation.product_id and operation.product_id.id or False
                        })
                        servicemc_line_obj.write(cr, uid, [operation.id], {'invoiced': True, 'invoice_line_id': invoice_line_id})
                for fee in servicemc.fees_lines:
                    if fee.to_invoice == True:
                        if group:
                            name = servicemc.name + '-' + fee.name
                        else:
                            name = fee.name
                        if not fee.product_id:
                            raise osv.except_osv(_('Warning!'), _('No product defined on Fees!'))

                        if fee.product_id.property_account_income:
                            account_id = fee.product_id.property_account_income.id
                        elif fee.product_id.categ_id.property_account_income_categ:
                            account_id = fee.product_id.categ_id.property_account_income_categ.id
                        else:
                            raise osv.except_osv(_('Error!'), _('No account defined for product "%s".') % fee.product_id.name)

                        invoice_fee_id = inv_line_obj.create(cr, uid, {
                            'invoice_id': inv_id,
                            'name': name,
                            'origin': servicemc.name,
                            'account_id': account_id,
                            'quantity': fee.product_uom_qty,
                            'invoice_line_tax_id': [(6,0,[x.id for x in fee.tax_id])],
                            'uos_id': fee.product_uom.id,
                            'product_id': fee.product_id and fee.product_id.id or False,
                            'price_unit': fee.price_unit,
                            'price_subtotal': fee.product_uom_qty*fee.price_unit
                        })
                        servicemc_fee_obj.write(cr, uid, [fee.id], {'invoiced': True, 'invoice_line_id': invoice_fee_id})
                res[servicemc.id] = inv_id
        return res

    def action_servicemc_ready(self, cr, uid, ids, context=None):
        """ Writes servicemc order state to 'Ready'
        @return: True
        """
        for servicemc in self.browse(cr, uid, ids, context=context):
            self.pool.get('mrp.servicemc.line').write(cr, uid, [l.id for
                    l in servicemc.operations], {'state': 'confirmed'}, context=context)
            self.write(cr, uid, [servicemc.id], {'state': 'ready'})
        return True

    def action_servicemc_start(self, cr, uid, ids, context=None):
        """ Writes servicemc order state to 'Under servicemc'
        @return: True
        """
        servicemc_line = self.pool.get('mrp.servicemc.line')
        for servicemc in self.browse(cr, uid, ids, context=context):
            servicemc_line.write(cr, uid, [l.id for
                    l in servicemc.operations], {'state': 'confirmed'}, context=context)
            servicemc.write({'state': 'under_servicemc'})
        return True

    def action_servicemc_end(self, cr, uid, ids, context=None):
        """ Writes servicemc order state to 'To be invoiced' if invoice method is
        After servicemc else state is set to 'Ready'.
        @return: True
        """
        for order in self.browse(cr, uid, ids, context=context):
            val = {}
            val['servicemced'] = True
            if (not order.invoiced and order.invoice_method=='after_servicemc'):
                val['state'] = '2binvoiced'
            elif (not order.invoiced and order.invoice_method=='b4servicemc'):
                val['state'] = 'ready'
            else:
                pass
            self.write(cr, uid, [order.id], val)
        return True

    def wkf_servicemc_done(self, cr, uid, ids, *args):
        self.action_servicemc_done(cr, uid, ids)
        return True

    def action_servicemc_done(self, cr, uid, ids, context=None):
        """ Creates stock move and picking for servicemc order.
        @return: Picking ids.
        """
        res = {}
        move_obj = self.pool.get('stock.move')
        wf_service = netsvc.LocalService("workflow")
        servicemc_line_obj = self.pool.get('mrp.servicemc.line')
        seq_obj = self.pool.get('ir.sequence')
        pick_obj = self.pool.get('stock.picking')
        for servicemc in self.browse(cr, uid, ids, context=context):
            for move in servicemc.operations:
                move_id = move_obj.create(cr, uid, {
                    'name': move.name,
                    'product_id': move.product_id.id,
                    'product_qty': move.product_uom_qty,
                    'product_uom': move.product_uom.id,
                    'partner_id': servicemc.address_id and servicemc.address_id.id or False,
                    'location_id': move.location_id.id,
                    'location_dest_id': move.location_dest_id.id,
                    'tracking_id': False,
                    'prodlot_id': move.prodlot_id and move.prodlot_id.id or False,
                    'state': 'assigned',
                })
                move_obj.action_done(cr, uid, [move_id], context=context)
                servicemc_line_obj.write(cr, uid, [move.id], {'move_id': move_id, 'state': 'done'}, context=context)
            if servicemc.deliver_bool:
                pick_name = seq_obj.get(cr, uid, 'stock.picking.out')
                picking = pick_obj.create(cr, uid, {
                    'name': pick_name,
                    'origin': servicemc.name,
                    'state': 'draft',
                    'move_type': 'one',
                    'partner_id': servicemc.address_id and servicemc.address_id.id or False,
                    'note': servicemc.internal_notes,
                    'invoice_state': 'none',
                    'type': 'out',
                })
                move_id = move_obj.create(cr, uid, {
                    'name': servicemc.name,
                    'picking_id': picking,
                    'product_id': servicemc.product_id.id,
                    'product_uom': servicemc.product_id.uom_id.id,
                    'prodlot_id': servicemc.prodlot_id and servicemc.prodlot_id.id or False,
                    'partner_id': servicemc.address_id and servicemc.address_id.id or False,
                    'location_id': servicemc.location_id.id,
                    'location_dest_id': servicemc.location_dest_id.id,
                    'tracking_id': False,
                    'state': 'assigned',
                })
                wf_service.trg_validate(uid, 'stock.picking', picking, 'button_confirm', cr)
                self.write(cr, uid, [servicemc.id], {'state': 'done', 'picking_id': picking})
                res[servicemc.id] = picking
            else:
                self.write(cr, uid, [servicemc.id], {'state': 'done'})
        return res
コード例 #18
0
class res_users(osv.osv):
    _inherit = 'res.users'
    _columns = {
        'quarantine_files_ids': fields.one2many('antivir.quarantine', 'user_id', 'Quarantine files')
    }
コード例 #19
0
class hr_contract_mod_wiz(osv.TransientModel):
    _name = 'hr.contract.mod.wiz'
    _description = 'Mis a jour salaire en masse'
    _columns = {
        'date': fields.date('Date', required=True),
        'perc_increase': fields.float('Pourcentage augmentation', required=True),
        'amount_increase': fields.float('Montant augmentation', required=True),
        'start': fields.many2one('account.period', 'Date effet'),  # Rétro-actif depuis               
        'period_id': fields.many2one('account.period', 'Periode applicable', required=True, domain=[('date_start', '>', datetime.date.today().strftime('%Y-01-01'))]),
        'employee_ids': fields.many2many('hr.employee', 'cont_dept_emp_rel', 'sum_id', 'emp_id', 'Employee(s)', domain=[('active', '=', True)]),
        'rubrique_ids':fields.one2many('rubrique.line.wiz', 'cont_mod_id', 'Rubriques'),
        }

    def generate(self, cr, uid, ids, context=None):
        data = self.read(cr, uid, ids, [])[0]
        # raise osv.except_osv(_('data'),_('data = %s')%(data))
        contract_obj = self.pool.get('hr.contract')
        period_obj = self.pool.get('account.period')
        proposal_obj = self.pool.get('hr.salary.proposal')
        proposal_line_obj = self.pool.get('hr.salary.proposal.line')
        period_id = period_obj.browse(cr, uid, [data['period_id'][0]])[0]
        start = period_obj.browse(cr, uid, [data['start'][0]])[0]
        prev_period_id = period_obj.browse(cr, uid, [data['period_id'][0] - 1])[0]
        rub_line_obj = self.pool.get('rub.update.line')
        ############################################################
        # if data:
        #    raise osv.except_osv(_('data'), _('%s')%data)
        v = data['period_id'][0]
        period_id = period_obj.browse(cr, uid, [v])[0]  # periode de paie et return an object type class
        start = period_obj.browse(cr, uid, [data['start'][0]])[0]  # periode pour les rappels
        # prev_period_id=period_obj.browse(cr,uid,[data['period_id'][0]-1])[0]
        
        created = []
        if not data['employee_ids']:
            raise osv.except_osv(_('Error'), _('You have to select at least 1 Employee. And try again'))
        proposal = proposal_obj.search(cr, uid, [('name', '=', period_id.id)])  # return list of result
        if proposal == []:
            proposal = proposal_obj.create(cr, uid,
                    {'name':period_id.id, 'start':start.id, 'date':datetime.date.today().strftime('%Y-%m-%d')})
        else:
            proposal = proposal[0]
        created.append(proposal)  # "id du proposition salariale (list) identifier par la période"
        date_today = datetime.date.today().strftime('%Y-%m-%d')
        contract_ids1 = contract_obj.search(cr, uid,
                    [('employee_id', 'in', data['employee_ids']),
                    '|', ('date_end', '=', False), ('date_end', '>=', date_today)])  # ou date_end est dans le futur(> today)
        contract_ids = contract_obj.read(cr, uid, contract_ids1, ['wage'])
        # raise osv.except_osv(_('contract_ids'),_('contract_ids = %s \n contract_ids1 = %s')%(contract_ids,contract_ids1))
        for contract in contract_ids:
            proposal_line = proposal_line_obj.search(cr, uid,
                    [('proposal_id', '=', created[0]), ('contract_id', '=', contract['id'])])
            if proposal_line == []:
                wage = contract['wage'] + (contract['wage'] * (data['perc_increase']) / 100) + data['amount_increase']
                pl = proposal_line_obj.create(cr, uid,
                        {'contract_id':contract['id'], 'salary_proposal':wage, 'proposal_id':created[0]})
                rubrique_lines = self.pool.get('rubrique.line.wiz').browse(cr, uid, data['rubrique_ids'])
                for rubrique in rubrique_lines:      
                    rub = {'proposal_line_id':pl,
                        'name':rubrique.name.id,
                        'perc_increase': rubrique.perc_increase,
                        'amount_increase': rubrique.amount_increase,
                        }
                    rub_line_obj.create(cr, uid, rub)
            else:
                wage = 0
                pl = 0
                if data['perc_increase'] != 0 or data['amount_increase'] != 0:
                    wage = contract['wage'] + (contract['wage'] * (data['perc_increase']) / 100) + data['amount_increase']
                    pl = proposal_line_obj.write(cr, uid, proposal_line[0],
                        {'contract_id':contract['id'], 'salary_proposal':wage, 'proposal_id':created[0]})
                else:
                    pl = proposal_line_obj.write(cr, uid, proposal_line[0],
                        {'contract_id':contract['id'], 'proposal_id':created[0]})
                # pl=proposal_line_obj.write(cr,uid,proposal_line[0],{'contract_id':contract['id'],'salary_proposal':wage,'proposal_id':created[0]})
                rubrique_lines = self.pool.get('rubrique.line.wiz').browse(cr, uid, data['rubrique_ids'])
                for rubrique in rubrique_lines:
                    condition = [('name', '=', rubrique.name.id), ('proposal_line_id', '=', proposal_line[0])]
                    search_id = rub_line_obj.search(cr, uid, condition)
                    rub = {'proposal_line_id':proposal_line[0],
                        'name':rubrique.name.id,
                        'perc_increase': rubrique.perc_increase,
                        'amount_increase': rubrique.amount_increase,
                        }
                    is_rub_exist = False
                    if len(search_id) == 0:
                        is_rub_exist = False
                    else:
                        is_rub_exist = True
                    if not is_rub_exist:
                        rub_line_obj.create(cr, uid, rub)
                    else:
                        rub_line_obj.write(cr, uid, search_id[0], rub)

        ##################################################
        # test={
        #    'domain': "[('id','in', ["+','.join(map(str,created))+"])]",
        #    'name': 'Contrats',
        #    'view_type': 'form',
        #    'view_mode': 'tree,form',
        #    'res_model': 'hr.salary.proposal',
        #    'view_id': False,
        #    'type': 'ir.actions.act_window',
        # }
        
        # if test:
        #    raise osv.except_osv(_('test'), _('%s')%test)
        ##################################################

        return {
            'domain': "[('id','in', [" + ','.join(map(str, created)) + "])]",
            'name': 'Contrats',
            'view_type': 'form',
            'view_mode': 'tree,form',
            'res_model': 'hr.salary.proposal',
            'view_id': False,
            'type': 'ir.actions.act_window',
        }

        
    def _from_date(self, cursor, user, context={}):
        return datetime.date.today().strftime('%Y-%m-%d');


    _defaults = {
        'date': _from_date, }
コード例 #20
0
     return resu
 _columns = {
     'employee_id': fields.many2one('hr.employee',  'Employee', required=True, select=True),
     'department_id':fields.related('employee_id','department_id', type='many2one', relation='hr.department', string='Department', store=True),
     'job_id':fields.related('employee_id','job_id', type='many2one', relation='hr.job', string='Title', store=True),
     'emp_code':fields.related('employee_id','emp_code', type='char', string='Employee Code', store=True),
     'mobile_phone':fields.related('employee_id','mobile_phone', type='char', string='Work Mobile', store=True),
     'borrow_money_residual':fields.related('employee_id','money_residual', type='float', string='Borrowed residual', readonly=True),
     
     'dimmission_reason':fields.text('Dimission Reason', required=True),
     'advice_to_company':fields.text('Advice to company'),
     'employment_start':fields.date('Employment Started'),
     'date_request':fields.date('Request Date', required=True),
     'date_done':fields.date('Done Date', required=False, readonly=True),
     
     'approve_ids': fields.one2many('hr.dimission.item', 'dimission_id', 'Approvals', domain=[('type','=','approve')]),
     'transfer_ids': fields.one2many('hr.dimission.item', 'dimission_id', 'Transfers', domain=[('type','=','transfer')]),
     
     'payslip_id': fields.many2many('hr.emppay', string='Payslip'),
     'attrpt_ids': fields.many2many('hr.rpt.attend.month', string='Attendance Reports'),
     'hr_clock_ids': fields.function(_emp_clocks, string='HR Clocks', type='many2many', relation='hr.clock', readonly=True),
     'attachment_lines': fields.one2many('ir.attachment', 'hr_admission_id','Attachment'),    
     'company_id':fields.many2one('res.company', 'Company', required=True),   
                                                  
     'state': fields.selection([
         ('draft', 'Draft'),
         ('in_progress', 'In Progress'),
         ('done', 'Done'),
         ('cancel', 'Cancel'),
     ], 'Status', select=True, readonly=True),
 }
コード例 #21
0
class hr_salary_proposal(osv.osv):

    _name = "hr.salary.proposal"
    _description = "Proposition de salaire"
    _columns = {
        'date':fields.date('Date'),
        'name': fields.many2one('account.period', 'Periode applicable', required=True),
        'start': fields.many2one('account.period', 'Periode effet'),
        'salary_line':fields.one2many('hr.salary.proposal.line', 'proposal_id', 'Nouvelle Grille'),

        }
    _order = "name desc"

    def validate (self, cr, uid, ids, context=None):
        """ Function doc """
        contract_obj = self.pool.get('hr.contract')
        rubrique_obj = self.pool.get('hr.payroll_ma.ligne_rubrique')
        salary_line_obj = self.pool.get('hr.salary.proposal.line')
        rubrique_objt = self.pool.get('hr.payroll_ma.rubrique')  # new line
        diff = 1
        for proposal in self.browse(cr, uid, ids):
            for line in proposal.salary_line:
                date_start = datetime.datetime.strptime(proposal.name.date_start, '%Y-%m-%d')
                # _logger.info(line.contract_id.rubrique_ids)
                contract_info = contract_obj.copy(cr, uid, line.contract_id.id,
                default={'date_start':date_start, 'wage':line.salary_proposal})
                perc = {}
                amt = {}
                rubriques = []
                for rub in line.rubrique_ids:
                    perc[rub.name.id] = rub.perc_increase
                    amt[rub.name.id] = rub.amount_increase
                    rubriques.append(rub.name.id)
                for rubrique in line.contract_id.rubrique_ids:                    
                    if rubrique.rubrique_id.id in rubriques:
                        amount = rubrique.montant + (rubrique.montant * perc[rubrique.rubrique_id.id] / 100) + amt[rubrique.rubrique_id.id]
                        amount_arrondi = int(amount / 10)  # * 10
                        reste_arrondi = amount % 10
                        if reste_arrondi >= 5:
                            amount_arrondi += 1
                        amount_arrondi = amount_arrondi * 10
                        amount = amount_arrondi
                        amount_diff = amount - rubrique.montant
                        rubrique_obj.copy(cr, uid, rubrique.id, default={'id_contract':contract_info, 'montant':amount, })
                        if proposal.start:
                            date1 = datetime.datetime.strptime(proposal.start.date_start, '%Y-%m-%d')
                            date2 = datetime.datetime.strptime(proposal.name.date_start, '%Y-%m-%d')
                            r = relativedelta.relativedelta(date2, date1)
                            diff = r.months
                            amount = amount_diff * diff
                            rubrique_obj.copy(cr, uid, rubrique.id,
                                default={'rubrique_id':rubrique.rubrique_id.rappel_rubrique_id.id,
                                        'id_contract':contract_info,
                                        'montant':amount, 'permanent':False,
                                        'date_stop':datetime.datetime.strptime(proposal.name.date_stop, '%Y-%m-%d'),
                                        'date_start':datetime.datetime.strptime(proposal.name.date_start, '%Y-%m-%d')
                                        })
                    else:
                        rubrique_obj.copy(cr, uid, rubrique.id, default={'id_contract':contract_info})
                # rappel saleire de base si il y avait augmentation
                # rubrique_obj.copy(cr,uid,rubrique.id,
                #                 default={ 'rubrique_id':rubrique.rubrique_id.rappel_rubrique_id.id,
                #                 'id_contract':contract_info,'montant':amount,'permanent':False,
                #                 'date_stop':datetime.datetime.strptime(proposal.name.date_stop,'%Y-%m-%d'),
                #                 'date_start':datetime.datetime.strptime(proposal.name.date_start,'%Y-%m-%d')})
                ################################################################################################
                T = False
                if line.wage != line.salary_proposal:
                    T = True
                if T:
                    # rubrique_objt = self.pool.get('hr.payroll_ma.rubrique')
                    rubrique_id = rubrique_objt.search(cr, uid, [('code', '=', '02')])  # id du rubrique rappel base
                    if len(rubrique_id) == 0:
                        raise osv.except_osv(_('Error'), _('This rubrique doesn\'t exist! \n create it! His code is: 02'))
                    amount = line.wage * (line.perc_increase / 100) * diff
                    new_rub_base = rubrique_obj.create(cr, uid, {'rubrique_id':rubrique_id[0],
                        'id_contract':contract_info,
                        'montant':amount, 'permanent':False,
                        'date_stop':datetime.datetime.strptime(proposal.name.date_stop, '%Y-%m-%d'),
                        'date_start':datetime.datetime.strptime(proposal.name.date_start, '%Y-%m-%d')})
                ################################################################################################
                new_contract = contract_info
                salary_line_obj.write(cr, uid, line.id, {'new_contract_id':new_contract})
コード例 #22
0
ファイル: rent.py プロジェクト: Cywaithaka/openerp-rent
 ),
 "product_uom": fields.many2one(
     "product.uom", "Unit of Measure ", required=True, readonly=True, states={"draft": [("readonly", False)]}
 ),
 "product_uos_qty": fields.float(
     "Quantity (UoS)",
     digits_compute=dp.get_precision("Product UoS"),
     readonly=True,
     states={"draft": [("readonly", False)]},
 ),
 "product_uos": fields.many2one("product.uom", "Product UoS"),
 "product_rent_qty": fields.function(
     _product_rent_qty, string="Rent Quantity", digits_compute=dp.get_precision("Product UoS")
 ),
 "th_weight": fields.float("Weight", readonly=True, states={"draft": [("readonly", False)]}),
 "move_ids": fields.one2many("stock.move", "rent_line_id", "Inventory Moves", readonly=True),
 "state": fields.selection(
     [
         ("draft", "Draft"),
         ("cancel", "Cancelled"),
         ("confirmed", "Waiting Approval"),
         ("accepted", "Approved"),
         ("returned", "Returned"),
         ("done", "Done"),
     ],
     "Status",
     required=True,
     readonly=True,
 ),
 "order_partner_id": fields.related(
     "order_id", "partner_id", type="many2one", relation="res.partner", store=True, string="Customer"
コード例 #23
0
class account_bank_statement(osv.osv):
    def create(self, cr, uid, vals, context=None):
        if 'line_ids' in vals:
            for idx, line in enumerate(vals['line_ids']):
                line[2]['sequence'] = idx + 1
        return super(account_bank_statement, self).create(cr,
                                                          uid,
                                                          vals,
                                                          context=context)

    def write(self, cr, uid, ids, vals, context=None):
        res = super(account_bank_statement, self).write(cr,
                                                        uid,
                                                        ids,
                                                        vals,
                                                        context=context)
        account_bank_statement_line_obj = self.pool.get(
            'account.bank.statement.line')
        for statement in self.browse(cr, uid, ids, context):
            for idx, line in enumerate(statement.line_ids):
                account_bank_statement_line_obj.write(cr,
                                                      uid, [line.id],
                                                      {'sequence': idx + 1},
                                                      context=context)
        return res

    def _default_journal_id(self, cr, uid, context=None):
        if context is None:
            context = {}
        journal_pool = self.pool.get('account.journal')
        journal_type = context.get('journal_type', False)
        company_id = self.pool.get('res.company')._company_default_get(
            cr, uid, 'account.bank.statement', context=context)
        if journal_type:
            ids = journal_pool.search(cr, uid,
                                      [('type', '=', journal_type),
                                       ('company_id', '=', company_id)])
            if ids:
                return ids[0]
        return False

    def _end_balance(self, cursor, user, ids, name, attr, context=None):
        res = {}
        for statement in self.browse(cursor, user, ids, context=context):
            res[statement.id] = statement.balance_start
            for line in statement.line_ids:
                res[statement.id] += line.amount
        return res

    def _get_period(self, cr, uid, context=None):
        periods = self.pool.get('account.period').find(cr,
                                                       uid,
                                                       context=context)
        if periods:
            return periods[0]
        return False

    def _currency(self, cursor, user, ids, name, args, context=None):
        res = {}
        res_currency_obj = self.pool.get('res.currency')
        res_users_obj = self.pool.get('res.users')
        default_currency = res_users_obj.browse(
            cursor, user, user, context=context).company_id.currency_id
        for statement in self.browse(cursor, user, ids, context=context):
            currency = statement.journal_id.currency
            if not currency:
                currency = default_currency
            res[statement.id] = currency.id
        currency_names = {}
        for currency_id, currency_name in res_currency_obj.name_get(
                cursor, user, [x for x in res.values()], context=context):
            currency_names[currency_id] = currency_name
        for statement_id in res.keys():
            currency_id = res[statement_id]
            res[statement_id] = (currency_id, currency_names[currency_id])
        return res

    def _get_statement(self, cr, uid, ids, context=None):
        result = {}
        for line in self.pool.get('account.bank.statement.line').browse(
                cr, uid, ids, context=context):
            result[line.statement_id.id] = True
        return result.keys()

    _order = "date desc, id desc"
    _name = "account.bank.statement"
    _description = "Bank Statement"
    _inherit = ['mail.thread']
    _columns = {
        'name':
        fields.char(
            'Reference',
            size=64,
            required=True,
            states={'draft': [('readonly', False)]},
            readonly=True,
            help=
            'if you give the Name other then /, its created Accounting Entries Move will be with same name as statement name. This allows the statement entries to have the same references than the statement itself'
        ),  # readonly for account_cash_statement
        'date':
        fields.date('Date',
                    required=True,
                    states={'confirm': [('readonly', True)]},
                    select=True),
        'journal_id':
        fields.many2one('account.journal',
                        'Journal',
                        required=True,
                        readonly=True,
                        states={'draft': [('readonly', False)]}),
        'period_id':
        fields.many2one('account.period',
                        'Period',
                        required=True,
                        states={'confirm': [('readonly', True)]}),
        'balance_start':
        fields.float('Starting Balance',
                     digits_compute=dp.get_precision('Account'),
                     states={'confirm': [('readonly', True)]}),
        'balance_end_real':
        fields.float('Ending Balance',
                     digits_compute=dp.get_precision('Account'),
                     states={'confirm': [('readonly', True)]}),
        'balance_end':
        fields.function(
            _end_balance,
            store={
                'account.bank.statement':
                (lambda self, cr, uid, ids, c={}: ids,
                 ['line_ids', 'move_line_ids',
                  'balance_start'], 10),
                'account.bank.statement.line':
                (_get_statement, ['amount'], 10),
            },
            string="Computed Balance",
            help=
            'Balance as calculated based on Starting Balance and transaction lines'
        ),
        'company_id':
        fields.related('journal_id',
                       'company_id',
                       type='many2one',
                       relation='res.company',
                       string='Company',
                       store=True,
                       readonly=True),
        'line_ids':
        fields.one2many('account.bank.statement.line',
                        'statement_id',
                        'Statement lines',
                        states={'confirm': [('readonly', True)]}),
        'move_line_ids':
        fields.one2many('account.move.line',
                        'statement_id',
                        'Entry lines',
                        states={'confirm': [('readonly', True)]}),
        'state':
        fields.selection(
            [
                ('draft', 'New'),
                ('open', 'Open'),  # used by cash statements
                ('confirm', 'Closed')
            ],
            'Status',
            required=True,
            readonly="1",
            help='When new statement is created the status will be \'Draft\'.\n'
            'And after getting confirmation from the bank it will be in \'Confirmed\' status.'
        ),
        'currency':
        fields.function(_currency,
                        string='Currency',
                        type='many2one',
                        relation='res.currency'),
        'account_id':
        fields.related(
            'journal_id',
            'default_debit_account_id',
            type='many2one',
            relation='account.account',
            string='Account used in this journal',
            readonly=True,
            help=
            'used in statement reconciliation domain, but shouldn\'t be used elswhere.'
        ),
    }

    _defaults = {
        'name':
        "/",
        'date':
        fields.date.context_today,
        'state':
        'draft',
        'journal_id':
        _default_journal_id,
        'period_id':
        _get_period,
        'company_id':
        lambda self, cr, uid, c: self.pool.get('res.company').
        _company_default_get(cr, uid, 'account.bank.statement', context=c),
    }

    def _check_company_id(self, cr, uid, ids, context=None):
        for statement in self.browse(cr, uid, ids, context=context):
            if statement.company_id.id != statement.period_id.company_id.id:
                return False
        return True

    _constraints = [
        (_check_company_id,
         'The journal and period chosen have to belong to the same company.',
         ['journal_id', 'period_id']),
    ]

    def onchange_date(self, cr, uid, ids, date, company_id, context=None):
        """
            Find the correct period to use for the given date and company_id, return it and set it in the context
        """
        res = {}
        period_pool = self.pool.get('account.period')

        if context is None:
            context = {}
        ctx = context.copy()
        ctx.update({'company_id': company_id})
        pids = period_pool.find(cr, uid, dt=date, context=ctx)
        if pids:
            res.update({'period_id': pids[0]})
            context.update({'period_id': pids[0]})

        return {
            'value': res,
            'context': context,
        }

    def button_dummy(self, cr, uid, ids, context=None):
        return self.write(cr, uid, ids, {}, context=context)

    def _prepare_move(self, cr, uid, st_line, st_line_number, context=None):
        """Prepare the dict of values to create the move from a
           statement line. This method may be overridden to implement custom
           move generation (making sure to call super() to establish
           a clean extension chain).

           :param browse_record st_line: account.bank.statement.line record to
                  create the move from.
           :param char st_line_number: will be used as the name of the generated account move
           :return: dict of value to create() the account.move
        """
        return {
            'journal_id': st_line.statement_id.journal_id.id,
            'period_id': st_line.statement_id.period_id.id,
            'date': st_line.date,
            'name': st_line_number,
            'ref': st_line.ref,
        }

    def _prepare_bank_move_line(self,
                                cr,
                                uid,
                                st_line,
                                move_id,
                                amount,
                                company_currency_id,
                                context=None):
        """Compute the args to build the dict of values to create the bank move line from a
           statement line by calling the _prepare_move_line_vals. This method may be
           overridden to implement custom move generation (making sure to call super() to
           establish a clean extension chain).

           :param browse_record st_line: account.bank.statement.line record to
                  create the move from.
           :param int/long move_id: ID of the account.move to link the move line
           :param float amount: amount of the move line
           :param int/long company_currency_id: ID of currency of the concerned company
           :return: dict of value to create() the bank account.move.line
        """
        anl_id = st_line.analytic_account_id and st_line.analytic_account_id.id or False
        debit = ((amount < 0) and -amount) or 0.0
        credit = ((amount > 0) and amount) or 0.0
        cur_id = False
        amt_cur = False
        if st_line.statement_id.currency.id <> company_currency_id:
            cur_id = st_line.statement_id.currency.id
        if st_line.account_id and st_line.account_id.currency_id and st_line.account_id.currency_id.id <> company_currency_id:
            cur_id = st_line.account_id.currency_id.id
        if cur_id:
            res_currency_obj = self.pool.get('res.currency')
            amt_cur = -res_currency_obj.compute(
                cr, uid, company_currency_id, cur_id, amount, context=context)

        res = self._prepare_move_line_vals(cr,
                                           uid,
                                           st_line,
                                           move_id,
                                           debit,
                                           credit,
                                           amount_currency=amt_cur,
                                           currency_id=cur_id,
                                           analytic_id=anl_id,
                                           context=context)
        return res

    def _get_counter_part_account(sefl, cr, uid, st_line, context=None):
        """Retrieve the account to use in the counterpart move.
           This method may be overridden to implement custom move generation (making sure to
           call super() to establish a clean extension chain).

           :param browse_record st_line: account.bank.statement.line record to
                  create the move from.
           :return: int/long of the account.account to use as counterpart
        """
        if st_line.amount >= 0:
            return st_line.statement_id.journal_id.default_credit_account_id.id
        return st_line.statement_id.journal_id.default_debit_account_id.id

    def _get_counter_part_partner(sefl, cr, uid, st_line, context=None):
        """Retrieve the partner to use in the counterpart move.
           This method may be overridden to implement custom move generation (making sure to
           call super() to establish a clean extension chain).

           :param browse_record st_line: account.bank.statement.line record to
                  create the move from.
           :return: int/long of the res.partner to use as counterpart
        """
        return st_line.partner_id and st_line.partner_id.id or False

    def _prepare_counterpart_move_line(self,
                                       cr,
                                       uid,
                                       st_line,
                                       move_id,
                                       amount,
                                       company_currency_id,
                                       context=None):
        """Compute the args to build the dict of values to create the counter part move line from a
           statement line by calling the _prepare_move_line_vals. This method may be
           overridden to implement custom move generation (making sure to call super() to
           establish a clean extension chain).

           :param browse_record st_line: account.bank.statement.line record to
                  create the move from.
           :param int/long move_id: ID of the account.move to link the move line
           :param float amount: amount of the move line
           :param int/long account_id: ID of account to use as counter part
           :param int/long company_currency_id: ID of currency of the concerned company
           :return: dict of value to create() the bank account.move.line
        """
        account_id = self._get_counter_part_account(cr,
                                                    uid,
                                                    st_line,
                                                    context=context)
        partner_id = self._get_counter_part_partner(cr,
                                                    uid,
                                                    st_line,
                                                    context=context)
        debit = ((amount > 0) and amount) or 0.0
        credit = ((amount < 0) and -amount) or 0.0
        cur_id = False
        amt_cur = False
        if st_line.statement_id.currency.id <> company_currency_id:
            amt_cur = st_line.amount
            cur_id = st_line.statement_id.currency.id
        return self._prepare_move_line_vals(cr,
                                            uid,
                                            st_line,
                                            move_id,
                                            debit,
                                            credit,
                                            amount_currency=amt_cur,
                                            currency_id=cur_id,
                                            account_id=account_id,
                                            partner_id=partner_id,
                                            context=context)

    def _prepare_move_line_vals(self,
                                cr,
                                uid,
                                st_line,
                                move_id,
                                debit,
                                credit,
                                currency_id=False,
                                amount_currency=False,
                                account_id=False,
                                analytic_id=False,
                                partner_id=False,
                                context=None):
        """Prepare the dict of values to create the move line from a
           statement line. All non-mandatory args will replace the default computed one.
           This method may be overridden to implement custom move generation (making sure to
           call super() to establish a clean extension chain).

           :param browse_record st_line: account.bank.statement.line record to
                  create the move from.
           :param int/long move_id: ID of the account.move to link the move line
           :param float debit: debit amount of the move line
           :param float credit: credit amount of the move line
           :param int/long currency_id: ID of currency of the move line to create
           :param float amount_currency: amount of the debit/credit expressed in the currency_id
           :param int/long account_id: ID of the account to use in the move line if different
                  from the statement line account ID
           :param int/long analytic_id: ID of analytic account to put on the move line
           :param int/long partner_id: ID of the partner to put on the move line
           :return: dict of value to create() the account.move.line
        """
        acc_id = account_id or st_line.account_id.id
        cur_id = currency_id or st_line.statement_id.currency.id
        par_id = partner_id or ((
            (st_line.partner_id) and st_line.partner_id.id) or False)
        return {
            'name': st_line.name,
            'date': st_line.date,
            'ref': st_line.ref,
            'move_id': move_id,
            'partner_id': par_id,
            'account_id': acc_id,
            'credit': credit,
            'debit': debit,
            'statement_id': st_line.statement_id.id,
            'journal_id': st_line.statement_id.journal_id.id,
            'period_id': st_line.statement_id.period_id.id,
            'currency_id': amount_currency and cur_id,
            'amount_currency': amount_currency,
            'analytic_account_id': analytic_id,
        }

    def create_move_from_st_line(self,
                                 cr,
                                 uid,
                                 st_line_id,
                                 company_currency_id,
                                 st_line_number,
                                 context=None):
        """Create the account move from the statement line.

           :param int/long st_line_id: ID of the account.bank.statement.line to create the move from.
           :param int/long company_currency_id: ID of the res.currency of the company
           :param char st_line_number: will be used as the name of the generated account move
           :return: ID of the account.move created
        """

        if context is None:
            context = {}
        res_currency_obj = self.pool.get('res.currency')
        account_move_obj = self.pool.get('account.move')
        account_move_line_obj = self.pool.get('account.move.line')
        account_bank_statement_line_obj = self.pool.get(
            'account.bank.statement.line')
        st_line = account_bank_statement_line_obj.browse(cr,
                                                         uid,
                                                         st_line_id,
                                                         context=context)
        st = st_line.statement_id

        context.update({'date': st_line.date})

        move_vals = self._prepare_move(cr,
                                       uid,
                                       st_line,
                                       st_line_number,
                                       context=context)
        move_id = account_move_obj.create(cr, uid, move_vals, context=context)
        account_bank_statement_line_obj.write(
            cr, uid, [st_line.id], {'move_ids': [(4, move_id, False)]})
        torec = []
        acc_cur = (
            (st_line.amount <= 0)
            and st.journal_id.default_debit_account_id) or st_line.account_id

        context.update({
            'res.currency.compute.account': acc_cur,
        })
        amount = res_currency_obj.compute(cr,
                                          uid,
                                          st.currency.id,
                                          company_currency_id,
                                          st_line.amount,
                                          context=context)

        bank_move_vals = self._prepare_bank_move_line(cr,
                                                      uid,
                                                      st_line,
                                                      move_id,
                                                      amount,
                                                      company_currency_id,
                                                      context=context)
        move_line_id = account_move_line_obj.create(cr,
                                                    uid,
                                                    bank_move_vals,
                                                    context=context)
        torec.append(move_line_id)

        counterpart_move_vals = self._prepare_counterpart_move_line(
            cr,
            uid,
            st_line,
            move_id,
            amount,
            company_currency_id,
            context=context)
        account_move_line_obj.create(cr,
                                     uid,
                                     counterpart_move_vals,
                                     context=context)

        for line in account_move_line_obj.browse(
                cr,
                uid, [
                    x.id for x in account_move_obj.browse(
                        cr, uid, move_id, context=context).line_id
                ],
                context=context):
            if line.state <> 'valid':
                raise osv.except_osv(
                    _('Error!'),
                    _('Journal item "%s" is not valid.') % line.name)

        # Bank statements will not consider boolean on journal entry_posted
        account_move_obj.post(cr, uid, [move_id], context=context)
        return move_id

    def get_next_st_line_number(self,
                                cr,
                                uid,
                                st_number,
                                st_line,
                                context=None):
        return st_number + '/' + str(st_line.sequence)

    def balance_check(self, cr, uid, st_id, journal_type='bank', context=None):
        st = self.browse(cr, uid, st_id, context=context)
        if not ((abs((st.balance_end or 0.0) - st.balance_end_real) < 0.0001)
                or
                (abs((st.balance_end or 0.0) - st.balance_end_real) < 0.0001)):
            raise osv.except_osv(
                _('Error!'),
                _('The statement balance is incorrect !\nThe expected balance (%.2f) is different than the computed one. (%.2f)'
                  ) % (st.balance_end_real, st.balance_end))
        return True

    def statement_close(self, cr, uid, ids, journal_type='bank', context=None):
        return self.write(cr, uid, ids, {'state': 'confirm'}, context=context)

    def check_status_condition(self, cr, uid, state, journal_type='bank'):
        return state in ('draft', 'open')

    def button_confirm_bank(self, cr, uid, ids, context=None):
        obj_seq = self.pool.get('ir.sequence')
        if context is None:
            context = {}

        for st in self.browse(cr, uid, ids, context=context):
            j_type = st.journal_id.type
            company_currency_id = st.journal_id.company_id.currency_id.id
            if not self.check_status_condition(
                    cr, uid, st.state, journal_type=j_type):
                continue

            self.balance_check(cr,
                               uid,
                               st.id,
                               journal_type=j_type,
                               context=context)
            if (not st.journal_id.default_credit_account_id) \
                    or (not st.journal_id.default_debit_account_id):
                raise osv.except_osv(
                    _('Configuration Error!'),
                    _('Please verify that an account is defined in the journal.'
                      ))

            if not st.name == '/':
                st_number = st.name
            else:
                c = {'fiscalyear_id': st.period_id.fiscalyear_id.id}
                if st.journal_id.sequence_id:
                    st_number = obj_seq.next_by_id(
                        cr, uid, st.journal_id.sequence_id.id, context=c)
                else:
                    st_number = obj_seq.next_by_code(cr,
                                                     uid,
                                                     'account.bank.statement',
                                                     context=c)

            for line in st.move_line_ids:
                if line.state <> 'valid':
                    raise osv.except_osv(
                        _('Error!'),
                        _('The account entries lines are not in valid state.'))
            for st_line in st.line_ids:
                if st_line.analytic_account_id:
                    if not st.journal_id.analytic_journal_id:
                        raise osv.except_osv(
                            _('No Analytic Journal!'),
                            _("You have to assign an analytic journal on the '%s' journal!"
                              ) % (st.journal_id.name, ))
                if not st_line.amount:
                    continue
                st_line_number = self.get_next_st_line_number(
                    cr, uid, st_number, st_line, context)
                self.create_move_from_st_line(cr, uid, st_line.id,
                                              company_currency_id,
                                              st_line_number, context)

            self.write(cr,
                       uid, [st.id], {
                           'name': st_number,
                           'balance_end_real': st.balance_end
                       },
                       context=context)
            self.message_post(
                cr,
                uid, [st.id],
                body=_('Statement %s confirmed, journal items were created.') %
                (st_number, ),
                context=context)
        return self.write(cr, uid, ids, {'state': 'confirm'}, context=context)

    def button_cancel(self, cr, uid, ids, context=None):
        done = []
        account_move_obj = self.pool.get('account.move')
        for st in self.browse(cr, uid, ids, context=context):
            if st.state == 'draft':
                continue
            move_ids = []
            for line in st.line_ids:
                move_ids += [x.id for x in line.move_ids]
            account_move_obj.button_cancel(cr, uid, move_ids, context=context)
            account_move_obj.unlink(cr, uid, move_ids, context)
            done.append(st.id)
        return self.write(cr, uid, done, {'state': 'draft'}, context=context)

    def _compute_balance_end_real(self, cr, uid, journal_id, context=None):
        res = False
        if journal_id:
            cr.execute(
                'SELECT balance_end_real \
                    FROM account_bank_statement \
                    WHERE journal_id = %s AND NOT state = %s \
                    ORDER BY date DESC,id DESC LIMIT 1', (journal_id, 'draft'))
            res = cr.fetchone()
        return res and res[0] or 0.0

    def onchange_journal_id(self,
                            cr,
                            uid,
                            statement_id,
                            journal_id,
                            context=None):
        if not journal_id:
            return {}
        balance_start = self._compute_balance_end_real(cr,
                                                       uid,
                                                       journal_id,
                                                       context=context)

        journal_data = self.pool.get('account.journal').read(
            cr, uid, journal_id, ['company_id', 'currency'], context=context)
        company_id = journal_data['company_id']
        currency_id = journal_data['currency'] or self.pool.get(
            'res.company').browse(cr, uid, company_id[0],
                                  context=context).currency_id.id
        return {
            'value': {
                'balance_start': balance_start,
                'company_id': company_id,
                'currency': currency_id
            }
        }

    def unlink(self, cr, uid, ids, context=None):
        stat = self.read(cr, uid, ids, ['state'], context=context)
        unlink_ids = []
        for t in stat:
            if t['state'] in ('draft'):
                unlink_ids.append(t['id'])
            else:
                raise osv.except_osv(
                    _('Invalid Action!'),
                    _('In order to delete a bank statement, you must first cancel it to delete related journal items.'
                      ))
        osv.osv.unlink(self, cr, uid, unlink_ids, context=context)
        return True

    def copy(self, cr, uid, id, default=None, context=None):
        if default is None:
            default = {}
        if context is None:
            context = {}
        default = default.copy()
        default['move_line_ids'] = []
        return super(account_bank_statement, self).copy(cr,
                                                        uid,
                                                        id,
                                                        default,
                                                        context=context)

    def button_journal_entries(self, cr, uid, ids, context=None):
        ctx = (context or {}).copy()
        ctx['journal_id'] = self.browse(cr, uid, ids[0],
                                        context=context).journal_id.id
        return {
            'view_type': 'form',
            'view_mode': 'tree',
            'res_model': 'account.move.line',
            'view_id': False,
            'type': 'ir.actions.act_window',
            'domain': [('statement_id', 'in', ids)],
            'context': ctx,
        }
コード例 #24
0
ファイル: models.py プロジェクト: 0967697922/odoo
    ('boolean', fields.boolean()),
    ('integer', fields.integer()),
    ('float', fields.float()),
    ('decimal', fields.float(digits=(16, 3))),
    ('string.bounded', fields.char('unknown', size=16)),
    ('string.required', fields.char('unknown', size=None, required=True)),
    ('string', fields.char('unknown', size=None)),
    ('date', fields.date()),
    ('datetime', fields.datetime()),
    ('text', fields.text()),
    ('selection', fields.selection([(1, "Foo"), (2, "Bar"), (3, "Qux"), (4, '')])),
    # here use size=-1 to store the values as integers instead of strings
    ('selection.function', fields.selection(selection_fn, size=-1)),
    # just relate to an integer
    ('many2one', fields.many2one('export.integer')),
    ('one2many', fields.one2many('export.one2many.child', 'parent_id')),
    ('many2many', fields.many2many('export.many2many.other')),
    ('function', fields.function(function_fn, fnct_inv=function_fn_write, type="integer")),
    # related: specialization of fields.function, should work the same way
    # TODO: reference
]

for name, field in models:
    class NewModel(orm.Model):
        _name = 'export.%s' % name
        _columns = {
            'const': fields.integer(),
            'value': field,
        }
        _defaults = {
            'const': 4,
コード例 #25
0
ファイル: rhwl_weixin.py プロジェクト: cash2one/odoo-dev
class rhwl_config(osv.osv):
    _name = "rhwl.weixin.base"

    _columns = {
        "name":
        fields.char("Name", size=20),
        "original_id":
        fields.char("Original ID", size=20),
        "code":
        fields.char("Code", size=10),
        "token_flag":
        fields.char(u"Token(令牌)", size=10),
        "appid":
        fields.char("AppID"),
        "appsecret":
        fields.char("AppSecret"),
        "token":
        fields.char("Token", readonly=True),
        "token_create":
        fields.datetime("TokenCreate", readonly=True),
        "expires_in":
        fields.integer("Expires_IN", readonly=True),
        "user_menu":
        fields.text("User Menu"),
        "ticket":
        fields.char("Ticket", readonly=True),
        "ticket_create":
        fields.datetime("TicketCreate", readonly=True),
        "ticket_expires":
        fields.integer("Ticket Expires", readonly=True),
        "welcome":
        fields.text("Welcome"),
        "users":
        fields.one2many("rhwl.weixin", "base_id", u"关注用户"),
        "menu":
        fields.one2many("rhwl.weixin.usermenu", "base_id", u"自定义菜单"),
        "is_valid":
        fields.boolean(u"已认证"),
        "service_type":
        fields.selection([("1", u"订阅号"), ("2", u"服务号"), ("3", u"企业号")],
                         u"帐号类型")
    }

    def _get_memcache(self, key):
        return MEMCACHE.get(key, None)

    def _set_memcache(self, key, val):
        MEMCACHE[key] = val

    def _get_memcache_id(self, cr, original, AgentID):
        ids = self._get_memcache((original, AgentID))
        if not ids:
            if (not AgentID) or AgentID == "0":
                ids = self.search(cr, SUPERUSER_ID,
                                  [("original_id", "=", original)])
            else:
                ids = self.search(cr, SUPERUSER_ID,
                                  [("original_id", "=", original),
                                   ("appid", "=", AgentID)])
            self._set_memcache((original, AgentID), ids)
        return ids

    #用户关注时,记录用户的OpenId信息,并返回设置的欢迎文字
    def action_subscribe(self, cr, original, fromUser, AgentID="0"):
        origId = self._get_memcache_id(cr, original, AgentID)
        user = self.pool.get('rhwl.weixin')

        for o in origId:
            id = user.search(cr, SUPERUSER_ID, [("base_id", "=", o),
                                                ('openid', '=', fromUser), '|',
                                                ('active', '=', False),
                                                ("active", "=", True)])

            if id:
                user.write(cr, SUPERUSER_ID, id, {"active": True})
            else:
                user.create(
                    cr, SUPERUSER_ID, {
                        "base_id": o,
                        'openid': fromUser,
                        'active': True,
                        'state': 'draft'
                    })
        cr.commit()
        obj = self.browse(cr, SUPERUSER_ID, origId[0])
        return obj.welcome

    def action_unsubscribe(self, cr, original, fromUser, AgentID="0"):
        origId = self._get_memcache_id(cr, original, AgentID)
        user = self.pool.get('rhwl.weixin')
        for o in origId:
            id = user.search(cr, SUPERUSER_ID, [("base_id", "=", o),
                                                ('openid', '=', fromUser)])
            if id:
                user.write(cr, SUPERUSER_ID, id, {"active": False})
        cr.commit()

    def action_event_clicked(self, cr, key, original, fromUser, appid=None):
        origId = self._get_memcache_id(cr, original, appid)
        obj = self.browse(cr, SUPERUSER_ID, origId)
        if obj.code == "rhwc" and key == "ONLINE_QUERY":
            return u"请您输入送检编号!"
        articles = self._get_htmlmsg(cr, origId[0], key)
        _logger.debug(articles)
        if articles[0]:
            userid = self._get_userid(cr, origId[0], fromUser)
            if not userid:
                articles = {
                    "Title": "内部ERP帐号绑定",
                    "Description": "您查阅的功能需要授权,请先进行内部ERP帐号绑定",
                    "PicUrl": "/rhwl_weixin/static/img/logo1.png",
                    "Url": "/rhwl_weixin/static/weixinbind.html"
                }
                return (obj.code.encode("utf-8"), [
                    articles,
                ])
            if articles[1]:
                is_has_group = False

                uobj = self.pool.get("res.users")
                for i in articles[1].split(","):
                    is_has_group = uobj.has_group(cr, userid, i)
                    if is_has_group: break
                if not is_has_group:
                    articles = {
                        "Title": "访问权限不足",
                        "Description": "您查阅的功能需要特别授权,请与管理员联系。",
                        "PicUrl": "/rhwl_weixin/static/img/logo1.png",
                    }
                    return (obj.code.encode("utf-8"), [
                        articles,
                    ])
        _logger.debug(articles[2])
        if articles[2]:
            return (obj.code.encode("utf-8"), articles[2])
        else:
            return u"此功能在开发中,敬请稍候!"

    def action_text_input(self, cr, content, original, fromUser):
        origId = self._get_memcache_id(cr, original, None)
        obj = self.browse(cr, SUPERUSER_ID, origId)

        if obj.code == "rhwc":  #人和无创公众号
            sample = self.pool.get("sale.sampleone")
            user = self.pool.get('rhwl.weixin')

            if content.isalnum() and len(content) == 6:
                id = user.search(cr, SUPERUSER_ID,
                                 [("base_id", "=", origId[0]),
                                  ("active", '=', True),
                                  ("state", "=", "process"),
                                  ("checkNum", "=", content)])
                if not id:
                    return u"请先输入样品编码。"
                else:
                    obj = user.browse(cr, SUPERUSER_ID, id)
                    mindate = datetime.datetime.utcnow() - datetime.timedelta(
                        minutes=5)
                    if obj.checkDateTime < mindate.strftime(
                            "%Y-%m-%d %H:%M:%S"):
                        return u"验证码已过期,请重新输入样品编码查询。"
                    else:
                        id = sample.search(cr, SUPERUSER_ID,
                                           [("name", "=", obj.sampleno)])
                        sample_obj = sample.browse(cr, SUPERUSER_ID, id)
                        user.write(cr, SUPERUSER_ID, obj.id, {"state": "pass"})
                        cr.commit()
                        return u"您的样品编码" + obj.sampleno + u"目前进度为【" + rhwl_sale.rhwl_sale_state_select.get(
                            sample_obj.check_state) + u"】,完成后详细的检测报告请与检测医院索取。"
            else:
                id = sample.search(cr, SUPERUSER_ID, [('name', '=', content)])

                if id:
                    openid = user.search(cr, SUPERUSER_ID,
                                         [('openid', '=', fromUser)])
                    obj = sample.browse(cr, SUPERUSER_ID, id)
                    rand = random.randint(111111, 999999)
                    checkDateTime = datetime.datetime.utcnow()
                    user.write(
                        cr, SUPERUSER_ID, openid, {
                            "telno": obj.yftelno,
                            "state": "process",
                            "checkNum": rand,
                            "checkDateTime": checkDateTime,
                            "sampleno": content
                        })
                    cr.commit()
                    if obj.yftelno:
                        self.pool.get("res.company").send_sms(
                            cr, SUPERUSER_ID, obj.yftelno,
                            u"您查询样品检测结果的验证码为%s,请在五分钟内输入,如果不是您本人操作,请不用处理。" %
                            (rand, ))
                        return u"验证码已经发送至检测知情同意书上登记的电话" + obj.yftelno[:3] + u"****" + obj.yftelno[
                            -4:] + u",请收到验证码后在五分钟内输入。"
                    else:
                        return u"您查询的样品编码在检测知情同意书上没有登记电话,不能发送验证码,请与送检医院查询结果。"
                else:
                    #if re.search("[^0-9a-zA-Z]",content):
                    #    return self.customer_service(fromUser,toUser)
                    #else:
                    return u"您所查询的样品编码[%s]不存在,请重新输入,输入时注意区分大小写字母,并去掉多余的空格!" % (
                        content)

        else:
            return u"欢迎光临"

    def _get_htmlmsg(self, cr, orig_id, key):
        msg = self.pool.get("rhwl.weixin.usermenu2")

        id = msg.search(cr, SUPERUSER_ID, [("parent.base_id.id", "=", orig_id),
                                           ("key", "=", key)])
        if not id:
            return (False, "", None)
        obj = msg.browse(cr, SUPERUSER_ID, id)
        if not obj.htmlmsg:
            return (obj.need_user, obj.groups, None)
        articles = []
        for j in obj.htmlmsg:
            val = {
                "Title": j.title.encode("utf-8"),
                "Description": j.description.encode("utf-8"),
                "PicUrl": j.picurl.encode("utf-8"),
            }
            if j.url:
                val["Url"] = j.url and j.url.encode("utf-8") or ""
            articles.append(val)
        return (obj.need_user, obj.groups, articles)

    def _get_userid(self, cr, orig_id, openid):
        weixin = self.pool.get("rhwl.weixin")

        id = weixin.search(cr, SUPERUSER_ID, [("base_id", "=", orig_id), '|',
                                              ('openid', '=', openid),
                                              ("rhwlid", "=", openid)])
        if id:
            obj = weixin.browse(cr, SUPERUSER_ID, id)
            return obj.user_id.id
        return None

    def _get_ticket(self, cr, uid, val, valType="code", context=None):
        arg = {"access_token": "", "type": "jsapi"}
        ids = self.search(cr, uid, [(valType, "=", val)], limit=1)
        obj = self.browse(cr, uid, ids, context=context)
        if not obj.ticket or (
                datetime.datetime.now() - datetime.datetime.strptime(
                    obj.ticket_create, tools.DEFAULT_SERVER_DATETIME_FORMAT)
        ).total_seconds() > (obj.ticket_expires - 30):
            arg['access_token'] = self._get_token(cr,
                                                  uid,
                                                  val,
                                                  valType,
                                                  obj,
                                                  context=context)
            if obj.service_type == "3":
                s = requests.post(
                    "https://qyapi.weixin.qq.com/cgi-bin/get_jsapi_ticket",
                    params=arg)
            else:
                s = requests.post(
                    "https://api.weixin.qq.com/cgi-bin/ticket/getticket",
                    params=arg)
            ref = s.content
            s.close()
            res = eval(ref)
            if res.get("errcode") == 0:
                self.write(
                    cr, uid, obj.id, {
                        "ticket": res.get("ticket"),
                        "ticket_create": fields.datetime.now(),
                        "ticket_expires": res.get("expires_in")
                    })
            else:
                raise osv.except_osv("错误", res.get("errmsg"))
            return res.get("ticket")
        elif obj.token:
            return obj.ticket.encode('utf-8')

    def _get_token(self, cr, uid, val, valType="code", obj=None, context=None):
        arg = {
            "grant_type": "client_credential",
            "appid": "",
            "secret": "",
        }
        arg_qy = {"corpid": "", "corpsecret": ""}

        if not obj:
            ids = self.search(cr, uid, [(valType, "=", val)], limit=1)
            obj = self.browse(cr, uid, ids, context=context)

        if obj.service_type == "3":
            #企业号处理
            if (not obj.token
                ) or (datetime.datetime.now() - datetime.datetime.strptime(
                    obj.token_create, tools.DEFAULT_SERVER_DATETIME_FORMAT)
                      ).total_seconds() > (obj.expires_in - 30):
                arg_qy["corpid"] = obj.original_id
                arg_qy["corpsecret"] = obj.appsecret
                s = requests.post(
                    "https://qyapi.weixin.qq.com/cgi-bin/gettoken",
                    params=arg_qy)
                ref = s.content
                s.close()
                res = eval(ref)
                if res.get("access_token"):
                    self.write(
                        cr, uid, obj.id, {
                            "token": res.get("access_token"),
                            "token_create": fields.datetime.now(),
                            "expires_in": res.get("expires_in")
                        })
                else:
                    raise osv.except_osv("错误", res.get("errmsg"))
                return res.get("access_token")
            else:
                return obj.token.encode('utf-8')
        else:
            if (not obj.token
                ) or (datetime.datetime.now() - datetime.datetime.strptime(
                    obj.token_create, tools.DEFAULT_SERVER_DATETIME_FORMAT)
                      ).total_seconds() > (obj.expires_in - 30):
                arg["appid"] = obj.appid
                arg["secret"] = obj.appsecret
                s = requests.post("https://api.weixin.qq.com/cgi-bin/token",
                                  params=arg)
                ref = s.content
                s.close()
                res = eval(ref)
                if res.get("access_token"):
                    self.write(
                        cr, uid, obj.id, {
                            "token": res.get("access_token"),
                            "token_create": fields.datetime.now(),
                            "expires_in": res.get("expires_in")
                        })
                else:
                    raise osv.except_osv("错误", res.get("errmsg"))
                _logger.info("Get New Token:" + res.get("access_token"))
                return res.get("access_token")
            elif obj.token:
                _logger.info("Get Old Token:" + obj.token.encode('utf-8'))
                return obj.token.encode('utf-8')

    def action_token(self, cr, uid, ids, context=None):
        for i in self.browse(cr, uid, ids, context=context):
            self._get_token(cr, uid, None, None, i, context)

    def _get_menu_detail_json(self, cr, uid, ids, context=None):
        d = {
            "sub_button": [],
        }
        obj = self.pool.get("rhwl.weixin.usermenu").browse(cr,
                                                           uid,
                                                           ids,
                                                           context=context)
        if obj.details:
            d["name"] = obj.name.encode('utf-8')
            for i in obj.details:
                dic = {
                    "type": i.type.encode('utf-8'),
                    "name": i.name.encode('utf-8'),
                }
                if i.type == "view":
                    dic["url"] = i.url.encode('utf-8')
                elif i.type == "click":
                    dic["key"] = i.key.encode('utf-8')

                d['sub_button'].append(dic)
            return d
        else:
            d = {}
            d["type"] = obj.type.encode('utf-8')
            d["name"] = obj.name.encode('utf-8')
            if obj.type == "view": d["url"] = obj.url.encode('utf-8')
            if obj.type == "click": d["key"] = obj.key.encode('utf-8')
            return d

    def _get_menu_json(self, cr, uid, id, context=None):
        m = {
            "button": [],
        }
        ids = self.pool.get("rhwl.weixin.usermenu").search(
            cr, uid, [("base_id", "=", id)], context=context)
        if not ids:
            raise osv.except_osv(u"错误", u"您还没有配置用户自定义菜单内容。")

        if isinstance(ids, (long, int)):
            ids = [
                ids,
            ]
        for i in ids:
            m['button'].append(
                self._get_menu_detail_json(cr, uid, i, context=context))
        return m

    def action_usermenu(self, cr, uid, ids, context=None):
        args = {}

        for i in self.browse(cr, uid, ids, context=context):
            if i.service_type == "3":
                create_url = "https://qyapi.weixin.qq.com/cgi-bin/menu/create"
                args["access_token"] = self._get_token(cr, uid, None, None, i,
                                                       context)
                args["agentid"] = i.appid
            else:
                create_url = "https://api.weixin.qq.com/cgi-bin/menu/create"
                args["access_token"] = self._get_token(cr, uid, None, None, i,
                                                       context)
            i.user_menu = str(
                self._get_menu_json(cr, uid, i.id, context=context))

            s = requests.post(
                create_url,
                params=args,
                data=json.dumps(eval(i.user_menu), ensure_ascii=False),
                headers={'content-type': 'application/json; encoding=utf-8'},
                allow_redirects=False)
            ref = s.content
            s.close()
            res = eval(ref)
            if res.get("errcode") != 0:
                raise osv.except_osv("错误" + str(res.get("errcode")),
                                     res.get("errmsg"))

    def send_template1(self, cr, uid, to_user, json_dict, context=None):
        id = self.pool.get("rhwl.weixin").search(
            cr, SUPERUSER_ID, [("base_id.code", "=", "rhwc"),
                               ("user_id", "=", to_user)])
        if not id: return
        id = id[0]
        obj = self.pool.get("rhwl.weixin").browse(cr, SUPERUSER_ID, id)
        json_dict["touser"] = obj.openid.encode('utf-8')
        if json_dict["url"]:
            json_dict["url"] += "?openid=" + obj.openid.encode('utf-8')
        token = self._get_token(cr, SUPERUSER_ID, "rhwc", context=context)
        s = requests.post(
            "https://api.weixin.qq.com/cgi-bin/message/template/send",
            params={"access_token": token},
            data=json.dumps(json_dict, ensure_ascii=False),
            headers={'content-type': 'application/json; encoding=utf-8'},
            allow_redirects=False)
        ref = s.content
        s.close()

    def send_template2(self, cr, uid, json_dict, col, context=None):
        template = {
            "touser": "******",
            "template_id": "D2fDRIhwFe9jpHgLtTjkRy5jOz_AqQnvuGzpYQFkgRs",
            "url": "",
            "topcolor": "#FF0000",
            "data": {
                "first": {
                    "value": json_dict["first"],
                    "color": "#173177"
                },
                "keyword1": {
                    "value": json_dict["keyword1"],
                    "color": "#173177"
                },
                "keyword2": {
                    "value": json_dict["keyword2"],
                    "color": "#173177"
                },
                "keyword3": {
                    "value": json_dict["keyword3"],
                    "color": "#173177"
                },
                "remark": {
                    "value": json_dict["remark"],
                    "color": "#173177"
                }
            }
        }
        id = self.pool.get("rhwl.weixin").search(cr, SUPERUSER_ID,
                                                 [(col, "=", True)])
        for i in id:
            obj = self.pool.get("rhwl.weixin").browse(cr,
                                                      SUPERUSER_ID,
                                                      i,
                                                      context=context)
            token = self._get_token(cr, SUPERUSER_ID, "rhwc", context=context)
            template["touser"] = obj.openid.encode('utf-8')

            s = requests.post(
                "https://api.weixin.qq.com/cgi-bin/message/template/send",
                params={"access_token": token},
                data=json.dumps(template, ensure_ascii=False),
                headers={'content-type': 'application/json; encoding=utf-8'},
                allow_redirects=False)
            ref = s.content
            s.close()

    def send_qy_text_ids(self, cr, uid, ids, content, context=None):
        vals = {
            "touser": "",
            "toparty": "",
            "totag": "",
            "msgtype": "text",
            "agentid": None,
            "text": {
                "content": ""
            },
            "safe": "0"
        }
        touser = []
        if ids:
            for i in self.pool.get("rhwl.weixin").browse(cr,
                                                         uid,
                                                         ids,
                                                         context=context):
                touser.append(i.openid.encode('utf-8'))
                if not vals["agentid"]:
                    vals["agentid"] = i.base_id.appid.encode('utf-8')
                    token = self._get_token(cr,
                                            SUPERUSER_ID,
                                            i.base_id.code.encode('utf-8'),
                                            context=context)
            vals["touser"] = '******'.join(touser)
            vals["text"]["content"] = content.encode('utf-8')
            #_logger.error(vals)
            s = requests.post(
                "https://qyapi.weixin.qq.com/cgi-bin/message/send",
                params={"access_token": token},
                data=json.dumps(vals, ensure_ascii=False),
                headers={'content-type': 'application/json; encoding=utf-8'},
                allow_redirects=False)
            ref = s.content
            s.close()

    def send_qy_text_openid(self,
                            cr,
                            uid,
                            code,
                            openid,
                            content,
                            context=None):
        ids = self.pool.get("rhwl.weixin").search(cr,
                                                  uid,
                                                  [("base_id.code", "=", code),
                                                   ("openid", "=", openid)],
                                                  context=context)
        self.send_qy_text_ids(cr, uid, ids, content, context=context)

    def send_qy_text(self, cr, uid, code, field_name, content, context=None):
        ids = self.pool.get("rhwl.weixin").search(cr,
                                                  uid,
                                                  [("base_id.code", "=", code),
                                                   (field_name, "=", True)],
                                                  context=context)
        self.send_qy_text_ids(cr, uid, ids, content, context=context)

    def get_dept_user(self, cr, uid, id, context=None):
        obj = self.browse(cr, uid, id, context=context)
        token = self._get_token(cr,
                                SUPERUSER_ID,
                                obj.code.encode("utf-8"),
                                context=context)
        vals = {
            "access_token": token,
            "department_id": 1,
            "fetch_child": 1,
            "status": 0
        }
        s = requests.post(
            "https://qyapi.weixin.qq.com/cgi-bin/user/simplelist",
            params=vals,
            headers={'content-type': 'application/json; encoding=utf-8'},
            allow_redirects=False)
        ref = eval(s.content)
        s.close()
        if ref["errcode"] == 0:
            for i in ref["userlist"]:
                u_id = self.pool.get("rhwl.weixin").search(
                    cr, SUPERUSER_ID, [("base_id", "=", obj.id),
                                       ("openid", "=", i["userid"])])
                if not u_id:
                    self.pool.get("rhwl.weixin").create(
                        cr, SUPERUSER_ID, {
                            "base_id": obj.id,
                            "openid": i["userid"],
                            "active": True,
                            "state": "draft"
                        })
コード例 #26
0
ファイル: installer.py プロジェクト: frouty/aeroo
            try:
                file_data = image_file.read()
                self._logo_image = base64.encodestring(file_data)
                return self._logo_image
            finally:
                image_file.close()
        else:
            self._logo_image = base64.encodestring(im.read())
            return self._logo_image

    def _get_image_fn(self, cr, uid, ids, name, args, context=None):
        image = self._get_image(cr, uid, context)
        return dict.fromkeys(ids, image) # ok to use .fromkeys() as the image is same for all 

    _columns = {
        'printer_ids':fields.one2many('aeroo.printers.temp', 'install_id', 'Printers'),
        'config_logo': fields.function(_get_image_fn, string='Image', type='binary', method=True),
        'state':fields.selection([
            ('init','Init'),
            ('done','Done'),
            
        ],'State', select=True, readonly=True),
    }

    def default_get(self, cr, uid, fields, context=None):
        printers_obj = self.pool.get('aeroo.printers')
        data = super(aeroo_printer_installer, self).default_get(cr, uid, fields, context=context)
        conn = cups.Connection()
        printers = conn.getPrinters()
        installed_ids = printers_obj.search(cr, 1, ['|',('active','=',False),('active','=',True)], context=context)
        printers_installed = printers_obj.read(cr, uid, installed_ids, context=context)
コード例 #27
0
ファイル: order.py プロジェクト: ToBeReplaced/OpenUpgrade
class sale_order(osv.osv):
    _inherit = 'sale.order'

    def _get_total(self, cr, uid, ids, name, arg, context=None):
        res = {}
        for order in self.browse(cr, uid, ids, context=context):
            total = 0.0
            for line in order.order_line:
                total += line.price_subtotal + line.price_unit * ((line.discount or 0.0) / 100.0) * line.product_uom_qty
            res[order.id] = total
        return res

    _columns = {
        'access_token': fields.char('Security Token', required=True, copy=False),
        'template_id': fields.many2one('sale.quote.template', 'Quotation Template', readonly=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}),
        'website_description': fields.html('Description'),
        'options' : fields.one2many('sale.order.option', 'order_id', 'Optional Products Lines', readonly=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}, copy=True),
        'amount_undiscounted': fields.function(_get_total, string='Amount Before Discount', type="float", digits=0),
        'quote_viewed': fields.boolean('Quotation Viewed'),
        'require_payment': fields.selection([
            (0, 'Not mandatory on website quote validation'),
            (1, 'Immediate after website order validation')
            ], 'Payment', help="Require immediate payment by the customer when validating the order from the website quote"),
    }

    def _get_template_id(self, cr, uid, context=None):
        try:
            template_id = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'website_quote', 'website_quote_template_default')[1]
        except ValueError:
            template_id = False
        return template_id

    _defaults = {
        'access_token': lambda self, cr, uid, ctx={}: str(uuid.uuid4()),
        'template_id' : _get_template_id,
    }

    def open_quotation(self, cr, uid, quote_id, context=None):
        quote = self.browse(cr, uid, quote_id[0], context=context)
        self.write(cr, uid, quote_id[0], {'quote_viewed': True}, context=context)
        return {
            'type': 'ir.actions.act_url',
            'target': 'self',
            'url': '/quote/%s/%s' % (quote.id, quote.access_token)
        }

    def onchange_template_id(self, cr, uid, ids, template_id, partner=False, fiscal_position_id=False, pricelist_id=False, context=None):
        if not template_id:
            return {}

        if partner:
            context = dict(context or {})
            context['lang'] = self.pool['res.partner'].browse(cr, uid, partner, context).lang

        pricelist_obj = self.pool['product.pricelist']

        lines = [(5,)]
        quote_template = self.pool.get('sale.quote.template').browse(cr, uid, template_id, context=context)
        for line in quote_template.quote_line:
            res = self.pool.get('sale.order.line').product_id_change(cr, uid, False,
                False, line.product_id.id, line.product_uom_qty, line.product_uom_id.id, line.product_uom_qty,
                line.product_uom_id.id, line.name, partner, False, True, time.strftime('%Y-%m-%d'),
                False, fiscal_position_id, True, context)
            data = res.get('value', {})
            if pricelist_id:
                uom_context = context.copy()
                uom_context['uom'] = line.product_uom_id.id
                price = pricelist_obj.price_get(cr, uid, [pricelist_id], line.product_id.id, 1, context=uom_context)[pricelist_id]
            else:
                price = line.price_unit

            if 'tax_id' in data:
                data['tax_id'] = [(6, 0, data['tax_id'])]
            data.update({
                'name': line.name,
                'price_unit': price,
                'discount': line.discount,
                'product_uom_qty': line.product_uom_qty,
                'product_id': line.product_id.id,
                'product_uom': line.product_uom_id.id,
                'website_description': line.website_description,
                'state': 'draft',
            })
            lines.append((0, 0, data))
        options = []
        for option in quote_template.options:
            if pricelist_id:
                uom_context = context.copy()
                uom_context['uom'] = option.uom_id.id
                price = pricelist_obj.price_get(cr, uid, [pricelist_id], option.product_id.id, 1, context=uom_context)[pricelist_id]
            else:
                price = option.price_unit
            options.append((0, 0, {
                'product_id': option.product_id.id,
                'name': option.name,
                'quantity': option.quantity,
                'uom_id': option.uom_id.id,
                'price_unit': price,
                'discount': option.discount,
                'website_description': option.website_description,
            }))
        date = False
        if quote_template.number_of_days > 0:
            date = (datetime.datetime.now() + datetime.timedelta(quote_template.number_of_days)).strftime("%Y-%m-%d")
        data = {
            'order_line': lines,
            'website_description': quote_template.website_description,
            'options': options,
            'validity_date': date,
            'require_payment': quote_template.require_payment
        }
        if quote_template.note:
            data['note'] = quote_template.note
        return {'value': data}

    def recommended_products(self, cr, uid, ids, context=None):
        order_line = self.browse(cr, uid, ids[0], context=context).order_line
        product_pool = self.pool.get('product.product')
        products = []
        for line in order_line:
            products += line.product_id.product_tmpl_id.recommended_products(context=context)
        return products

    def get_access_action(self, cr, uid, ids, context=None):
        """ Override method that generated the link to access the document. Instead
        of the classic form view, redirect to the online quote if exists. """
        quote = self.browse(cr, uid, ids[0], context=context)
        if not quote.template_id:
            return super(sale_order, self).get_access_action(cr, uid, ids, context=context)
        return {
            'type': 'ir.actions.act_url',
            'url': '/quote/%s' % quote.id,
            'target': 'self',
            'res_id': quote.id,
        }

    def action_quotation_send(self, cr, uid, ids, context=None):
        action = super(sale_order, self).action_quotation_send(cr, uid, ids, context=context)
        ir_model_data = self.pool.get('ir.model.data')
        quote_template_id = self.read(cr, uid, ids, ['template_id'], context=context)[0]['template_id']
        if quote_template_id:
            try:
                template_id = ir_model_data.get_object_reference(cr, uid, 'website_quote', 'email_template_edi_sale')[1]
            except ValueError:
                pass
            else:
                action['context'].update({
                    'default_template_id': template_id,
                    'default_use_template': True
                })

        return action

    def _confirm_online_quote(self, cr, uid, order_id, tx, context=None):
        """ Payment callback: validate the order and write tx details in chatter """
        order = self.browse(cr, uid, order_id, context=context)

        # create draft invoice if transaction is ok
        if tx and tx.state == 'done':
            if order.state in ['draft', 'sent']:
                self.signal_workflow(cr, SUPERUSER_ID, [order.id], 'manual_invoice', context=context)
            message = _('Order payed by %s. Transaction: %s. Amount: %s.') % (tx.partner_id.name, tx.acquirer_reference, tx.amount)
            self.message_post(cr, uid, order_id, body=message, type='comment', subtype='mt_comment', context=context)
            return True
        return False

    def create(self, cr, uid, values, context=None):
        if not values.get('template_id'):
            defaults = self.default_get(cr, uid, ['template_id'], context=context)
            template_values = self.onchange_template_id(cr, uid, [], defaults.get('template_id'), partner=values.get('partner_id'), fiscal_position_id=values.get('fiscal_position'), context=context).get('value', {})
            values = dict(template_values, **values)
        return super(sale_order, self).create(cr, uid, values, context=context)
コード例 #28
0
class prestashop_backend(orm.Model):
    _name = 'prestashop.backend'
    _doc = 'Prestashop Backend'
    _inherit = 'connector.backend'

    _backend_type = 'prestashop'

    def _select_versions(self, cr, uid, context=None):
        """ Available versions

        Can be inherited to add custom versions.
        """
        return [('1.5', '1.5')]

    _columns = {
        'version':
        fields.selection(_select_versions, string='Version', required=True),
        'location':
        fields.char('Location'),
        'webservice_key':
        fields.char('Webservice key',
                    help="You have to put it in 'username' of the PrestaShop "
                    "Webservice api path invite"),
        'warehouse_id':
        fields.many2one(
            'stock.warehouse',
            'Warehouse',
            required=True,
            help='Warehouse used to compute the stock quantities.'),
        'taxes_included':
        fields.boolean("Use tax included prices"),
        'import_partners_since':
        fields.datetime('Import partners since'),
        'import_orders_since':
        fields.datetime('Import Orders since'),
        'import_products_since':
        fields.datetime('Import Products since'),
        'import_refunds_since':
        fields.datetime('Import Refunds since'),
        'import_suppliers_since':
        fields.datetime('Import Suppliers since'),
        'language_ids':
        fields.one2many('prestashop.res.lang', 'backend_id', 'Languages'),
        'company_id':
        fields.many2one('res.company', 'Company', select=1, required=True),
        'discount_product_id':
        fields.many2one('product.product',
                        'Dicount Product',
                        select=1,
                        required=False),
        'shipping_product_id':
        fields.many2one('product.product',
                        'Shipping Product',
                        select=1,
                        required=False),
    }

    _defaults = {
        'company_id':
        lambda s, cr, uid, c: s.pool.get('res.company')._company_default_get(
            cr, uid, 'prestashop.backend', context=c),
    }

    def synchronize_metadata(self, cr, uid, ids, context=None):
        if not hasattr(ids, '__iter__'):
            ids = [ids]
        session = ConnectorSession(cr, uid, context=context)
        for backend_id in ids:
            for model in ('prestashop.shop.group', 'prestashop.shop'):
                # import directly, do not delay because this
                # is a fast operation, a direct return is fine
                # and it is simpler to import them sequentially
                import_batch(session, model, backend_id)
        return True

    def synchronize_basedata(self, cr, uid, ids, context=None):
        if not hasattr(ids, '__iter__'):
            ids = [ids]
        session = ConnectorSession(cr, uid, context=context)
        for backend_id in ids:
            for model_name in [
                    'prestashop.res.lang',
                    'prestashop.res.country',
                    'prestashop.res.currency',
                    'prestashop.account.tax',
            ]:
                env = get_environment(session, model_name, backend_id)
                directBinder = env.get_connector_unit(DirectBinder)
                directBinder.run()

            import_batch(session, 'prestashop.account.tax.group', backend_id)
            import_batch(session, 'prestashop.sale.order.state', backend_id)
        return True

    def _date_as_user_tz(self, cr, uid, dtstr):
        if not dtstr:
            return None
        users_obj = self.pool.get('res.users')
        user = users_obj.browse(cr, uid, uid)
        timezone = pytz.timezone(user.partner_id.tz or 'utc')
        dt = datetime.strptime(dtstr, DEFAULT_SERVER_DATETIME_FORMAT)
        dt = pytz.utc.localize(dt)
        dt = dt.astimezone(timezone)
        return dt

    def import_customers_since(self, cr, uid, ids, context=None):
        if not hasattr(ids, '__iter__'):
            ids = [ids]
        session = ConnectorSession(cr, uid, context=context)
        for backend_record in self.browse(cr, uid, ids, context=context):
            since_date = self._date_as_user_tz(
                cr, uid, backend_record.import_partners_since)
            import_customers_since.delay(
                session,
                backend_record.id,
                since_date,
                priority=10,
            )

        return True

    def import_products(self, cr, uid, ids, context=None):
        if not hasattr(ids, '__iter__'):
            ids = [ids]
        session = ConnectorSession(cr, uid, context=context)
        for backend_record in self.browse(cr, uid, ids, context=context):
            since_date = self._date_as_user_tz(
                cr, uid, backend_record.import_products_since)
            import_products.delay(session,
                                  backend_record.id,
                                  since_date,
                                  priority=10)
        return True

    def import_carriers(self, cr, uid, ids, context=None):
        if not hasattr(ids, '__iter__'):
            ids = [ids]
        session = ConnectorSession(cr, uid, context=context)
        for backend_id in ids:
            import_carriers.delay(session, backend_id, priority=10)
        return True

    def update_product_stock_qty(self, cr, uid, ids, context=None):
        if not hasattr(ids, '__iter__'):
            ids = [ids]
        session = ConnectorSession(cr, uid, context=context)
        export_product_quantities.delay(session, ids)
        return True

    def import_stock_qty(self, cr, uid, ids, context=None):
        if not hasattr(ids, '__iter__'):
            ids = [ids]
        session = ConnectorSession(cr, uid, context=context)
        for backend_id in ids:
            import_inventory.delay(session, backend_id)

    def import_sale_orders(self, cr, uid, ids, context=None):
        if not hasattr(ids, '__iter__'):
            ids = [ids]
        session = ConnectorSession(cr, uid, context=context)
        for backend_record in self.browse(cr, uid, ids, context=context):
            since_date = self._date_as_user_tz(
                cr, uid, backend_record.import_orders_since)
            import_orders_since.delay(
                session,
                backend_record.id,
                since_date,
                priority=5,
            )
        return True

    def import_payment_methods(self, cr, uid, ids, context=None):
        if not hasattr(ids, '__iter__'):
            ids = [ids]
        session = ConnectorSession(cr, uid, context=context)
        for backend_record in self.browse(cr, uid, ids, context=context):
            import_batch.delay(session, 'payment.method', backend_record.id)
        return True

    def import_refunds(self, cr, uid, ids, context=None):
        if not hasattr(ids, '__iter__'):
            ids = [ids]
        session = ConnectorSession(cr, uid, context=context)
        for backend_record in self.browse(cr, uid, ids, context=context):
            since_date = self._date_as_user_tz(
                cr, uid, backend_record.import_refunds_since)
            import_refunds.delay(session, backend_record.id, since_date)
        return True

    def import_suppliers(self, cr, uid, ids, context=None):
        if not hasattr(ids, '__iter__'):
            ids = [ids]
        session = ConnectorSession(cr, uid, context=context)
        for backend_record in self.browse(cr, uid, ids, context=context):
            since_date = self._date_as_user_tz(
                cr, uid, backend_record.import_suppliers_since)
            import_suppliers.delay(session, backend_record.id, since_date)
        return True

    def _scheduler_launch(self, cr, uid, callback, domain=None, context=None):
        if domain is None:
            domain = []
        ids = self.search(cr, uid, domain, context=context)
        if ids:
            callback(cr, uid, ids, context=context)

    def _scheduler_update_product_stock_qty(self,
                                            cr,
                                            uid,
                                            domain=None,
                                            context=None):
        self._scheduler_launch(cr,
                               uid,
                               self.update_product_stock_qty,
                               domain=domain,
                               context=context)

    def _scheduler_import_sale_orders(self,
                                      cr,
                                      uid,
                                      domain=None,
                                      context=None):
        self._scheduler_launch(cr,
                               uid,
                               self.import_sale_orders,
                               domain=domain,
                               context=context)

    def _scheduler_import_customers(self, cr, uid, domain=None, context=None):
        self._scheduler_launch(cr,
                               uid,
                               self.import_customers_since,
                               domain=domain,
                               context=context)

    def _scheduler_import_products(self, cr, uid, domain=None, context=None):
        self._scheduler_launch(cr,
                               uid,
                               self.import_products,
                               domain=domain,
                               context=context)

    def _scheduler_import_carriers(self, cr, uid, domain=None, context=None):
        self._scheduler_launch(cr,
                               uid,
                               self.import_carriers,
                               domain=domain,
                               context=context)

    def _scheduler_import_payment_methods(self,
                                          cr,
                                          uid,
                                          domain=None,
                                          context=None):
        self._scheduler_launch(cr,
                               uid,
                               self.import_payment_methods,
                               domain=domain,
                               context=context)

    def _scheduler_import_refunds(self, cr, uid, domain=None, context=None):
        self._scheduler_launch(cr,
                               uid,
                               self.import_refunds,
                               domain=domain,
                               context=context)

    def _scheduler_import_suppliers(self, cr, uid, domain=None, context=None):
        self._scheduler_launch(cr,
                               uid,
                               self.import_suppliers,
                               domain=domain,
                               context=context)

    def import_record(self,
                      cr,
                      uid,
                      backend_id,
                      model_name,
                      ext_id,
                      context=None):
        session = ConnectorSession(cr, uid, context=context)
        import_record(session, model_name, backend_id, ext_id)
        return True
コード例 #29
0
class sale_devis(osv.osv):
    _name = "sale.devis"
    _description = "Sales Devis"
    _rec_name = 'reference'
    _order = "reference desc, id desc"

    def draft(self, cr, uid, ids):
        self.write(cr, uid, ids, {'state': 'draft'})
        return True

    def envoyer(self, cr, uid, ids, context):
        '''
           Methode du workflow: changer l'état du devis à l'état envoyé
        '''
        self.reset_taxes(cr, uid, ids, context)
        self.write(cr, uid, ids, {'state': 'sent'})
        return True

    def confirmer(self, cr, uid, ids, context):
        '''
           Methode du workflow: permet la confirmation du devis et la création du Bon de commande
        '''
        self.reset_taxes(cr, uid, ids, context)
        self.write(cr, uid, ids, {'state': 'confirmed'})

        return True

    def create(self, cr, uid, vals, context=None):
        vals['reference'] = self.pool.get('ir.sequence').get(
            cr, uid, 'sale.devis')

        new_id = super(sale_devis, self).create(cr, uid, vals, context=context)
        self.reset_taxes(cr, uid, [new_id], context)
        return new_id

    def action_view_order(self, cr, uid, ids, context=None):
        for devis in self.browse(cr, uid, ids):
            mod_obj = self.pool.get('ir.model.data')
            act_obj = self.pool.get('ir.actions.act_window')

            result = mod_obj.get_object_reference(cr, uid, 'sale',
                                                  'action_order_tree')
            id = result and result[1] or False
            result = act_obj.read(cr, uid, [id], context=context)[0]
            res = mod_obj.get_object_reference(cr, uid, 'sale',
                                               'view_order_form')
            result['views'] = [(res and res[1] or False, 'form')]
            cr.execute("select id from sale_order where devis_id = %s",
                       (devis.id, ))
            res = cr.dictfetchone()
            result['res_id'] = res['id']
            return result

    def _currency_get(self, cr, uid, context=None):
        ids = self.pool.get('res.currency').search(cr,
                                                   uid, [('name', '=', 'TND')],
                                                   context=context)
        return ids[0]

    @api.one
    @api.depends('devis_lines.price_subtotal', 'tax_lines.amount')
    def _amount_all(self):
        '''
           Methode qui calcule les montants suivants
           amount_untaxed
           amount_tax
           amount_total
           undiscount_total
           discount_total  
        '''
        print "partner_id.exone===", self.partner_id.exoner
        if self.partner_id.exoner:
            self.amount_tax = 0
        else:
            self.amount_tax = sum(line.amount for line in self.tax_lines)
        self.amount_untaxed = sum(line.price_subtotal
                                  for line in self.devis_lines)

        self.discount_total = sum((line.product_qty * line.price_unit *
                                   ((line.discount or 0.0) / 100.0))
                                  for line in self.devis_lines)
        self.undiscount_total = sum(line.product_qty * line.price_unit
                                    for line in self.devis_lines)
        self.amount_total = self.amount_untaxed + self.amount_tax

    _columns = {
        'reference':
        fields.char('Référence', size=64, readonly=True),
        'date':
        fields.datetime('Date', required=True),
        'partner_id':
        fields.many2one('res.partner',
                        'Client',
                        required=True,
                        domain="[('customer','=',True)]"),
        'company_id':
        fields.many2one('res.company', 'Company'),
        'currency_id':
        fields.many2one('res.currency', 'Devise', required=True),
        'devis_lines':
        fields.one2many('sale.devis.line', 'devis_id', 'Ligne de devis'),
        'tax_lines':
        fields.one2many(
            'sale.devis.taxe',
            'devis_id',
            'Lignes Tax',
        ),
        'discount_total':
        fields.float(string='Total Remise',
                     digits_compute=dp.get_precision('Account'),
                     store=True,
                     readonly=True,
                     compute='_amount_all',
                     track_visibility='always'),
        'undiscount_total':
        fields.float(string='Total HT sans remise',
                     digits_compute=dp.get_precision('Account'),
                     store=True,
                     readonly=True,
                     compute='_amount_all',
                     track_visibility='always'),
        'amount_untaxed':
        fields.float(string='Total HT',
                     digits_compute=dp.get_precision('Account'),
                     store=True,
                     readonly=True,
                     compute='_amount_all',
                     track_visibility='always'),
        'amount_tax':
        fields.float(string='Total Taxe',
                     digits_compute=dp.get_precision('Account'),
                     store=True,
                     readonly=True,
                     compute='_amount_all',
                     track_visibility='always'),
        'amount_total':
        fields.float(string='Total',
                     digits_compute=dp.get_precision('Account'),
                     store=True,
                     readonly=True,
                     compute='_amount_all',
                     track_visibility='always'),
        'state':
        fields.selection([('draft', 'Brouillon'), ('sent', 'Envoyé'),
                          ('confirmed', 'Confirmé')]),
        #'comment' : fields.char('comment', size=64),
        'note':
        fields.text(),
    }
    _defaults = {
        'state':
        'draft',
        'company_id':
        lambda self, cr, uid, c: self.pool.get('res.company').
        _company_default_get(cr, uid, 'procurement.order', context=c),
        'currency_id':
        _currency_get,
    }

    def button_reset_taxes(self, cr, uid, ids, context=None):
        '''
           Action du bouton reset Taxes
        '''
        self.reset_taxes(cr, uid, ids, context)
        return True

    def reset_taxes(self, cr, uid, ids, context=None):
        '''
           Methode qui permet de calculer et mettre à jour les lignes de taxes
        '''
        if context is None:
            context = {}
        ctx = context.copy()
        ait_obj = self.pool.get('sale.devis.taxe')
        for id in ids:
            partner = self.browse(cr, uid, id, context=ctx).partner_id
            if partner.lang:
                cr.execute("DELETE FROM sale_devis_taxe WHERE devis_id=%s",
                           (id, ))
                ctx.update({'lang': partner.lang})
            for taxe in ait_obj.compute(cr, uid, id, context=ctx).values():
                ait_obj.create(cr, uid, taxe)
        return True
コード例 #30
0
    def _default_location(self, cr, uid, ids, context=None):
        try:
            loc_model, location_id = self.pool.get("ir.model.data").get_object_reference(
                cr, uid, "stock", "stock_location_stock"
            )
        except ValueError, e:
            return False
        return location_id or False

    _columns = {
        "location_id": fields.many2one("stock.location", "Location", required=True),
        "import_file": fields.binary("File", filters="*.xls"),
        # to consider the product current inventory or not, if yes then add the current inventory to the upload excel quantity as the quantity to do physical inventory
        "consider_inventory": fields.boolean("Consider Current Inventory", select=True),
        "all_done": fields.boolean("All Data Imported", readonly=True, select=True),
        "result_line": fields.one2many("stock.import.inventory.result", "import_id", "Importing Result", readonly=True),
    }
    _defaults = {"location_id": _default_location}

    def view_init(self, cr, uid, fields_list, context=None):
        """
         Creates view dynamically and adding fields at runtime.
         @param self: The object pointer.
         @param cr: A database cursor
         @param uid: ID of the user currently logged in
         @param context: A standard dictionary
         @return: New arch of view with new columns.
        """
        if context is None:
            context = {}
        super(stock_import_inventory, self).view_init(cr, uid, fields_list, context=context)
コード例 #31
0
ファイル: product.py プロジェクト: eLBati/odoo_modules
class product_ebay(osv.osv):
    _inherit = "product.template"

    _columns = {
        'copies':
        fields.char(string="NoOfCopies"),
        'ebay_oem_code':
        fields.char(string="EbayOEM-obsolete"),
        'with_chip':
        fields.boolean(string="With chip"),
        'ebay_sync':
        fields.boolean(string="Sync with ebay"),
        'ebay_id':
        fields.one2many('ebay.ids', 'product_id', string="Ebay_ids"),
        'ebay_date_added':
        fields.datetime(string="Added to Ebay"),
        'ebay_price':
        fields.float(string="Ebay price"),
        'ebay_template_id':
        fields.many2one('ebay.template'),
        'ebay_item_location':
        fields.char(string="Ebay postal"),
        'ebay_payment_instruction':
        fields.text(string="Ebay payment instructions"),
        'ebay_shipping_cost':
        fields.float(string="Ebay shipping cost"),
        'ebay_additional_item_cost':
        fields.float(string="Ebay add. shipping cost"),
        'ebay_free_shipping':
        fields.boolean(string="Ebay free shipping"),
        'ebay_extra_name':
        fields.char(string="Ebay extra att name"),
        'ebay_extra_value':
        fields.char(string="Ebay extra att value"),
        'main_name_part':
        fields.char(string="Ebay main name part"),
        'name_parts':
        fields.one2many('ebay.name.parts', 'np_id'),
        'stock_limit':
        fields.integer(default=5, string="Ebay stock limit"),
        'ebay_listing_duration':
        fields.selection((('Days_7', '7 days'), ('Days_30', '30 days'),
                          ('GTC', 'Good `Till Canceled')),
                         string="Ebay listing duration"),
        'ebay_custom_desc':
        fields.text(string="Custom description"),
        'ebay_force_shipping_cost':
        fields.boolean(string="Use this shipping cost")
    }

    def export_now(self, cr, uid, ids, context=None):
        self.pool.get('ebay').export_products(cr,
                                              uid,
                                              ids,
                                              product_id=ids,
                                              context=None)

    def remove_product(self, cr, uid, ids, context=None):
        self.pool.get('ebay').remove_product(cr, uid, ids, context=None)

    def open_on_ebay(self, cr, uid, ids, context=None):
        #This opens link for product on ebay
        product = self.browse(cr, uid, ids, context=context)
        product = product[0]
        ebay_ids = [x.ebay_id for x in product.ebay_ids]
        if ebay_ids:
            for e in ebay_ids:
                url = 'http://cgi.ebay.it/ws/eBayISAPI.dll?ViewItem&item=%s' % str(
                    e)
                webbrowser.open(url, new=2, autoraise=True)

    def set_price(self, cr, uid, ids, context=None):

        for record in self.browse(cr, uid, ids, context=context):
            ebay_price = record.list_price - 0.1
            record.ebay_price = ebay_price

        return True

    def divide_name(self, cr, uid, ids, context=None):
        current_record = None
        for record in self.browse(cr, uid, ids, context=context):
            current_record = record

        desc = current_record.description

        if len(desc) <= 80:
            return True

        split = desc.split('FOR ')
        main = split[0] + 'FOR '
        rest = ''

        for x in range(1, len(split)):
            rest += split[x]

        others = rest.split(',')

        parts = []
        line = ''

        current_record.main_name_part = main

        for y in range(0, len(others)):
            if (len(line) + len(others[y])) < (80 - len(main)):
                if (len(line) > 0):
                    line += ", "
                line += others[y]
                if y == len(others) - 1:
                    parts.append(line)
            else:
                parts.append(line)
                line = ''

        for p in parts:
            if (p[0] == ' '):
                p = p.replace(p[0], '')

            pro_id = current_record.id
            self.pool.get('ebay.name.parts').create(cr, uid, {
                'np_id': pro_id,
                'name': p
            })

        return True
コード例 #32
0
        return val
    
    STATE_SELECTION = [
        ('draft', 'New'),    
        ('open', 'Accepted'),
        ('cancel', 'Refused'),
        ('close', 'Done')
    ]
            
    _name='devil.formulas'
    _description='Formula Calculation'
    _columns={
              'name': fields.char('Transaction Code',size=124),
              'date': fields.date('Transaction Date'),
              'cust_id': fields.many2one('devil.customer','Customer'),
              'formula_line': fields.one2many('devil.items.lines','formula_id','FormulaLines'),
<<<<<<< HEAD
              'total_amt_disc': fields.float('Amount Discount', required=True, ),
=======
>>>>>>> 08375b10183304dea2ebfe2187b2858b17177cbb
              'total_amount': fields.function(_amount_all, string='TotalAmount'),
              'state': fields.selection(STATE_SELECTION, 'Status', readonly=True, select=True),
    }
    _defaults = {
        'state': lambda *a: 'draft',
    }
    
    def button_dummy(self, cr, uid, ids, context=None):
        return True
    
    
コード例 #33
0
class change_account_move_line_wizard(TransientModel):
    _name = 'change.account.move.line.wizard'
    _description = 'Wizard to manage move of move lines'

    def default_get(self, cr, uid, fields, context):
        res = super(change_account_move_line_wizard,
                    self).default_get(cr, uid, fields, context=context)
        account = self.pool.get('account.account').browse(cr,
                                                          uid,
                                                          context['active_id'],
                                                          context=context)
        # Get move line without partners per company
        partners = []
        sql_req = """
                SELECT company_id, count(*) as quantity
                FROM account_move_line
                WHERE partner_id is NULL
                AND account_id = %s
                group by company_id
                """ % (account.id)
        cr.execute(sql_req)
        for item in cr.fetchall():
            partners.append((0, 0, {
                'company_id': item[0],
                'move_number': item[1],
                'partner_id': False,
            }))

        res.update({
            'source_account_id': account.id,
            'source_company_id': account.company_id.id,
            'source_type': account.type,
            'source_move_number': account.move_number,
            'source_reconciled_move_number': account.reconciled_move_number,
            'source_closed_period_move_number':
            account.closed_period_move_number,
            'source_invoice_number': account.invoice_number,
            'source_voucher_line_number': account.voucher_line_number,
            'line_ids': partners,
        })
        return res

    # --- Columns
    _columns = {
        'source_account_id':
        fields.many2one('account.account',
                        'Source account',
                        domain=[('type', '=', 'view')],
                        readonly=True),
        'source_company_id':
        fields.many2one('res.company',
                        'Company of the source account',
                        readonly=True),
        'source_type':
        fields.char('Type of the source account', readonly=True),
        'source_move_number':
        fields.integer('Number of moves in the source account', readonly=True),
        'source_invoice_number':
        fields.integer('Number of invoices in the source account',
                       readonly=True),
        'source_voucher_line_number':
        fields.integer('Number of voucher line in the source account',
                       readonly=True),
        'source_reconciled_move_number':
        fields.integer('Number of reconciled moves in the source account',
                       readonly=True),
        'source_closed_period_move_number':
        fields.integer('Number of moves in closed periods', readonly=True),
        'destination_account_id':
        fields.many2one('account.account',
                        'Destination account',
                        required=True,
                        domain=[('type', '!=', 'view')]),
        'destination_company_id':
        fields.many2one('res.company',
                        'Company of the destination account',
                        readonly=True),
        'destination_type':
        fields.char('Type of the destination account', readonly=True),
        'destination_move_number':
        fields.integer('Number of moves in the destination account',
                       readonly=True),
        'change_view_type':
        fields.boolean('Change source account in view type'),
        'line_ids':
        fields.one2many('change.account.move.line.wizard.line', 'wizard_id',
                        'Partners list'),
    }

    def onchange_destination_account_id(self, cr, uid, ids,
                                        destination_account_id,
                                        destination_company_id,
                                        destination_type,
                                        destination_move_number, context):
        if destination_account_id:
            account = self.pool.get('account.account').browse(
                cr, uid, destination_account_id, context=context)
            return {
                'value': {
                    'destination_company_id': account.company_id.id,
                    'destination_type': account.type,
                    'destination_move_number': account.move_number,
                }
            }
        else:
            return {
                'value': {
                    'destination_company_id': None,
                    'destination_type': None,
                    'destination_move_number': None,
                }
            }
        return {}

    def button_change_move_line(self, cr, uid, ids, context=None):
        aa_obj = self.pool.get('account.account')
        ai_obj = self.pool.get('account.invoice')
        am_obj = self.pool.get('account.move')
        aml_obj = self.pool.get('account.move.line')
        ap_obj = self.pool.get('account.period')
        avl_obj = self.pool.get('account.voucher.line')
        reconcile_infos = {}
        close_period_infos = []
        for data in self.browse(cr, uid, ids, context=context):
            # check constraint
            if not (data.source_account_id.company_id.id !=
                    data.destination_account_id.company_id.id):
                assert 'Incorrect request', _(
                    'Source and destination account must be belong to the same company.'
                )

            # Select all account_move_line to change
            aml_ids = aml_obj.search(
                cr,
                uid, [
                    ('account_id', '=', data.source_account_id.id),
                ],
                context=context)

            # Select all account_invoice to change
            ai_ids = ai_obj.search(
                cr,
                uid, [
                    ('account_id', '=', data.source_account_id.id),
                ],
                context=context)

            # Select all account_invoice to change
            avl_ids = avl_obj.search(
                cr,
                uid, [
                    ('account_id', '=', data.source_account_id.id),
                ],
                context=context)
            print avl_ids

            if aml_ids:
                # Search reconciled move lines
                aml_reconcile_ids = aml_obj.search(
                    cr,
                    uid, [
                        ('account_id', '=', data.source_account_id.id),
                        ('reconcile_id', '!=', False),
                    ],
                    context=context)

                # Select all account_move associated to set them in draft state
                cr.execute(
                    "SELECT distinct(move_id) FROM account_move_line WHERE id in (%s)"
                    % (str(aml_ids).strip('[]'), ))
                move_ids = [r[0] for r in cr.fetchall()]

                # backup reconcile information
                for aml in aml_obj.browse(cr,
                                          uid,
                                          aml_reconcile_ids,
                                          context=context):
                    reconcile_infos[aml.id] = aml.reconcile_id.id

                # Redo reconcile
                aml_obj.write(cr,
                              uid,
                              aml_reconcile_ids, {
                                  'reconcile_id': False,
                              },
                              context=context)

                # Backup periods
                cr.execute("""
                    SELECT distinct(period_id) 
                    FROM account_move_line aml 
                    INNER JOIN account_period ap ON aml.period_id =ap.id 
                    WHERE aml.id in (%s) 
                    AND ap.state in ('done')
                    """ % (str(aml_ids).strip('[]'), ))
                close_period_infos = [r[0] for r in cr.fetchall()]

                # Open Closed periods
                if close_period_infos:
                    ap_obj.action_draft(cr, uid, close_period_infos)

                # Cancel all account_move associated
                am_obj.button_cancel(cr, uid, move_ids, context=context)

                # Change account_move_line account
                aml_obj.write(cr,
                              uid,
                              aml_ids, {
                                  'account_id': data.destination_account_id.id,
                              },
                              context=context)

                # Change account_move_line partner, if it not set
                for line_id in data.line_ids:
                    aml_partner_ids = aml_obj.search(
                        cr,
                        uid, [
                            ('id', 'in', aml_ids),
                            ('partner_id', '=', False),
                            ('company_id', '=', line_id.company_id.id),
                        ],
                        context=context)
                    aml_obj.write(cr,
                                  uid,
                                  aml_partner_ids, {
                                      'partner_id': line_id.partner_id.id,
                                  },
                                  context=context)

                # Validate again all account_move associated
                am_obj.button_validate(cr, uid, move_ids, context=context)

                # Redo reconcile
                for aml_reconcile_id in aml_reconcile_ids:
                    aml_obj.write(
                        cr,
                        uid,
                        aml_reconcile_id, {
                            'reconcile_id': reconcile_infos[aml_reconcile_id],
                        },
                        context=context)

                # Close periods
                # NOTA : A function doesn't exist to do that. (except in a transient model)
                if close_period_infos:
                    mode = 'done'
                    cr.execute(
                        'update account_journal_period set state=%s where period_id in %s',
                        (
                            mode,
                            tuple(close_period_infos),
                        ))
                    cr.execute(
                        'update account_period set state=%s where id in %s', (
                            mode,
                            tuple(close_period_infos),
                        ))

            if ai_ids:
                # change account_invoice account
                ai_obj.write(cr,
                             uid,
                             ai_ids, {
                                 'account_id': data.destination_account_id.id,
                             },
                             context=context)

            if avl_ids:
                print avl_ids
                # change account_voucher_line account
                avl_obj.write(cr,
                              uid,
                              avl_ids, {
                                  'account_id': data.destination_account_id.id,
                              },
                              context=context)

            # (Optional) change type of the source account
            if data.change_view_type:
                aa_obj.write(cr,
                             uid, [data.source_account_id.id], {
                                 'type': 'view',
                             },
                             context=context)

        return {}
コード例 #34
0
ファイル: rent.py プロジェクト: allanwong/openerp-rent
    _columns = {
        'name': fields.text('Description', required=True, readonly=True, states={'draft': [('readonly', False)]}),
        'order_id': fields.many2one('rent.order', 'Rent Reference', required=True, ondelete='cascade', select=True, readonly=True, states={'draft':[('readonly',False)]}),
        'sequence': fields.integer('Sequence'),
        'product_id': fields.many2one('product.product', 'Product', domain=[('is_rent', '=', True)], change_default=True),
        'invoice_lines': fields.many2many('account.invoice.line', 'rent_order_line_invoice_rel', 'order_line_id', 'invoice_id', 'Invoice Lines', readonly=True),
        'price_unit': fields.float('Unit Price', required=True, digits_compute= dp.get_precision('Product Price'), readonly=True, states={'draft': [('readonly', False)]}),
        'price_subtotal': fields.function(_amount_line, string='Subtotal', digits_compute= dp.get_precision('Account')),
        'tax_id': fields.many2many('account.tax', 'rent_order_tax', 'order_line_id', 'tax_id', 'Taxes', readonly=True, states={'draft': [('readonly', False)]}),
        'product_uom_qty': fields.float('Quantity', digits_compute= dp.get_precision('Product Unit of Measure'), required=True, readonly=True, states={'draft': [('readonly', False)]}),
        'product_uom': fields.many2one('product.uom', 'Unit of Measure ', required=True, readonly=True, states={'draft': [('readonly', False)]}),
        'product_uos_qty': fields.float('Quantity (UoS)' ,digits_compute= dp.get_precision('Product UoS'), readonly=True, states={'draft': [('readonly', False)]}),
        'product_uos': fields.many2one('product.uom', 'Product UoS'),
        'product_rent_qty': fields.function(_product_rent_qty, string='Rent Quantity', digits_compute= dp.get_precision('Product UoS')),
        'th_weight': fields.float('Weight', readonly=True, states={'draft': [('readonly', False)]}),
        'move_ids': fields.one2many('stock.move', 'rent_line_id', 'Inventory Moves', readonly=True),
        'state': fields.selection([
            ('draft', 'Draft'),
            ('cancel', 'Cancelled'),
            ('confirmed', 'Waiting Approval'),
            ('accepted', 'Approved'),
            ('returned', 'Returned'),
            ('done', 'Done'),
            ], 'Status', required=True, readonly=True),
        'order_partner_id': fields.related('order_id', 'partner_id', type='many2one', relation='res.partner', store=True, string='Customer'),
        'salesman_id':fields.related('order_id', 'user_id', type='many2one', relation='res.users', store=True, string='Salesperson'),
        'company_id': fields.related('order_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True),
    }

    _order = 'order_id desc, sequence, id'
コード例 #35
0
class sale_order(osv.osv):
    _inherit = "sale.order"

    def copy(self, cr, uid, id, default=None, context=None):
        if not default:
            default = {}
        default.update({
            'shipped': False,
            'picking_ids': [],
        })
        return super(sale_order, self).copy(cr,
                                            uid,
                                            id,
                                            default,
                                            context=context)

    def shipping_policy_change(self, cr, uid, ids, policy, context=None):
        if not policy:
            return {}
        inv_qty = 'order'
        if policy == 'prepaid':
            inv_qty = 'order'
        elif policy == 'picking':
            inv_qty = 'procurement'
        return {'value': {'invoice_quantity': inv_qty}}

    def write(self, cr, uid, ids, vals, context=None):
        if vals.get('order_policy', False):
            if vals['order_policy'] == 'prepaid':
                vals.update({'invoice_quantity': 'order'})
            elif vals['order_policy'] == 'picking':
                vals.update({'invoice_quantity': 'procurement'})
        return super(sale_order, self).write(cr,
                                             uid,
                                             ids,
                                             vals,
                                             context=context)

    def create(self, cr, uid, vals, context=None):
        if vals.get('order_policy', False):
            if vals['order_policy'] == 'prepaid':
                vals.update({'invoice_quantity': 'order'})
            if vals['order_policy'] == 'picking':
                vals.update({'invoice_quantity': 'procurement'})
        order = super(sale_order, self).create(cr, uid, vals, context=context)
        return order

    # This is False
    def _picked_rate(self, cr, uid, ids, name, arg, context=None):
        if not ids:
            return {}
        res = {}
        tmp = {}
        for id in ids:
            tmp[id] = {'picked': 0.0, 'total': 0.0}
        cr.execute(
            '''SELECT
                p.sale_id as sale_order_id, sum(m.product_qty) as nbr, mp.state as procurement_state, m.state as move_state, p.type as picking_type
            FROM
                stock_move m
            LEFT JOIN
                stock_picking p on (p.id=m.picking_id)
            LEFT JOIN
                procurement_order mp on (mp.move_id=m.id)
            WHERE
                p.sale_id IN %s GROUP BY m.state, mp.state, p.sale_id, p.type''',
            (tuple(ids), ))

        for item in cr.dictfetchall():
            if item['move_state'] == 'cancel':
                continue

            if item['picking_type'] == 'in':  #this is a returned picking
                tmp[item['sale_order_id']]['total'] -= item[
                    'nbr'] or 0.0  # Deducting the return picking qty
                if item['procurement_state'] == 'done' or item[
                        'move_state'] == 'done':
                    tmp[item['sale_order_id']]['picked'] -= item['nbr'] or 0.0
            else:
                tmp[item['sale_order_id']]['total'] += item['nbr'] or 0.0
                if item['procurement_state'] == 'done' or item[
                        'move_state'] == 'done':
                    tmp[item['sale_order_id']]['picked'] += item['nbr'] or 0.0

        for order in self.browse(cr, uid, ids, context=context):
            if order.shipped:
                res[order.id] = 100.0
            else:
                res[order.id] = tmp[order.id]['total'] and (
                    100.0 * tmp[order.id]['picked'] /
                    tmp[order.id]['total']) or 0.0
        return res

    _columns = {
        'state':
        fields.selection(
            [
                ('draft', 'Draft Quotation'),
                ('sent', 'Quotation Sent'),
                ('cancel', 'Cancelled'),
                ('waiting_date', 'Waiting Schedule'),
                ('progress', 'Sales Order'),
                ('manual', 'Sale to Invoice'),
                ('shipping_except', 'Shipping Exception'),
                ('invoice_except', 'Invoice Exception'),
                ('done', 'Done'),
            ],
            'Status',
            readonly=True,
            help="Gives the status of the quotation or sales order.\
              \nThe exception status is automatically set when a cancel operation occurs \
              in the invoice validation (Invoice Exception) or in the picking list process (Shipping Exception).\nThe 'Waiting Schedule' status is set when the invoice is confirmed\
               but waiting for the scheduler to run on the order date.",
            select=True),
        'incoterm':
        fields.many2one(
            'stock.incoterms',
            'Incoterm',
            help=
            "International Commercial Terms are a series of predefined commercial terms used in international transactions."
        ),
        'picking_policy':
        fields.selection(
            [('direct', 'Deliver each product when available'),
             ('one', 'Deliver all products at once')],
            'Shipping Policy',
            required=True,
            readonly=True,
            states={
                'draft': [('readonly', False)],
                'sent': [('readonly', False)]
            },
            help=
            """Pick 'Deliver each product when available' if you allow partial delivery."""
        ),
        'order_policy':
        fields.selection(
            [
                ('manual', 'On Demand'),
                ('picking', 'On Delivery Order'),
                ('prepaid', 'Before Delivery'),
            ],
            'Create Invoice',
            required=True,
            readonly=True,
            states={
                'draft': [('readonly', False)],
                'sent': [('readonly', False)]
            },
            help=
            """On demand: A draft invoice can be created from the sales order when needed. \nOn delivery order: A draft invoice can be created from the delivery order when the products have been delivered. \nBefore delivery: A draft invoice is created from the sales order and must be paid before the products can be delivered."""
        ),
        'picking_ids':
        fields.one2many(
            'stock.picking.out',
            'sale_id',
            'Related Picking',
            readonly=True,
            help=
            "This is a list of delivery orders that has been generated for this sales order."
        ),
        'shipped':
        fields.boolean(
            'Delivered',
            readonly=True,
            help=
            "It indicates that the sales order has been delivered. This field is updated only after the scheduler(s) have been launched."
        ),
        'picked_rate':
        fields.function(_picked_rate, string='Picked', type='float'),
        'invoice_quantity':
        fields.selection(
            [('order', 'Ordered Quantities'),
             ('procurement', 'Shipped Quantities')],
            'Invoice on',
            help=
            "The sales order will automatically create the invoice proposition (draft invoice).\
                                              You have to choose  if you want your invoice based on ordered ",
            required=True,
            readonly=True,
            states={'draft': [('readonly', False)]}),
    }
    _defaults = {
        'picking_policy': 'direct',
        'order_policy': 'manual',
        'invoice_quantity': 'order',
    }

    # Form filling
    def unlink(self, cr, uid, ids, context=None):
        sale_orders = self.read(cr, uid, ids, ['state'], context=context)
        unlink_ids = []
        for s in sale_orders:
            if s['state'] in ['draft', 'cancel']:
                unlink_ids.append(s['id'])
            else:
                raise osv.except_osv(
                    _('Invalid Action!'),
                    _('In order to delete a confirmed sales order, you must cancel it.\nTo do so, you must first cancel related picking for delivery orders.'
                      ))

        return osv.osv.unlink(self, cr, uid, unlink_ids, context=context)

    def action_view_delivery(self, cr, uid, ids, context=None):
        '''
        This function returns an action that display existing delivery orders of given sales order ids. It can either be a in a list or in a form view, if there is only one delivery order to show.
        '''
        mod_obj = self.pool.get('ir.model.data')
        act_obj = self.pool.get('ir.actions.act_window')

        result = mod_obj.get_object_reference(cr, uid, 'stock',
                                              'action_picking_tree')
        id = result and result[1] or False
        result = act_obj.read(cr, uid, [id], context=context)[0]
        #compute the number of delivery orders to display
        pick_ids = []
        for so in self.browse(cr, uid, ids, context=context):
            pick_ids += [picking.id for picking in so.picking_ids]
        #choose the view_mode accordingly
        if len(pick_ids) > 1:
            result['domain'] = "[('id','in',[" + ','.join(map(
                str, pick_ids)) + "])]"
        else:
            res = mod_obj.get_object_reference(cr, uid, 'stock',
                                               'view_picking_out_form')
            result['views'] = [(res and res[1] or False, 'form')]
            result['res_id'] = pick_ids and pick_ids[0] or False
        return result

    def action_invoice_create(self,
                              cr,
                              uid,
                              ids,
                              grouped=False,
                              states=['confirmed', 'done', 'exception'],
                              date_invoice=False,
                              context=None):
        picking_obj = self.pool.get('stock.picking')
        res = super(sale_order,
                    self).action_invoice_create(cr,
                                                uid,
                                                ids,
                                                grouped=grouped,
                                                states=states,
                                                date_invoice=date_invoice,
                                                context=context)
        for order in self.browse(cr, uid, ids, context=context):
            if order.order_policy == 'picking':
                picking_obj.write(cr, uid,
                                  map(lambda x: x.id, order.picking_ids),
                                  {'invoice_state': 'invoiced'})
        return res

    def action_cancel(self, cr, uid, ids, context=None):
        wf_service = netsvc.LocalService("workflow")
        if context is None:
            context = {}
        sale_order_line_obj = self.pool.get('sale.order.line')
        proc_obj = self.pool.get('procurement.order')
        for sale in self.browse(cr, uid, ids, context=context):
            for pick in sale.picking_ids:
                if pick.state not in ('draft', 'cancel'):
                    raise osv.except_osv(
                        _('Cannot cancel sales order!'),
                        _('You must first cancel all delivery order(s) attached to this sales order.'
                          ))
                if pick.state == 'cancel':
                    for mov in pick.move_lines:
                        proc_ids = proc_obj.search(cr, uid,
                                                   [('move_id', '=', mov.id)])
                        if proc_ids:
                            for proc in proc_ids:
                                wf_service.trg_validate(
                                    uid, 'procurement.order', proc,
                                    'button_check', cr)
            for r in self.read(cr, uid, ids, ['picking_ids']):
                for pick in r['picking_ids']:
                    wf_service.trg_validate(uid, 'stock.picking', pick,
                                            'button_cancel', cr)
        return super(sale_order, self).action_cancel(cr,
                                                     uid,
                                                     ids,
                                                     context=context)

    def action_wait(self, cr, uid, ids, context=None):
        res = super(sale_order, self).action_wait(cr,
                                                  uid,
                                                  ids,
                                                  context=context)
        for o in self.browse(cr, uid, ids):
            noprod = self.test_no_product(cr, uid, o, context)
            if noprod and o.order_policy == 'picking':
                self.write(cr,
                           uid, [o.id], {'order_policy': 'manual'},
                           context=context)
        return res

    def procurement_lines_get(self, cr, uid, ids, *args):
        res = []
        for order in self.browse(cr, uid, ids, context={}):
            for line in order.order_line:
                if line.procurement_id:
                    res.append(line.procurement_id.id)
        return res

    def date_to_datetime(self, cr, uid, userdate, context=None):
        """ Convert date values expressed in user's timezone to
        server-side UTC timestamp, assuming a default arbitrary
        time of 12:00 AM - because a time is needed.
    
        :param str userdate: date string in in user time zone
        :return: UTC datetime string for server-side use
        """
        # TODO: move to fields.datetime in server after 7.0
        user_date = datetime.strptime(userdate, DEFAULT_SERVER_DATE_FORMAT)
        if context and context.get('tz'):
            tz_name = context['tz']
        else:
            tz_name = self.pool.get('res.users').read(cr, SUPERUSER_ID, uid,
                                                      ['tz'])['tz']
        if tz_name:
            utc = pytz.timezone('UTC')
            context_tz = pytz.timezone(tz_name)
            user_datetime = user_date + relativedelta(hours=12.0)
            local_timestamp = context_tz.localize(user_datetime, is_dst=False)
            user_datetime = local_timestamp.astimezone(utc)
            return user_datetime.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
        return user_date.strftime(DEFAULT_SERVER_DATETIME_FORMAT)

    # if mode == 'finished':
    #   returns True if all lines are done, False otherwise
    # if mode == 'canceled':
    #   returns True if there is at least one canceled line, False otherwise
    def test_state(self, cr, uid, ids, mode, *args):
        assert mode in ('finished',
                        'canceled'), _("invalid mode for test_state")
        finished = True
        canceled = False
        write_done_ids = []
        write_cancel_ids = []
        for order in self.browse(cr, uid, ids, context={}):
            for line in order.order_line:
                if (not line.procurement_id) or (line.procurement_id.state
                                                 == 'done'):
                    if line.state != 'done':
                        write_done_ids.append(line.id)
                else:
                    finished = False
                if line.procurement_id:
                    if (line.procurement_id.state == 'cancel'):
                        canceled = True
                        if line.state != 'exception':
                            write_cancel_ids.append(line.id)
        if write_done_ids:
            self.pool.get('sale.order.line').write(cr, uid, write_done_ids,
                                                   {'state': 'done'})
        if write_cancel_ids:
            self.pool.get('sale.order.line').write(cr, uid, write_cancel_ids,
                                                   {'state': 'exception'})

        if mode == 'finished':
            return finished
        elif mode == 'canceled':
            return canceled

    def _prepare_order_line_procurement(self,
                                        cr,
                                        uid,
                                        order,
                                        line,
                                        move_id,
                                        date_planned,
                                        context=None):
        return {
            'name': line.name,
            'origin': order.name,
            'date_planned': date_planned,
            'product_id': line.product_id.id,
            'product_qty': line.product_uom_qty,
            'product_uom': line.product_uom.id,
            'product_uos_qty': (line.product_uos and line.product_uos_qty)\
                    or line.product_uom_qty,
            'product_uos': (line.product_uos and line.product_uos.id)\
                    or line.product_uom.id,
            'location_id': order.shop_id.warehouse_id.lot_stock_id.id,
            'procure_method': line.product_id.procure_method,
            'move_id': move_id,
            'company_id': order.company_id.id,
            'note': line.name,
        }

    def _prepare_order_line_move(self,
                                 cr,
                                 uid,
                                 order,
                                 line,
                                 picking_id,
                                 date_planned,
                                 context=None):
        location_id = order.shop_id.warehouse_id.lot_stock_id.id
        output_id = order.shop_id.warehouse_id.lot_output_id.id
        return {
            'name': line.name,
            'picking_id': picking_id,
            'product_id': line.product_id.id,
            'date': date_planned,
            'date_expected': date_planned,
            'product_qty': line.product_uom_qty,
            'product_uom': line.product_uom.id,
            'product_uos_qty': (line.product_uos and line.product_uos_qty) or line.product_uom_qty,
            'product_uos': (line.product_uos and line.product_uos.id)\
                    or line.product_uom.id,
            'product_packaging': line.product_packaging.id,
            'partner_id': line.address_allotment_id.id or order.partner_shipping_id.id,
            'location_id': location_id,
            'location_dest_id': output_id,
            'sale_line_id': line.id,
            'tracking_id': False,
            'state': 'draft',
            #'state': 'waiting',
            'company_id': order.company_id.id,
            'price_unit': line.product_id.standard_price or 0.0
        }

    def _prepare_order_picking(self, cr, uid, order, context=None):
        pick_name = self.pool.get('ir.sequence').get(cr, uid,
                                                     'stock.picking.out')
        return {
            'name': pick_name,
            'origin': order.name,
            'date': self.date_to_datetime(cr, uid, order.date_order, context),
            'type': 'out',
            'state': 'auto',
            'move_type': order.picking_policy,
            'sale_id': order.id,
            'partner_id': order.partner_shipping_id.id,
            'note': order.note,
            'invoice_state': (order.order_policy == 'picking' and '2binvoiced')
            or 'none',
            'company_id': order.company_id.id,
        }

    def ship_recreate(self, cr, uid, order, line, move_id, proc_id):
        # FIXME: deals with potentially cancelled shipments, seems broken (specially if shipment has production lot)
        """
        Define ship_recreate for process after shipping exception
        param order: sales order to which the order lines belong
        param line: sales order line records to procure
        param move_id: the ID of stock move
        param proc_id: the ID of procurement
        """
        move_obj = self.pool.get('stock.move')
        if order.state == 'shipping_except':
            for pick in order.picking_ids:
                for move in pick.move_lines:
                    if move.state == 'cancel':
                        mov_ids = move_obj.search(
                            cr, uid, [('state', '=', 'cancel'),
                                      ('sale_line_id', '=', line.id),
                                      ('picking_id', '=', pick.id)])
                        if mov_ids:
                            for mov in move_obj.browse(cr, uid, mov_ids):
                                # FIXME: the following seems broken: what if move_id doesn't exist? What if there are several mov_ids? Shouldn't that be a sum?
                                move_obj.write(
                                    cr, uid, [move_id], {
                                        'product_qty': mov.product_qty,
                                        'product_uos_qty': mov.product_uos_qty
                                    })
                                self.pool.get('procurement.order').write(
                                    cr, uid, [proc_id], {
                                        'product_qty': mov.product_qty,
                                        'product_uos_qty': mov.product_uos_qty
                                    })
        return True

    def _get_date_planned(self,
                          cr,
                          uid,
                          order,
                          line,
                          start_date,
                          context=None):
        start_date = self.date_to_datetime(cr, uid, start_date, context)
        date_planned = datetime.strptime(
            start_date, DEFAULT_SERVER_DATETIME_FORMAT) + relativedelta(
                days=line.delay or 0.0)
        date_planned = (date_planned -
                        timedelta(days=order.company_id.security_lead)
                        ).strftime(DEFAULT_SERVER_DATETIME_FORMAT)
        return date_planned

    def _create_pickings_and_procurements(self,
                                          cr,
                                          uid,
                                          order,
                                          order_lines,
                                          picking_id=False,
                                          context=None):
        """Create the required procurements to supply sales order lines, also connecting
        the procurements to appropriate stock moves in order to bring the goods to the
        sales order's requested location.

        If ``picking_id`` is provided, the stock moves will be added to it, otherwise
        a standard outgoing picking will be created to wrap the stock moves, as returned
        by :meth:`~._prepare_order_picking`.

        Modules that wish to customize the procurements or partition the stock moves over
        multiple stock pickings may override this method and call ``super()`` with
        different subsets of ``order_lines`` and/or preset ``picking_id`` values.

        :param browse_record order: sales order to which the order lines belong
        :param list(browse_record) order_lines: sales order line records to procure
        :param int picking_id: optional ID of a stock picking to which the created stock moves
                               will be added. A new picking will be created if ommitted.
        :return: True
        """
        move_obj = self.pool.get('stock.move')
        picking_obj = self.pool.get('stock.picking')
        procurement_obj = self.pool.get('procurement.order')
        proc_ids = []

        for line in order_lines:
            if line.state == 'done':
                continue

            date_planned = self._get_date_planned(cr,
                                                  uid,
                                                  order,
                                                  line,
                                                  order.date_order,
                                                  context=context)

            if line.product_id:
                if line.product_id.type in ('product', 'consu'):
                    if not picking_id:
                        picking_id = picking_obj.create(
                            cr, uid,
                            self._prepare_order_picking(cr,
                                                        uid,
                                                        order,
                                                        context=context))
                    move_id = move_obj.create(
                        cr, uid,
                        self._prepare_order_line_move(cr,
                                                      uid,
                                                      order,
                                                      line,
                                                      picking_id,
                                                      date_planned,
                                                      context=context))
                else:
                    # a service has no stock move
                    move_id = False

                proc_id = procurement_obj.create(
                    cr, uid,
                    self._prepare_order_line_procurement(cr,
                                                         uid,
                                                         order,
                                                         line,
                                                         move_id,
                                                         date_planned,
                                                         context=context))
                proc_ids.append(proc_id)
                line.write({'procurement_id': proc_id})
                self.ship_recreate(cr, uid, order, line, move_id, proc_id)

        wf_service = netsvc.LocalService("workflow")
        if picking_id:
            wf_service.trg_validate(uid, 'stock.picking', picking_id,
                                    'button_confirm', cr)
        for proc_id in proc_ids:
            wf_service.trg_validate(uid, 'procurement.order', proc_id,
                                    'button_confirm', cr)

        val = {}
        if order.state == 'shipping_except':
            val['state'] = 'progress'
            val['shipped'] = False

            if (order.order_policy == 'manual'):
                for line in order.order_line:
                    if (not line.invoiced) and (line.state
                                                not in ('cancel', 'draft')):
                        val['state'] = 'manual'
                        break
        order.write(val)
        return True

    def action_ship_create(self, cr, uid, ids, context=None):
        for order in self.browse(cr, uid, ids, context=context):
            self._create_pickings_and_procurements(cr,
                                                   uid,
                                                   order,
                                                   order.order_line,
                                                   None,
                                                   context=context)
        return True

    def action_ship_end(self, cr, uid, ids, context=None):
        for order in self.browse(cr, uid, ids, context=context):
            val = {'shipped': True}
            if order.state == 'shipping_except':
                val['state'] = 'progress'
                if (order.order_policy == 'manual'):
                    for line in order.order_line:
                        if (not line.invoiced) and (line.state
                                                    not in ('cancel',
                                                            'draft')):
                            val['state'] = 'manual'
                            break
            for line in order.order_line:
                towrite = []
                if line.state == 'exception':
                    towrite.append(line.id)
                if towrite:
                    self.pool.get('sale.order.line').write(cr,
                                                           uid,
                                                           towrite,
                                                           {'state': 'done'},
                                                           context=context)
            res = self.write(cr, uid, [order.id], val)
        return True

    def has_stockable_products(self, cr, uid, ids, *args):
        for order in self.browse(cr, uid, ids):
            for order_line in order.order_line:
                if order_line.product_id and order_line.product_id.type in (
                        'product', 'consu'):
                    return True
        return False
コード例 #36
0
     else:
         kip_ids=",".join(map(str,ids))
         cr.execute("Select payment_import_id id from kderp_import_payment_line where payment_import_id in (%s) and state='draft'" % (kip_ids))
         list_error=[]
         for new_id in cr.fetchall():
             list_error.append(new_id[0])
         for id in ids:
             if id not in list_error:
                 self.write(cr, uid, [id], {'state':'done'})
     return True        
 
 _columns={
             'date':fields.date('Date', required=True, states={'done':[('readonly',True)]}, help="Date of Accounting Import Payment to Supplier to ERP"),
             'name':fields.char('Code Import',size=32,required=True,select=True,states={'done':[('readonly',True)]}),
             'description':fields.char('Desc.',size=128,states={'done':[('readonly',True)]}),
             'import_line':fields.one2many('kderp.import.payment.line','payment_import_id','Details',states={'done':[('readonly',True)]}),
             'state':fields.selection([('draft','Draft'),('done','Done')],'State',readonly=True,select=True)               
           }
 _sql_constraints = [
                     ('supplier_payment_import_unique',"unique(name)","KDERP Error: The Code Import must be unique !")
                     ]
 _defaults = {
     'state': 'draft',
     'date': lambda *a: time.strftime('%Y-%m-%d'),
     'name':lambda *a: time.strftime('AISP-%Y%b%d.%H%M')
     }
 
 def load(self, cr, uid, fields, data, context=None):
 #def import_data(self, cr, uid, fields, datas, mode='init', current_module='', noupdate=False, context=None, filename=None):
     try:
         payment_id_pos = fields.index('import_line/payment_number')
コード例 #37
0
class sale_order_line(osv.osv):
    def _number_packages(self, cr, uid, ids, field_name, arg, context=None):
        res = {}
        for line in self.browse(cr, uid, ids, context=context):
            try:
                res[line.id] = int(
                    (line.product_uom_qty + line.product_packaging.qty -
                     0.0001) / line.product_packaging.qty)
            except:
                res[line.id] = 1
        return res

    _inherit = 'sale.order.line'
    _columns = {
        'delay':
        fields.float(
            'Delivery Lead Time',
            required=True,
            help=
            "Number of days between the order confirmation and the shipping of the products to the customer",
            readonly=True,
            states={'draft': [('readonly', False)]}),
        'procurement_id':
        fields.many2one('procurement.order', 'Procurement'),
        'property_ids':
        fields.many2many('mrp.property',
                         'sale_order_line_property_rel',
                         'order_id',
                         'property_id',
                         'Properties',
                         readonly=True,
                         states={'draft': [('readonly', False)]}),
        'product_packaging':
        fields.many2one('product.packaging', 'Packaging'),
        'move_ids':
        fields.one2many('stock.move',
                        'sale_line_id',
                        'Inventory Moves',
                        readonly=True),
        'number_packages':
        fields.function(_number_packages,
                        type='integer',
                        string='Number Packages'),
    }
    _defaults = {
        'delay': 0.0,
        'product_packaging': False,
    }

    def _get_line_qty(self, cr, uid, line, context=None):
        if line.procurement_id and not (line.order_id.invoice_quantity
                                        == 'order'):
            return self.pool.get('procurement.order').quantity_get(
                cr, uid, line.procurement_id.id, context=context)
        else:
            return super(sale_order_line, self)._get_line_qty(cr,
                                                              uid,
                                                              line,
                                                              context=context)

    def _get_line_uom(self, cr, uid, line, context=None):
        if line.procurement_id and not (line.order_id.invoice_quantity
                                        == 'order'):
            return self.pool.get('procurement.order').uom_get(
                cr, uid, line.procurement_id.id, context=context)
        else:
            return super(sale_order_line, self)._get_line_uom(cr,
                                                              uid,
                                                              line,
                                                              context=context)

    def button_cancel(self, cr, uid, ids, context=None):
        res = super(sale_order_line, self).button_cancel(cr,
                                                         uid,
                                                         ids,
                                                         context=context)
        for line in self.browse(cr, uid, ids, context=context):
            for move_line in line.move_ids:
                if move_line.state != 'cancel':
                    raise osv.except_osv(
                        _('Cannot cancel sales order line!'),
                        _('You must first cancel stock moves attached to this sales order line.'
                          ))
        return res

    def copy_data(self, cr, uid, id, default=None, context=None):
        if not default:
            default = {}
        default.update({'move_ids': []})
        return super(sale_order_line, self).copy_data(cr,
                                                      uid,
                                                      id,
                                                      default,
                                                      context=context)

    def product_packaging_change(self,
                                 cr,
                                 uid,
                                 ids,
                                 pricelist,
                                 product,
                                 qty=0,
                                 uom=False,
                                 partner_id=False,
                                 packaging=False,
                                 flag=False,
                                 context=None):
        if not product:
            return {'value': {'product_packaging': False}}
        product_obj = self.pool.get('product.product')
        product_uom_obj = self.pool.get('product.uom')
        pack_obj = self.pool.get('product.packaging')
        warning = {}
        result = {}
        warning_msgs = ''
        if flag:
            res = self.product_id_change(cr,
                                         uid,
                                         ids,
                                         pricelist=pricelist,
                                         product=product,
                                         qty=qty,
                                         uom=uom,
                                         partner_id=partner_id,
                                         packaging=packaging,
                                         flag=False,
                                         context=context)
            warning_msgs = res.get('warning') and res['warning']['message']

        products = product_obj.browse(cr, uid, product, context=context)
        if not products.packaging:
            packaging = result['product_packaging'] = False
        elif not packaging and products.packaging and not flag:
            packaging = products.packaging[0].id
            result['product_packaging'] = packaging

        if packaging:
            default_uom = products.uom_id and products.uom_id.id
            pack = pack_obj.browse(cr, uid, packaging, context=context)
            q = product_uom_obj._compute_qty(cr, uid, uom, pack.qty,
                                             default_uom)
            #            qty = qty - qty % q + q
            if qty and (q and not (qty % q) == 0):
                ean = pack.ean or _('(n/a)')
                qty_pack = pack.qty
                type_ul = pack.ul
                if not warning_msgs:
                    warn_msg = _("You selected a quantity of %d Units.\n"
                                "But it's not compatible with the selected packaging.\n"
                                "Here is a proposition of quantities according to the packaging:\n"
                                "EAN: %s Quantity: %s Type of ul: %s") % \
                                    (qty, ean, qty_pack, type_ul.name)
                    warning_msgs += _(
                        "Picking Information ! : ") + warn_msg + "\n\n"
                warning = {
                    'title': _('Configuration Error!'),
                    'message': warning_msgs
                }
            result['product_uom_qty'] = qty

        return {'value': result, 'warning': warning}

    def product_id_change(self,
                          cr,
                          uid,
                          ids,
                          pricelist,
                          product,
                          qty=0,
                          uom=False,
                          qty_uos=0,
                          uos=False,
                          name='',
                          partner_id=False,
                          lang=False,
                          update_tax=True,
                          date_order=False,
                          packaging=False,
                          fiscal_position=False,
                          flag=False,
                          context=None):
        context = context or {}
        product_uom_obj = self.pool.get('product.uom')
        partner_obj = self.pool.get('res.partner')
        product_obj = self.pool.get('product.product')
        warning = {}
        res = super(sale_order_line,
                    self).product_id_change(cr,
                                            uid,
                                            ids,
                                            pricelist,
                                            product,
                                            qty=qty,
                                            uom=uom,
                                            qty_uos=qty_uos,
                                            uos=uos,
                                            name=name,
                                            partner_id=partner_id,
                                            lang=lang,
                                            update_tax=update_tax,
                                            date_order=date_order,
                                            packaging=packaging,
                                            fiscal_position=fiscal_position,
                                            flag=flag,
                                            context=context)

        if not product:
            res['value'].update({'product_packaging': False})
            return res

        #update of result obtained in super function
        product_obj = product_obj.browse(cr, uid, product, context=context)
        res['value']['delay'] = (product_obj.sale_delay or 0.0)
        res['value']['type'] = product_obj.procure_method

        #check if product is available, and if not: raise an error
        uom2 = False
        if uom:
            uom2 = product_uom_obj.browse(cr, uid, uom)
            if product_obj.uom_id.category_id.id != uom2.category_id.id:
                uom = False
        if not uom2:
            uom2 = product_obj.uom_id

        # Calling product_packaging_change function after updating UoM
        res_packing = self.product_packaging_change(cr,
                                                    uid,
                                                    ids,
                                                    pricelist,
                                                    product,
                                                    qty,
                                                    uom,
                                                    partner_id,
                                                    packaging,
                                                    context=context)
        res['value'].update(res_packing.get('value', {}))
        warning_msgs = res_packing.get(
            'warning') and res_packing['warning']['message'] or ''
        compare_qty = float_compare(
            product_obj.virtual_available * uom2.factor,
            qty * product_obj.uom_id.factor,
            precision_rounding=product_obj.uom_id.rounding)
        if (product_obj.type=='product') and int(compare_qty) == -1 \
          and (product_obj.procure_method=='make_to_stock'):
            warn_msg = _('You plan to sell %.2f %s but you only have %.2f %s available !\nThe real stock is %.2f %s. (without reservations)') % \
                    (qty, uom2 and uom2.name or product_obj.uom_id.name,
                     max(0,product_obj.virtual_available), product_obj.uom_id.name,
                     max(0,product_obj.qty_available), product_obj.uom_id.name)
            warning_msgs += _("Not enough stock ! : ") + warn_msg + "\n\n"

        #update of warning messages
        if warning_msgs:
            warning = {
                'title': _('Configuration Error!'),
                'message': warning_msgs
            }
        res.update({'warning': warning})
        return res
コード例 #38
0
        'l10n_br_account.fiscal.category', 'Categoria'),
    'fiscal_type': fields.selection(COMPANY_FISCAL_TYPE,
        u'Regime Tributário', required=True),
    'revenue_start': fields.float(
        'Faturamento Inicial', digits_compute=dp.get_precision('Account'),
        help="Faixa inicial de faturamento bruto"),
    'revenue_end': fields.float(
        'Faturamento Final', digits_compute=dp.get_precision('Account'),
        help="Faixa inicial de faturamento bruto")
}

OTHERS_FISCAL_RULE_COLUMNS_TEMPLATE = {
    'parent_id': fields.many2one(
            'account.fiscal.position.rule.template', 'Regra Pai'),
    'child_ids': fields.one2many(
            'account.fiscal.position.rule.template',
            'parent_id', 'Regras Filhas'),
}

OTHERS_FISCAL_RULE_COLUMNS = {
    'parent_id': fields.many2one(
            'account.fiscal.position.rule', 'Regra Pai'),
    'child_ids': fields.one2many(
            'account.fiscal.position.rule', 'parent_id', 'Regras Filhas'),
}

FISCAL_RULE_DEFAULTS = {
    'fiscal_type': COMPANY_FISCAL_TYPE_DEFAULT,
    'revenue_start': 0.00,
    'revenue_end': 0.00
}
コード例 #39
0
class account_asset_asset(osv.osv):
    _name = 'account.asset.asset'
    _description = 'Asset'

    def unlink(self, cr, uid, ids, context=None):
        for asset in self.browse(cr, uid, ids, context=context):
            if asset.account_move_line_ids:
                raise osv.except_osv(
                    _('Error!'),
                    _('You cannot delete an asset that contains posted depreciation lines.'
                      ))
        return super(account_asset_asset, self).unlink(cr,
                                                       uid,
                                                       ids,
                                                       context=context)

    def _get_period(self, cr, uid, context=None):
        periods = self.pool.get('account.period').find(cr,
                                                       uid,
                                                       context=context)
        if periods:
            return periods[0]
        else:
            return False

    def _get_last_depreciation_date(self, cr, uid, ids, context=None):
        """
        @param id: ids of a account.asset.asset objects
        @return: Returns a dictionary of the effective dates of the last depreciation entry made for given asset ids. If there isn't any, return the purchase date of this asset
        """
        cr.execute(
            """
            SELECT a.id as id, COALESCE(MAX(l.date),a.purchase_date) AS date
            FROM account_asset_asset a
            LEFT JOIN account_move_line l ON (l.asset_id = a.id)
            WHERE a.id IN %s
            GROUP BY a.id, a.purchase_date """, (tuple(ids), ))
        return dict(cr.fetchall())

    def _compute_board_amount(self,
                              cr,
                              uid,
                              asset,
                              i,
                              residual_amount,
                              amount_to_depr,
                              undone_dotation_number,
                              posted_depreciation_line_ids,
                              total_days,
                              depreciation_date,
                              context=None):
        #by default amount = 0
        amount = 0
        if i == undone_dotation_number:
            amount = residual_amount
        else:
            if asset.method == 'linear':
                amount = amount_to_depr / (undone_dotation_number -
                                           len(posted_depreciation_line_ids))
                if asset.prorata:
                    amount = amount_to_depr / asset.method_number
                    days = total_days - float(depreciation_date.strftime('%j'))
                    if i == 1:
                        amount = (amount_to_depr /
                                  asset.method_number) / total_days * days
                    elif i == undone_dotation_number:
                        amount = (amount_to_depr / asset.method_number
                                  ) / total_days * (total_days - days)
            elif asset.method == 'degressive':
                amount = residual_amount * asset.method_progress_factor
                if asset.prorata:
                    days = total_days - float(depreciation_date.strftime('%j'))
                    if i == 1:
                        amount = (
                            residual_amount *
                            asset.method_progress_factor) / total_days * days
                    elif i == undone_dotation_number:
                        amount = (residual_amount *
                                  asset.method_progress_factor
                                  ) / total_days * (total_days - days)
        return amount

    def _compute_board_undone_dotation_nb(self,
                                          cr,
                                          uid,
                                          asset,
                                          depreciation_date,
                                          total_days,
                                          context=None):
        undone_dotation_number = asset.method_number
        if asset.method_time == 'end':
            end_date = datetime.strptime(asset.method_end, '%Y-%m-%d')
            undone_dotation_number = 0
            while depreciation_date <= end_date:
                depreciation_date = (
                    datetime(depreciation_date.year, depreciation_date.month,
                             depreciation_date.day) +
                    relativedelta(months=+asset.method_period))
                undone_dotation_number += 1
        if asset.prorata:
            undone_dotation_number += 1
        return undone_dotation_number

    def compute_depreciation_board(self, cr, uid, ids, context=None):
        depreciation_lin_obj = self.pool.get('account.asset.depreciation.line')
        currency_obj = self.pool.get('res.currency')
        for asset in self.browse(cr, uid, ids, context=context):
            if asset.value_residual == 0.0:
                continue
            posted_depreciation_line_ids = depreciation_lin_obj.search(
                cr,
                uid, [('asset_id', '=', asset.id), ('move_check', '=', True)],
                order='depreciation_date desc')
            old_depreciation_line_ids = depreciation_lin_obj.search(
                cr, uid, [('asset_id', '=', asset.id),
                          ('move_id', '=', False)])
            if old_depreciation_line_ids:
                depreciation_lin_obj.unlink(cr,
                                            uid,
                                            old_depreciation_line_ids,
                                            context=context)

            amount_to_depr = residual_amount = asset.value_residual
            if asset.prorata:
                depreciation_date = datetime.strptime(
                    self._get_last_depreciation_date(cr, uid, [asset.id],
                                                     context)[asset.id],
                    '%Y-%m-%d')
            else:
                # depreciation_date = 1st January of purchase year
                purchase_date = datetime.strptime(asset.purchase_date,
                                                  '%Y-%m-%d')
                #if we already have some previous validated entries, starting date isn't 1st January but last entry + method period
                if (len(posted_depreciation_line_ids) > 0):
                    last_depreciation_date = datetime.strptime(
                        depreciation_lin_obj.browse(
                            cr,
                            uid,
                            posted_depreciation_line_ids[0],
                            context=context).depreciation_date, '%Y-%m-%d')
                    depreciation_date = (
                        last_depreciation_date +
                        relativedelta(months=+asset.method_period))
                else:
                    depreciation_date = datetime(purchase_date.year, 1, 1)
            day = depreciation_date.day
            month = depreciation_date.month
            year = depreciation_date.year
            total_days = (year % 4) and 365 or 366

            undone_dotation_number = self._compute_board_undone_dotation_nb(
                cr, uid, asset, depreciation_date, total_days, context=context)
            for x in range(len(posted_depreciation_line_ids),
                           undone_dotation_number):
                i = x + 1
                amount = self._compute_board_amount(
                    cr,
                    uid,
                    asset,
                    i,
                    residual_amount,
                    amount_to_depr,
                    undone_dotation_number,
                    posted_depreciation_line_ids,
                    total_days,
                    depreciation_date,
                    context=context)
                company_currency = asset.company_id.currency_id.id
                current_currency = asset.currency_id.id
                # compute amount into company currency
                amount = currency_obj.compute(cr,
                                              uid,
                                              current_currency,
                                              company_currency,
                                              amount,
                                              context=context)
                residual_amount -= amount
                vals = {
                    'amount':
                    amount,
                    'asset_id':
                    asset.id,
                    'sequence':
                    i,
                    'name':
                    str(asset.id) + '/' + str(i),
                    'remaining_value':
                    residual_amount,
                    'depreciated_value':
                    (asset.purchase_value - asset.salvage_value) -
                    (residual_amount + amount),
                    'depreciation_date':
                    depreciation_date.strftime('%Y-%m-%d'),
                }
                depreciation_lin_obj.create(cr, uid, vals, context=context)
                # Considering Depr. Period as months
                depreciation_date = (
                    datetime(year, month, day) +
                    relativedelta(months=+asset.method_period))
                day = depreciation_date.day
                month = depreciation_date.month
                year = depreciation_date.year
        return True

    def validate(self, cr, uid, ids, context=None):
        if context is None:
            context = {}
        return self.write(cr, uid, ids, {'state': 'open'}, context)

    def set_to_close(self, cr, uid, ids, context=None):
        return self.write(cr, uid, ids, {'state': 'close'}, context=context)

    def set_to_draft(self, cr, uid, ids, context=None):
        return self.write(cr, uid, ids, {'state': 'draft'}, context=context)

    def _amount_residual(self, cr, uid, ids, name, args, context=None):
        cr.execute(
            """SELECT
                l.asset_id as id, SUM(abs(l.debit-l.credit)) AS amount
            FROM
                account_move_line l
            WHERE
                l.asset_id IN %s GROUP BY l.asset_id """, (tuple(ids), ))
        res = dict(cr.fetchall())
        for asset in self.browse(cr, uid, ids, context):
            res[asset.id] = asset.purchase_value - res.get(
                asset.id, 0.0) - asset.salvage_value
        for id in ids:
            res.setdefault(id, 0.0)
        return res

    def onchange_company_id(self,
                            cr,
                            uid,
                            ids,
                            company_id=False,
                            context=None):
        val = {}
        if company_id:
            company = self.pool.get('res.company').browse(cr,
                                                          uid,
                                                          company_id,
                                                          context=context)
            if company.currency_id.company_id and company.currency_id.company_id.id != company_id:
                val['currency_id'] = False
            else:
                val['currency_id'] = company.currency_id.id
        return {'value': val}

    def onchange_purchase_salvage_value(self,
                                        cr,
                                        uid,
                                        ids,
                                        purchase_value,
                                        salvage_value,
                                        context=None):
        val = {}
        for asset in self.browse(cr, uid, ids, context=context):
            if purchase_value:
                val['value_residual'] = purchase_value - salvage_value
            if salvage_value:
                val['value_residual'] = purchase_value - salvage_value
        return {'value': val}

    def _entry_count(self, cr, uid, ids, field_name, arg, context=None):
        res = dict(map(lambda x: (x, 0), ids))
        try:
            for entry in self.browse(cr, uid, ids, context=context):
                res[entry.id] = len(entry.account_move_line_ids)
        except:
            pass
        return res
    _columns = {
        'account_move_line_ids': fields.one2many('account.move.line', 'asset_id', 'Entries', readonly=True, states={'draft':[('readonly',False)]}),
        'entry_count': fields.function(_entry_count, string='# Asset Entries', type='integer'),
        'name': fields.char('Asset Name', size=64, required=True, readonly=True, states={'draft':[('readonly',False)]}),
        'code': fields.char('Reference', size=32, readonly=True, states={'draft':[('readonly',False)]}),
        'purchase_value': fields.float('Gross Value', required=True, readonly=True, states={'draft':[('readonly',False)]}),
        'currency_id': fields.many2one('res.currency','Currency',required=True, readonly=True, states={'draft':[('readonly',False)]}),
        'company_id': fields.many2one('res.company', 'Company', required=True, readonly=True, states={'draft':[('readonly',False)]}),
        'note': fields.text('Note'),
        'category_id': fields.many2one('account.asset.category', 'Asset Category', required=True, change_default=True, readonly=True, states={'draft':[('readonly',False)]}),
        'parent_id': fields.many2one('account.asset.asset', 'Parent Asset', readonly=True, states={'draft':[('readonly',False)]}),
        'child_ids': fields.one2many('account.asset.asset', 'parent_id', 'Children Assets'),
        'purchase_date': fields.date('Purchase Date', required=True, readonly=True, states={'draft':[('readonly',False)]}),
        'state': fields.selection([('draft','Draft'),('open','Running'),('close','Close')], 'Status', required=True,
                                  help="When an asset is created, the status is 'Draft'.\n" \
                                       "If the asset is confirmed, the status goes in 'Running' and the depreciation lines can be posted in the accounting.\n" \
                                       "You can manually close an asset when the depreciation is over. If the last line of depreciation is posted, the asset automatically goes in that status."),
        'active': fields.boolean('Active'),
        'partner_id': fields.many2one('res.partner', 'Partner', readonly=True, states={'draft':[('readonly',False)]}),
        'method': fields.selection([('linear','Linear'),('degressive','Degressive')], 'Computation Method', required=True, readonly=True, states={'draft':[('readonly',False)]}, help="Choose the method to use to compute the amount of depreciation lines.\n"\
            "  * Linear: Calculated on basis of: Gross Value / Number of Depreciations\n" \
            "  * Degressive: Calculated on basis of: Residual Value * Degressive Factor"),
        'method_number': fields.integer('Number of Depreciations', readonly=True, states={'draft':[('readonly',False)]}, help="The number of depreciations needed to depreciate your asset"),
        'method_period': fields.integer('Number of Months in a Period', required=True, readonly=True, states={'draft':[('readonly',False)]}, help="The amount of time between two depreciations, in months"),
        'method_end': fields.date('Ending Date', readonly=True, states={'draft':[('readonly',False)]}),
        'method_progress_factor': fields.float('Degressive Factor', readonly=True, states={'draft':[('readonly',False)]}),
        'value_residual': fields.function(_amount_residual, method=True, digits_compute=dp.get_precision('Account'), string='Residual Value'),
        'method_time': fields.selection([('number','Number of Depreciations'),('end','Ending Date')], 'Time Method', required=True, readonly=True, states={'draft':[('readonly',False)]},
                                  help="Choose the method to use to compute the dates and number of depreciation lines.\n"\
                                       "  * Number of Depreciations: Fix the number of depreciation lines and the time between 2 depreciations.\n" \
                                       "  * Ending Date: Choose the time between 2 depreciations and the date the depreciations won't go beyond."),
        'prorata':fields.boolean('Prorata Temporis', readonly=True, states={'draft':[('readonly',False)]}, help='Indicates that the first depreciation entry for this asset have to be done from the purchase date instead of the first January'),
        'history_ids': fields.one2many('account.asset.history', 'asset_id', 'History', readonly=True),
        'depreciation_line_ids': fields.one2many('account.asset.depreciation.line', 'asset_id', 'Depreciation Lines', readonly=True, states={'draft':[('readonly',False)],'open':[('readonly',False)]}),
        'salvage_value': fields.float('Salvage Value', digits_compute=dp.get_precision('Account'), help="It is the amount you plan to have that you cannot depreciate.", readonly=True, states={'draft':[('readonly',False)]}),
    }
    _defaults = {
        'code':
        lambda obj, cr, uid, context: obj.pool.get('ir.sequence').get(
            cr, uid, 'account.asset.code'),
        'purchase_date':
        lambda obj, cr, uid, context: time.strftime('%Y-%m-%d'),
        'active':
        True,
        'state':
        'draft',
        'method':
        'linear',
        'method_number':
        5,
        'method_time':
        'number',
        'method_period':
        12,
        'method_progress_factor':
        0.3,
        'currency_id':
        lambda self, cr, uid, c: self.pool.get('res.users').browse(
            cr, uid, uid, c).company_id.currency_id.id,
        'company_id':
        lambda self, cr, uid, context: self.pool.get('res.company').
        _company_default_get(cr, uid, 'account.asset.asset', context=context),
    }

    def _check_recursion(self, cr, uid, ids, context=None, parent=None):
        return super(account_asset_asset,
                     self)._check_recursion(cr,
                                            uid,
                                            ids,
                                            context=context,
                                            parent=parent)

    def _check_prorata(self, cr, uid, ids, context=None):
        for asset in self.browse(cr, uid, ids, context=context):
            if asset.prorata and asset.method_time != 'number':
                return False
        return True

    _constraints = [
        (_check_recursion, 'Error ! You cannot create recursive assets.',
         ['parent_id']),
        (_check_prorata,
         'Prorata temporis can be applied only for time method "number of depreciations".',
         ['prorata']),
    ]

    def onchange_category_id(self, cr, uid, ids, category_id, context=None):
        res = {'value': {}}
        asset_categ_obj = self.pool.get('account.asset.category')
        if category_id:
            category_obj = asset_categ_obj.browse(cr,
                                                  uid,
                                                  category_id,
                                                  context=context)
            res['value'] = {
                'method': category_obj.method,
                'method_number': category_obj.method_number,
                'method_time': category_obj.method_time,
                'method_period': category_obj.method_period,
                'method_progress_factor': category_obj.method_progress_factor,
                'method_end': category_obj.method_end,
                'prorata': category_obj.prorata,
            }
        return res

    def onchange_method_time(self,
                             cr,
                             uid,
                             ids,
                             method_time='number',
                             context=None):
        res = {'value': {}}
        if method_time != 'number':
            res['value'] = {'prorata': False}
        return res

    def copy(self, cr, uid, id, default=None, context=None):
        if default is None:
            default = {}
        if context is None:
            context = {}
        default.update({
            'depreciation_line_ids': [],
            'account_move_line_ids': [],
            'history_ids': [],
            'state': 'draft'
        })
        return super(account_asset_asset, self).copy(cr,
                                                     uid,
                                                     id,
                                                     default,
                                                     context=context)

    def _compute_entries(self, cr, uid, ids, period_id, context=None):
        result = []
        period_obj = self.pool.get('account.period')
        depreciation_obj = self.pool.get('account.asset.depreciation.line')
        period = period_obj.browse(cr, uid, period_id, context=context)
        depreciation_ids = depreciation_obj.search(
            cr,
            uid, [('asset_id', 'in', ids),
                  ('depreciation_date', '<=', period.date_stop),
                  ('depreciation_date', '>=', period.date_start),
                  ('move_check', '=', False)],
            context=context)
        if context is None:
            context = {}
        context.update({'depreciation_date': period.date_stop})
        return depreciation_obj.create_move(cr,
                                            uid,
                                            depreciation_ids,
                                            context=context)

    def create(self, cr, uid, vals, context=None):
        asset_id = super(account_asset_asset, self).create(cr,
                                                           uid,
                                                           vals,
                                                           context=context)
        self.compute_depreciation_board(cr, uid, [asset_id], context=context)
        return asset_id

    def open_entries(self, cr, uid, ids, context=None):
        if context is None:
            context = {}
        context.update({
            'search_default_asset_id': ids,
            'default_asset_id': ids
        })
        return {
            'name': _('Journal Items'),
            'view_type': 'form',
            'view_mode': 'tree,form',
            'res_model': 'account.move.line',
            'view_id': False,
            'type': 'ir.actions.act_window',
            'context': context,
        }
コード例 #40
0
    _columns = {
        'name':fields.char('Memo', size=256),
        'log_ref': fields.char('Check-log Ref', size=128),
<<<<<<< HEAD
#        'origin' : fields.char('Origin', size=128),
        'check_status' :fields.selection([('void','Voided'),('print','Printed'),('re_print','Re-Printed'),('clear','Cleared')]),
        'chk_seq': fields.char("Check Number", size=64, readonly=True),
        'invoice_ids': fields.one2many('account.invoice', 'voucher_id', 'Invoices', ondelete='cascade'),
        'jtype':fields.related('journal_id','type', string="Journal Type", type='selection', selection=[('sale', 'Sale'),('sale_refund','Sale Refund'), ('purchase', 'Purchase'), ('purchase_refund','Purchase Refund'), ('cash', 'Cash'), ('bank', 'Bank and Checks'), ('general', 'General'), ('situation', 'Opening/Closing Situation')],),
    }                                                                                                    
=======
#         'origin' : fields.char('Origin', size=128),
        'check_status' :fields.selection([('void','Voided'),('print','Printed'),('re_print','Re-Printed'),('clear','Cleared')]),
        'chk_seq': fields.char("Check Number", size=64, readonly=True),
        'invoice_ids': fields.one2many('account.invoice', 'voucher_id', 'Invoices', ondelete='cascade'),
        'reference': fields.char('Origin', size=64, readonly=True, states={'draft':[('readonly',False)]}, help="Source document which generated the payment."),
        'jtype':fields.related('journal_id','type', string="Journal Type", type='selection', selection=[('sale', 'Sale'),('sale_refund','Sale Refund'), ('purchase', 'Purchase'), ('purchase_refund','Purchase Refund'), ('cash', 'Cash'), ('bank', 'Bank and Checks'), ('general', 'General'), ('situation', 'Opening/Closing Situation')],),
    }
>>>>>>> c1979f64b3360c86d60e00c92be0271d89f97f2d

    def print_checks(self, cr, uid, ids, context=None):
        check_state = self.browse(cr, uid, ids[0],context=None).check_status
        view_ref = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'account_check_writing', 'view_account_check_write')
        view_id = view_ref and view_ref[1] or False,
        context.update({'active_ids':ids, 'check_state': check_state})
        return {
               'type': 'ir.actions.act_window',
               'name': 'Print Checks',
               'view_mode': 'form',
               'view_type': 'form',
コード例 #41
0
ファイル: hr.py プロジェクト: zop2010/odoo
class hr_employee(osv.osv):
    _name = "hr.employee"
    _description = "Employee"
    _order = 'name_related'
    _inherits = {'resource.resource': "resource_id"}
    _inherit = ['mail.thread']

    _mail_post_access = 'read'

    def _get_image(self, cr, uid, ids, name, args, context=None):
        result = dict.fromkeys(ids, False)
        for obj in self.browse(cr, uid, ids, context=context):
            result[obj.id] = tools.image_get_resized_images(obj.image)
        return result

    def _set_image(self, cr, uid, id, name, value, args, context=None):
        return self.write(cr,
                          uid, [id],
                          {'image': tools.image_resize_image_big(value)},
                          context=context)

    _columns = {
        #we need a related field in order to be able to sort the employee by name
        'name_related': fields.related('resource_id', 'name', type='char', string='Name', readonly=True, store=True),
        'country_id': fields.many2one('res.country', 'Nationality'),
        'birthday': fields.date("Date of Birth"),
        'ssnid': fields.char('SSN No', help='Social Security Number'),
        'sinid': fields.char('SIN No', help="Social Insurance Number"),
        'identification_id': fields.char('Identification No'),
        'otherid': fields.char('Other Id'),
        'gender': fields.selection([('male', 'Male'), ('female', 'Female')], 'Gender'),
        'marital': fields.selection([('single', 'Single'), ('married', 'Married'), ('widower', 'Widower'), ('divorced', 'Divorced')], 'Marital Status'),
        'department_id': fields.many2one('hr.department', 'Department'),
        'address_id': fields.many2one('res.partner', 'Working Address'),
        'address_home_id': fields.many2one('res.partner', 'Home Address'),
        'bank_account_id': fields.many2one('res.partner.bank', 'Bank Account Number', domain="[('partner_id','=',address_home_id)]", help="Employee bank salary account"),
        'work_phone': fields.char('Work Phone', readonly=False),
        'mobile_phone': fields.char('Work Mobile', readonly=False),
        'work_email': fields.char('Work Email', size=240),
        'work_location': fields.char('Office Location'),
        'notes': fields.text('Notes'),
        'parent_id': fields.many2one('hr.employee', 'Manager'),
        'category_ids': fields.many2many('hr.employee.category', 'employee_category_rel', 'emp_id', 'category_id', 'Tags'),
        'child_ids': fields.one2many('hr.employee', 'parent_id', 'Subordinates'),
        'resource_id': fields.many2one('resource.resource', 'Resource', ondelete='cascade', required=True),
        'coach_id': fields.many2one('hr.employee', 'Coach'),
        'job_id': fields.many2one('hr.job', 'Job Title'),
        # image: all image fields are base64 encoded and PIL-supported
        'image': fields.binary("Photo",
            help="This field holds the image used as photo for the employee, limited to 1024x1024px."),
        'image_medium': fields.function(_get_image, fnct_inv=_set_image,
            string="Medium-sized photo", type="binary", multi="_get_image",
            store = {
                'hr.employee': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
            },
            help="Medium-sized photo of the employee. It is automatically "\
                 "resized as a 128x128px image, with aspect ratio preserved. "\
                 "Use this field in form views or some kanban views."),
        'image_small': fields.function(_get_image, fnct_inv=_set_image,
            string="Small-sized photo", type="binary", multi="_get_image",
            store = {
                'hr.employee': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
            },
            help="Small-sized photo of the employee. It is automatically "\
                 "resized as a 64x64px image, with aspect ratio preserved. "\
                 "Use this field anywhere a small image is required."),
        'passport_id': fields.char('Passport No'),
        'color': fields.integer('Color Index'),
        'city': fields.related('address_id', 'city', type='char', string='City'),
        'login': fields.related('user_id', 'login', type='char', string='Login', readonly=1),
        'last_login': fields.related('user_id', 'date', type='datetime', string='Latest Connection', readonly=1),
    }

    def _get_default_image(self, cr, uid, context=None):
        image_path = get_module_resource('hr', 'static/src/img',
                                         'default_image.png')
        return tools.image_resize_image_big(
            open(image_path, 'rb').read().encode('base64'))

    defaults = {
        'active': 1,
        'image': _get_default_image,
        'color': 0,
    }

    def _broadcast_welcome(self, cr, uid, employee_id, context=None):
        """ Broadcast the welcome message to all users in the employee company. """
        employee = self.browse(cr, uid, employee_id, context=context)
        partner_ids = []
        _model, group_id = self.pool['ir.model.data'].get_object_reference(
            cr, uid, 'base', 'group_user')
        if employee.user_id:
            company_id = employee.user_id.company_id.id
        elif employee.company_id:
            company_id = employee.company_id.id
        elif employee.job_id:
            company_id = employee.job_id.company_id.id
        elif employee.department_id:
            company_id = employee.department_id.company_id.id
        else:
            company_id = self.pool['res.company']._company_default_get(
                cr, uid, 'hr.employee', context=context)
        res_users = self.pool['res.users']
        user_ids = res_users.search(cr,
                                    SUPERUSER_ID,
                                    [('company_id', '=', company_id),
                                     ('groups_id', 'in', group_id)],
                                    context=context)
        partner_ids = list(
            set(u.partner_id.id for u in res_users.browse(
                cr, SUPERUSER_ID, user_ids, context=context)))
        self.message_post(
            cr,
            uid, [employee_id],
            body=
            _('Welcome to %s! Please help him/her take the first steps with Odoo!'
              ) % (employee.name),
            partner_ids=partner_ids,
            subtype='mail.mt_comment',
            context=context)
        return True

    def create(self, cr, uid, data, context=None):
        context = dict(context or {})
        if context.get("mail_broadcast"):
            context['mail_create_nolog'] = True

        employee_id = super(hr_employee, self).create(cr,
                                                      uid,
                                                      data,
                                                      context=context)

        if context.get("mail_broadcast"):
            self._broadcast_welcome(cr, uid, employee_id, context=context)
        return employee_id

    def unlink(self, cr, uid, ids, context=None):
        resource_ids = []
        for employee in self.browse(cr, uid, ids, context=context):
            resource_ids.append(employee.resource_id.id)
        super(hr_employee, self).unlink(cr, uid, ids, context=context)
        return self.pool.get('resource.resource').unlink(cr,
                                                         uid,
                                                         resource_ids,
                                                         context=context)

    def onchange_address_id(self, cr, uid, ids, address, context=None):
        if address:
            address = self.pool.get('res.partner').browse(cr,
                                                          uid,
                                                          address,
                                                          context=context)
            return {
                'value': {
                    'work_phone': address.phone,
                    'mobile_phone': address.mobile
                }
            }
        return {'value': {}}

    def onchange_company(self, cr, uid, ids, company, context=None):
        address_id = False
        if company:
            company_id = self.pool.get('res.company').browse(cr,
                                                             uid,
                                                             company,
                                                             context=context)
            address = self.pool.get('res.partner').address_get(
                cr, uid, [company_id.partner_id.id], ['default'])
            address_id = address and address['default'] or False
        return {'value': {'address_id': address_id}}

    def onchange_department_id(self,
                               cr,
                               uid,
                               ids,
                               department_id,
                               context=None):
        value = {'parent_id': False}
        if department_id:
            department = self.pool.get('hr.department').browse(
                cr, uid, department_id)
            value['parent_id'] = department.manager_id.id
        return {'value': value}

    def onchange_user(self, cr, uid, ids, user_id, context=None):
        work_email = False
        if user_id:
            work_email = self.pool.get('res.users').browse(
                cr, uid, user_id, context=context).email
        return {'value': {'work_email': work_email}}

    def action_follow(self, cr, uid, ids, context=None):
        """ Wrapper because message_subscribe_users take a user_ids=None
            that receive the context without the wrapper. """
        return self.message_subscribe_users(cr, uid, ids, context=context)

    def action_unfollow(self, cr, uid, ids, context=None):
        """ Wrapper because message_unsubscribe_users take a user_ids=None
            that receive the context without the wrapper. """
        return self.message_unsubscribe_users(cr, uid, ids, context=context)

    def get_suggested_thread(self,
                             cr,
                             uid,
                             removed_suggested_threads=None,
                             context=None):
        """Show the suggestion of employees if display_employees_suggestions if the
        user perference allows it. """
        user = self.pool.get('res.users').browse(cr, uid, uid, context)
        if not user.display_employees_suggestions:
            return []
        else:
            return super(hr_employee,
                         self).get_suggested_thread(cr, uid,
                                                    removed_suggested_threads,
                                                    context)

    def _message_get_auto_subscribe_fields(self,
                                           cr,
                                           uid,
                                           updated_fields,
                                           auto_follow_fields=None,
                                           context=None):
        """ Overwrite of the original method to always follow user_id field,
        even when not track_visibility so that a user will follow it's employee
        """
        if auto_follow_fields is None:
            auto_follow_fields = ['user_id']
        user_field_lst = []
        for name, column_info in self._all_columns.items():
            if name in auto_follow_fields and name in updated_fields and column_info.column._obj == 'res.users':
                user_field_lst.append(name)
        return user_field_lst

    def _check_recursion(self, cr, uid, ids, context=None):
        level = 100
        while len(ids):
            cr.execute(
                'SELECT DISTINCT parent_id FROM hr_employee WHERE id IN %s AND parent_id!=id',
                (tuple(ids), ))
            ids = filter(None, map(lambda x: x[0], cr.fetchall()))
            if not level:
                return False
            level -= 1
        return True

    _constraints = [
        (_check_recursion,
         'Error! You cannot create recursive hierarchy of Employee(s).',
         ['parent_id']),
    ]
コード例 #42
0
            return {}

    def on_change_intervall(self, cr, uid, id, interval):
        ###Function that will update the cron
        ###freqeuence
        self.pool.get("currency.rate.update").save_cron(cr, uid, {"interval_type": interval})
        compagnies = self.search(cr, uid, [])
        for comp in compagnies:
            self.write(cr, uid, comp, {"interval_type": interval})
        return {}

    _inherit = "res.company"
    _columns = {
        ### activate the currency update
        "auto_currency_up": fields.boolean("Automatical update of the currency this company"),
        "services_to_use": fields.one2many("currency.rate.update.service", "company_id", "Currency update services"),
        ###predifine cron frequence
        "interval_type": fields.selection(
            [("days", "Day(s)"), ("weeks", "Week(s)"), ("months", "Month(s)")],
            "Currency update frequence",
            help="""changing this value will
                                                 also affect other compagnies""",
        ),
        ###function field that allows to know the
        ###mutli company currency implementation
        "multi_company_currency_enable": fields.function(
            _multi_curr_enable,
            method=True,
            type="boolean",
            string="Multi company currency",
            help="if this case is not check you can" + " not set currency is active on two company",
コード例 #43
0
ファイル: hr.py プロジェクト: zop2010/odoo
class hr_department(osv.osv):
    _name = "hr.department"
    _description = "HR Department"
    _inherit = ['mail.thread', 'ir.needaction_mixin']

    def _dept_name_get_fnc(self,
                           cr,
                           uid,
                           ids,
                           prop,
                           unknow_none,
                           context=None):
        res = self.name_get(cr, uid, ids, context=context)
        return dict(res)

    _columns = {
        'name':
        fields.char('Department Name', required=True),
        'complete_name':
        fields.function(_dept_name_get_fnc, type="char", string='Name'),
        'company_id':
        fields.many2one('res.company', 'Company', select=True, required=False),
        'parent_id':
        fields.many2one('hr.department', 'Parent Department', select=True),
        'child_ids':
        fields.one2many('hr.department', 'parent_id', 'Child Departments'),
        'manager_id':
        fields.many2one('hr.employee', 'Manager', track_visibility='onchange'),
        'member_ids':
        fields.one2many('hr.employee',
                        'department_id',
                        'Members',
                        readonly=True),
        'jobs_ids':
        fields.one2many('hr.job', 'department_id', 'Jobs'),
        'note':
        fields.text('Note'),
    }

    _defaults = {
        'company_id':
        lambda self, cr, uid, c: self.pool.get('res.company').
        _company_default_get(cr, uid, 'hr.department', context=c),
    }

    def _check_recursion(self, cr, uid, ids, context=None):
        if context is None:
            context = {}
        level = 100
        while len(ids):
            cr.execute(
                'select distinct parent_id from hr_department where id IN %s',
                (tuple(ids), ))
            ids = filter(None, map(lambda x: x[0], cr.fetchall()))
            if not level:
                return False
            level -= 1
        return True

    _constraints = [
        (_check_recursion, 'Error! You cannot create recursive departments.',
         ['parent_id'])
    ]

    def name_get(self, cr, uid, ids, context=None):
        if context is None:
            context = {}
        if not ids:
            return []
        reads = self.read(cr, uid, ids, ['name', 'parent_id'], context=context)
        res = []
        for record in reads:
            name = record['name']
            if record['parent_id']:
                name = record['parent_id'][1] + ' / ' + name
            res.append((record['id'], name))
        return res

    def create(self, cr, uid, vals, context=None):
        # TDE note: auto-subscription of manager done by hand, because currently
        # the tracking allows to track+subscribe fields linked to a res.user record
        # An update of the limited behavior should come, but not currently done.
        manager_id = vals.get("manager_id")
        new_id = super(hr_department, self).create(cr,
                                                   uid,
                                                   vals,
                                                   context=context)
        if manager_id:
            employee = self.pool.get('hr.employee').browse(cr,
                                                           uid,
                                                           manager_id,
                                                           context=context)
            if employee.user_id:
                self.message_subscribe_users(cr,
                                             uid, [new_id],
                                             user_ids=[employee.user_id.id],
                                             context=context)
        return new_id

    def write(self, cr, uid, ids, vals, context=None):
        # TDE note: auto-subscription of manager done by hand, because currently
        # the tracking allows to track+subscribe fields linked to a res.user record
        # An update of the limited behavior should come, but not currently done.
        if isinstance(ids, (int, long)):
            ids = [ids]
        manager_id = vals.get("manager_id")
        if manager_id:
            employee = self.pool.get('hr.employee').browse(cr,
                                                           uid,
                                                           manager_id,
                                                           context=context)
            if employee.user_id:
                self.message_subscribe_users(cr,
                                             uid, [ids],
                                             user_ids=[employee.user_id.id],
                                             context=context)
        return super(hr_department, self).write(cr,
                                                uid,
                                                ids,
                                                vals,
                                                context=context)
コード例 #44
0
        'cc_charge':fields.boolean('Charge'),
        'cc_info_hide':fields.boolean('Credit Info Hide'),
        'cc_status':fields.text('Status Message'),
        'cc_details_autofill':fields.boolean('Credit Card Details Auto Fill'),
        'cc_reseller':fields.boolean('Reseller'),
        'rel_sale_order_id':fields.many2one('sale.order', 'Related Sale Order'),
        'cc_trans_id':fields.char('Transaction ID', size=128),
        'cc_bank':fields.many2one('res.bank', 'Bank'),
        'cc_details':fields.many2one('res.partner.bank', 'Bank'),
        'cc_length':fields.integer('CC Length'),
        'cc_transaction':fields.boolean('Transaction Done'),
        'key':fields.char('Encryption Key', size=1024,
                          help="The Key used to Encrypt the Credit Card Number"),
        'cc_refund_amt':fields.float('Refund Amt'),
        'is_charged': fields.boolean('CreditCard Charged'),
        'trans_history_ids': fields.one2many('transaction.details', 'voucher_id', 'Transaction History')
    }
    _defaults = {
        'cc_info_hide': lambda * a: True,
        'cc_p_authorize': lambda * a: True,
    }

    def onchange_cc_details(self, cr, uid, ids, cc_details, context={}):
        dic = {}
        if cc_details:
            context['cc_no'] = 'no_mask'
            bank = self.pool.get('res.partner.bank').browse(cr, uid, cc_details, context=context)
            dic['cc_e_d_month'] = bank.cc_e_d_month
            dic['cc_e_d_year'] = bank.cc_e_d_year
            dic['cc_number'] = bank.cc_number
            dic['cc_v'] = bank.cc_v
コード例 #45
0
ファイル: hr.py プロジェクト: zop2010/odoo
class hr_job(osv.Model):
    def _get_nbr_employees(self, cr, uid, ids, name, args, context=None):
        res = {}
        for job in self.browse(cr, uid, ids, context=context):
            nb_employees = len(job.employee_ids or [])
            res[job.id] = {
                'no_of_employee': nb_employees,
                'expected_employees': nb_employees + job.no_of_recruitment,
            }
        return res

    def _get_job_position(self, cr, uid, ids, context=None):
        res = []
        for employee in self.pool.get('hr.employee').browse(cr,
                                                            uid,
                                                            ids,
                                                            context=context):
            if employee.job_id:
                res.append(employee.job_id.id)
        return res

    _name = "hr.job"
    _description = "Job Position"
    _inherit = ['mail.thread']
    _columns = {
        'name':
        fields.char('Job Name', required=True, select=True),
        'expected_employees':
        fields.function(
            _get_nbr_employees,
            string='Total Forecasted Employees',
            help=
            'Expected number of employees for this job position after new recruitment.',
            store={
                'hr.job': (lambda self, cr, uid, ids, c=None: ids,
                           ['no_of_recruitment'], 10),
                'hr.employee': (_get_job_position, ['job_id'], 10),
            },
            type='integer',
            multi='_get_nbr_employees'),
        'no_of_employee':
        fields.function(
            _get_nbr_employees,
            string="Current Number of Employees",
            help='Number of employees currently occupying this job position.',
            store={
                'hr.employee': (_get_job_position, ['job_id'], 10),
            },
            type='integer',
            multi='_get_nbr_employees'),
        'no_of_recruitment':
        fields.integer('Expected New Employees',
                       copy=False,
                       help='Number of new employees you expect to recruit.'),
        'no_of_hired_employee':
        fields.integer(
            'Hired Employees',
            copy=False,
            help=
            'Number of hired employees for this job position during recruitment phase.'
        ),
        'employee_ids':
        fields.one2many('hr.employee',
                        'job_id',
                        'Employees',
                        groups='base.group_user'),
        'description':
        fields.text('Job Description'),
        'requirements':
        fields.text('Requirements'),
        'department_id':
        fields.many2one('hr.department', 'Department'),
        'company_id':
        fields.many2one('res.company', 'Company'),
        'state':
        fields.selection(
            [('open', 'Recruitment Closed'),
             ('recruit', 'Recruitment in Progress')],
            string='Status',
            readonly=True,
            required=True,
            track_visibility='always',
            copy=False,
            help=
            "By default 'Closed', set it to 'In Recruitment' if recruitment process is going on for this job position."
        ),
        'write_date':
        fields.datetime('Update Date', readonly=True),
    }

    _defaults = {
        'company_id':
        lambda self, cr, uid, ctx=None: self.pool.get('res.company').
        _company_default_get(cr, uid, 'hr.job', context=ctx),
        'state':
        'open',
    }

    _sql_constraints = [
        ('name_company_uniq', 'unique(name, company_id, department_id)',
         'The name of the job position must be unique per department in company!'
         ),
        ('hired_employee_check',
         "CHECK ( no_of_hired_employee <= no_of_recruitment )",
         "Number of hired employee must be less than expected number of employee in recruitment."
         ),
    ]

    def set_recruit(self, cr, uid, ids, context=None):
        for job in self.browse(cr, uid, ids, context=context):
            no_of_recruitment = job.no_of_recruitment == 0 and 1 or job.no_of_recruitment
            self.write(cr,
                       uid, [job.id], {
                           'state': 'recruit',
                           'no_of_recruitment': no_of_recruitment
                       },
                       context=context)
        return True

    def set_open(self, cr, uid, ids, context=None):
        self.write(cr,
                   uid,
                   ids, {
                       'state': 'open',
                       'no_of_recruitment': 0,
                       'no_of_hired_employee': 0
                   },
                   context=context)
        return True

    def copy(self, cr, uid, id, default=None, context=None):
        if default is None:
            default = {}
        if 'name' not in default:
            job = self.browse(cr, uid, id, context=context)
            default['name'] = _("%s (copy)") % (job.name)
        return super(hr_job, self).copy(cr,
                                        uid,
                                        id,
                                        default=default,
                                        context=context)

    # ----------------------------------------
    # Compatibility methods
    # ----------------------------------------
    _no_of_employee = _get_nbr_employees  # v7 compatibility
    job_open = set_open  # v7 compatibility
    job_recruitment = set_recruit  # v7 compatibility
コード例 #46
0
                            kail.write({'reason':e})
                            done = False
            if done: 
                kai.write({'state':'done'})
        pass
        
    IMPORT_TYPE = (('lq','Liquidation'),('usage','Usage'),('spec','Specification'))
    _columns={
              'name':fields.date("Import Date", 
                                    states={'done':[('readonly',True)]}, required=True),              
              'remarks':fields.char('Remarks',size=256, 
                                    states={'done':[('readonly',True)]}),                                                               
                
              'state':fields.selection((('draft','Draft'),('done','Completed')),'State',readonly=True),
              
              'detail_ids':fields.one2many('kderp.import.asset.detail','import_id','Details',states={'done':[('readonly',True)]}),
              'detail_spec_ids':fields.one2many('kderp.import.asset.detail','import_id','Details',states={'done':[('readonly',True)]}),
              'detail_usage_ids':fields.one2many('kderp.import.asset.detail','import_id','Details',states={'done':[('readonly',True)]}),
              'import_type':fields.selection(IMPORT_TYPE,'Import type',states={'done':[('readonly',True)]}),
              }
    _defaults={
               'name':lambda *a: time.strftime('%Y-%m-%d'),
               'state':lambda *a: 'draft'
               }    
    
kderp_asset_import()  

class kderp_import_asset_detail(Model):    
    _name = 'kderp.import.asset.detail'
    _rec_name = 'asset_id'
    
コード例 #47
0
class ElectricComponent(electric_component_base):
    _inherit = 'component.component'
    _description = 'Components'

    def electric_info(self, cr, uid, ids, field_name, arg, context=None):
        return super(ElectricComponent, self).electric_info(cr, uid, ids, field_name, arg, context=context)

    # def _electric_info(self, cr, uid, ids, field_name, arg, context=None):
    #     res = dict.fromkeys(ids, "")
    #     for component in self.browse(cr, uid, ids, context=context):
    #         cmodel = self.pool[component.component_model]
    #         for c in cmodel.browse(cr, uid, [('delegated_id' in ids)], context=context):
    #             if 'component_info' in c:
    #                 res[c.delegated_id] = c.component_info;
    #     return res;

    def _get_attachment_number(self, cr, uid, ids, field_name, arg, context=None):
        res = dict.fromkeys(ids, 0)
        return res

    def _test_count(self, cr, uid, ids, field_name, arg, context=None):
        res = dict.fromkeys(ids, 0)
        for component in self.browse(cr, uid, ids, context=context):
            if component.component_model_test in self.pool:
                if 'delegated_id' in component:
                    def_id = component.id
                else:
                    true_components = self.pool[component.component_model]
                    def_id = true_components.search(cr, uid, [('delegated_id', '=', component.id)], limit=1)
                count = self.pool[component.component_model_test].search_count(cr, uid, [('component_id',"=",def_id)], context);
                res[component.id] = count
        return res

    def _get_attachment_number(self, cr, uid, ids, field_name, arg, context=None):
        res = dict.fromkeys(ids, 0)
        component_docs = self.pool['ir.attachment']
        for docs in component_docs.read_group(cr, uid, [('res_model', '=', 'component.component'), ('res_id', 'in', ids)],
                                          ['res_id'], ['res_id'], context):
            res[docs['res_id']] = component_docs.search_count(cr,uid, [('res_id', '=', docs['res_id'])], context=context)
        return res

    def fields_view_get(self, cr, uid, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
        result = super(ElectricComponent, self).fields_view_get(cr, uid, view_id, view_type, context, toolbar, submenu)
        return result

    _columns = {
        'electric_info': fields.function(electric_info, 'Information', type='char'),
        'customer_id': fields.many2one('res.partner', 'Customer'),
        'component_model': fields.char('Component Model'),
        'component_model_test': fields.char('Component Model Test'),
        'test_count': fields.function(_test_count, string='Test Sheets', type='integer'),
        'attachment_number': fields.function(_get_attachment_number, string="Documents Attached", type="integer"),
        'attachment_ids': fields.one2many('ir.attachment', 'res_id', domain=[('res_model', '=', 'component.component')], string='Attachments')
    }

    @api.model
    def create(self, values):
        # values = self._test_image_small(values)
        return super(ElectricComponent, self).create(values)

    @api.multi
    def write(self, vals):
        # self._test_image_small(vals)
        res = super(ElectricComponent, self).write(vals)
        return res

    def can_create(self):
        return self.electric_component_type != 'all_components'

    _defaults = {
        'electric_component_type': 'all_components',
    }

    def unlink(self, cr, uid, ids, context=None):
        for component in self.browse(cr, uid, ids, context=context):
            if not('delegated_id' in component):
                true_components = self.pool[component.component_model]
                def_id = true_components.search(cr, uid, [('delegated_id', '=', component.id)], limit=1)
                self.pool[component.component_model].unlink(cr, uid, def_id, context=context)
        return super(ElectricComponent, self).unlink(cr, uid, ids, context)
コード例 #48
0
    _description = "Import Inventory"

    def _default_location(self, cr, uid, ids, context=None):
        try:
            loc_model, location_id = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'stock', 'stock_location_stock')
        except ValueError, e:
            return False
        return location_id or False

    _columns = {
        'location_id': fields.many2one('stock.location', 'Location', required=True),
        'import_file': fields.binary('File', filters="*.xls"),
        #to consider the product current inventory or not, if yes then add the current inventory to the upload excel quantity as the quantity to do physical inventory
        'consider_inventory': fields.boolean('Consider Current Inventory', select=True), 
        'all_done': fields.boolean('All Data Imported', readonly=True, select=True), 
        'result_line': fields.one2many('stock.import.inventory.result', 'import_id', 'Importing Result', readonly=True), 
        'file_template': fields.binary('Template File', readonly=True),
        'file_template_name': fields.char('Template File Name'),
    }
    
    def _get_template(self, cr, uid, context):
        cur_path = os.path.split(os.path.realpath(__file__))[0]
        path = os.path.join(cur_path,'stock_import_template.xls')
        data = open(path,'rb').read().encode('base64')
#        data = os.path.getsize(path)
        return data
    
    _defaults = {
        'location_id': _default_location,
        'file_template': _get_template,
        'file_template_name': 'stock_import_template.xls'
コード例 #49
0
class periodic_inventory_valuation(osv.osv):
    _name = "periodic.inventory.valuation"
    _description = "Periodic Inventory Valuation"
    _columns = {
        'name':
        fields.char('Name', size=64, required=True, help=""),
        'move_id':
        fields.many2one(
            'account.move',
            'Journal Entry',
            help=
            'Journal Entry For this Periodic Inventory Valuation Document, it will be created when Document is Posted'
        ),
        'company_id':
        fields.many2one('res.company',
                        'Company',
                        help='Company for this Document'),
        'period_id':
        fields.many2one(
            'account.period',
            'Period',
            help=
            'Accounting Period to be used when creating Journal Entries and Accounting Entries'
        ),
        'inventory_valuation_journal_id':
        fields.many2one(
            'account.journal',
            'Journal',
            help=
            'Accounting Journal to be used when creating Journal Entries and Accounting Entries'
        ),
        'currency_id':
        fields.many2one(
            'res.currency',
            'Currency',
            help=
            'Currency to be used when creating Journal Entries and Accounting Entries'
        ),
        'date':
        fields.date(
            'Valuation Date',
            help=
            'Date to be used when creating Journal Entries and Accounting Entries'
        ),
        'state':
        fields.selection([('draft', 'Readying Valuation'),
                          ('confirm', 'Ready to Valuate'),
                          ('done', 'Valuated Inventory')]),
        'product_ids':
        fields.many2many('product.product',
                         'piv_prod_rel',
                         'product_id',
                         'piv_id',
                         'Valuating Products',
                         help='Products to be Valuated'),
        'stock_move_ids':
        fields.many2many('stock.move',
                         'piv_sm_rel',
                         'stock_move_id',
                         'piv_id',
                         'Stock Moves',
                         help='Stock Moves to be used as Control Sample'),
        'ail_ids':
        fields.many2many(
            'account.invoice.line',
            'piv_ail_rel',
            'ail_id',
            'piv_id',
            'Account Invoice Lines',
            help='Account Invoice Lines to be used to Valuate Inventory'),
        'aml_ids':
        fields.many2many(
            'account.move.line',
            'piv_aml_rel',
            'aml_id',
            'piv_id',
            'Account Move Lines',
            help='Account Move Lines to be Created to Valuate Inventory'),
        'pivl_ids':
        fields.one2many(
            'periodic.inventory.valuation.line',
            'piv_id',
            'Periodic Inventory Valuation Lines',
            help=
            'Periodic Inventory Valuation Lines created to valuate Inventory'),
        'first':
        fields.boolean('First run'),
    }
    _defaults = {
        'state':
        'draft',
        'company_id':
        lambda s, c, u, ctx: s.pool.get('res.users').browse(
            c, u, u, context=ctx).company_id.id,
        'first':
        False,
        'currency_id':
        lambda s, c, u, ctx: s.pool.get('res.users').browse(
            c, u, u, context=ctx).company_id.currency_id.id,
        'inventory_valuation_journal_id':
        lambda s, c, u, ctx: s.pool.get('res.users').browse(
            c, u, u, context=ctx).company_id.inventory_valuation_journal_id.id,
    }

    def get_period(self, cr, uid, ids, date, context=None):
        if context is None:
            context = {}

        period_obj = self.pool.get('account.period')
        period_ids = period_obj.find(cr, uid, dt=date, context=context)
        period_ids = period_obj.search(cr,
                                       uid, [('id', 'in', period_ids),
                                             ('special', '=', False)],
                                       context=context)
        period_ids = period_ids and period_ids[0] or False
        if not period_ids:
            raise osv.except_osv(
                _('Error!'),
                _('There is no fiscal year defined for this date.\nPlease create one from the configuration of the accounting menu.'
                  ))

        return period_ids

    def exchange(self,
                 cr,
                 uid,
                 ids,
                 from_amount,
                 to_currency_id,
                 from_currency_id,
                 exchange_date,
                 context=None):
        if context is None:
            context = {}
        if from_currency_id == to_currency_id:
            return from_amount
        curr_obj = self.pool.get('res.currency')
        context['date'] = exchange_date
        return curr_obj.compute(cr,
                                uid,
                                from_currency_id,
                                to_currency_id,
                                from_amount,
                                context=context)

    def validate_data(self, cr, uid, ids, date, context=None):
        if context is None:
            context = {}

        if ids:
            if type(ids) is list:
                peri_inv_allowed = self.search(cr,
                                               uid, [('id', '!=', ids[0])],
                                               order='id desc',
                                               limit=1,
                                               context=context)
            else:
                peri_inv_allowed = self.search(cr,
                                               uid, [('id', '!=', ids)],
                                               order='id desc',
                                               limit=1,
                                               context=context)
        else:
            peri_inv_allowed = self.search(cr,
                                           uid, [],
                                           order='id desc',
                                           limit=1,
                                           context=context)

        all_per_inv = self.browse(cr, uid, peri_inv_allowed, context=context)
        #$$$
        for i in all_per_inv:
            if date <= i.date:
                raise osv.except_osv(
                    'Record with this data existing !',
                    'Can not create a record with repeated date')

        return True

    def write(self, cr, uid, ids, vals, context=None):
        if context is None:
            context = {}

        if type(ids) is list:
            brw_per_inv = self.browse(cr, uid, ids[0], context=context)
        else:
            brw_per_inv = self.browse(cr, uid, ids, context=context)

        if brw_per_inv.state == 'done':
            raise osv.except_osv('Can not write the record',
                                 'When a stock is done, can not be write')

        self.validate_data(cr, uid, ids, brw_per_inv.date, context=context)

        vals['period_id'] = self.get_period(cr,
                                            uid,
                                            ids,
                                            vals.get('date'),
                                            context=context)
        return super(periodic_inventory_valuation, self).write(cr,
                                                               uid,
                                                               ids,
                                                               vals,
                                                               context=context)

    def create(self, cr, uid, vals, context=None):
        if context is None:
            context = {}

        inv = self.pool.get('res.users').browse(
            cr, uid, uid,
            context=context).company_id.inventory_valuation_journal_id
        if not inv.id:
            raise osv.except_osv(
                'You need to define the journal',
                'Must be defined in the company the journal to generate the journal items for periodic inventory'
            )

        self.validate_data(cr, uid, False, vals.get('date'), context=context)
        vals['period_id'] = self.get_period(cr,
                                            uid,
                                            False,
                                            vals.get('date'),
                                            context=context)
        return super(periodic_inventory_valuation,
                     self).create(cr, uid, vals, context=context)

    def unlink(self, cr, uid, ids, context=None):
        if context is None:
            context = {}
        brw_per_inv = self.browse(cr, uid, ids[0], context=context)

        if brw_per_inv.state == 'done':
            raise osv.except_osv('Can not delete the record',
                                 'When a stock is done, can not be deleted')

        return super(periodic_inventory_valuation,
                     self).unlink(cr, uid, ids, context=context)

    def load_valuation_items(self, cr, uid, ids, context=None):
        context = context or {}
        ids = isinstance(ids, (int, long)) and [ids] or ids
        prod_obj = self.pool.get('product.product')

        prod_ids = prod_obj.search(cr,
                                   uid, [
                                       ('type', '=', 'product'),
                                       ('valuation', '=', 'manual_periodic'),
                                   ],
                                   context=context)

        period_obj = self.pool.get('account.period')
        piv_brw = self.browse(cr, uid, ids[0], context=context)
        date = piv_brw.date
        company_id = piv_brw.company_id.id
        currency_id = piv_brw.currency_id.id

        inventory_valuation_journal_id = piv_brw.company_id.inventory_valuation_journal_id.id

        period_id = piv_brw.period_id.id

        inv_obj = self.pool.get('account.invoice')

        # Se obtiene la linea del producto del registro anterior
        if type(ids) is list:
            piv_id = self.search(cr,
                                 uid, [('id', '!=', ids[0]),
                                       ('state', '=', 'done')],
                                 order='id desc',
                                 limit=1,
                                 context=context)
        else:
            piv_id = self.search(cr,
                                 uid, [('id', '!=', ids),
                                       ('state', '=', 'done')],
                                 order='id desc',
                                 limit=1,
                                 context=context)

        piv = self.browse(cr, uid, ids[0], context=context)
        fecha_now = datetime.datetime.strptime(piv.date, '%Y-%m-%d')

        if piv_id:
            piv_id = piv_id[0]
            piv_before = self.browse(cr, uid, piv_id, context=context)
            fecha_before = datetime.datetime.strptime(piv_before.date,
                                                      '%Y-%m-%d')
        else:
            fecha_before = False

        inv_ids = []

        if fecha_before:
            inv_ids = inv_obj.search(cr,
                                     uid, [('state', 'in', ('open', 'paid')),
                                           ('date_invoice', '>', fecha_before),
                                           ('date_invoice', '<=', fecha_now),
                                           ('company_id', '=', company_id)],
                                     context=context)
        else:
            inv_ids = inv_obj.search(cr,
                                     uid, [('state', 'in', ('open', 'paid')),
                                           ('date_invoice', '<=', fecha_now),
                                           ('company_id', '=', company_id)],
                                     context=context)

        if not inv_ids:
            raise osv.except_osv(
                _('Error!'),
                _('There are no invoices defined for this period.\nMake sure you are using the right date.'
                  ))
        ail_obj = self.pool.get('account.invoice.line')
        ail_ids = ail_obj.search(cr,
                                 uid, [('invoice_id', 'in', inv_ids),
                                       ('product_id', 'in', prod_ids)],
                                 context=context)
        if not ail_ids:
            raise osv.except_osv(
                _('Error!'),
                _('There are no invoices lines defined for this period.\nMake sure you are using the right date.'
                  ))

        period_brw = period_obj.browse(cr, uid, period_id, context=context)
        date_start = period_brw.date_start
        date_stop = period_brw.date_stop

        sl_obj = self.pool.get('stock.location')
        int_sl_ids = sl_obj.search(cr,
                                   uid, [('usage', '=', 'internal')],
                                   context=context)
        ext_sl_ids = sl_obj.search(cr,
                                   uid, [('usage', '!=', 'internal')],
                                   context=context)

        sm_obj = self.pool.get('stock.move')
        incoming_sm_ids = sm_obj.search(
            cr,
            uid, [
                ('state', '=', 'done'),
                ('company_id', '=', company_id),
                ('location_id', 'in', ext_sl_ids),
                ('location_dest_id', 'in', int_sl_ids),
                ('date', '>=', date_start),
                ('date', '<=', date_stop),
            ],
            context=context)
        outgoing_sm_ids = sm_obj.search(
            cr,
            uid, [
                ('state', '=', 'done'),
                ('company_id', '=', company_id),
                ('location_id', 'in', int_sl_ids),
                ('location_dest_id', 'in', ext_sl_ids),
                ('date', '>=', date_start),
                ('date', '<=', date_stop),
            ],
            context=context)

        # Se establecen parametros para usar en los calculos
        periodic_line = self.pool.get('periodic.inventory.valuation.line')
        lineas = []
        move_id = False
        state = 'draft'

        # Si no se han hecho calculos, se cargan datos iniciales, aqui la condicion deberia ser si el estado es draft
        # Se debe validar que si es el primer registro cargar datos en 0, si no es el primer registro entonces tomar
        # valores del ultimo registro
        if not piv.first:
            state = 'confirm'

            pivline_init_ids = []
            # Se itera sobre los productos que sean de tipo producto y con valuation tipo manual_periodic
            for prod_id in prod_ids:
                prod = prod_obj.browse(cr, uid, prod_id, context=context)

                piv_line_id = False

                if piv_id:
                    piv_line_id = periodic_line.search(
                        cr,
                        uid, [('piv_id', '=', piv_id),
                              ('product_id', '=', prod_id)],
                        context=context)

                # condicional aqui de piv_line_brw, puede que no exista
                if piv_line_id:
                    piv_line_brw = periodic_line.browse(cr,
                                                        uid,
                                                        piv_line_id,
                                                        context=context)[0]
                    line_qty_init = piv_line_brw.qty_final
                    line_average_cost = piv_line_brw.average_cost
                    line_valuation = piv_line_brw.valuation
                else:
                    line_qty_init = 0.0
                    line_average_cost = 0.0
                    line_valuation = 0.0

                # Guardar informacion de la linea piv a crear en el registro actual
                pivline_init_ids.append(
                    periodic_line.create(cr,
                                         uid, {
                                             'piv_id': ids[0],
                                             'product_id': prod_id,
                                             'qty_init': line_qty_init,
                                             'qty_final': 0.0,
                                             'qty_sale': 0.0,
                                             'qty_purchase': 0.0,
                                             'uom_id': prod.uom_id.id,
                                             'average_cost': line_average_cost,
                                             'valuation': line_valuation,
                                         },
                                         context=context))

            # Cargar lineas nuevas en el registro actual
            self.write(cr,
                       uid,
                       ids[0], {
                           'pivl_ids': [(6, 0, pivline_init_ids)],
                       },
                       context=context)
        else:
            state = 'done'
            product_price_purs = {}
            product_price_sales = {}

            # Se iteran que esten pagadas o abiertas y que esten dentro del periodo al que corresponde
            # la fecha actual
            product_price = []
            for ail_id in ail_ids:
                ail = ail_obj.browse(cr, uid, ail_id, context=context)

                # si la factura se relaciona a la lista de productos que se filtraron
                if ail.product_id.id in prod_ids:

                    produc_obj = prod_obj.browse(cr,
                                                 uid,
                                                 ail.product_id.id,
                                                 context=context)

                    price_unit = self.exchange(cr,
                                               uid,
                                               ids,
                                               ail.price_unit,
                                               ail.invoice_id.currency_id.id,
                                               currency_id,
                                               date,
                                               context=context)

                    if ail.invoice_id.type == 'in_invoice':
                        p_p_pur = {'qty': ail.quantity, 'price': price_unit}
                        if product_price_purs.get(ail.product_id.id, False):
                            product_price_purs[ail.product_id.id].append(
                                p_p_pur)
                        else:
                            product_price_purs[ail.product_id.id] = [p_p_pur]
                    elif ail.invoice_id.type == 'out_invoice':
                        p_p_sale = {'qty': ail.quantity, 'price': price_unit}
                        if product_price_sales.get(ail.product_id.id, False):
                            product_price_sales[ail.product_id.id].append(
                                p_p_sale)
                        else:
                            product_price_sales[ail.product_id.id] = [p_p_sale]
                    else:
                        print ail.invoice_id.type
                    product_price.append(ail.product_id.id)

            lineas = []
            for i in prod_ids:

                prod = prod_obj.browse(cr, uid, i, context=context)
                val_line_ids = periodic_line.search(cr,
                                                    uid,
                                                    [('product_id', '=', i),
                                                     ('piv_id', '=', ids[0])],
                                                    context=context)
                val_line = periodic_line.browse(cr,
                                                uid,
                                                val_line_ids,
                                                context=context)[0]
                #~~~~~~~~~~~
                qty_pur = 0
                costo = 0.0
                qty_sale = 0
                # Si el producto fue parte de una compra
                if product_price_purs.get(i, False):
                    for j in product_price_purs[i]:
                        costo += j.get('qty') * j.get('price')
                        qty_pur += j.get('qty')

                # Si el producto fue parte de una venta
                if product_price_sales.get(i, False):
                    for k in product_price_sales[i]:
                        #inventario_final -= k.get('qty')
                        qty_sale += k.get('qty')
                inventario_final = val_line.qty_init + qty_pur - qty_sale

                costo += val_line.valuation
                qty = val_line.qty_init + qty_pur  # este val_line.init es el final de la linea anterior

                if qty == 0:
                    costo_promedio = 0
                else:
                    costo_promedio = round(costo / qty, 2)

                valuation = (val_line.valuation) + (
                    qty_pur * costo_promedio) - (qty_sale * costo_promedio)
                # ~~~~~~~~~~~

                # Algo pasa con prod.property_account_expense y prod.property_account_income
                # Establezco los diarios para hacer los asientos

                # Product valuation and journal item amount
                journal_item = valuation - val_line.valuation

                debit = journal_item > 0 and journal_item or 0.0
                credit = journal_item < 0 and (journal_item * -1) or 0.0

                if journal_item != 0:
                    if prod.property_account_expense:
                        account_expense = prod.property_account_expense
                    else:
                        account_expense = prod.product_tmpl_id.categ_id.property_account_expense_categ

                    account_income = prod.product_tmpl_id.categ_id.property_stock_valuation_account_id

                    if not account_expense or not account_income:
                        raise osv.except_osv(
                            _('Error!'),
                            _('Product Account.\nThere are no accounts defined for the product %s.'
                              % (prod.name)))

                    context['journal_id'] = inventory_valuation_journal_id
                    context['period_id'] = period_id
                    move_line = {
                        'name': 'GANANCIA O PERDIDA DE INVENTARIO',
                        'partner_id': False,
                        'product_id': prod.id,
                        'account_id': account_income.id,
                        'move_id': False,
                        'journal_id': inventory_valuation_journal_id,
                        'period_id': period_id,
                        'date': date_stop,
                        'debit': debit,
                        'credit': credit,
                    }

                    line_id = self.pool.get('account.move.line').create(
                        cr, uid, move_line, context=context)
                    lineas.append(line_id)

                    move_line['account_id'] = account_expense.id
                    move_line['debit'] = credit
                    move_line['credit'] = debit

                    line_id = self.pool.get('account.move.line').create(
                        cr, uid, move_line, context=context)
                    lineas.append(line_id)

                periodic_line.write(
                    cr, uid, val_line.id, {
                        'average_cost': costo_promedio,
                        'valuation': valuation,
                        'qty_sale': qty_sale,
                        'qty_purchase': qty_pur,
                        'qty_final': inventario_final,
                    })
            ##############################################################
            if lineas:
                move_id = self.pool.get('account.move.line').browse(
                    cr, uid, lineas[0], context=context).move_id.id
            else:
                move_id = False

        self.write(
            cr,
            uid,
            ids[0], {
                'product_ids': [(6, 0, prod_ids)],
                'ail_ids': [(6, 0, ail_ids)],
                'date': date or fields.date.today(),
                'stock_move_ids': [(6, 0, incoming_sm_ids + outgoing_sm_ids)],
                'first': True,
                'aml_ids': [(6, 0, lineas)],
                'move_id': move_id,
                'state': state,
            },
            context=context)

        return True
コード例 #50
0
ファイル: delivery.py プロジェクト: CodeFirstLab/odoo
                    _logger.info("Carrier %s: %s", carrier.name, e.name)
                    price = 0.0
              else:
                  price = 0.0
            res[carrier.id] = {
                'price': price,
                'available': available
            }
        return res

    _columns = {
        'name': fields.char('Delivery Method', required=True, translate=True),
        'sequence': fields.integer('Sequence', help="Determine the display order"),
        'partner_id': fields.many2one('res.partner', 'Transport Company', required=True, help="The partner that is doing the delivery service."),
        'product_id': fields.many2one('product.product', 'Delivery Product', required=True),
        'grids_id': fields.one2many('delivery.grid', 'carrier_id', 'Delivery Grids'),
        'available' : fields.function(get_price, string='Available',type='boolean', multi='price',
            help="Is the carrier method possible with the current order."),
        'price' : fields.function(get_price, string='Price', multi='price'),
        'active': fields.boolean('Active', help="If the active field is set to False, it will allow you to hide the delivery carrier without removing it."),
        'normal_price': fields.float('Normal Price', help="Keep empty if the pricing depends on the advanced pricing per destination"),
        'free_if_more_than': fields.boolean('Free If Order Total Amount Is More Than', help="If the order is more expensive than a certain amount, the customer can benefit from a free shipping"),
        'amount': fields.float('Amount', help="Amount of the order to benefit from a free shipping, expressed in the company currency"),
        'use_detailed_pricelist': fields.boolean('Advanced Pricing per Destination', help="Check this box if you want to manage delivery prices that depends on the destination, the weight, the total of the order, etc."),
        'pricelist_ids': fields.one2many('delivery.grid', 'carrier_id', 'Advanced Pricing'),
    }

    _defaults = {
        'active': 1,
        'free_if_more_than': False,
        'sequence': 10,
コード例 #51
0
class create_purchase_requestion(osv.osv_memory):
    """ 
    class to manage the wizard of creating the purchase requestion """

    _description='create purchase requestion'
    _name = 'create.purchase.requestion'
    _columns = {
                'srock_exchange': fields.many2one('exchange.order', 'Stock Exchange', readonly=True),
                'current_date': fields.date('Current Date', readonly=True),
                'products_ids':fields.one2many('create.purchase.requestion.products', 'wizard_id' , 'Products'),                
                }
    
    _defaults = {
                #'srock_exchange':lambda cr,uid,ids,context:context['active_id'] or False,
                'current_date': lambda *a: time.strftime('%Y-%m-%d'),
                }

    def default_get(self, cr, uid, fields, context=None):
        """ 
        To get default values for the object.

        @return: A dictionary which of fields with values.
        """
        if context is None:
            context = {}

        exchang_obj = self.pool.get('exchange.order')
        res ={}
        exchang_ids = context.get('active_ids', [])
        if not exchang_ids:
            return res

        result = []
        for req in exchang_obj.browse(cr, uid, exchang_ids, context=context):
            for product in req.order_line:
                result.append(self.__create_products(product))
        res.update({'products_ids': result})
        if 'current_date' in fields:
            res.update({'current_date': time.strftime('%Y-%m-%d %H:%M:%S')})
        return res

    def __create_products(self, product):
        product_memory = {
            'product_id' : product.product_id.id,
            'product_qty':product.product_qty,
            'stock_exchange_line' : product.id,
            'description': product.notes,
        }
        return product_memory

    def create_purchase_requestion(self, cr, uid, ids, context=None):
        #TODO change the state of the purchase requestion to quotes and let the wizard in specefic state
        """
        Button function to create purchase requestion from the
 
        @return: Purchase Requestion Id
        """        
        purchase_requestion_obj = self.pool.get('ireq.m')
        exchange = self.pool.get('exchange.order').browse(cr, uid, context['active_id'])
        requestion_lines_obj = self.pool.get('ireq.products')
        prod = self.pool.get('product.product')
        wf_service = netsvc.LocalService("workflow")
        if exchange.purchase_requestion_id:
            raise  osv.except_osv(_('Warning'), _('You allredy create a purchase requestion for this exchange order '))
        for wizard in self.browse(cr, uid, ids):
            requestion_id =  purchase_requestion_obj.create(cr, uid, {'company_id': exchange.company_id.id,
                                                                      'user': context['uid'],
                                                                      'cat_id':exchange.category_id.id or False,
                                                                      'ir_ref': exchange.name, 
                                                                      'department_id' : exchange.department_id.id,
                                                                      'exchane_order_id':[(4, exchange.id)],})
            for wizard_lines in wizard.products_ids:
                product = prod.browse(cr, uid,wizard_lines.product_id.id)
                requestion_lines_obj.create(cr, uid, {'pr_rq_id':requestion_id,
                                                      'product_id': wizard_lines.product_id.id,
                                                      'name': product.name,
                                                      'product_qty': wizard_lines.product_qty,
                                                      'product_uom': product.uom_po_id.id, 
                                                      'desc': wizard_lines.description,})
         
        exchange.write({'purchase_requestion_id':requestion_id , 'state' : 'wait_purchase' }) 
        wf_service.trg_validate(uid, 'ireq.m', requestion_id, 'draft', cr)
        return requestion_id
コード例 #52
0
ファイル: company.py プロジェクト: Cywaithaka/odoo-community
                cr,
                uid,
                save_cron
            )

        return super(res_company, self).write(cr, uid, ids, vals, context=context)



    _inherit = "res.company"
    _columns = {
        ### activate the currency update
        'auto_currency_up': fields.boolean('Automatical update of the currency this company'),
        'services_to_use' : fields.one2many(
                                            'currency.rate.update.service',
                                            'company_id',
                                            'Currency update services'
                                            ),
        ###predifine cron frequence
        'interval_type': fields.selection(
                                                [
                                                    ('days','Day(s)'),
                                                    ('weeks', 'Week(s)'),
                                                    ('months', 'Month(s)')
                                                ],
                                                'Currency update frequence',
                                                help="""changing this value will
                                                 also affect other compagnies"""
                                            ),
        ###function field that allows to know the
        ###mutli company currency implementation
コード例 #53
0
ファイル: dym_penyerahan_bpkb.py プロジェクト: kit9/dym
class dym_penyerahan_bpkb(osv.osv):
    _name = "dym.penyerahan.bpkb"

    def _get_default_branch(self,cr,uid,ids,context=None):
        user_obj = self.pool.get('res.users')        
        user = user_obj.browse(cr,uid,uid)
        if user.branch_type!='HO':
            if not user.branch_id:
                return False
            return user.branch_id.id
        else:
            return False

    @api.depends('penyerahan_line.name')
    def _amount_all(self):
        for ib in self:
            amount_total = 0.0
            for line in ib.penyerahan_line:
                ib.update({
                    'total_record': len(ib.penyerahan_line),
                })
    
    _columns = {
        'name': fields.char('No Reference', readonly=True),
        'branch_id': fields.many2one('dym.branch', string='Branch', required=True),
        'division':fields.selection([('Unit','Showroom')], 'Division', change_default=True, select=True),
        'penerima':fields.char('Penerima'),
        'partner_id':fields.many2one('res.partner','Customer'),
        'partner_cabang': fields.many2one('dym.cabang.partner',string='Customer Branch'),
        'keterangan':fields.char('Keterangan'),
        'tanggal':fields.date('Tanggal'),
        'penyerahan_line' : fields.one2many('dym.penyerahan.bpkb.line','penyerahan_id',string="Penyerahan STNK"),  
        'state': fields.selection([('draft', 'Draft'), ('posted','Posted'),('cancel','Canceled')], 'State', readonly=True),
        'engine_no': fields.related('penyerahan_line', 'name', type='char', string='No Engine'),
        'customer_stnk': fields.related('penyerahan_line', 'customer_stnk', type='many2one', relation='res.partner', string='Customer STNK', help=' Syarat Penyerahan BKPB: \
                                    \n* Semua tagihan harus sudah lunas (termasuk pajak progresif). \
                                    \n* Sudah proses STNK. \
                                    \n* Sudah terima BPKB'),
        'no_bpkb': fields.related('penyerahan_line', 'no_bpkb', type='char', string='No BPKB'),
        'tgl_penyerahan_bpkb' :fields.date('Tgl Penyerahan BPKB'),
        'cetak_ke' : fields.integer('Cetak Ke'),     
        'confirm_uid':fields.many2one('res.users',string="Posted by"),
        'confirm_date':fields.datetime('Posted on'),        
        'total_record' : fields.integer(string='Total Engine', store=True, readonly=True, compute='_amount_all'),
    }
 
    _defaults = {
        'state':'draft',
        'division' : 'Unit',
        'tanggal': fields.date.context_today,
        'tgl_penyerahan_bpkb': fields.date.context_today,
        'cetak_ke' : 0,
        'branch_id': _get_default_branch,
    } 
    
    def post_penyerahan(self,cr,uid,ids,context=None):
        val = self.browse(cr,uid,ids)
        lot_pool = self.pool.get('stock.production.lot') 
        tanggal = datetime.now()
        for x in val.penyerahan_line :
            lot_search = lot_pool.search(cr,uid,[
                ('id','=',x.name.id)
                ])
            lot_browse = lot_pool.browse(cr,uid,lot_search)
            lot_browse.write({
                   'tgl_penyerahan_bpkb':x.tgl_ambil_bpkb,
                   'lokasi_bpkb_id':False,
                   })   
        self.write(cr, uid, ids, {'state': 'posted','tanggal':tanggal,'confirm_uid':uid,'confirm_date':datetime.now()})       
        return True
    
    def create(self, cr, uid, vals, context=None):
        # if not vals['penyerahan_line'] :
        #     raise osv.except_osv(('Perhatian !'), ("Tidak ada detail penyerahan. Data tidak bisa di save."))
        lot_penyerahan = []
        for x in vals['penyerahan_line']:
            lot_penyerahan.append(x.pop(2))
        lot_pool = self.pool.get('stock.production.lot')
        penyerahan_pool = self.pool.get('dym.penyerahan.bpkb.line')
        vals['name'] = self.pool.get('ir.sequence').get_per_branch(cr, uid, vals['branch_id'], 'PBK', division='Unit')
        
        vals['tanggal'] = time.strftime('%Y-%m-%d'),
        del[vals['penyerahan_line']]

        
        penyerahan_id = super(dym_penyerahan_bpkb, self).create(cr, uid, vals, context=context) 

        if penyerahan_id :         
            for x in lot_penyerahan :
                lot_search = lot_pool.search(cr,uid,[
                            ('id','=',x['name'])
                            ])
                if not lot_search :
                    raise osv.except_osv(('Perhatian !'), ("No Engine tidak ditemukan !"))
                lot_browse = lot_pool.browse(cr,uid,lot_search)
                lot_browse.write({
                       'penyerahan_bpkb_id':penyerahan_id,
                       })   
                penyerahan_pool.create(cr, uid, {
                    'name':lot_browse.id,
                    'penyerahan_id':penyerahan_id,
                    'customer_stnk':lot_browse.customer_stnk.id,
                    'no_bpkb':lot_browse.no_bpkb,
                    'no_urut':lot_browse.no_urut_bpkb,
                    'tgl_ambil_bpkb':x['tgl_ambil_bpkb']
                })
                           
        else :
            return False
        return penyerahan_id

    def write(self, cr, uid, ids, vals, context=None):
        if context is None:
            context = {}
        vals.get('penyerahan_line',[]).sort(reverse=True)

        collect = self.browse(cr,uid,ids)
        lot_penyerahan = []
        lot_pool = self.pool.get('stock.production.lot')
        line_pool = self.pool.get('dym.penyerahan.bpkb.line')
        lot = vals.get('penyerahan_line', False)
        if lot :
            for x,item in enumerate(lot) :
                lot_id = item[1]
                if item[0] == 2 :               
                    line_search = line_pool.search(cr,uid,[
                                                           ('id','=',lot_id)
                                                           ])
                    line_browse = line_pool.browse(cr,uid,line_search)
                    lot_search = lot_pool.search(cr,uid,[
                                           ('id','=',line_browse.name.id)
                                           ])
                    if not line_search :
                        raise osv.except_osv(('Perhatian !'), ("Nomor Engine tidak ada didalam daftar Penerimaan Line"))
                    if not lot_search :
                        raise osv.except_osv(('Perhatian !'), ("Nomor Engine tidak ada didalam daftar Engine Nomor"))
                    lot_browse = lot_pool.browse(cr,uid,lot_search)
                    # del[vals['penyerahan_line']]
                    lot_browse.write({
                                   'penyerahan_bpkb_id':False,
                                   'tgl_penyerahan_bpkb':False
                                     })
                    # line_pool.unlink(cr,uid,lot_id, context=context)
                        
                elif item[0] == 0 :
                    values = item[2]
                    lot_search = lot_pool.search(cr,uid,[
                                                        ('id','=',values['name'])
                                                        ])
                    if not lot_search :
                        raise osv.except_osv(('Perhatian !'), ("Nomor Engine tidak ada didalam daftar Engine Nomor"))
                    
                    lot_browse = lot_pool.browse(cr,uid,lot_search)
                    lot_browse.write({
                           'penyerahan_bpkb_id':collect.id,
                           }) 
                    
        return super(dym_penyerahan_bpkb, self).write(cr, uid, ids, vals, context=context) 

    def unlink(self, cr, uid, ids, context=None):
        for item in self.browse(cr, uid, ids, context=context):
            if item.state != 'draft':
                raise osv.except_osv(('Perhatian !'), ("Penyerahan BPKB sudah di post ! tidak bisa didelete !"))

        lot_pool = self.pool.get('stock.production.lot')
        lot_search = lot_pool.search(cr,uid,[
                                           ('penyerahan_bpkb_id','=',ids)
                                           ])
        lot_browse = lot_pool.browse(cr,uid,lot_search)
        for x in lot_browse :
            x.write({
                     'tgl_penyerahan_bpkb':False,
                     })
        return super(dym_penyerahan_bpkb, self).unlink(cr, uid, ids, context=context)   
    
    def onchange_partner(self,cr,uid,ids,partner,penerima,context=None):
        warning = {}  
        value = {}  
        result = {}

        obj_browse = self.pool.get('res.partner').browse(cr,uid,[partner]) 


        if partner:
            res_partner = self.pool.get('res.partner').search(cr,uid,[
                                                                      ('id','=',partner)
                                                                      ])
            res_partner_browse = self.pool.get('res.partner').browse(cr,uid,res_partner)            
            if obj_browse.finance_company :
                value = {'penerima':res_partner_browse.name}
        if partner and penerima :
            if obj_browse.finance_company and penerima != obj_browse.name:
                warning = {
                        'title': ('Perhatian !'),
                        'message': ('A/N BPKB adalah Finance Company, Nama Penerima harus sama'),
                    } 
                if warning :
                    value = {'penerima':False}

        result['value'] = value         
        result['warning'] = warning
        return result

    def onchange_branch(self, cr, uid, ids, branch_id, context=None):
        warning = {}  
        domain = {}  
        value = {}  
        result = {}  
        if branch_id:
            branch = self.pool.get('dym.branch').browse(cr,uid,[branch_id])
            domain_lot = ['&','&','&','&',('tgl_proses_birojasa','!=',False),('tgl_terima_bpkb','!=',False),('state_stnk','=','proses_stnk'),('branch_id','=',branch_id),('tgl_penyerahan_bpkb','=',False),'|',('finco_id','!=',False),'&',('customer_id','!=',False),('finco_id','=',False)]
            lot_ids = self.pool.get('stock.production.lot').search(cr, uid, domain_lot)
            lot = self.pool.get('stock.production.lot').browse(cr, uid, lot_ids)
            finco = lot.mapped('finco_id')
            partner = lot.filtered(lambda r: not r.finco_id).mapped('customer_id')
            domain['partner_id'] = ['|',('id','in',finco.ids),('id','in',partner.ids)]
        result['domain'] = domain       
        result['value'] = value         
        result['warning'] = warning
        return result
コード例 #54
0
                        raise orm.except_orm('Error', 'Failure creating the'
                            ' account move lines.')
                else:
                    logging.getLogger(self._name).info("Este activo ya esta asentado!")

    _columns = {
        'asset_code': fields.char('Codigo', size=32, required=False, readonly=False),
        'category_id': fields.many2one('account.asset.category', 'Asset Category', required=True,
                                       change_default=True, readonly=True, states={'draft':[('readonly',False)]},
                                       domain=[('type','=','normal')]),
        'category_parent_id': fields.many2one("account.asset.category", string="Categoria Padre del Activo",
                                              required=False, readonly=True, states={'draft':[('readonly',False)]},
                                              domain=[('type','=','view')] ),
        'account_analytic_id': fields.many2one("account.analytic.account", string="Cuenta analitica",
                                               required=True, domain=[('type','=','normal')]),
        'asset_move_ids': fields.one2many('account.asset.move', 'asset_id','Movimientos'),

        #'asset_move_ids': fields.one2many('account.asset.move', 'asset_id', 'Movements')
    }

    _defaults = {
        'asset_code': lambda obj, cr, uid, context: obj.pool.get('ir.sequence').get(cr, uid, 'asset.number')
    }


class AssetMove(orm.Model):

    _name = 'account.asset.move'
    _description = 'Movimiento de Activo Fijo'

    READONLY_STATES = {
コード例 #55
0
class ResUser(orm.Model):
    _inherit = 'res.users'

    _columns = {
        'user_profile':
        fields.boolean('Is User Profile'),
        'user_profile_id':
        fields.many2one('res.users',
                        'User Profile',
                        domain=[('user_profile', '=', True)],
                        context={'active_test': False}),
        'user_ids':
        fields.one2many('res.users',
                        'user_profile_id',
                        'Users',
                        domain=[('user_profile', '=', False)]),
        'field_ids':
        fields.many2many('ir.model.fields',
                         'res_users_fields_rel',
                         'user_id',
                         'field_id',
                         'Fields to update',
                         domain=[('model', 'in', ('res.users', 'res.partner')),
                                 ('name', 'not in',
                                  ('user_profile', 'user_profile_id',
                                   'user_ids', 'field_ids'))]),
    }

    def _get_default_field_ids(self, cr, uid, ids, context=None):
        return self.pool.get('ir.model.fields').search(
            cr,
            uid, [
                ('model', 'in', ('res.users', 'res.partner')),
                ('name', 'in', ('action_id', 'menu_id', 'groups_id')),
            ],
            context=context)

    _defaults = {
        'field_ids': _get_default_field_ids,
    }

    _sql_constraints = [
        ('active_admin_check', 'CHECK (id = 1 AND active = TRUE OR id <> 1)',
         'The user with id = 1 must be always active!'),
        ('profile_without_profile_id',
         'CHECK( (user_profile = TRUE AND user_profile_id IS NULL) OR user_profile = FALSE )',
         'Profile users cannot be linked to a profile!'),
    ]

    def onchange_user_profile(self, cr, uid, ids, user_profile):
        if user_profile:
            return {
                'value': {
                    'active': ids == [1] and True or False,
                    'user_profile_id': False
                }
            }
        return {}

    def _get_user_vals_from_profile(self,
                                    cr,
                                    uid,
                                    user_profile_id,
                                    context=None):
        vals = {}
        user_profile = self.read(cr, uid, user_profile_id)
        for field in self.pool.get('ir.model.fields').read(
                cr, uid, user_profile['field_ids'], ['name']):
            value = user_profile[field['name']]
            if isinstance(value, tuple):
                value = value[0]
            if isinstance(value, list):
                value = [(6, 0, value)]
            vals[field['name']] = value
        vals['user_ids'] = [(5, 0)]
        return vals

    def create(self, cr, uid, vals, context=None):
        if vals.get('user_profile_id'):
            vals.update(
                self._get_user_vals_from_profile(cr, uid,
                                                 vals['user_profile_id'],
                                                 context))
        return super(ResUser, self).create(cr, uid, vals, context)

    def write(self, cr, uid, ids, vals, context=None):
        if isinstance(ids, (int, long)):
            ids = [ids]
        if vals.get('user_profile_id'):
            new_profile_user_ids = []
            same_profile_user_ids = []
            for user in self.read(cr, uid, ids,
                                  ['user_profile', 'user_profile_id'], context,
                                  '_classic_write'):
                if user['user_profile']:
                    raise orm.except_orm(
                        _('Warning!'),
                        _('You cannot change the profile of a user which is itself a profile!'
                          ))
                if user['user_profile_id'] == vals['user_profile_id']:
                    same_profile_user_ids.append(user['id'])
                else:
                    new_profile_user_ids.append(user['id'])
            if same_profile_user_ids:
                super(ResUser, self).write(cr, uid, same_profile_user_ids,
                                           vals, context)
            if new_profile_user_ids:
                vals.update(
                    self._get_user_vals_from_profile(cr, uid,
                                                     vals['user_profile_id'],
                                                     context))
                super(ResUser, self).write(cr, uid, new_profile_user_ids, vals,
                                           context)
        else:
            super(ResUser, self).write(cr, uid, ids, vals, context)
            for user_profile in self.browse(cr, uid, ids, context):
                if user_profile.user_profile and user_profile.user_ids and any(
                        field.name in vals
                        for field in user_profile.field_ids):
                    profile_vals = self._get_user_vals_from_profile(
                        cr, uid, user_profile.id, context)
                    self.write(cr, uid,
                               [user.id for user in user_profile['user_ids']],
                               profile_vals, context)
        return True

    def copy_data(self, cr, uid, user_id, default=None, context=None):
        default = default.copy() if default else {}
        default['user_ids'] = []
        return super(ResUser, self).copy_data(cr, uid, user_id, default,
                                              context)