Subversion Repositories SmartDukaan

'''
Created on 28-Apr-2010

@author: ashish
'''
from shop2020.utils.Utils import log_entry, to_py_date
from shop2020.model.v1.user.impl.UserDataAccessors import create_user, update_user, get_user_by_id, get_user_by_email, update_password,\
    set_user_as_logged_out, set_user_as_logged_in, remove_address_for_user,\
    add_address_for_user, delete_user, authenticate_user, user_exists, get_user_state, initialize, set_default_address,\
    create_anonymous_user, forgot_password, get_all_addresses_for_user, get_address, get_default_address_id, get_default_pincode,\
    create_user_communication, get_user_communication_by_id, get_user_communication_by_user, get_all_user_communications,\
    create_affiliate, get_affiliate_by_id, get_affiliate_by_name, get_tracker_by_id, add_track_log, get_track_log_by_id, get_track_logs_by_affiliate,\
    get_track_logs_by_user, get_track_logs, create_master_affiliate,\
    get_master_affiliate_by_id, get_master_affiliate_by_name, get_affiliates_by_master_affiliate, get_all_master_affiliates
from shop2020.model.v1.user.impl.CartDataAccessors import create_cart, get_cart,\
    get_cart_by_id, get_cart_by_user_id_and_status, get_carts_by_status,\
    get_carts_between, change_cart_status, add_item_to_cart,\
    change_item_status, add_address_to_cart, commit_cart,\
    validate_cart, merge_cart, delete_item_from_cart, check_out, reset_cart,\
    apply_coupon_to_cart, remove_coupon
from shop2020.model.v1.user.impl.Converters import to_t_user, to_t_user_state, to_t_cart, to_t_address, to_t_user_communication,\
     to_t_master_affiliate, to_t_affiliate, to_t_tracker, to_t_track_log

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

from shop2020.model.v1.user.impl.WidgetDataAccessor import update_my_research, get_browse_history,\
    update_browse_history, delete_item_from_my_research, merge_browse_history, get_my_research
from shop2020.model.v1.user.impl.WidgetConverters import to_t_widget
from shop2020.model.v1.user.impl import UserDataAccessors, CartDataAccessors,\
    WidgetDataAccessor

