Subversion Repositories SmartDukaan

'''
Created on 28-Apr-2010

@author: ashish
'''
from elixir import session
from shop2020.model.v1.user.impl import Dataservice
from shop2020.model.v1.user.impl.CartDataAccessors import create_cart
from shop2020.model.v1.user.impl.Dataservice import User, UserCommunication, \
    Address, Affiliate, Tracker, TrackLog, MasterAffiliate, UserWidgetItem, \
    FacebookUser, UserSource, PrivateDealUser, Counter, AccessTokenizer
from shop2020.thriftpy.model.v1.user.ttypes import UserContextException, \
    AuthenticationException, Sex, WidgetType as WType
from shop2020.utils.Utils import log_entry, to_py_date
from sqlalchemy import desc, select
from sqlalchemy.sql import and_
from sqlalchemy.sql.expression import or_
import datetime
import os, binascii

CounterStateMap = {"Telangana" : "TS", "Andhra Pradesh" : "AP"}

def initialize(dbname='user', db_hostname="localhost"):
    log_entry("initialize@DataAccessor", "Initializing data service")
    Dataservice.initialize(dbname, db_hostname)

def create_anonymous_user(jsession_id):
    user=User.get_by(jsession_id=jsession_id)
    #user=User.query.with_lockmode("update").filter_by(jsession_id=jsession_id)
    if not user is None:
        return user
    cart = create_cart()
    user = User()
    anonymous_str = "anonymous"
    user.email = jsession_id + "@anonymous.com"
    user.password = anonymous_str
    user.name = anonymous_str
    user.communication_email = jsession_id + "@anonymous.com"
    user.jsession_id = jsession_id
    user.is_anonymous = True
    user.sex = Sex.WONT_SAY
    user.active_cart = cart
    user.trust_level = 0
    user.active_since = datetime.datetime.now()
    session.commit()

    return user

def get_user_by_id(user_id):
    return User.get_by(id=user_id)

def get_user_by_cart_id(cart_id):
    return User.get_by(active_cart_id=cart_id)

def get_user_by_mobile_number(mobile_number):
    return User.get_by(mobile_number=mobile_number)

def get_user_by_email(email):
    return User.get_by(email=email)

def create_user(user_to_add):
    user = User.get_by(email=user_to_add.email)
    if user:
        if user.password == user_to_add.password  or user_to_add.password == "":
            if user_to_add.password == "":
                add_private_deal_user(user.id)
            return user
        else:
            raise UserContextException(109, "User already exists with this email id.")
    
    cart = create_cart()

    user = User()
    user.email = user_to_add.email
    user.password = user_to_add.password
    user.name = user_to_add.name
    user.communication_email = user_to_add.communicationEmail
    user.jsession_id = user_to_add.jsessionId
    user.is_anonymous = False
    user.sex = user_to_add.sex
    user.date_of_birth = user_to_add.dateOfBirth
    user.active_cart = cart
    user.mobile_number = user_to_add.mobileNumber
    user.source = user_to_add.source
    user.source_start_time = to_py_date(user_to_add.sourceStartTime)
    user.trust_level = 0
    user.active_since = datetime.datetime.now()
    addresses = []
    if user_to_add.addresses:
        address = user_to_add.addresses[0]
        address_to_add = Address()
        address_to_add.line_1 = address.line1
        address_to_add.line_2 = address.line2
        address_to_add.landmark = address.landmark
        address_to_add.city = address.city
        address_to_add.country = address.country
        address_to_add.state = address.state
        address_to_add.pin = address.pin
        address_to_add.type = address.type
        address_to_add.name = address.name
        address_to_add.phone = address.phone
        address_to_add.added_on = to_py_date(address.addedOn)
        address_to_add.enabled = True
        address_to_add.user = user
        address_to_add.type = 1
        address_to_add.added_on = datetime.datetime.now()
        addresses.append(address_to_add)
        user.addresses = addresses
    us = UserSource()
    us.user = user
    us.source_id = 1
    if user_to_add.sourceId:
        us.source_id = user_to_add.sourceId
    
    if user_to_add.isFacebookUser:
        fuser = FacebookUser()
        fuser.facebook_access_token = user_to_add.facebookAccessToken
        fuser.facebook_id = user_to_add.facebookId
        fuser.user = user
    session.commit()
    if user_to_add.addresses:
        user.default_address_id = user.addresses[0].id
    session.commit()
    
    if user_to_add.password == "":
        add_private_deal_user(user.id)
    return user

