Přejít na obsah
Menu
You need to be registered to interact with the community.
This question has been flagged
6775 Zobrazení

Related Error is from its Logger is deprecated

Found the solution ###################  by below code, it from the 'sale promotion' module of openerp 7

migrate it to odoo8 because ,


**********************************************code****************************

try:

    #Backward compatible

    from sets import Set as set

except:

    pass





try:
from sets import Set as set
except:
pass

from openerp.osv import osv, fields
import logging
from openerp.tools.misc import ustr
from openerp.tools.translate import _

# LOGGER = logging()
#LOGGER = netsvc.Logger()
DEBUG = True
PRODUCT_UOM_ID = 1

ATTRIBUTES = [
('amount_untaxed', _('Untaxed Total')),
('amount_tax', 'Tax Amount'),
('amount_total', 'Total Amount'),
('product', 'Product Code in order'),
('prod_qty', 'Product Quantity combination'),
('prod_unit_price', 'Product UnitPrice combination'),
('prod_sub_total', 'Product SubTotal combination'),
# ('prod_net_price', 'Product NetPrice combination'),
('prod_discount', 'Product Discount combination'),
('prod_weight', 'Product Weight combination'),
('comp_sub_total', 'Compute sub total of products'),
('comp_sub_total_x', 'Compute sub total excluding products'),
#('tot_item_qty', 'Total Items Quantity'),
#('tot_weight', 'Total Weight'),
#('tot_item_qty', 'Total Items Quantity'),
('custom', 'Custom domain expression'),
]

COMPARATORS = [
('==', _('equals')),
('!=', _('not equal to')),
('>', _('greater than')),
('>=', _('greater than or equal to')),
('<', _('less than')),
('<=', _('less than or equal to')),
('in', _('is in')),
('not in', _('is not in')),
]

ACTION_TYPES = [
# ('prod_disc_perc', _('Discount % on Product')),
# ('prod_disc_fix', _('Fixed amount on Product')),
# ('cart_disc_perc', _('Discount % on Sub Total')),
# ('cart_disc_fix', _('Fixed amount on Sub Total')),
('prod_x_get_y', _('Buy X get Y free'))
]

class PromotionsRules(osv.Model):
"Bonus Rules"
_name = "promos.rules"
_description = __doc__
_order = 'sequence'

def count_coupon_use(self, cursor, user, ids,
name, arg, context=None):
'''
This function count the number of sale orders(not in cancelled state)
that are linked to a particular coupon.
@param cursor: Database Cursor
@param user: ID of User
@param ids: ID of Current record.
@param name: Name of the field which calls this function.
@param arg: Any argument(here None).
@param context: Context(no direct use).
@return: No. of of sale orders(not in cancelled state)
that are linked to a particular coupon
'''
sales_obj = self.pool.get('sale.order')
res = {}
for promotion_rule in self.browse(cursor, user, ids, context):
matching_ids = []
if promotion_rule.coupon_code:
#If there is uses per coupon defined check if its overused
if promotion_rule.uses_per_coupon > -1:
matching_ids = sales_obj.search(cursor, user,
[
('coupon_code', '=', promotion_rule.coupon_code),
('state', '<>', 'cancel')
], context=context)

res[promotion_rule.id] = len(matching_ids)
return res

_columns = {
'name':fields.char('Bonus Name', size=50, required=True),
'description':fields.text('Description'),
'active':fields.boolean('Active'),
'stop_further':fields.boolean('Stop Checks',
help="Stops further promotions being checked"),
'shop':fields.many2one('stock.warehouse', 'Shop', required=True),
#'shop':fields.char('Shop'),
'partner_categories':fields.many2many(
'res.partner.category',
'rule_partner_cat_rel',
'category_id',
'rule_id',
string="Partner Categories",
help="Applicable to all if none is selected"
),
'coupon_code':fields.char('Bonus Code', size=20),
'uses_per_coupon':fields.integer('Uses per Bonus'),
'uses_per_partner':fields.integer('Uses per Partner'),
'coupon_used': fields.function(
count_coupon_use,
method=True,
type='integer',
string='Number of Bonus Uses',
help='The number of times this coupon has been used.'),
'from_date':fields.datetime('From Date'),
'to_date':fields.datetime('To Date'),
'sequence':fields.integer('Sequence'),
'logic':fields.selection([
('and', 'All'),
('or', 'Any'),
], string="Logic", required=True),
'expected_logic_result':fields.selection([
('True', 'True'),
('False', 'False')
], string="Output", required=True),
'expressions':fields.one2many(
'promos.rules.conditions.exps',
'promotion',
string='Expressions/Conditions'
),
'actions':fields.one2many(
'promos.rules.actions',
'promotion',
string="Actions"
)
}
_defaults = {
'logic':lambda * a:'and',
'expected_logic_result':lambda * a:'True'
}

