Subversion Repositories SmartDukaan

'''

Created on May 24, 2010

@author: Varun Gupta

'''

from elixir import session

from shop2020.clients.CatalogClient import CatalogClient

from shop2020.clients.UserClient import UserClient

from shop2020.model.v1.user.impl import Dataservice

from shop2020.model.v1.user.impl.Dataservice import Promotion, Coupon, \

    PromotionTracker, RechargeVoucher

from shop2020.model.v1.user.impl.PromotionRuleDataUtilities import \

    get_coupon_usage_count, get_coupon_usage_count_by_user

from shop2020.thriftpy.model.v1.user.ttypes import PromotionException

from shop2020.utils.Utils import to_py_date

from sqlalchemy.sql.expression import exists

from string import Template

import datetime

import traceback

import uuid

from shop2020.model.v1.user.impl.Converters import to_t_coupon

from shop2020.model.v1.user.promotionrules import rule_specific_emi_discount_on_specific_items

def initialize(dbname = 'user', db_hostname="localhost"):

    Dataservice.initialize(dbname, db_hostname)

def create_promotion(name, rule_execution_src, start_on, end_on):

    promotion = Promotion()

    promotion.name = name

    promotion.rule_execution_src = rule_execution_src

    promotion.start_on = to_py_date(start_on)

    promotion.end_on = to_py_date(end_on)

    promotion.created_on = datetime.datetime.now()

    session.commit()

def get_all_promotions():

    return Promotion.query.all()

def generate_coupons_for_promotion(promotion_id, coupon_code):

    promotion = Promotion.get_by(id = promotion_id)

    coupon = Coupon()

    coupon.promotion = promotion

    coupon.coupon_code = coupon_code

    coupon.arguments = ""

    session.commit()

def remove_all_coupons_by_promotion_id(promotion_id):

    promotion = Promotion.get_by(id=promotion_id)

    if(promotion is None):

        raise PromotionException(101, 'Could not find Promotion for id' + str(promotion_id))

    elif(promotion.end_on > datetime.datetime.now()):

        raise PromotionException(111, 'This promotion is still running. Promotion id' + str(promotion_id))

    deletecount = Coupon.query.filter_by(promotion_id = promotion_id).delete()

    session.commit()

    return deletecount

def create_coupon(promotionId, couponCode, arguments, isCod, prefix=None):

    if promotionId not in (26,27,28):

        raise PromotionException(101, 'Only promotion ids 26 and 27 are expected')

    promotion = Promotion.get_by(id = promotionId)

    if promotion:

        if couponCode == '':

            coupon_code = uuid.uuid4().hex[:10] if prefix is None else prefix + uuid.uuid4().hex[:10]

        else:

            coupon_code = couponCode

        coupon = Coupon.get_by(coupon_code = coupon_code)

        while coupon is not None:

            coupon_code = uuid.uuid4().hex[:10] if prefix is None else prefix + uuid.uuid4().hex[:10]

            coupon = Coupon.get_by(coupon_code = coupon_code)

        coupon = Coupon()

        coupon.promotion = promotion

        coupon.coupon_code = coupon_code

        coupon.arguments = arguments

        session.commit()

        return coupon_code

    else:

        raise PromotionException(101, 'Could not find Promotion for id' + str(promotionId))

def get_coupon(coupon_code):

    return Coupon.get_by(coupon_code = coupon_code)