#===============================================================================
# Need to provide the update apis here for relevant fields in PrimaryInfo.
#===============================================================================
def update_user(user_to_update):
    if not user_to_update.userId:
        raise UserContextException(110, "user does not exist")
    user = get_user_by_id(user_to_update.userId)
    user.email = user_to_update.email
    user.password = user_to_update.password
    user.name = user_to_update.name
    user.communication_email = user_to_update.communicationEmail
    user.jsession_id = user_to_update.jsessionId
    user.is_anonymous = user_to_update.isAnonymous
    user.sex = user_to_update.sex
    user.date_of_birth = user_to_update.dateOfBirth
    user.mobile_number = user_to_update.mobileNumber
    if user_to_update.isFacebookUser:
        if user.fbusers and user.fbusers[0]:
            fuser = user.fbusers[0]
        else:
            fuser = FacebookUser()
        if user_to_update.facebookAccessToken is not None:
            fuser.facebook_access_token = user_to_update.facebookAccessToken
        if user_to_update.facebookId is not None:
            fuser.facebook_id = user_to_update.facebookId
        fuser.user = user
    session.commit()
    return user

def authenticate_user(user_handle, password):
    user = User.get_by(email=user_handle)
    if not user:
        raise AuthenticationException("This email address is not registered.", 102)
    
    if user.password == get_db_password(password):
        return user
    else:
        raise AuthenticationException("Wrong username or password", 102)

def user_exists(email):
    try:
        user = User.get_by(email=email)
        if user:
            return True
        else:
            return False
    except:
        return False

def add_address_for_user(address, user_id, set_default):
    user = get_user_by_id(user_id)

    if not user:
        raise_user_exception(user_id)
    if not address:
        raise UserContextException(103,"Address cannot be null")
    
    address_to_add = Address()
    address_to_add.line_1 = address.line1
    address_to_add.line_2 = address.line2
    address_to_add.landmark = address.landmark
    address_to_add.city = address.city
    address_to_add.country = address.country
    address_to_add.state = address.state
    address_to_add.pin = address.pin
    address_to_add.type = address.type
    address_to_add.name = address.name
    address_to_add.phone = address.phone
    address_to_add.added_on = to_py_date(address.addedOn)
    address_to_add.enabled = True
    address_to_add.user = user
    session.commit()
    
    if set_default is True:
        user.default_address_id = address_to_add.id
    #set default address if nothing is default    
    if user.default_address_id is None:
        user.default_address_id = address_to_add.id
            
    session.commit()
    
    return address_to_add.id
    
def remove_address_for_user(user_id, address_id):
    address = get_address(address_id) 
        
    if not address:
        raise UserContextException(103, "Address not found")
    if address.user.id != user_id:
        raise UserContextException(104, "This address belongs to some other user")
    address.enabled = False
    user = User.get_by(id=user_id)
    if user.default_address_id == address_id:
        firstValidAddress = Address.query.filter_by(user_id = user_id, enabled=True).first()
        if firstValidAddress is None:
            user.default_address_id = None
        else:
            user.default_address_id = firstValidAddress.id
    session.commit()
    return True

def set_user_as_logged_in(user_id, time_stamp):
    user = User.get_by(id=user_id)
    
    if not user:
        raise_user_exception(user_id)
    
    if not time_stamp:
        user.last_login = datetime.datetime.now()
    else:
        user.last_login = to_py_date(time_stamp)
    session.commit()
    return True
    
def set_user_as_logged_out(user_id, time_stamp):
    user = User.get_by(id=user_id)
    
    if not user:
        raise_user_exception(user_id)
    
    if not time_stamp:
        user.last_logout = datetime.datetime.now()
    else:
        user.last_logout = to_py_date(time_stamp)
    session.commit()
    return True

def set_default_address(user_id, address_id):
    user = get_user_by_id(user_id)
    address = Address.get_by(id=address_id)
    if not user:
        raise_user_exception(user_id)
    if not address:
        raise UserContextException(103, "Address not found")
    if address.user.id != user.id:
        raise UserContextException(104, "This address belongs to some other user")
        
    user.default_address_id = address_id 
    session.commit()
    
def update_password(user_id, old_password, new_password):
    user = get_user_by_id(user_id)
    
    if not user:
        raise_user_exception(user_id)
    
    if user.password != old_password:
        return False
    
    if check_for_valid_password(new_password):
        user.password = get_db_password(new_password)
        session.commit()
        return True
    else:
        return False