def promotion_date(self, str_date):
"Converts string date to date"
import time
try:
return time.strptime(str_date, '%Y-%m-%d %H:%M:%S')
except:
try:
return time.strptime(str_date, '%Y-%m-%d')
except:
return str_date


def check_primary_conditions(self, cursor, user,
promotion_rule, order, context):
"""
Checks the conditions for
Coupon Code
Validity Date
@param cursor: Database Cursor
@param user: ID of User
@param promotion_rule: Browse record sent by calling func.
@param order: Browse record sent by calling func.
@param context: Context(no direct use).
"""
sales_obj = self.pool.get('sale.order')
#Check if the customer is in the specified partner cats
if promotion_rule.partner_categories:
applicable_ids = [
category.id \
for category in promotion_rule.partner_categories
]
partner_categories = [
category.id \
for category in order.partner_id.category_id
]
if not set(applicable_ids).intersection(partner_categories):
raise Exception("Not applicable to Partner Category")
if promotion_rule.coupon_code:
#If the codes don't match then this is not the promo
if not order.coupon_code == promotion_rule.coupon_code:
raise Exception("Coupon codes do not match")
# Calling count_coupon_use to check whether no. of
# uses is greater than allowed uses.
count = self.count_coupon_use(cursor, user, [promotion_rule.id],
True, None, context).values()[0]
if count > promotion_rule.uses_per_coupon:
raise Exception("Coupon is overused")
#If a limitation exists on the usage per partner
if promotion_rule.uses_per_partner > -1:
matching_ids = sales_obj.search(cursor, user,
[
('partner_id', '=', order.partner_id.id),
('coupon_code', '=', promotion_rule.coupon_code),
('state', '<>', 'cancel')
], context=context)
if len(matching_ids) > promotion_rule.uses_per_partner:
raise Exception("Customer already used Bonus")
#if a start date has been specified
if promotion_rule.from_date and \
not (self.promotion_date(
order.date_order) >= self.promotion_date(promotion_rule.from_date)):
raise Exception("Order before start of Offers")
#If an end date has been specified
if promotion_rule.to_date and \
not (self.promotion_date(
order.date_order) <= self.promotion_date(promotion_rule.to_date)):
raise Exception("Order after end of Offers")
#All tests have succeeded
return True

def evaluate(self, cursor, user, promotion_rule, order, context=None):
"""
Evaluates if a promotion is valid
@param cursor: Database Cursor
@param user: ID of User
@param promotion_rule: Browse Record
@param order: Browse Record
@param context: Context(no direct use).
"""
if not context:
context = {}
expression_obj = self.pool.get('promos.rules.conditions.exps')
try:
self.check_primary_conditions(
cursor, user,
promotion_rule, order,
context)
except Exception, e:
if DEBUG:
logging.getLogger('Promotions').info(ustr(e))
# netsvc.Logger().notifyChannel("Promotions",
# netsvc.LOG_INFO,
# ustr(e))
return False
#Now to the rules checking
expected_result = eval(promotion_rule.expected_logic_result)
logic = promotion_rule.logic
#Evaluate each expression
for expression in promotion_rule.expressions:
result = 'Execution Failed'
try:
result = expression_obj.evaluate(cursor, user,
expression, order, context)
#For and logic, any False is completely false
if (not (result == expected_result)) and (logic == 'and'):
return False
#For OR logic any True is completely True
if (result == expected_result) and (logic == 'or'):
return True
#If stop_further is given, then execution stops if the
#condition was satisfied
if (result == expected_result) and expression.stop_further:
return True
except Exception, e:
raise osv.except_osv("Expression Error", e)
finally:
if DEBUG:
#True
logging.getLogger('Promotions').info("%s evaluated to %s" % (
expression.serialised_expr,
result
)
)
# netsvc.Logger().notifyChannel(
# "Promotions",
# netsvc.LOG_INFO,
# "%s evaluated to %s" % (
# expression.serialised_expr,
# result
# )
# )
if logic == 'and':
#If control comes here for and logic, then all conditions were
#satisfied
return True
#if control comes here for OR logic, none were satisfied
return False

def execute_actions(self, cursor, user, promotion_rule,
order_id, context):
"""
Executes the actions associated with this rule
@param cursor: Database Cursor
@param user: ID of User
@param promotion_rule: Browse Record
@param order_id: ID of sale order
@param context: Context(no direct use).
"""
action_obj = self.pool.get('promos.rules.actions')
if DEBUG:
#True
logging.getLogger('Promotions').info("Applying promo %s to %s" % (
promotion_rule.id,
order_id
)
)

# netsvc.Logger().notifyChannel(
# "Promotions", netsvc.LOG_INFO,
# "Applying promo %s to %s" % (
# promotion_rule.id,
# order_id
# ))
 

Avatar
Zrušit
Related Posts Odpovědi Zobrazení Aktivita
1
srp 17
2988
1
pro 17
3555
1
kvě 25
2102
0
srp 24
1917
2
čvn 24
8708