Subversion Repositories SmartDukaan

'''
Created on 28-Apr-2010

@author: ashish
'''
from shop2020.utils.Utils import log_entry
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_default_address_id, get_default_pincode,\
    create_user_communication, get_user_communication_by_id, get_user_communication_by_user, get_all_user_communications
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
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

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 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 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.
        If all 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 getUserCount(self, userType):
        """
        Returns number of registered users.
        If anonymous flag = -1, All users
        If anonymous flag = 1, Anonymous users only
        If anonymous flag = 0, Non-anonymous users only
        
        Parameters:
         - anonymousFlag
        """
        return UserDataAccessors.get_user_count(userType)
    
    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()
            
    '''