def apply_recharge_coupon(coupon_code, total_amount, user_id):

    coupon = Coupon.get_by(coupon_code = coupon_code)

    discount = 0

    if coupon:

        args = eval(coupon.arguments) if coupon.arguments is not None else {}

        todate = datetime.datetime.now()

        if 'endOn' in args and todate > to_py_date(args['endOn']) :

            return {0:'This coupon has expired'}

        if 'minDiscountableVal' in args and total_amount < int(args['minDiscountableVal']):

            return {0:'This coupon is valid for purchases equal to or more than Rs.' + (args['minDiscountableVal'])}

        if 'couponType' not in args or args['couponType'] not in ('recharge','both'):

            return {0:'Invalid Coupon'}

        isUserSpecific = False

        if args['emails'] != '*':

            user_client = UserClient().get_client()

            user = user_client.getUserById(user_id)

            isUserSpecific = True

            if user.email not in args['emails']:

                return {0:'Invalid coupon'}

        if 'startHour' in args and 'startMinute' in args and 'endHour' in args and 'endMinute' in args :

            startHour = int(args['startHour'])

            startMinute = int(args['startMinute'])

            endHour = int(args['endHour'])   

            endMinute = int(args['endMinute'])

            now = datetime.datetime.now()

            curtime = datetime.time(now.hour, now.minute, now.second)

            starttime = datetime.time(startHour, startMinute, 0)

            endtime = datetime.time(endHour, endMinute, 0)

            if (curtime < starttime or curtime > endtime):

                return {0:'Currently this coupon is unavailable'}

        if 'usage_limit_for_user' in args :

            userLimit = args['usage_limit_for_user']

        else :

            userLimit = 1

        count_coupon_usage_by_user = get_coupon_usage_count_by_user(coupon_code, user_id)

        if count_coupon_usage_by_user >= userLimit:

            return {0:'Invalid Coupon'}

        if 'globalLimit' in args :

            globalLimit = args['globalLimit']

            count_coupon_usage = get_coupon_usage_count(coupon_code)

            if count_coupon_usage >= globalLimit:

                return {0:'This promotion is over.'}

        if 'discountType' in args:

            discountType = args['discountType']

        else :

            discountType = 'absolute' #Default is absolute

        if discountType == 'percent' :

            discount = round(total_amount * (args['discount']/float(100)))

        elif discountType == 'absolute' :

            discount = min(args['discount'], total_amount)

        else :

            return {0 : 'Invalid coupon'}

        if 'maxDiscount' in args and discount > int(args['maxDiscount']):

            return {int(args['maxDiscount']):"Coupon Applied"}

        if isUserSpecific :

            return {discount:'login'}

        return {discount:'Coupon Applied'}

    else:

        return {0:'Invalid Coupon'}

def apply_coupon(coupon_code, cart_id):

    coupon = Coupon.get_by(coupon_code = coupon_code)

    if coupon:

        todate = datetime.datetime.now()

        if not (coupon.promotion.start_on <=  todate and coupon.promotion.end_on >= todate):

            raise PromotionException(101, 'Promotion has expired')

        user_client = UserClient().get_client()

        cart = user_client.getCart(cart_id)

        coupon_module = coupon.promotion.rule_execution_src.strip()

        try:

            user_client.deleteDiscountsFromCart(cart_id)

            imported_coupon_module = __import__("shop2020.model.v1.user.promotionrules", globals(), locals(), [coupon_module])

            rule = eval("imported_coupon_module." + coupon_module)

            args = eval(coupon.arguments) if coupon.arguments is not None else {}

            '''

            Processing in case of EMI

            '''

            if coupon.promotion.type == 2:

                updated_cart = rule.execute(cart, coupon_code, args)

            else:

                updated_cart, discounts = rule.execute(cart, coupon_code, args)

                if discounts and len(discounts) > 0:    

                    user_client.saveDiscounts(discounts)

            user_client.applyCouponToCart(updated_cart, coupon_code)

            return updated_cart

        except ImportError as e:

            traceback.print_stack()

            #TODO: Better message

            raise PromotionException(100, 'Internal error occurred.')

    else:

        print 'Invalid Coupon Code'

        raise PromotionException(101, 'Invalid Coupon Code')

def get_emi_discount(cart_id):

    try:

        user_client = UserClient().get_client()

        cart = user_client.getCart(cart_id)

        if not (cart.couponCode is None or cart.couponCode == ""):

            coupon = Coupon.get_by(coupon_code = cart.couponCode)

            args = eval(coupon.arguments) if coupon.arguments is not None else {}

            if coupon.promotion.type != 2:

                return {}

            else:

                return rule_specific_emi_discount_on_specific_items.getEmiDiscounts(cart, coupon.coupon_code, args)

        else:

            return {}

    except ImportError as e:

        traceback.print_stack()

        return {}

def track_coupon_usage(coupon_code, transaction_id, user_id):

    promotion_tracker = PromotionTracker()

    promotion_tracker.coupon_code = coupon_code

    promotion_tracker.transaction_id = transaction_id

    promotion_tracker.user_id = user_id

    promotion_tracker.applied_on = datetime.datetime.now()

    session.commit()

