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 shutil

dtrUserMap = {}

negative_items = []

negative_categories = [10013,10017,10006]

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

        self.dtr_user_id = dtr_user_id

        self.delivered_order_value = delivered_order_value

        self.pending_order_value = pending_order_value

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

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

            .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 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) \

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

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

    shutil.rmtree(cache_path)

if __name__ == '__main__':

    main()

    fetchNegativeItems()

    fetchOrders()

    commit()

    removeCache()