Subversion Repositories SmartDukaan

'''
Created on 28-Apr-2010

@author: ashish
'''
from shop2020.model.v1.user.impl import Dataservice
from shop2020.utils.Utils import log_entry, to_py_date
from shop2020.thriftpy.model.v1.user.ttypes import WidgetType as WType
from shop2020.model.v1.user.impl.Dataservice import User, UserCommunication, IPMap,\
    Address, SocialHandle, UserState, InternalInfo, SocialService, Affiliate, Tracker, TrackLog,\
    MasterAffiliate, UserNote, UserWidgetItem
from shop2020.thriftpy.model.v1.user.ttypes import UserContextException,\
    AuthenticationException, AccountStatus, Sex
from elixir import session
import datetime
from sqlalchemy import desc


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, cart):
    user=User.get_by(jsession_id=jsession_id)
    if not user is None:
        return user
    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_id = cart.id
    #initialize userState
    user_state = UserState()
    user_state.is_email_verified = False
    user_state.is_sms_verified = False
    user_state.account_status = AccountStatus.ACTIVE
    user_state.ip_list = []
    user_state.active_since = datetime.datetime.now()
    user_state.user = user
    session.commit()

    cart.user_id = user.id    
    session.commit()
    
    return user

def get_user_by_id(user_id):
    return User.get_by(id=user_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, cart):
    if user_to_add.userId:
        raise UserContextException(109, "id is set, user cannot be created")
    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_id = cart.id
    user.mobile_number = user_to_add.mobileNumber
    user.source = user_to_add.source
    user.source_start_time = to_py_date(user_to_add.sourceStartTime)

    #initialize userState
    user_state = UserState()
    user_state.is_email_verified = False
    user_state.is_sms_verified = False
    user_state.account_status = AccountStatus.ACTIVE
    user_state.ip_list = []
    user_state.active_since = datetime.datetime.now()
    user_state.user = user
    session.commit();
    
    #Now create the user phones. Mostly, this should only be a mobile number

    cart.user_id = user.id    
    session.commit()

    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.active_cart_id = user_to_update.activeCartId
    user.mobile_number = user_to_update.mobileNumber
    session.commit()
    return user

def delete_user(user_id):
    user = get_user_by_id(user_id)
    
    if not user:
        raise_user_exception(user_id)
        
    user.state.account_status = AccountStatus.DELETED
    session.commit()
    return True
    
def get_user_state(user_id):
    userstate = UserState.get_by(user_id=user_id)
    return userstate

def get_internal_info(user_id):
    info = InternalInfo.get_by(user_id=user_id)
    return info

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
    session.commit()
    return True

def set_user_as_logged_in(user_id, time_stamp):
    user_state = UserState.get_by(user_id=user_id)
    #user = get_user_by_id(user_id)
    
    if not user_state:
        raise_user_exception(user_id)
    
    if not time_stamp:
        user_state.last_login = datetime.datetime.now()
    else:
        user_state.last_login = to_py_date(time_stamp)
    session.commit()
    return True
    
def set_user_as_logged_out(user_id, time_stamp):
    user_state = UserState.get_by(user_id=user_id)
    
    if not user_state:
        raise_user_exception(user_id)
    
    if not time_stamp:
        user_state.last_logout = datetime.datetime.now()
    else:
        user_state.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()
    
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 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 = 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):
    return Affiliate.get_by(id = affiliate_id).tracklogs

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 get_social_service(service_id):
    service = SocialService.get_by(service_id)
    return service

def add_ip_address_for_user(ip_address, time_stamp, user_id):
    user = get_user_by_id(user_id)
    if not user:
        raise_user_exception(user_id)
    #user exists create an IP address object
    ip_address = IPMap()
    ip_address.ip = ip_address
    ip_address.timestamp = to_py_date(time_stamp)
    ip_address.user_state = user.state
    session.commit()
    return True
    
def get_social_service_by_name(service_name):
    service = SocialService.get_by(name=service_name)
    
    if not service:
        raise UserContextException(106, "No such social service exists")
    return service
    
def add_social_handle(user_id, social_service, handle):
    user = get_user_by_id(user_id)
    
    if not user:
        raise_user_exception(user_id)
    
    service = get_social_service_by_name(social_service)
    
    #get if use already has this service.
    social_handle = SocialHandle.filter(service=service).filter(user=user).one()
    if not social_handle:
        #create a new handle
        social_handle = SocialHandle()
        social_handle.service = service
        social_handle.user = user
        social_handle.handle = handle
    else:
        social_handle.handle = handle
    session.commit()
    return True


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 forgot_password(email):
    try:
        user = User.get_by(email=email)
        if user:
            new_password = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(8))
            mail = Mail()
            mail.to = []
            mail.to.append(email)
            mail.sender = ""
            mail.password = ""
            mail.data = "Your new password is " + user.password
            helper_client = HelperClient()
            helper_client.__start__()
            client = helper_client.get_client()
            client.sendMail(mail);
            
            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).join(UserState)
    if start_date != -1:
        query = query.filter(UserState.active_since >= to_py_date(start_date))
    if end_date != -1:
        query = query.filter(UserState.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))

'''
My Notes methods
'''
def get_user_notes(user_id, entity_id):
    return UserNote.query.filter_by(user_id = user_id).filter_by(entity_id = entity_id).all()

def put_user_note(user_id, entity_id, slide, note):
    user_notes = UserNote.query.filter_by(user_id = user_id).filter_by(entity_id = entity_id).filter_by(slide = slide).all()
    
    if user_notes is None or len(user_notes) == 0:
        user_note = UserNote()
        user_note.user_id = user_id
        user_note.entity_id = entity_id
        user_note.slide = slide
        user_note.note = note
    else:
        user_note = user_notes.pop()
        user_note.note = note
    
    session.commit()


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" + itemId

def close_session():
    if session.is_active:
        print "session is active. closing it."
        session.close()