def get_active_coupons():

    return Coupon.query.all()

def get_successful_payment_count_for_coupon(coupon_code):

    return PromotionTracker.query.filter_by(coupon_code = coupon_code).count()

def get_rule_doc_string(rule_name):

    imported_coupon_module = __import__("shop2020.model.v1.user.promotionrules", globals(), locals(), [rule_name])

    rule = eval("imported_coupon_module." + rule_name)

    return rule.__doc__

def close_session():

    if session.is_active:

        session.close()

def is_alive():

    try:

        session.query(Promotion.id).limit(1).one()

        return True

    except:

        return False

def get_discounts_for_entity(entity_id):

    catalog_client = CatalogClient().get_client()

    items = catalog_client.getItemsByCatalogId(entity_id)

    discount_finder = ItemDiscountFinder()

    discounts = discount_finder.getCouponsAndDiscountsOnItem(items[0])

    if len(discounts) > 0:

        return {discounts[0][0]: discounts[0][1]}

    else:

        return {}

def get_item_discount_map(item_ids):

    discount_finder = ItemDiscountFinder()

    item_coupons_discounts = []

    catalog_client = CatalogClient().get_client()

    for item_id in item_ids:

        item = catalog_client.getItem(item_id)

        discounts = discount_finder.getCouponsAndDiscountsOnItem(item)

        for discount in discounts:

            item_coupons_discounts.append((item_id, discount[0], discount[1]))

            break

    return item_coupons_discounts

def get_active_gvs(promotion_id):

    all_coupons = session.query(Coupon).filter_by(promotion_id=promotion_id).filter(~exists().where(Coupon.coupon_code==PromotionTracker.coupon_code)).all()

    return [to_t_coupon(coupon) for coupon in all_coupons]

def delete_coupon(coupon_code):

    Coupon.query.filter_by(coupon_code = coupon_code).delete()

    session.commit()

def get_all_coupons_by_promotion_id(promotion_id):

    all_coupons = Coupon.query.filter_by(promotion_id = promotion_id).all()

    return [to_t_coupon(coupon) for coupon in all_coupons]

def add_voucher(t_voucher):

    voucher = RechargeVoucher()

    voucher.available = True

    voucher.amount = t_voucher.amount

    voucher.voucherCode = t_voucher.voucherCode

    voucher.voucherType = t_voucher.voucherType

    if t_voucher.issuedOn:

        voucher.issuedOn = to_py_date(t_voucher.issuedOn)

    if t_voucher.expiredOn:

        voucher.expiredOn = to_py_date(t_voucher.expiredOn)

    session.commit()

def assign_voucher(userId, userEmail, voucherType, amount):

    voucher = RechargeVoucher.query.filter_by(voucherType = voucherType, amount = amount, available = True).first()

    if not voucher:

        raise PromotionException(501, 'Voucher of this type is not available.')

    voucher.userId = userId

    voucher.available = False

    voucher.issuedOn = datetime.datetime.now()

    voucher.email = userEmail

    session.commit()

    return voucher

def mark_voucher_as_redeemed(voucherCode, redeemedOn):

    voucher = RechargeVoucher.query.filter_by(voucherCode = voucherCode).first()

    voucher.redeemedOn = to_py_date(redeemedOn)

    voucher.redeemed = True

    session.commit()

    return True

class ItemDiscountFinder:

    def __init__(self):

        self.coupon_modules = {}

        coupons = get_active_coupons()

        for coupon in coupons:

            if coupon.coupon_code not in ('SAHOLIC4RS', 'SAndroid', 'SAHOLIC4MJ', 'SAHOLIC4SS', 'SJunglee'):

                coupon_rule = coupon.promotion.rule_execution_src.strip()

                imported_coupon_module = __import__("shop2020.model.v1.user.promotionrules", globals(), locals(), [coupon_rule])

                self.coupon_modules[coupon.coupon_code] = eval("imported_coupon_module." + coupon_rule)

    def getCouponsAndDiscountsOnItem(self, item):

        discounts = []

        for coupon_code, coupon_rule_module in self.coupon_modules.iteritems():

            discount = coupon_rule_module.getDiscountOnItem(item)

            if discount is not None:

                discounts.append((coupon_code, discount))

        return discounts