Subversion Repositories SmartDukaan

'''

Created on Apr 12, 2015

@author: amit

'''

from bs4 import BeautifulSoup

from datetime import datetime, timedelta

from dtr import main

from dtr.dao import Order, SubOrder

from dtr.main import getBrowserObject, getStore, ParseException, ungzipResponse, \

    Store as MStore, sourceMap, tprint, todict

from dtr.sources.amazon import readSSh

from dtr.storage.DataService import paytm_coupon_usages

from dtr.utils.utils import fetchResponseUsingProxy, find_between

from elixir import *

from pymongo.mongo_client import MongoClient

import json

import os

import traceback

class Store(MStore):

    OrderStatusMap = {

                      main.Store.ORDER_PLACED : ['in process', 'ready to be shipped', 'order recieved', 'order received', 'pending confirmation', 'waiting for courier pickup'],

                      main.Store.ORDER_DELIVERED : ['delivered'],

                      main.Store.ORDER_SHIPPED : ['in transit', 'shipped'],

                      main.Store.ORDER_CANCELLED : ['failed', 'payment failed', 'cancelled']

                      }

    def __init__(self,store_id):

        client = MongoClient('mongodb://localhost:27017/')

        self.db = client.dtr

        super(Store, self).__init__(store_id)

    def saveOrder(self, merchantOrder):

        MStore.saveOrder(self, merchantOrder)

    def parseTrackingUrl(self, trackingUrl):

        subOrder = {}

        page = fetchResponseUsingProxy(trackingUrl)

        soup = BeautifulSoup(page)

        subOrder['detailedStatus'] = soup.h1.text

        subOrder['status'] = self._getStatusFromDetailedStatus(subOrder['detailedStatus'])

    def scrapeStoreOrders(self):

        orders = self.db.merchantOrder.find({"storeId":1, "closed":False, "subOrders":{"$elemMatch":{"closed":False, "trackingUrl":{"$exists":True}}}})

        for merchantOrder in orders:

            executeBulk = False

            try:

                bulk = self.db.merchantOrder.initialize_ordered_bulk_op()

                closed = True

                map1 = {}

                for subOrder in merchantOrder.get("subOrders"):

                    if subOrder.get("closed"):

                        continue

                    elif subOrder.get("trackingUrl") is None:

                        closed = False

                        continue

                    executeBulk = True

                    findMap = {"orderId":merchantOrder.get("orderId"), "subOrders.merchantSubOrderId":subOrder.get("merchantSubOrderId")} 

                    trackingUrl = subOrder.get("trackingUrl")

                    if not map1.has_key(trackingUrl):

                        map1[trackingUrl] = self.parseTrackingUrl(trackingUrl)

                    newOrder = map1.get(trackingUrl)

                    updateMap = self.getUpdateMap(newOrder, subOrder.get('cashBackStatus'))

                    print findMap, "\n", updateMap

                    bulk.find(findMap).update({'$set' : updateMap})

                    closed = closed and newOrder['closed']

                if executeBulk:

                    bulk.find({"orderId":merchantOrder.get("orderId")}).update({"$set":{"closed":closed, "parseError":False}})

                    bulk.execute()

            except:

                tprint("Could not update " + str(merchantOrder['orderId']) + " For store " + self.getName())

                self.db.merchantOrder.update({"orderId":merchantOrder['orderId']}, {"$set":{"parseError":True}})

                traceback.print_exc()

    def getTrackingUrls(self, userId):

        missingOrderUrls = []

        #missingOrders = self._getMissingOrders({'userId':userId})

        #for missingOrder in missingOrders:

        #    missingOrderUrls.append(ORDER_REDIRECT_URL%(missingOrder['merchantOrderId']))

        orders = self._getActiveOrders({'userId':userId, "subOrders.trackingUrl":{"$exists":False} }, {"merchantOrderId":1})

        for order in orders:

            print order

            missingOrderUrls.append("https://paytm.com/shop/orderdetail/%s?actions=1&channel=web&version=2"%(order.get("merchantOrderId")))

        return missingOrderUrls

    def trackOrdersForUser(self, userId, url, rawHtml):

        merchantOrderId = find_between(rawHtml, "https://paytm.com/shop/orderdetail/","?actions=1&channel=web&version=2")

        directory = "/PaytmTrack/User" + str(userId)

        if not os.path.exists(directory):

            os.makedirs(directory)

        executeBulk = False

        filename = directory + "/" + merchantOrderId + "-" +  datetime.strftime(datetime.now(), '%d-%m:%H:%M:%S')   

        f = open(filename,'w')

        f.write(rawHtml) # python will convert \n to os.linesep

        f.close() # you can omit in most cases as the destructor will call if

        rawHtml = find_between(rawHtml,"<pre>", "</pre>")

        if rawHtml == "":

            raise    

        ordermap = json.loads(rawHtml).get("order")

        merchantOrder = self.db.merchantOrder.find_one({"merchantOrderId":merchantOrderId})

        try:

            bulk = self.db.merchantOrder.initialize_ordered_bulk_op()

            closed=True

            for item in ordermap.get("items"):

                merchantSubOrderId = str(item.get("id"))

                for subOrder in merchantOrder.get("subOrders"):

                    if not subOrder.get("closed"):

                        if merchantSubOrderId == subOrder.get("merchantSubOrderId") and item.get("status_text") != subOrder.get("detailedStatus"):

                            executeBulk = True

                            findMap = {"orderId":merchantOrder.get("orderId"), "subOrders.merchantSubOrderId":subOrder.get("merchantSubOrderId")}

                            newSub = {}

                            detailedStatus = item.get("status_text")

                            newSub['detailedStatus'] = detailedStatus

                            status  = self._getStatusFromDetailedStatus(detailedStatus)

                            newSub['status'] = status if status else subOrder.get("status")  

                            updateMap = self.getUpdateMap(newSub, subOrder.get("cashBackStatus"))

                            bulk.find(findMap).update({'$set' : updateMap})

                            closed = closed and newSub['closed']

                            break

                        else:

                            continue

            if executeBulk:

                bulk.find({"orderId":merchantOrder.get("orderId")}).update({"$set":{"closed":closed, "parseError":False}})

                bulk.execute()

        except:

                tprint("Could not update " + str(merchantOrder['orderId']) + " For store " + self.getName())

                self.db.merchantOrder.update({"orderId":merchantOrder['orderId']}, {"$set":{"parseError":True}})

                traceback.print_exc()

    def parseOrderRawHtml(self, orderId, subTagId, userId, rawHtml, orderSuccessUrl):

        #Expected is json

        orderSuccessUrl = find_between(orderSuccessUrl, "<pre>", "</pre>")

        if orderSuccessUrl != "": 

            try:

                resp = {}

                #orderSuccessUrl = "https://paytm.com/shop/orderdetail/1155961075?actions=1&channel=web&version=2"

                ordermap = json.loads(rawHtml).get("order")

                if not ordermap.get("need_shipping"):

                    resp['result'] = 'RECHARGE_ORDER_IGNORED'

                    return resp

                elif ordermap.get("payment_status") == "PROCESSING":

                    resp['result'] = 'PAYMENT_PENDING_IGNORED'

                    return resp

                order = Order(orderId, userId, subTagId, self.store_id, orderSuccessUrl)

                order.deliveryCharges = ordermap.get("shipping_charges") - ordermap.get("shipping_discount")

                order.merchantOrderId = str(ordermap.get("id"))  

                order.discountApplied = ordermap.get("discount_amount")

                order.paidAmount = ordermap.get("grandtotal")

                order.placedOn = datetime.strftime(getISTDate(ordermap.get("created_at")),"%d-%m-%Y %H:%M:%S") 

                order.requireDetail = False

                order.status = 'success'

                order.totalAmount = ordermap.get("subtotal")

                subOrders = []

                order.subOrders = subOrders

                coupon_code = None

                total_cashback = 0

                for item in ordermap.get("items"):

                    product = item.get("product")

                    shareUrl = product.get("seourl").replace("catalog.paytm.com/v1", "paytm.com/shop")

                    paytmcashback = 0

                    if item.get("promo_code"):

                        coupon_code = item.get("promo_code")

                        for s in item.get("promo_text").split(): 

                            if s.isdigit():

                                paytmcashback = int(s)

                                total_cashback += paytmcashback

                                break

                    amountPaid = item.get("subtotal") - paytmcashback 

                    detailedStatus = item.get("status_text")

                    status = self._getStatusFromDetailedStatus(detailedStatus)

                    if status == None:

                        status = MStore.ORDER_PLACED

                    subOrder = SubOrder(item.get("title"), item.get("product").get(""), ordermap.get("date"), amountPaid, status, item.get("quantity"))

                    subOrder.imgUrl = product.get("thumbnail")

                    subOrder.detailedStatus = detailedStatus

                    subOrder.productUrl = shareUrl

                    subOrder.productCode = product.get("url").split("?")[0].split("/")[-1]

                    subOrder.merchantSubOrderId = str(item.get("id"))

                    if status == MStore.ORDER_PLACED: 

                        if item.get("status_flow")[1].get("date"):

                            subOrder.estimatedShippingDate = datetime.strftime(getISTDate(item.get("status_flow")[1].get("date")), "%d %b")

                        if item.get("status_flow")[2].get("date"):

                            subOrder.estimatedDeliveryDate = datetime.strftime(getISTDate(item.get("status_flow")[2].get("date")), "%d %b")

                    else:

                        subOrder.closed = False

                    subOrders.append(subOrder)

                if coupon_code:

                    usage = paytm_coupon_usages()

                    usage.cashback = total_cashback

                    usage.coupon = coupon_code

                    usage.user_id = userId

                    usage.order_id = orderId

                    session.commit()

                self.populateDerivedFields(order)

                if self._saveToOrder(todict(order)):

                    resp['result'] = 'ORDER_CREATED'

                else:

                    resp['result'] = 'ORDER_ALREADY_CREATED_IGNORED'

            except:

                resp['result'] = 'ORDER_NOT_CREATED'

        else:

            resp['result'] = 'ORDER_NOT_CREATED'

        return resp

    def _getStatusFromDetailedStatus(self, detailedStatus):

        for key, value in Store.OrderStatusMap.iteritems():

            if detailedStatus.lower() in value:

                return key

        print "Detailed Status-", detailedStatus,  "need to be mapped for Store-", self.store_name

        return None

def getISTDate(tzString):

    tzDate = datetime.strptime(tzString, "%Y-%m-%dT%H:%M:%S.%fZ") 

    tzDate = tzDate + timedelta(0,19800)

    return tzDate

def main():

    store = getStore(6)

    #store.scrapeStoreOrders()

    store.parseOrderRawHtml(312119, 'SUB1', 14, readSSh("/home/amit/paytm.json"), "someurl")

    #print store.getTrackingUrls(14)

if __name__ == '__main__':

    main()