def create_user_communication(user_id, email, communication_type, order_id, awb, product, subject, message):

    user_communication = UserCommunication()
    user_communication.user_id = user_id
    user_communication.communication_type = communication_type
    
    if order_id > 0:
        user_communication.order_id = order_id
    user_communication.airwaybill_no = awb
    user_communication.reply_to = email
    user_communication.product_name = product
    user_communication.subject = subject
    user_communication.message = message
    user_communication.communication_timestamp = datetime.datetime.now()
    session.commit()
    return True

def get_user_communication_by_id(user_communication_id):
    return UserCommunication.get_by(id = user_communication_id)
    
def get_user_communication_by_user(user_communication_user_id):
    return UserCommunication.query.filter_by(user_id = user_communication_user_id).order_by(-UserCommunication.id).all()

def get_all_user_communications():
    return UserCommunication.query.order_by(-UserCommunication.id).all()

def remove_user_communication(commId):
    UserCommunication.query.filter_by(id=commId).delete()
    session.commit()
    
def create_master_affiliate(name, added_on):
    master_affiliate = MasterAffiliate()
    master_affiliate.name = name
    master_affiliate.added_on = to_py_date(added_on)
    session.commit()
    return master_affiliate

def get_all_master_affiliates():
    return MasterAffiliate.query.all()

def get_master_affiliate_by_id(id):
    return MasterAffiliate.get_by(id = id)

def get_master_affiliate_by_name(name):
    return MasterAffiliate.get_by(name = name)

def create_affiliate(name, url, master_affiliate_id, added_on):
    affiliate = Affiliate()
    affiliate.name = name
    if url is not None:
        affiliate.url = url
    affiliate.master_affiliate_id = master_affiliate_id
    affiliate.added_on = to_py_date(added_on)
    session.commit()
    return affiliate

def get_affiliate_by_id(id):
    return Affiliate.get_by(id = id)

def get_affiliate_by_name(name):
    return Affiliate.get_by(name = name)

def get_affiliates_by_master_affiliate(master_affiliate_id):
    return MasterAffiliate.get_by(id =  master_affiliate_id).affiliates

def get_tracker_by_id(id):
    return Tracker.get_by(id = id)

def add_track_log(affiliate_id, user_id, event, url, data, added_on):
    track_log = TrackLog()
    track_log.affiliate_id = affiliate_id
    if user_id:
        track_log.user_id = user_id
    track_log.event_id = event
    if url:
        track_log.url = url
    if data:
        track_log.data = data
    track_log.added_on = to_py_date(added_on)
    session.commit()
    return track_log.id

def get_track_log_by_id(id):
    return TrackLog.get_by(id = id)

def get_track_logs_by_affiliate(affiliate_id, start_date, end_date):
    query = TrackLog.query
    
    if affiliate_id:
        query = query.filter(TrackLog.affiliate_id == affiliate_id)
    if start_date:
        query = query.filter(TrackLog.added_on >= to_py_date(start_date))
    if end_date:
        query = query.filter(TrackLog.added_on <= to_py_date(end_date))
    return query.all()

def get_track_logs_by_user(user_id):
    return TrackLog.query.filter(TrackLog.user_id == user_id).all()

def get_track_logs(affiliate_id, user_id, event, url):
    query = TrackLog.query
    
    if affiliate_id:
        query = query.filter(TrackLog.affiliate_id == affiliate_id)
    if user_id:
        query = query.filter(TrackLog.user_id == user_id)
    if event:
        query = query.filter(TrackLog.event == event)
    if url:
        query = query.filter(TrackLog.url == url)
    return query.all()


def get_address(address_id):
    address = Address.get_by(id=address_id)
    return address

def forgot_password(email, password):
    try:
        user = User.get_by(email=email)
        if user:
            user.password = password
            session.commit()
            return True
        else:
            return False
    except:
        return False

def get_all_addresses_for_user(userId):
    return Address.query.filter_by(user_id = userId, enabled=True).all()
    
def get_default_address_id(userId):
    user = get_user_by_id(userId);
    if user.default_address_id is None:
        return 0
    return user.default_address_id

def get_default_pincode(user_id):
    user = get_user_by_id(user_id)
    if not user:
        raise_user_exception(user_id)
    default_address_id = user.default_address_id
    if default_address_id:
        address = Address.get_by(id=default_address_id)
        default_pincode = address.pin 
    else:
        default_pincode = '110001' 
    return default_pincode     

