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, PrivateDealUserAddressMapping, \

    Line

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

from shop2020.model.v1.user.impl.Converters import to_t_line

tinStates = ['Delhi']

CounterStateMap = {"Andhra Pradesh":"AP",

                    "Arunachal Pradesh":"AR",

                    "Assam":"AS",

                    "Bihar":"BR",

                    "Chhattisgarh":"CT",

                    "Goa":"GA",

                    "Gujarat":"GJ",

                    "Haryana":"HR",

                    "Himachal Pradesh":"HP",

                    "Jammu and Kashmir":"JK",

                    "Jharkhand":"JH",

                    "Karnataka":"KA",

                    "Kerala":"KL",

                    "Madhya Pradesh":"MP",

                    "Maharashtra":"MH",

                    "Manipur":"MN",

                    "Meghalaya":"ML",

                    "Mizoram":"MZ",

                    "Nagaland":"NL",

                    "Odisha":"OR",

                    "Punjab":"PB",

                    "Rajasthan":"RJ",

                    "Sikkim":"SK",

                    "Tamil Nadu":"TN",

                    "Telangana":"TS",

                    "Tripura":"TR",

                    "Uttarakhand":"UT",

                    "Uttar Pradesh":"UP",

                    "West Bengal":"WB",

                    "Andaman and Nicobar Islands":"AN",

                    "Chandigarh":"CH",

                    "Dadra and Nagar Haveli":"DN",

                    "Daman and Diu":"DD",

                    "Delhi":"DL",

                    "Lakshadweep":"LD",

                    "Puducherry":"PY",

                    "Pondicherry":"PY"

                    }

def initialize(dbname='user', db_hostname="localhost"):

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

    Dataservice.initialize(dbname, db_hostname)

#lets not commit cart and set id to -1

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

    user.id = -1

    #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 = datetime.datetime.now()

    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, a, b  = 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)

    addressMapping = PrivateDealUserAddressMapping.query.filter_by(user_id = address.user_id,address_id=address_id).first()

    if addressMapping is None:

        return address, {}, {}

    else:

        return address, {address_id:addressMapping.taxInvoiceAvailable}, {address_id:addressMapping.creditOptionAvailable}