class UserContextServiceHandler:
    
    
    def __init__(self, dbname='user'):
        initialize(dbname)

    """
    service
    """
    def createAnonymousUser(self, jsessionId):
        try:
            cart = create_cart(-1)
            return to_t_user(create_anonymous_user(jsessionId, cart))
        finally:
            UserDataAccessors.close_session()
    def getUserById(self, userId):
        """
        Parameters:
        - userId
        """
        try:
            return to_t_user(get_user_by_id(userId))
        finally:
            UserDataAccessors.close_session()

    def getUserByEmail(self, email):
        """
        Parameters:
         - email
        """
        try:
            return to_t_user(get_user_by_email(email))
        finally:
            UserDataAccessors.close_session()


    def createUser(self, user):
        """
        Parameters:
        - user
        """
        try:
            cart = create_cart(-1)
            return to_t_user(create_user(user, cart))
        finally:
            UserDataAccessors.close_session()
            
    def updateUser(self, user):
        """
        Parameters:
        - user
        """
        try:
            return to_t_user(update_user(user))
        finally:
            UserDataAccessors.close_session()
            
    def deleteUser(self, userId):
        """
        Parameters:
        - userId
        """
        try:
            return delete_user(userId)
        finally:
            UserDataAccessors.close_session()
            
    def getUserState(self, userId):
        """
        Parameters:
        - userId
        """
        log_entry(self, "get State")
        try:
            return to_t_user_state(get_user_state(userId))
        finally:
            UserDataAccessors.close_session()
            
    def authenticateUser(self, email, password):
        """
        Parameters:
        - email
        - password
        """
        log_entry(self, "authenticate user")
        try:
            return to_t_user(authenticate_user(email, password))
        finally:
            UserDataAccessors.close_session()
            
    def userExists(self, email):
        """
        Parameters:
        - email
        """
        log_entry(self, "user exists")
        try:
            return user_exists(email)
        finally:
            UserDataAccessors.close_session()
            
    def addAddressForUser(self, userId, address, setDefault):
        """
        Parameters:
        - userId
        - address
        - setDefault
        """
        log_entry(self, "add address for user")
        try:
            return add_address_for_user(address, userId, setDefault)
        finally:
            UserDataAccessors.close_session()
            
    def removeAddressForUser(self, userid, addressId):
        """
        Parameters:
        - userid
        - addressId
        """
        log_entry(self, "removing address")
        try:
            return remove_address_for_user(userid, addressId)
        finally:
            UserDataAccessors.close_session()
            
    def setUserAsLoggedIn(self, userId, timestamp):
        """
        Parameters:
        - userId
        - timestamp
        """
        log_entry(self, "set_user_as_logged_in")
        try:
            return set_user_as_logged_in(userId, timestamp)
        finally:
            UserDataAccessors.close_session()
            
    def setUserAsLoggedOut(self, userId, timestamp):
        """
        Parameters:
        - userId
        - timestamp
        """
        log_entry(self, "set user as logged out")
        try:
            return set_user_as_logged_out(userId, timestamp)
        finally:
            UserDataAccessors.close_session()
            
    def setDefaultAddress(self, userId, addressId):
        """
        Parameters:
        - userId
        - addressId
        """
        try:
            return set_default_address(userId, addressId)
        finally:
            UserDataAccessors.close_session()
            
    def updatePassword(self, userid, oldPassword, newPassword):
        """
        Parameters:
         - userid
         - oldPassword
         - newPassword
        """
        log_entry(self, "updating password")
        try:
            return update_password(userid, oldPassword, newPassword)
        finally:
            UserDataAccessors.close_session()
            
    def forgotPassword(self, email, password):
        """
        Parameters:
         - email
        """
        log_entry(self, "forgot password")
        try:
            return forgot_password(email, password)
        finally:
            UserDataAccessors.close_session()
            
    def getAllAddressesForUser(self, userId):
        """
        Parameters:
         - userId
        """
        try:
            addresses = get_all_addresses_for_user(userId)
            
            t_addresses = list()
            for address in addresses:
                t_addresses.append(to_t_address(address))
            return t_addresses
        finally:
            UserDataAccessors.close_session()
              
    def getAddressById(self, addressId):
        """
        Parameters:
         - addressId
        """
        try:
            return to_t_address(get_address(addressId))
        finally:
            UserDataAccessors.close_session()
              
    def getDefaultAddressId(self, userId):
        """
        Parameters:
         - userId
        """
        try:
            return get_default_address_id(userId)
        finally:
            UserDataAccessors.close_session()

    def getDefaultPincode(self, userId):
        """
        Parameters:
         - userId
        """
        try:
            return get_default_pincode(userId)
        finally:
            UserDataAccessors.close_session()

    def createCart(self, userId):
        """
        Parameters:
        - userId
        """
        try:
            return create_cart(userId).id
        finally:
            UserDataAccessors.close_session()
            
    def getCurrentCart(self, userId):
        """
        Parameters:
         - userId
        """
        try:
            cart = get_cart(userId)
            if cart:
                return to_t_cart(cart)
            else:
                raise ShoppingCartException(101, "not cart attached to this user")
        finally:
            CartDataAccessors.close_session()
            
    def getCart(self, cartId):
        """
        Parameters:
         - cartId
        """
        try:
            cart = get_cart_by_id(cartId)
            if cart:
                return to_t_cart(cart)
            else:
                raise ShoppingCartException(101, "not cart attached to this id")
        finally:
            CartDataAccessors.close_session()
            
    def getCartsForUser(self, userId, status):
        """
        Parameters:
         - userId
         - status
        """
        try:
            if not userId:
                raise ShoppingCartException(101, "user_id is not provided")
            
            carts = get_cart_by_user_id_and_status(userId, status)
            t_carts = []
            if carts:
                for cart in carts:
                    t_carts.append(to_t_cart(cart))
            return t_carts
        finally:
            CartDataAccessors.close_session()
                
    def getCartsByStatus(self, status):
        """
        Parameters:
         - status
        """
        try:
            carts = get_carts_by_status(status)
            t_carts = []
            if carts:
                for cart in carts:
                    t_carts.append(to_t_cart(cart))
            return t_carts
        finally:
            CartDataAccessors.close_session()
            
    def getCartsByTime(self, from_time, to_time, status):
        """
        Parameters:
         - from_time
         - to_time
         - status
        """
        try:
            carts = get_carts_between(from_time, to_time, status)
            t_carts = []
            if carts:
                for cart in carts:
                    t_carts.append(to_t_cart(cart))
            return t_carts
        finally:
            CartDataAccessors.close_session()
            
    def changeCartStatus(self, cartId, status):
        """
        Parameters:
         - cartId
         - status
        """
        try:
            change_cart_status(cartId, status)
        finally:
            CartDataAccessors.close_session()
            
    def addItemToCart(self, cartId, itemId, quantity):
        """
        Parameters:
         - cartId
         - itemId
         - quantity
        """
        try:
            add_item_to_cart(cartId, itemId, quantity)
        finally:
            CartDataAccessors.close_session()
            
    def deleteItemFromCart(self, cartId, itemId):
        """
        Parameters:
         - cartId
         - itemId
        """
        try:
            delete_item_from_cart(cartId, itemId)
        finally:
            CartDataAccessors.close_session()
            
    def changeQuantity(self, cartId, itemId, quantity):
        """
        Parameters:
         - cartId
         - itemId
         - quantity
        """
        try:
            add_item_to_cart(cartId, itemId, quantity)
        finally:
            CartDataAccessors.close_session()
            
    def changeItemStatus(self, cartId, itemId, status):
        """
        Parameters:
         - cartId
         - itemId
        """
        try:
            return change_item_status(cartId, itemId, status)
        finally:
            CartDataAccessors.close_session()
            
    def addAddressToCart(self, cartId, addressId):
        """
        Parameters:
         - cartId
         - addressId
        """
        try:
            return add_address_to_cart(cartId, addressId)
        finally:
            CartDataAccessors.close_session()
    
    def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
        '''
        Parameters:
        - cartId
        - couponCode
        - totalPrice
        - discountedPrice
        '''
        try:
            apply_coupon_to_cart(cartId, couponCode, totalPrice, discountedPrice)
        finally:
            CartDataAccessors.close_session()
    
    def removeCoupon(self, cartId):
        '''
        Parameters:
        - cartId
        '''
        try:
            remove_coupon(cartId)
        finally:
            CartDataAccessors.close_session()
    
    def createOrders(self, cartId):
        """
        Parameters:
         - cartId
        """
        try:
            return commit_cart(cartId)
        finally:
            CartDataAccessors.close_session()

    def validateCart(self, cartId):
        """
        Validates that:
        1. The checkout timestamp is greater than the updatedOn timestamp.
        2. All of the lines in the cart are active items.
        3. The estimate for any of the lines in cart doesn't change.
        4. If a Coupon Code is attached, it gets applied and discounted price is computed
        If first three are true, returns empty string; else returns appropriate message.
        
        Parameters:
         - cartId
        """
        try:
            return validate_cart(cartId)
        finally:
            CartDataAccessors.close_session()
            
    def mergeCart(self, fromCartId, toCartId):
        """
        Parameters:
         - fromCartId
         - toCartId
        """
        try:
            merge_cart(fromCartId, toCartId)
        finally:
            CartDataAccessors.close_session()
            
    def checkOut(self, cartId):
        """
        Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
        
        Parameters:
         - cartId
        """
        try:
            return check_out(cartId)
        finally:
            CartDataAccessors.close_session()
            
    def resetCart(self, cartId, items):
        """
        The second parameter is a map of item ids and their quantities which have been successfully processed.
        This methods removes the specified quantiry of the specified item from the cart.
        
        Parameters:
         - cartId
         - items
        """
        try:
            return reset_cart(cartId, items)
        finally:
            CartDataAccessors.close_session()

    #Widget related methods
    def getMyResearch(self, userId):
        """
        Parameters:
         - user_id
        """
        try:
            return to_t_widget(get_my_research(userId))
        finally:
            WidgetDataAccessor.close_session()
    
    def updateMyResearch(self, userId, itemId):
        """
        Parameters:
         - user_id
         - item_id
        """
        try:
            return update_my_research(userId, itemId)
        finally:
            WidgetDataAccessor.close_session()

    def deleteItemFromMyResearch(self, userId, itemId):
        """
        Parameters:
         - user_id
         - item_id
        """
        try:
            return delete_item_from_my_research(userId, itemId)
        finally:
            WidgetDataAccessor.close_session()
            
    def updateBrowseHistory(self, userId, itemId):
        """
        Parameters: 
        - user_id
        - item_id
        """
        try:
            update_browse_history(userId, itemId)
        finally:
            WidgetDataAccessor.close_session()
            
    def getBrowseHistory(self, userId):
        """
        Parameters:
         - user_id
        """
        try:
            return to_t_widget(get_browse_history(userId))
        finally:
            WidgetDataAccessor.close_session()
            
    def mergeBrowseHistory(self, fromUserId, toUserId):
        """
        Parameters:
         - user_id
        """
        try:
            return merge_browse_history(fromUserId, toUserId)
        finally:
            WidgetDataAccessor.close_session()
    
    def saveUserCommunication(self, userId, email, communicationType, orderId, awb, product, subject, message):
        """
        Parameters:
         - userId
         - email
         - communicationType
         - orderId
         - awb
         - product
         - subject
         - message
        """
        try:
            return create_user_communication(userId, email, communicationType, orderId, awb, product, subject, message)
        finally:
            UserDataAccessors.close_session()
    
    def getUserCommunicationById(self, id):
        """
        Parameters:
         - id
        """
        try:
            return to_t_user_communication(get_user_communication_by_id(id))
        finally:
            UserDataAccessors.close_session()
    
    def getUserCommunicationByUser(self, userId):
        """
        Parameters:
         - userId
        """
        try:
            return [to_t_user_communication(user_communication) for user_communication in get_user_communication_by_user(userId)]
        finally:
            UserDataAccessors.close_session()
    
    def getAllUserCommunications(self):
        try:
            return [to_t_user_communication(user_communication) for user_communication in get_all_user_communications()]
        finally:
            UserDataAccessors.close_session()

    def createMasterAffiliate(self, name, addedOn):
        """
        Parameters
         - name
         - addedOn
        """
        try:
            return to_t_master_affiliate(create_master_affiliate(name, addedOn))
        finally:
            UserDataAccessors.close_session()
    
    def getAllMasterAffiliates(self):
        try:
            return [to_t_master_affiliate(masterAffiliate) for masterAffiliate in get_all_master_affiliates()]
        finally:
            UserDataAccessors.close_session()
    
    def getMasterAffiliateById(self, id):
        """
        Parameters
         - id
        """
        try:
            return to_t_master_affiliate(get_master_affiliate_by_id(id))
        finally:
            UserDataAccessors.close_session()
    
    def getMasterAffiliateByName(self, name):
        """
        Parameters
         - id
        """
        try:
            return to_t_master_affiliate(get_master_affiliate_by_name(name))
        finally:
            UserDataAccessors.close_session()
    
    def createAffiliate(self, name, url, masterAffiliateId, addedOn):
        """
        Parameters
         - name
         - url
         - masterAffiliateId
         - addedOn
        """
        try:
            return to_t_affiliate(create_affiliate(name, url, masterAffiliateId, addedOn))
        finally:
            UserDataAccessors.close_session()
    
    def getAffiliateById(self, id):
        """
        Parameters
         - id
        """
        try:
            return to_t_affiliate(get_affiliate_by_id(id))
        finally:
            UserDataAccessors.close_session()
    
    def getAffiliateByName(self, name):
        """
        Parameters
         - name
        """
        try:
            return to_t_affiliate(get_affiliate_by_name(name))
        finally:
            UserDataAccessors.close_session()
    
    def getAffiliatesByMasterAffiliate(self, masterAffiliateId):
        """
        Parameters
         - master_id
        """
        try:
            return [to_t_affiliate(affiliate) for affiliate in get_affiliates_by_master_affiliate(masterAffiliateId)]
        finally:
            UserDataAccessors.close_session()
            
    def getTrackerById(self, trackerId):
        """
        Parameters
         - trackerId
        """
        try:
            return to_t_tracker(get_tracker_by_id(trackerId))
        finally:
            UserDataAccessors.close_session()
            
    def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
        """
        Parameter
         - affiliateId
         - userId
         - event
         - url
         - data
         - addedOn
        """
        try:
            return add_track_log(affiliateId, userId, event, url, data, addedOn)
        finally:
            UserDataAccessors.close_session()
    
    def getTrackLogById(self, id):
        """
        Parameter
         - id
        """
        try:
            return to_t_track_log(get_track_log_by_id(id))
        finally:
            UserDataAccessors.close_session()
    
    def getTrackLogsByAffiliate(self, affiliateId):
        """
        Parameter
         - affiliate_id
        """
        try:
            return [to_t_track_log(track_log) for track_log in get_track_logs_by_affiliate(affiliateId)]
        finally:
            UserDataAccessors.close_session()
    
    def getTrackLogsByUser(self, user_id):
        """
        Parameter
         - user_id
        """
        try:
            return [to_t_track_log(track_log) for track_log in get_track_logs_by_user(user_id)]
        finally:
            UserDataAccessors.close_session()
    
    def getTrackLogs(self, affiliateId, userId, event, url):
        """
        Parameter
         - affiliateId
         - userId
         - event
         - url
        """
        try:
            return [to_t_track_log(track_log) for track_log in get_track_logs(affiliateId, userId, event, url)]
        finally:
            UserDataAccessors.close_session()
    
    def getUserCount(self, userType):
        """
        Returns number of registered users.
        If userType = null, then it returns count of all users, including anonymous
        If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
        If userType = UserType.USER, then it returns count of non-anonymous users only
        
        Parameters:
         - userType
        """
        try:
            return UserDataAccessors.get_user_count(userType)
        finally:
            UserDataAccessors.close_session()

    def getAllUsers(self, userType, startDate, endDate):
        """
        Returns list of users of type userType. If userType is null, then returns all the users.
        
        Parameters:
         - userType
        """
        try:
            users = UserDataAccessors.get_users(userType, startDate, endDate)
            t_users = list()
            for user in users:
                t_users.append(to_t_user(user))
            return t_users
        finally:
            UserDataAccessors.close_session()
    
    def closeSession(self, ):
        CartDataAccessors.close_session()
        UserDataAccessors.close_session()
        WidgetDataAccessor.close_session()

        
    '''        
    def addWidget(self, widget):
        """
        Parameters:
         - widget
        """
        try:
            add_widget(widget)
        finally:
            WidgetDataAccessor.close_session()
    
    def addItemToWidget(self, widget_id, items):
        """
        Parameters:
         - widget_id
         - items
        """
        try:
            add_items_to_widget(widget_id, items)
        finally:
            WidgetDataAccessor.close_session()
            
    def updateWidget(self, widgetId, enable):
        """
        Parameters:
         - widgetId
         - enable
        """
        try:
            update_widget(widgetId, enable)
        finally:
            WidgetDataAccessor.close_session()
            
    def updateWidgetItem(self, widgetId, enable):
        """
        Parameters:
         - widgetId
         - enable
        """
        try:
            update_widget(widgetId, enable)
        finally:
            WidgetDataAccessor.close_session()
            
    def deleteItemFromWidget(self, widget_id, item_id):
        """
        Parameters:
         - widget_id
         - item_id
        """
        try:
            return delete_item_from_widget(widget_id, item_id)
        finally:
            WidgetDataAccessor.close_session()
            
    def getWidget(self, type, userId, onlyEnabled):
        """
        Parameters:
         - type
         - userId
         - onlyEnabled
        """
        try:
            widget = get_widget_by_type(type, userId, onlyEnabled)
            return to_t_widget(widget)
        finally:
            WidgetDataAccessor.close_session()
            
    def updateRatings(self, item_id, type, rating, user_id):
        """
        Parameters:
        - item_id
        - type
        - rating
        - user_id
        """
        try:
            update_ratings(user_id, item_id, rating, type)
        finally:
            WidgetDataAccessor.close_session()
            
    def getRatings(self, item_id, user_id):
        """
        Parameters:
        - item_id
        - user_id
        """
        try:
            all_ratings, user_ratings = get_ratings(user_id, item_id)
            return to_t_ratings(user_ratings, all_ratings, item_id, user_id)
        finally:
            WidgetDataAccessor.close_session()
            
    '''