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

dtrUserMap = {}

negative_items = []
negative_categories = [10013,10017]

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


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

if __name__ == '__main__':
    main()
    fetchNegativeItems()
    fetchOrders()
    commit()