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
# ))