def get_user_count(user_type):
    if user_type is None:
        return User.query.count()
    else:
        return User.query.filter_by(is_anonymous = user_type).count()
    
def get_users(user_type, start_date, end_date):
    query = session.query(User)
    if start_date != -1:
        query = query.filter(User.active_since >= to_py_date(start_date))
    if end_date != -1:
        query = query.filter(User.active_since <= to_py_date(end_date))
    if user_type is not None:
        query = query.filter(User.is_anonymous == user_type)
    return query.all()
    
#=============================================================================
# Helper functions 
#=============================================================================

'''
This function returns the password as stored in the db
'''    
def get_db_password(password):
    return password

def check_for_valid_password(password):
    if not password:
        raise UserContextException(105,"password cannot be null")
    return True
#------------------------------------------------------------------------------ 

#===============================================================================
# raises the UserContextException
#===============================================================================
def raise_user_exception(user_id):
    raise UserContextException(101, "no such user in system %d" %(user_id))

def get_my_research_items(userId):
    query = UserWidgetItem.query.filter_by(userId=userId)
    query = query.filter_by(widgetId=WType.MY_RESEARCH)
    query = query.order_by(desc(UserWidgetItem.addedOn))
    widgetItems = query.all()
    return [widgetItem.itemId for widgetItem in widgetItems]
    
def get_browse_history_items(userId):
    query = UserWidgetItem.query.filter_by(userId=userId)
    query = query.filter_by(widgetId=WType.BROWSE_HISTORY)
    query = query.order_by(desc(UserWidgetItem.addedOn)).limit(10)
    widgetItems = query.all()
    return [widgetItem.itemId for widgetItem in widgetItems]
        
def update_my_research(userId, itemId):
    isNew = False
    query = UserWidgetItem.query.filter_by(userId=userId)
    query = query.filter_by(widgetId=WType.MY_RESEARCH)
    query = query.filter_by(itemId=itemId)
    widgetItem = query.first()
    if not widgetItem:
        isNew = True
        widgetItem = UserWidgetItem()
        widgetItem.userId = userId
        widgetItem.widgetId = WType.MY_RESEARCH
        widgetItem.itemId = itemId  
    widgetItem.addedOn = datetime.datetime.now()
    session.commit()
    return isNew

def update_browse_history(userId, itemId):
    query = UserWidgetItem.query.filter_by(userId=userId)
    query = query.filter_by(widgetId=WType.BROWSE_HISTORY)
    query = query.filter_by(itemId=itemId)
    widgetItem = query.first()
    if not widgetItem:
        widgetItem = UserWidgetItem()
        widgetItem.userId = userId
        widgetItem.widgetId = WType.BROWSE_HISTORY
        widgetItem.itemId = itemId
    widgetItem.addedOn = datetime.datetime.now()
    session.commit()

def delete_item_from_my_research(userId, itemId):
    query = UserWidgetItem.query.filter_by(userId=userId)
    query = query.filter_by(widgetId=WType.MY_RESEARCH)
    query = query.filter_by(itemId=itemId)
    widgetItem = query.first()
    if widgetItem:
        widgetItem.delete()
        session.commit()
    else:
        print "Not item in my research to delete with itemId " + str(itemId)

def increase_trust_level(userId, trustLevelDelta):
    user = User.query.filter_by(id = userId).with_lockmode('update').first()
    user.trust_level += trustLevelDelta
    session.commit()

def get_trust_level(userId):
    user = User.query.filter_by(id = userId).first()
    return user.trust_level

def get_user_emails(start_date, end_date):
    emails = select([User.table.c.communication_email], and_(User.table.c.active_since >= start_date, User.table.c.active_since <= end_date, User.table.c.is_anonymous==0)).execute()
    email_addresses = []
    
    for email in emails:
        email_addresses.append(str(email[0]))
    
    return email_addresses

def is_private_deal_user(userId):
    try:
        user = PrivateDealUser.get_by(id=userId)
        if user is None:
            return False
        elif not user.isActive:
            return False
        else:
            return True
    except:
        print("Error : Unable to get details for User Id : " + str(userId))
        return False
    finally:
        close_session()

def add_private_deal_user(userId):
    user = PrivateDealUser.get_by(id=userId)
    if user is None:
        try:
            pd = PrivateDealUser()
            pd.id = userId
            pd.created_on = datetime.datetime.now()
            pd.isActive = True
            pd.bulkShipmentAmountLimit=50000
            session.commit()
            return True
        except Exception as e:
            print "Unable to add user to private deals",e
            return False
    else:
        return True

