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, 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
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

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):
        initialize()

    """
    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 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):
        """
        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 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()
            
    '''