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