Subversion Repositories SmartDukaan

'''

Created on 20-Jul-2010

@author: ashish

'''

from shop2020.thriftpy.model.v1.user.ttypes import WidgetException as WException

from shop2020.thriftpy.model.v1.user.ttypes import WidgetType as WType

from shop2020.model.v1.user.impl.Dataservice import Widget, Item, WidgetItem

from elixir import *

from sqlalchemy import desc

from sqlalchemy.orm import join, contains_eager

import datetime

def get_widget_by_id(id):

    return Widget.get_by(id=id)

def get_item_by_id(id):

    return Item.get_by(id=id)

def get_item_by_item_id(item_id):

    return Item.get_by(item_id=item_id)

def get_widget_item(item, widget):

    try:

        query = WidgetItem.query.filter_by(item=item)

        query = query.filter_by(widget=widget)

        return query.one()

    except:

        return None

def add_widget(widget):

    if not widget:

        raise WException(101, "Cannot add null widget")

    if widget.id:

        raise WException(101, "id is already assigned")

    w = Widget()

    if widget.customer_id:

        w.customer_id = widget.customer_id

    w.type = widget.type

    w.name = widget.name

    w.enabled = True

    session.commit()

    for item in widget.items:

        w_item = get_item_by_item_id(item.item_id)

        if not w_item:

            #item is not present in system, we need to add the item

            w_item = Item()

            w_item.item_id = item.item_id

            w_item.enabled = True

            session.commit()

        #create a widgetitem mapping here now

        widget_item = get_widget_item(w_item, w)

        if not widget_item:

            widget_item = WidgetItem()

            widget_item.widget = w

            widget_item.item = w_item

        widget_item.added_on = datetime.datetime.now()

        session.commit()

def add_items_to_widget(widget_id, items):

    widget = get_widget_by_id(widget_id)

    if not widget:

        raise WException(101, "Widget not found")

    for itemid in items:

        item = get_item_by_item_id(itemid)

        if item is None:

            item = Item()

            item.item_id = itemid

            item.enabled = True

            session.commit()

        #check if widgetitem is already present

        witem = get_widget_item(item, widget)

        if not witem:

            witem = WidgetItem()

            witem.widget = widget

            witem.item = item

        witem.added_on = datetime.datetime.now()

        session.commit()

def get_my_research_widget(userId):

    query = Widget.query.filter_by(user_id=userId)

    query = query.filter_by(type=WType.MY_RESEARCH)

    query = query.filter_by(enabled=1)

    try:

        widget = query.one()

    except:

        widget = None

    if not widget:

        #research widget not present            

        widget = Widget()

        widget.type = WType.MY_RESEARCH

        widget.enabled = True

        widget.user_id = userId

        widget.name = "My Research"

        session.commit()

    return widget

def update_my_research(userId, itemId):

    isNew = False

    #get my research widget 

    research_widget = get_my_research_widget(userId)

    #search for item id

    item = get_item_by_item_id(itemId)

    if not item:

        #Ideally it should throw an exception, but we are allowing additions here for now.

        item = Item()

        item.item_id = itemId

        item.enabled = True

        session.commit()

    witem = get_widget_item(item, research_widget)

    if not witem:

        witem = WidgetItem()

        witem.widget = research_widget

        witem.item = item

        isNew = True

    witem.added_on = datetime.datetime.now()

    session.commit()

    return isNew

def delete_item_from_widget(widget_id, item_id):

    widget = get_widget_by_id(widget_id)

    item = get_item_by_item_id(item_id)

    if not item:

        #ideally it should throw an exception, but we are returning simply

        return

    query = WidgetItem.query.filter_by(item=item)

    query = query.filter_by(widget=widget)

    witem = query.one()

    witem.delete()

    session.commit()

    return

def delete_item_from_my_research(userId, itemId):

    #get my research widget 

    research_widget = get_my_research_widget(userId)

    #search for item id

    delete_item_from_widget(research_widget.id, itemId )

def update_widget(widget_id, enabled):

    widget = get_widget_by_id(widget_id)

    if not widget:

        raise WException(101, "widget not present")

    if enabled:

        widget.enabled = True

    else:

        widget.enabled = False

    session.commit()

