Subversion Repositories SmartDukaan

from sqlalchemy.orm import aliased

def add_sales_associate(pmsa, referrerEmail, l1_userEmail):

    d_pmsa = PMSA.query.filter(or_(PMSA.emailId == pmsa.emailId, PMSA.phone == pmsa.phone)).all()

    if d_pmsa:

        return "User with same phone or email already exists"

    referrer = PMSA.get_by(emailId = referrerEmail, activated=True)

    d_pmsa = PMSA()

    d_pmsa.name = pmsa.name

    d_pmsa.phone = pmsa.phone 

    d_pmsa.emailId = pmsa.emailId

    d_pmsa.address = pmsa.address

    d_pmsa.state = pmsa.state

    d_pmsa.level = pmsa.level

    d_pmsa.activated = pmsa.activated

    d_pmsa.pin = pmsa.pin

    if referrerEmail != l1_userEmail:

        if referrer is None or referrer.level != 'L2':

            return "Not valid referrer"

        l1_user = PMSA.get_by(id = referrer.l1_id)

        if l1_user.emailId != l1_userEmail:

            return "You are not authorized to refer"

        d_pmsa.l2_id = referrer.id

    else:

        l1_user = referrer

    d_pmsa.l1_id = l1_user.id

    for i in range(0,5):

        activation_code = "SA"+str(generate_random_code(8))

        code_exists = PMSA.get_by(code=activation_code)

        if not code_exists:

            break

        if i==4:

            return "Activation code generation failed"

    d_pmsa.code = activation_code

    session.commit()

    return "User added successfully.Activation Code %s"%(activation_code)

def search_pmsa(pmsaSearchFilter, associateEmail):

    associate = PMSA.get_by(emailId = associateEmail)

    query = session.query(PMSA).filter(PMSA.l1_id == associate.id)

    if pmsaSearchFilter.name:

        query = query.filter(PMSA.name == pmsaSearchFilter.name)

    if pmsaSearchFilter.emailId:

        query = query.filter(PMSA.emailId == pmsaSearchFilter.emailId)

    if pmsaSearchFilter.phone:

        query = query.filter(PMSA.phone == pmsaSearchFilter.phone)

    if pmsaSearchFilter.code:

        query = query.filter(PMSA.code == pmsaSearchFilter.code)

    if pmsaSearchFilter.l2_email:

        referrer = PMSA.get_by(emailId = pmsaSearchFilter.l2_email)

        if referrer:

            query = query.filter(PMSA.l2_id == referrer.id)

        else:

            return []

    return query.all()

def get_pmsa_user(id, associateEmail):

    associate = PMSA.get_by(emailId = associateEmail)

    pmsa = PMSA.get_by(id=id)

    if pmsa.l1_id != associate.id:

        return None 

    l2_user_email = ""

    if pmsa.l2_id:

        l2_user = PMSA.get_by(id=pmsa.l2_id)

        l2_user_email = l2_user.emailId

    return pmsa, associate.emailId, l2_user_email

def update_pmsa_user(pmsa, associateEmail):

    d_pmsa = PMSA.query.filter(or_(PMSA.emailId == pmsa.emailId, PMSA.phone == pmsa.phone)).all()

    if not d_pmsa or (len(d_pmsa)==1 and d_pmsa[0].id == pmsa.id):

        n_pmsa = PMSA.get_by(id=pmsa.id)

        associate = PMSA.get_by(emailId = associateEmail)

        if n_pmsa.l1_id != associate.id:

            return "You dont have permission to edit this user"

        n_pmsa.name = pmsa.name

        n_pmsa.phone = pmsa.phone 

        n_pmsa.emailId = pmsa.emailId

        n_pmsa.address = pmsa.address

        n_pmsa.state = pmsa.state

        n_pmsa.activated = pmsa.activated

        n_pmsa.pin = pmsa.pin

        session.commit()

        return "User updated successfully"

    return "User with same email or phone exists"

def get_pending_pmsa(associateEmail):

    associate = PMSA.get_by(emailId = associateEmail)

    query = session.query(PMSA).filter(PMSA.l1_id == associate.id).filter(PMSA.activated == False)

    return query.all()

def get_pmsa_users(associateEmail):

    associate = PMSA.get_by(emailId = associateEmail)

    query = session.query(PMSA).filter(PMSA.l1_id == associate.id).order_by(desc(PMSA.createdAt))

    return query.all()

def get_stats_for_associates(associateEmail):

    a = PMSA.get_by(emailId = associateEmail)

    if a is None:

        return [0,0,0,0,0]

    l2 = session.query(PMSA.id).filter(PMSA.l1_id == a.id).filter(PMSA.level == "L2").count()

    l3 = session.query(PMSA.id).filter(PMSA.l1_id == a.id).filter(PMSA.level == "L3").count()

    not_activated = session.query(PMSA.id).filter(PMSA.l1_id == a.id).filter(PMSA.activated == False).count()

    total = session.query(PMSA.id).filter(PMSA.l1_id == a.id).count()

    return [l2,l3,total,not_activated,total-not_activated]