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()
        return widget
    except:
        return None
    
        
def update_my_research(userId, itemId):
    isNew = False
    #get my research widget 
    research_widget = get_my_research_widget(userId)
    
    if not research_widget:
        #research widget not present            
        research_widget = Widget()
        research_widget.type = WType.MY_RESEARCH
        research_widget.enabled = True
        research_widget.user_id = userId
        research_widget.name = "My Research"
        session.commit()

    #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()
        return widget
    except:
        widget = Widget()
        widget.type = WType.MY_RESEARCH
        widget.enabled = True
        widget.user_id = userId
        widget.name = "My Research"
        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()
'''