def get_widget_by_user_id(type, userId, enabled):

    try:

        query = Widget.query.filter_by(type = type)

        query = query.filter_by(userId=userId)

        if enabled:

            query = query.filter_by(enabled=enabled)

        return query.one()

    except:

        raise WException(101, "no widget found")

def get_my_research(userId):

    query = Widget.query.filter_by(user_id=userId)

    query = query.filter_by(type=WType.MY_RESEARCH)

    query = query.filter_by(enabled=1)

    try:

        widget = query.one()

    except:

        widget = None

    if not widget:

        #browse history not present            

        widget = Widget()

        widget.type = WType.MY_RESEARCH

        widget.enabled = True

        widget.user_id = userId

        widget.name = "My Research"

        session.commit()

    return widget

def get_browse_history(userId):

    query = session.query(WidgetItem).join(Widget).join(Item)

    query = query.filter(Widget.user_id == userId).filter(Widget.type == WType.BROWSE_HISTORY).filter(Widget.enabled == 1)

    query = query.order_by(desc(WidgetItem.added_on)).limit(10)

    widgetitems = query.options(contains_eager(WidgetItem.widget)).options(contains_eager(WidgetItem.item)).all()

    widget = Widget()

    widget.type = WType.BROWSE_HISTORY

    widget.enabled = True

    widget.user_id = userId

    widget.name = "Browse History"

    if widgetitems is not None:

        for widgetitem in widgetitems:

            if widget.id is None:

                widget.id = widgetitem.widget.id

            widget.items.append(widgetitem)

    else:

        session.commit()

    return widget

def update_browse_history(userId, itemId):

    query = Widget.query.filter_by(user_id = userId)

    query = query.filter_by(type = WType.BROWSE_HISTORY) 

    try:

        current_widget = query.one()

    except:

        current_widget = Widget()

        current_widget.user_id = userId

        current_widget.enabled = True

        current_widget.type = WType.BROWSE_HISTORY

        current_widget.name = "Browse History"

    session.commit()

    items = []

    items.append(itemId)

    add_items_to_widget(current_widget.id, items)

def merge_browse_history(fromUserId, toUserId):

    pass

def close_session():

    if session.is_active:

        print "session is active. closing it."

        session.close()

'''

def get_ratings(user_id, item_id):

    query = Ratings.query.filter_by(item_id = item_id)

    type_ratings = query.all()

    if user_id:

        query = UserRatings.query.filter_by(item_id = item_id)

        query = query.filter_by(user_id = user_id)

        try:

            user_rating = query.one()

        except:

            return type_ratings, None

        return type_ratings, user_rating

    return type_ratings, None

def update_ratings(user_id, item_id, rating, type):

    if user_id:

        if type == RType.USER_CURRENT:

            query = UserRatings.query.filter_by(item_id = item_id)

            query = query.filter_by(user_id = user_id)

            try:

                user_rating = query.one()

            except:

                user_rating = UserRatings()

                user_rating.user_id = user_id

                user_rating.item_id = item_id

            user_rating.rating = rating

            session.commit()

            #update cumulative ratings

            query = UserRatings.query.filter_by(item_id = item_id)

            ratings = query.all()

            user_count = len(ratings)

            query = Ratings.query.filter_by(item_id = item_id)

            query = Ratings.query.filter_by(type = RType.USER_ALL)

            try:

                current_rating = query.one()

                new_rating = (current_rating.rating*(user_count -1) + rating)/user_count

                current_rating.rating = new_rating

            except:

                current_rating = Ratings()

                current_rating.type= RType.USER_ALL

                current_rating.item_id = item_id

                current_rating.rating = rating

            session.commit()

    else:

        query = Ratings.query.filter_by(item_id = item_id)

        query = Ratings.query.filter_by(type = type)

        try:

            current_rating = query.one()

            current_rating.rating = rating

        except:

            current_rating = Ratings()

            current_rating.type= type

            current_rating.item_id = item_id

            current_rating.rating = rating

        session.commit()

'''