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

from shop2020.model.v1.user.impl.Dataservice import User, UserCommunication, IPMap,\

    Address, SocialHandle, UserState, InternalInfo, SocialService, Affiliate, Tracker, TrackLog,\

    MasterAffiliate, UserNote

from shop2020.thriftpy.model.v1.user.ttypes import UserContextException,\

    AuthenticationException, AccountStatus, Sex

from shop2020.clients.HelperClient import HelperClient

from elixir import session

import datetime, random, string

from shop2020.thriftpy.utils.ttypes import Mail

def initialize(dbname='user'):

    log_entry("initialize@DataAccessor", "Initializing data service")

    Dataservice.initialize(dbname)

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

    #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):

    query = Address.query.filter(Address.user.has(id = userId))

    query = query.filter(Address.enabled == True)

    return query.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_id, note):

    user_notes = UserNote.query.filter_by(user_id = user_id).filter_by(entity_id = entity_id).filter_by(slide_id = slide_id).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_id = slide_id

        user_note.note = note

    else:

        user_note = user_notes.pop()

        user_note.note = note

    session.commit()

def close_session():

    if session.is_active:

        print "session is active. closing it."

        session.close()