Subversion Repositories SmartDukaan

from elixir import *

import datetime

from dtr.utils.utils import get_mongo_connection, to_java_date

from shop2020.model.v1.order.impl import DataService as OrderDataService

from shop2020.model.v1.catalog.impl import DataService as CatalogDataService 

from shop2020.model.v1.order.impl.DataService import Order, LineItem

from shop2020.model.v1.catalog.impl.DataService import Item

from shop2020.thriftpy.model.v1.order.ttypes import OrderStatus, OrderSource

import glob

import os

import smtplib

from email.mime.multipart import MIMEMultipart

from email.mime.text import MIMEText

dtrUserMap = {}

negative_items = []

negative_categories = [10013,10017,10006,12101]

pending_order_status = [2,3,4,5,6,7,8,13,9,10,16,17,81,80, 40]

startDate = datetime.datetime.strptime('01-04-2016 00:00:00', '%d-%m-%Y %H:%M:%S')

endDate = datetime.datetime.strptime('01-05-2016 00:00:00', '%d-%m-%Y %H:%M:%S')

run_time = to_java_date(datetime.datetime.now())

cache_path = "/var/www/dtrdashboard/app/tmp/cache/target/"

class UserOrderData:

    def __init__(self, dtr_user_id, delivered_order_value, pending_order_value, email):

        self.dtr_user_id = dtr_user_id

        self.delivered_order_value = delivered_order_value

        self.pending_order_value = pending_order_value

        self.email = email

def fetchNegativeItems():

    global negative_items

    try:

        CatalogDataService.initialize('catalog', '192.168.190.114', False)

        itemIds = session.query(Item.id).filter(Item.category.in_(negative_categories)).all()

        negative_items = list(zip(*itemIds)[0])

    finally:

        session.close()

def main():

    all_users = get_mongo_connection().Catalog.PromoOffer.find({},{'user_id':1,'saholic_user_id':1})

    for user in all_users:

        dtrUserMap[user.get('saholic_user_id')] = UserOrderData(user.get('user_id'), 0, 0,"")

def fetchOrders():

    global dtrUserMap

    OrderDataService.initialize('transaction', '192.168.190.114', setup=False)

    try:

        for user_id in dtrUserMap.keys():

            customer_email = ""

            delivered_orders  = session.query(Order.customer_id, LineItem.item_id, LineItem.total_price, Order.customer_email) \

            .join((LineItem,Order.id==LineItem.order_id)).filter(Order.customer_id==user_id).filter(Order.created_timestamp>startDate).filter(Order.created_timestamp<endDate).filter(Order.status==OrderStatus.DELIVERY_SUCCESS).filter(Order.source==OrderSource.WEBSITE).all()

            delivered_order_value = 0

            pending_order_value = 0

            for delivered_order in delivered_orders:

                if customer_email=="":

                    customer_email = delivered_order[3]

                if delivered_order[1] in negative_items:

                    continue

                delivered_order_value = delivered_order_value + delivered_order[2]

            pending_orders  = session.query(Order.customer_id, LineItem.item_id, LineItem.total_price, Order.customer_email) \

            .join((LineItem,Order.id==LineItem.order_id)).filter(Order.customer_id==user_id).filter(Order.created_timestamp>startDate).filter(Order.created_timestamp<endDate).filter(Order.status.in_(pending_order_status)).filter(Order.source==OrderSource.WEBSITE).all()

            for pending_order in pending_orders:

                if customer_email=="":

                    customer_email = pending_order[3]

                if pending_order[1] in negative_items:

                    continue

                pending_order_value = pending_order_value + pending_order[2]

            user_order_obj = dtrUserMap.get(user_id)

            user_order_obj.delivered_order_value = delivered_order_value

            user_order_obj.pending_order_value = pending_order_value

            user_order_obj.email = customer_email

    finally:

        session.close()

def commit():

    for k, v in dtrUserMap.iteritems():

        get_mongo_connection().Catalog.PromoOffer.update({'user_id':v.dtr_user_id},{"$set":{'pending_order_value':v.pending_order_value,'delivered_order_value':v.delivered_order_value,'last_run_timestamp': run_time}})

def removeCache():

    os.chdir(cache_path)

    files=glob.glob('cake*')

    for filename in files:

        os.unlink(filename)

def sendMail():

    message="""<html>

            <body>

            <h3>April Acc. Offer</h3>

            <table border="1" style="width:100%;">

            <thead>

            <tr><th>user_id</th>

            <th>email</th>

            <th>target1</th>

            <th>target2</th>

            <th>delivered orders</th>

            <th>pending orders</th>

            </tr></thead>

            <tbody>"""

    promo_offers = get_mongo_connection().Catalog.PromoOffer.find({})

    for promo_offer in promo_offers:

        message+="""<tr>

        <td style="text-align:center">"""+str(promo_offer['user_id'])+"""</td>

        <td style="text-align:center">"""+dtrUserMap.get(promo_offer['saholic_user_id']).email+"""</td>

        <td style="text-align:center">"""+str(promo_offer['target1'])+"""</td>

        <td style="text-align:center">"""+str(promo_offer['target2'])+"""</td>

        <td style="text-align:center">"""+str(promo_offer['delivered_order_value'])+"""</td>

        <td style="text-align:center">"""+str(promo_offer['pending_order_value'])+"""</td>

        </tr>"""

    message+="""</tbody></table></body></html>"""

    print message

    mailServer = smtplib.SMTP("smtp.gmail.com", 587)

    mailServer.ehlo()

    mailServer.starttls()

    mailServer.ehlo()

    recipients = ['kshitij.sood@saholic.com']

    #recipients = ['rajneesh.arora@saholic.com','kshitij.sood@saholic.com','chaitnaya.vats@saholic.com']

    msg = MIMEMultipart()

    msg['Subject'] = "April Acc Offer" + ' - ' + str(datetime.datetime.now().date())

    msg['From'] = ""

    msg['To'] = ",".join(recipients)

    msg.preamble = "April Acc Offer" + ' - ' + str(datetime.datetime.now().date())

    html_msg = MIMEText(message, 'html')

    msg.attach(html_msg)

    mailServer.login("build@shop2020.in", "cafe@nes")

    mailServer.sendmail("cafe@nes", recipients, msg.as_string())

if __name__ == '__main__':

    main()

    fetchNegativeItems()

    fetchOrders()

    commit()

    removeCache()

    sendMail()