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.thriftpy.model.v1.user.ttypes import RatingType as RType
from shop2020.model.v1.user.impl.Dataservice import Widget, Item, WidgetItem,\
    Ratings, UserRatings
from elixir import *
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 = 1
    
    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 = 1
            w_item.snippet = item.snippet
            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 item in items:
        i = get_item_by_item_id(item)
        if i:
            #check if widgetitem is already present
            witem = get_widget_item(i, widget)
            if not witem:
                witem = WidgetItem()
                witem.widget = widget
                witem.item = i
            witem.added_on = datetime.datetime.now()
            session.commit()

def get_my_research_widget(user_id):
    query = Widget.query.filter_by(customer_id=user_id)
    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 = 1
        widget.customer_id = user_id
        widget.name = "My Research"
        session.commit()
    return widget
        
def update_my_research(user_id, item_id):
    isNew = False
    #get my research widget 
    research_widget = get_my_research_widget(user_id)
    #search for item id
    item = get_item_by_item_id(item_id)
    if not item:
        #Ideally it should throw an exception, but we are allowing additions here for now.
        item = Item()
        item.item_id = item_id
        item.snippet = "Lorem Ipsum"
        item.enabled = 1
        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(user_id, item_id):
    #get my research widget 
    research_widget = get_my_research_widget(user_id)
    #search for item id
    delete_item_from_widget(research_widget.id, item_id )
    
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 = 1
    else:
        widget.enabled = 0
    session.commit()
    
def update_widget_item(widget_item, enabled):
    
    pass

def get_widget_by_user_id(type, user_id, is_session_id, enabled):
    try:
        query = Widget.query.filter_by(type = type)
        if is_session_id == True:
            query = query.query.filter_by(session_id=user_id)
        else:
            query = query.filter_by(customer_id=user_id)

        if enabled:
            query = query.filter_by(enabled=1)
        
        return query.one()
    except Exception as inst:
        print type(inst)
        print inst.args
        print inst
        raise WException(101, "no widget found")

    
def get_widget_by_type(type, user_id, enabled):
    try:
        query = Widget.query.filter_by(type = type)
        if enabled:
            query = query.filter_by(enabled=1)
        
        if user_id:
            query = query.filter_by(customer_id=user_id)
        return query.one()
    except:
        raise WException(101, "no widget found")
        """
        except Exception as inst:
        print type(inst)
        print inst.args
        print inst
        raise WException(101, "no widget found")
        """
        

def get_my_research(user_id):
    return get_widget_by_type(WType.MY_RESEARCH, user_id)

def get_browse_history(user_id, is_session_id):
    if is_session_id == True:
        return get_widget_by_user_id(WType.BROWSE_HISTORY, user_id, is_session_id)
    else:
        return get_widget_by_user_id(WType.BROWSE_HISTORY, user_id, is_session_id)

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()
    
        
def update_browse_history(user_id, item_id, is_session_id):
    if is_session_id == True:
        query = Widget.query.filter_by(session_id = user_id)
        query = query.filter_by(type = WType.BROWSE_HISTORY)
        try:
            current_widget = query.one()
        except:
            current_widget = Widget()
            current_widget.session_id = user_id
            current_widget.enabled = True
            current_widget.type = WType.BROWSE_HISTORY    
    else:
        query = Widget.query.filter_by(customer_id = user_id)
        query = query.filter_by(type = WType.BROWSE_HISTORY) 
        try:
            current_widget = query.one()
        except:
            current_widget = Widget()
            current_widget.customer_id = user_id
            current_widget.enabled = True
            current_widget.type = WType.BROWSE_HISTORY
    session.commit()
    items = []
    items.append(item_id)
    add_items_to_widget(current_widget.id, items)