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

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

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 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