def change_private_deal_user_status(userId,isActive):
    user = PrivateDealUser.get_by(id=userId)
    if user is None:
        return False
    else:
        user.isActive = isActive
        session.commit()
        return True

def get_private_deal_user(userId):
    return PrivateDealUser.get_by(id=userId)

def register_counter(tCounter, userId):
    firstValidAddress = Address.query.filter_by(user_id = userId, enabled=True).first()
    counter = Counter()
    _setCounter(counter, tCounter, firstValidAddress)
    pDealUser = PrivateDealUser() 
    pDealUser.counter = counter
    pDealUser.tin = tCounter.tin
    pDealUser.id = userId
    pDealUser.created_on = datetime.datetime.now()
    pDealUser.isActive = True
    pDealUser.bulkShipmentAmountLimit=50000
    session.commit()
    m = {}
    m['counter_code'] = counter.code
    return m 

def _setCounter(counter,tCounter,address):
    #counter = Counter()
    counter.name = tCounter.name
    counter.ownerName = tCounter.ownerName
    counter.createdOn = datetime.datetime.now()
    counter.email = tCounter.email
    counter.mobile = tCounter.mobile
    counter.addressId = address.id
    counter.dob = tCounter.dob
    counter.tin = tCounter.tin 
    query = Counter.query.filter(Counter.code.like(CounterStateMap[address.state] + '%')).order_by(Counter.id.desc())
    lastStateCounter = query.first()
    if lastStateCounter:
        counter.code = CounterStateMap[address.state] + str(int(lastStateCounter.code[2:])+1).zfill(6)
    else:
        counter.code = CounterStateMap[address.state] + "000001"
    counter.striker = tCounter.striker
    if tCounter.alternateMobile:
        counter.alternateMobile = tCounter.alternateMobile
    if tCounter.spCounterSize:
        counter.spCounterSize = tCounter.spCounterSize
    if tCounter.fpCounterSize:
        counter.fpCounterSize = tCounter.fpCounterSize
        
def search_counter(type1, searchString):
    if type1=="counter_code":
        return Counter.query.filter(Counter.code==searchString).all()
    elif type1=="mobile":
        return Counter.query.filter(or_(Counter.alternateMobile==searchString, Counter.mobile==searchString)).all()
    elif type1=="email":
        return Counter.query.filter(Counter.email==searchString).all()
    elif type1=="counter_name":
        return Counter.query.filter(Counter.name.like("%" + searchString + "%")).all()
    else:
        return []

def get_all_users_by_counter(counterid):
    dealers = PrivateDealUser.query.filter(PrivateDealUser.counter_id == counterid).all()
    dealerids = [dealer.id for dealer in dealers]
    print dealerids  
    if len(dealerids) > 0:
        return User.query.filter(User.id.in_(dealerids)).all()
    return []
            
def get_active_access_token_for_user(userId, source):
    user = get_private_deal_user(userId)
    if user is not None:
        accessTokenObj = AccessTokenizer.query.filter(AccessTokenizer.userId==userId).filter(AccessTokenizer.source==source).filter(AccessTokenizer.expired==False).filter(AccessTokenizer.expiredTime>datetime.datetime.now()).first()
        if accessTokenObj is not None:
            return accessTokenObj.tokenString
        else:
            accessTokenObj = AccessTokenizer()
            accessTokenObj.userId = userId
            accessTokenObj.source = source
            accessTokenObj.tokenString = binascii.b2a_hex(os.urandom(15))
            accessTokenObj.expiredTime = datetime.datetime.now()+datetime.timedelta(minutes=10)
            accessTokenObj.expired = False
            session.commit()
            return accessTokenObj.tokenString
    else:
        return 'Invalid User'
    
def validate_access_token(accessToken):
    accessTokenObj = AccessTokenizer.query.filter(AccessTokenizer.tokenString==accessToken).filter(AccessTokenizer.expired==False).filter(AccessTokenizer.expiredTime>datetime.datetime.now()).first()
    if accessTokenObj is not None:
        accessTokenObj.expired = True
        session.commit()
        return True
    else:
        return False
        
    
def close_session():
    if session.is_active:
        print "session is active. closing it."
        session.close()

def is_alive():
    try:
        session.query(User.id).limit(1).one()
        return True
    except:
        return False