def get_counter_name(user_ids):

    result = session.query(PrivateDealUserAddressMapping,Address).join((Address,PrivateDealUserAddressMapping.address_id==Address.id)).filter(PrivateDealUserAddressMapping.user_id.in_(user_ids)).filter(PrivateDealUserAddressMapping.creditOptionAvailable==1).all()

    userCounterMap = {}

    if result is not None:

        for r in result:

            if userCounterMap.has_key(r.PrivateDealUserAddressMapping.user_id):

                pass

            else:

                userCounterMap[r.PrivateDealUserAddressMapping.user_id] = r.Address.name

    return userCounterMap

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

    addresses = Address.query.filter_by(user_id = userId, enabled=True).all()

    privateDealUser = get_private_deal_user(userId)

    taxInvoiceMap = {}

    creditOptionMap = {}

    if privateDealUser is None:

        return addresses, taxInvoiceMap, creditOptionMap

    else:

        addressMappings = PrivateDealUserAddressMapping.query.filter_by(user_id = userId).all()

        for mapping in addressMappings:

            taxInvoiceMap[mapping.address_id] = mapping.taxInvoiceAvailable

            creditOptionMap[mapping.address_id] = mapping.creditOptionAvailable

        for address in addresses:

            if not taxInvoiceMap.has_key(address.id):

                taxInvoiceMap[address.id] = False

            if not creditOptionMap.has_key(address.id):

                creditOptionMap[address.id] = False 

        return addresses, taxInvoiceMap, creditOptionMap

    '''

    privateDealUser = get_private_deal_user(userId)

    if privateDealUser is None:

        return Address.query.filter_by(user_id = userId, enabled=True).all()

    else:

        if privateDealUser.counter:

            if privateDealUser.counter.documentVerified:

                return Address.query.filter_by(user_id = userId, enabled=True).all()

            else:

                return Address.query.filter_by(id=privateDealUser.counter.addressId).all()

    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 is None:

        return 0

    if user.default_address_id is None:

        return 0

    return user.default_address_id

    '''

    privateDealUser = get_private_deal_user(userId)

    if privateDealUser is None:

        if user.default_address_id is None:

            return 0

    else:

        if privateDealUser.counter: 

            return privateDealUser.counter.addressId

        else:

            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

    '''

    default_address_id = get_default_address_id(user_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

            pd.creditorAssigned = False

            pd.tinVerified = False

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

    try:

        firstValidAddress = Address.query.filter_by(id=tCounter.address).first()

    except:

        pass

    if not firstValidAddress:

        firstValidAddress = Address.query.filter_by(user_id = userId, enabled=True).first()

    counter = Counter()

    _setCounter(counter, tCounter, firstValidAddress)

    pDealUser = PrivateDealUser.query.filter_by(id=userId).first()

    if not pDealUser:

        pDealUser = PrivateDealUser() 

        pDealUser.created_on = datetime.datetime.now()

        pDealUser.bulkShipmentAmountLimit=50000

    pDealUser.counter = counter

    pDealUser.tinVerified = True if tCounter.documentVerified else False

    pDealUser.tin = tCounter.tin

    pDealUser.isActive = True

    session.commit()

    m = {}

    m['counter_code'] = counter.code

    return m 

def _setCounter(counter,tCounter,address):

    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.gstin = tCounter.gstin

    counter.documentVerified = tCounter.documentVerified

#    if counter.documentVerified:

#        pduaddress = PrivateDealUserAddressMapping()

#        pduaddress.address_id = address.id

#        pduaddress.creditOptionAvailable = False

#        pduaddress.user_id = address.user_id

#        if address.state in tinStates:

#            pduaddress.taxInvoiceAvailable = True

#        else:

#            pduaddress.taxInvoiceAvailable = False

    counter.verificationType = tCounter.verificationType

    counter.verifiedOn = datetime.datetime.now() 

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

    elif type1=="tin":

        return Counter.query.filter(Counter.tin==searchString).all()

    else:

        return []

def get_counter_by_user_id(user_id):

    pdu = PrivateDealUser.query.filter(PrivateDealUser.id==user_id).first()

    if pdu is None:

        return None

    else:

        return pdu.counter

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 is_address_editable_for_counter(userId):

    privateDealUser = get_private_deal_user(userId)

    if privateDealUser is None:

        return True

    else:

        if privateDealUser.counter:

            if privateDealUser.counter.documentVerified:

                return True

            else:

                return False  

    return True 

def get_billing_address_for_user(userId):

    privateDealUser = get_private_deal_user(userId)

    if privateDealUser is None:

        return None, {}, {}

    if privateDealUser.counter:

        return get_address(privateDealUser.counter.addressId)

    else:

        return None, {}, {}

def is_creditor_assigned(userId):

    try:

        privateDealUser = get_private_deal_user(userId)

        if privateDealUser.creditorAssigned:

            return True

        else:

            return False

    except:

        return False

def is_tax_invoice_enabled_user(userId):

    try:

        privateDealUser = get_private_deal_user(userId)

        if privateDealUser.tin and privateDealUser.tinVerified:

            return True

        else:

            return False

    except:

        return False

def tax_invoice_available(address_id):

    addressMapping = PrivateDealUserAddressMapping.query.filter_by(address_id=address_id).first()

    return True if addressMapping and addressMapping.taxInvoiceAvailable else False

def update_address(t_address):

    address, o1, o2 = get_address(t_address.id)

    if address:

        address.line_1 = t_address.line1

        address.line_2  = t_address.line2

        address.city = t_address.city

        address.pin = t_address.pin

        address.state = t_address.state

        session.commit()

        return True

    return False

def update_counter(t_counter):

    counter=Counter.get_by(id=t_counter.id)

    if counter:

        counter.gstin = t_counter.gstin

        counter.documentVerified  = t_counter.documentVerified

        session.commit()  

        return True  

    return False

def get_cart_by_value(cartIds):

    returnMap = {}

    lines = Line.query.filter(Line.cart_id.in_(cartIds)).all()

    for line in lines:

        if returnMap.has_key(line.cart_id):

            returnMap.get(line.cart_id).append(to_t_line(line))

        else:

            returnMap[line.cart_id] = [to_t_line(line)]

    return returnMap

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

if __name__ == '__main__':

    Dataservice.initialize()

    print (get_cart_by_value([1005394]))