WebSVN – SmartDukaan – Diff – /trunk/PyProj/src/shop2020/model/v1/user/impl/UserContextSerivceHandler.py

 Created on 28-Apr-2010
 @author: ashish
 '''
 from shop2020.utils.Utils import log_entry
-from shop2020.model.v1.user.impl.DataAccessors import add_social_handle,\
+from shop2020.model.v1.user.impl.UserDataAccessors import create_user, update_user, get_user_by_id, update_password,\
-    delete_user, update_password, set_user_as_logged_out, set_user_as_logged_in,\
+    set_user_as_logged_out, set_user_as_logged_in, remove_address_for_user,\
-    remove_address_for_user, add_address_for_user, add_ip_address_for_user,\
+    add_address_for_user, delete_user, authenticate_user, user_exists, get_user_state, initialize, set_default_address,\
+    create_anonymous_user
+from shop2020.model.v1.user.impl.CartDataAccessors import create_cart, get_cart,\
-    user_exists, authenticate_user, get_context, get_internal_info,\
+    get_cart_by_id, get_cart_by_user_id_and_status, get_carts_by_status,\
-    get_primary_info, get_state, get_context_by_email_or_handle,\
+    get_carts_between, change_cart_status, add_item_to_cart,\
-    get_context_by_session_id, get_context_by_id, create_context, update_context,\
+    change_item_quantity, change_item_status, add_address_to_cart, commit_cart,\
-    initialize, set_default_address
+    validate_cart, merge_cart, delete_item_from_cart
-from shop2020.model.v1.user.impl.Converters import to_t_user_context,\
+from shop2020.model.v1.user.impl.Converters import to_t_user, to_t_user_state, to_t_cart
+from shop2020.clients.TransactionClient import TransactionClient
+from shop2020.thriftpy.model.v1.user.ttypes import ShoppingCartException
+from shop2020.model.v1.user.impl.WidgetDataAccessor import add_widget,\
+    add_items_to_widget, update_my_research, update_widget, get_widget_by_type,\
-    to_t_internal_info, to_t_primary_info, to_t_user_state
+    get_my_research, get_ratings, update_ratings, get_browse_history,\
+    update_browse_history, delete_item_from_my_research, delete_item_from_widget
+from shop2020.model.v1.user.impl.WidgetConverters import to_t_widget, to_t_ratings
 class UserContextServiceHandler:
     def __init__(self):
         initialize()
+        self.transaction_client = TransactionClient()
     """
-    User session context service handler
+    service
     """
-    def createContext(self, context, updateExisting):
+    def createAnonymousUser(self, jsessionId):
+        cart = create_cart(-1)
+        return to_t_user(create_anonymous_user(jsessionId, cart))
+    def getUserById(self, userId):
         """
         Parameters:
-         - context
+        - userId
-         - updateExisting
         """
-        log_entry(self, "create or update context")
-        if not updateExisting:
-            id = create_context(context)
-        else:
-            id = update_context(context)
-        return to_t_user_context(get_context_by_id(id))
+        return to_t_user(get_user_by_id(userId))
-        pass
-    def getContextFromId(self, userId, isSessionId):
+    def createUser(self, user):
         """
         Parameters:
-         - userId
+        - user
-         - isSessionId
         """
-        log_entry(self, "get context from id")
-        if isSessionId:
+        cart = create_cart(-1)
-            return to_t_user_context(get_context_by_session_id(userId))
-        else:
-            return to_t_user_context(get_context_by_id(userId))
+        return to_t_user(create_user(user, cart))
-        pass
-    def getContextFromEmailOrHandle(self, emailorhandle, isEmail):
+    def updateUser(self, user):
         """
         Parameters:
-         - emailorhandle
-         - isEmail
+        - user
         """
-        log_entry(self, "get context from email or handle")
+        return to_t_user(update_user(user))
-        return to_t_user_context(get_context_by_email_or_handle(emailorhandle, isEmail))
-        pass
-    def getState(self, userId, isSessionId):
+    def deleteUser(self, userId):
         """
         Parameters:
-         - userId
+        - userId
+        """
+        return delete_user(userId)
+    def getUserState(self, userId):
+        """
+        Parameters:
-         - isSessionId
+        - userId
         """
         log_entry(self, "get State")
-        return to_t_user_state(get_state(userId, isSessionId))
+        return to_t_user_state(get_user_state(userId))
+    def authenticateUser(self, email, password):
+        """
+        Parameters:
+        - email
+        - password
+        """
+        log_entry(self, "authenticate user")
+        return to_t_user(authenticate_user(email, password))
+    def userExists(self, email):
+        """
+        Parameters:
+        - email
+        """
+        log_entry(self, "user exists")
+        return user_exists(email)
+    def addAddressForUser(self, userId, address, timestamp, setDefault):
+        """
+        Parameters:
+        - userId
+        - address
+        - timestamp
+        - setDefault
+        """
+        log_entry(self, "add address for user")
+        return add_address_for_user(address, userId, timestamp, setDefault)
+    def removeAddressForUser(self, userid, addressId):
+        """
+        Parameters:
+        - userid
+        - addressId
+        """
+        log_entry(self, "removing address")
+        return remove_address_for_user(userid, addressId)
+    def setUserAsLoggedIn(self, userId, timestamp):
+        """
+        Parameters:
+        - userId
+        - timestamp
+        """
+        log_entry(self, "set_user_as_logged_in")
+        return set_user_as_logged_in(userId, timestamp)
+    def setUserAsLoggedOut(self, userId, timestamp):
+        """
+        Parameters:
+        - userId
+        - timestamp
-        pass
+        """
+        log_entry(self, "set user as logged out")
+        return set_user_as_logged_out(userId, timestamp)
+    def setDefaultAddress(self, userId, addressId):
+        """
+        Parameters:
+        - userId
+        - addressId
+        """
+        return set_default_address(userId, addressId)
-    def getPrimaryInfo(self, userId, isSessionId):
+    def updatePassword(self, userId, password):
+        """
+        Parameters:
+        - userId
+        - password
+        """
+        log_entry(self, "updating password")
+        return update_password(userId, password)
+    def createCart(self, userId):
+        """
+        Parameters:
+        - userId
+        """
+        return create_cart(userId).id
+    def getCurrentCart(self, userId):
         """
         Parameters:
          - userId
-         - isSessionId
         """
+        cart = get_cart(userId)
+        if cart:
-        log_entry(self, "get primary info")
+            return to_t_cart(cart)
+        else:
-        return to_t_primary_info(get_primary_info(userId, isSessionId))
+            raise ShoppingCartException(101, "not cart attached to this user")
+    def getCart(self, cartId):
+        """
+        Parameters:
+         - cartId
+        """
+        cart = get_cart_by_id(cartId)
+        if cart:
+            return to_t_cart(cart)
-        pass
+        else:
+            raise ShoppingCartException(101, "not cart attached to this id")
-    def getInternalInfo(self, userId, isSessionId):
+    def getCartsForUser(self, userId, status):
         """
         Parameters:
          - userId
-         - isSessionId
+         - status
         """
+        if not userId:
-        log_entry(self, "get internal info")
+            raise ShoppingCartException(101, "user_id is not provided")
-        return to_t_internal_info(get_internal_info(userId, isSessionId))
+        carts = get_cart_by_user_id_and_status(userId, status)
+        t_carts = []
-        pass
+        if carts:
+            for cart in carts:
+                t_carts.append(to_t_cart(cart))
+        return t_carts
-    def getContext(self, email, password):
+    def getCartsByStatus(self, status):
         """
         Parameters:
-         - email
+         - status
-         - password
         """
+        carts = get_carts_by_status(status)
+        t_carts = []
+        if carts:
-        log_entry(self, "get context")
+            for cart in carts:
-        return to_t_user_context(get_context(email, password))
+                t_carts.append(to_t_cart(cart))
-        pass
+        return t_carts
-    def authenticateUser(self, handle, password, isEmail):
+    def getCartsByTime(self, from_time, to_time, status):
         """
         Parameters:
-         - handle
+         - from_time
-         - password
+         - to_time
-         - isEmail
+         - status
         """
+        carts = get_carts_between(from_time, to_time, status)
+        t_carts = []
+        if carts:
-        log_entry(self, "authenticate user")
+            for cart in carts:
-        return authenticate_user(handle, password)
+                t_carts.append(to_t_cart(cart))
-        pass
+        return t_carts
-    def userExists(self, email):
+    def changeCartStatus(self, cartId, status):
         """
         Parameters:
+         - cartId
-         - email
+         - status
         """
-        log_entry(self, "user exists")
+        change_cart_status(cartId, status)
-        return user_exists(email)
-        pass
-    def addIpAdressForUser(self, ip, timestamp, userId):
+    def addItemToCart(self, cartId, itemId, quantity):
         """
         Parameters:
-         - ip
+         - cartId
-         - timestamp
+         - itemId
-         - userId
+         - quantity
         """
-        log_entry(self, "add ipaddress for user")
-        return add_ip_address_for_user(ip, timestamp, userId)
+        return add_item_to_cart(cartId, itemId, quantity)
-        pass
-    def addAddressForUser(self, address, userid, timestamp, setDefault):
+    def deleteItemFromCart(self, cartId, itemId):
         """
         Parameters:
-         - address
+         - cartId
-         - userid
+         - itemId
-         - timestamp
-         - setDefault
         """
-        log_entry(self, "add address for user")
+        delete_item_from_cart(cartId, itemId)
-        return add_address_for_user(address, userid, timestamp, setDefault)
+    def changeQuantity(self, cartId, itemId, quantity):
+        """
+        Parameters:
+         - cartId
+         - itemId
+         - quantity
-        pass
+        """
+        return change_item_quantity(cartId, itemId, quantity)
+    def changeItemStatus(self, cartId, itemId, status):
+        """
+        Parameters:
+         - cartId
+         - itemId
+        """
+        return change_item_status(cartId, itemId, status)
-    def removeAddressForUser(self, userid, addressId):
+    def addAddressToCart(self, cartId, addressId):
         """
         Parameters:
-         - userid
+         - cartId
          - addressId
         """
-        log_entry(self, "removing address")
-        return remove_address_for_user(userid, addressId)
+        return add_address_to_cart(cartId, addressId)
-        pass
-    def setUserAsLoggedIn(self, userId, timestamp):
+    def commitCart(self, cartId):
         """
         Parameters:
-         - userId
+         - cartId
-         - timestamp
         """
-        log_entry(self, "set_user_as_logged_in")
-        return set_user_as_logged_in(userId, timestamp)
+        return commit_cart(cartId, self.transaction_client)
-        pass
-    def setUserAsLoggedOut(self, userid, timestamp):
+    def validateCart(self, cartId):
         """
         Parameters:
-         - userid
+         - cartId
-         - timestamp
         """
-        log_entry(self, "set user as logged out")
-        return set_user_as_logged_out(userid, timestamp)
+        return validate_cart(cartId)
-        pass
-    def setDefaultAddress(self, userid, addressId):
+    def mergeCart(self, fromCartId, toCartId):
         """
         Parameters:
-         - userid
+         - fromCartId
-         - addressId
+         - toCartId
         """
-        return set_default_address(userid, addressId)
+        merge_cart(fromCartId, toCartId)
-        pass
-    def updatePassword(self, userid, password):
+    def addWidget(self, widget):
         """
         Parameters:
-         - userid
+         - widget
-         - password
         """
-        log_entry(self, "updating password")
+        add_widget(widget)
-        return update_password(userid, password)
-        pass
-    def deleteUser(self, userid, isSessionId):
+    def addItemToWidget(self, widget_id, items):
         """
         Parameters:
-         - userid
+         - widget_id
-         - isSessionId
+         - items
         """
-        log_entry(self, "Deleting user")
+        add_items_to_widget(widget_id, items)
-        return delete_user(userid, isSessionId)
-    def sendEmailVerification(self, userid):
+    def updateMyResearch(self, user_id, item_id):
         """
         Parameters:
-         - userid
+         - user_id
+         - item_id
         """
-        pass
+        return update_my_research(user_id, item_id)
-    def sendSMSVerification(self, userid):
+    def updateWidget(self, widgetId, enable):
         """
         Parameters:
-         - userid
+         - widgetId
+         - enable
         """
-        pass
+        update_widget(widgetId, enable)
+    def updateWidgetItem(self, widgetId, enable):
+        """
+        Parameters:
+         - widgetId
+         - enable
+        """
+        update_widget(widgetId, enable)
-    def confirmEmailVerification(self, userid):
+    def deleteItemFromWidget(self, widget_id, item_id):
         """
         Parameters:
+         - widget_id
-         - userid
+         - item_id
         """
-        pass
+        return delete_item_from_widget(widget_id, item_id)
-    def confirmSMSVerification(self, userid):
+    def deleteItemFromMyResearch(self, user_id, item_id):
         """
         Parameters:
-         - userid
+         - user_id
+         - item_id
         """
-        pass
+        return delete_item_from_my_research(user_id, item_id)
-    def addSocialhandle(self, userid, socialService, handle):
+    def getWidget(self, type, userId, onlyEnabled):
         """
         Parameters:
-         - userid
+         - type
-         - socialService
+         - userId
-         - handle
+         - onlyEnabled
         """
-        log_entry(self, "adding social handle")
+        widget = get_widget_by_type(type, userId, onlyEnabled)
-        return add_social_handle(userid, socialService, handle)
+        return to_t_widget(widget)
-    def sendNewPasswordById(self, userid):
+    def getMyResearch(self, user_id):
         """
         Parameters:
-         - userid
+         - user_id
         """
-        pass
+        return to_t_widget(get_my_research(user_id))
+    def updateRatings(self, item_id, type, rating, user_id):
+        """
+        Parameters:
+        - item_id
+        - type
+        - rating
+        - user_id
+        """
+        update_ratings(user_id, item_id, rating, type)
+    def getRatings(self, item_id, user_id):
+        """
+        Parameters:
+        - item_id
+        - user_id
+        """
+        all_ratings, user_ratings = get_ratings(user_id, item_id)
+        return to_t_ratings(user_ratings, all_ratings, item_id, user_id)
+    def updateBrowseHistory(self, user_id, item_id, is_session_id):
+        """
+        Parameters:
+        - user_id
+        - item_id
+        - isSessionId
+        """
+        update_browse_history(user_id, item_id, is_session_id)
-    def sendNewPasswordByHandle(self, emailOrHandle, isEmail):
+    def getBrowseHistory(self, user_id, is_session_id):
         """
         Parameters:
-         - emailOrHandle
+         - user_id
-         - isEmail
+         - is_session_id
         """
-        pass
+        return to_t_widget(get_browse_history(user_id, is_session_id))

Subversion Repositories SmartDukaan

(root)/trunk/PyProj/src/shop2020/model/v1/user/impl/UserContextSerivceHandler.py – Rev 515 → 557