Subversion Repositories SmartDukaan

'''
Created on Jan 15, 2015

@author: amit
'''
from BeautifulSoup import BeautifulSoup
from bson.binary import Binary
from datetime import datetime, date, timedelta
from dtr import main
from dtr.config import PythonPropertyReader
from dtr.dao import AffiliateInfo, Order, SubOrder
from dtr.main import getBrowserObject, ScrapeException, getStore, ParseException, \
    Store as MStore, ungzipResponse, tprint
from pprint import pprint
from pymongo import MongoClient
import json
import pymongo
import re
import traceback
import urllib
import urllib2

ORDERSTATUS  = {"PAYMENT_PENDING" : 0,
"PAYMENT_FAILED" : 1,
"COD_VERIFICATION_PENDING" : 2,
"SUBMITTED_FOR_PROCESSING" : 3,
"ACCEPTED" : 4,
"INVENTORY_LOW" : 5,
"REJECTED" : 6,
"BILLED" : 7,
"PAYMENT_FLAGGED" : 8,
"SHIPPED_FROM_WH" : 9,
"SHIPPED_TO_LOGST" : 10,
"PAYMENT_FLAGGED_DENIED" : 11,
"DELIVERY_SUCCESS" : 12,
"CANCEL_REQUEST_RECEIVED" : 13,
"CANCEL_REQUEST_CONFIRMED" : 14,
"CANCELLED_ON_CUSTOMER_REQUEST" : 15,
"SHIPPED_TO_DESTINATION_CITY" : 16,
"REACHED_DESTINATION_CITY" : 17,
"COD_VERIFICATION_FAILED" : 18,
"FAILED" : 19,
"RTO_IN_TRANSIT" : 20,
"RTO_RECEIVED_PRESTINE" : 21,
"DOA_PICKUP_REQUEST_RAISED" : 22,
"DOA_PICKUP_CONFIRMED" : 23,
"DOA_RETURN_IN_TRANSIT" : 24,
"DOA_RECEIVED_PRESTINE" : 25,
"DOA_CERT_INVALID" : 26,
"DOA_CERT_VALID" : 27,
"RTO_RESHIPPED" : 28,
"DOA_INVALID_RESHIPPED" : 29,
"DOA_VALID_RESHIPPED" : 30,
"RTO_REFUNDED" : 31,
"DOA_VALID_REFUNDED" : 32,
"DOA_INVALID_REFUNDED" : 33,
"CANCELLED_DUE_TO_LOW_INVENTORY" : 34,
"LOW_INV_PO_RAISED" : 35,
"LOW_INV_REVERSAL_IN_PROCESS" : 36,
"LOW_INV_NOT_AVAILABLE_AT_HOTSPOT" : 37,
"LOW_INV_PO_RAISED_TIMEOUT" : 38,
"LOW_INV_REVERSAL_TIMEOUT" : 39,
"FIRST_DELIVERY_ATTEMPT_MADE" : 40,
"CAPTURE_IN_PROCESS" : 41,
"DOA_REQUEST_RECEIVED" : 42,
"DOA_REQUEST_AUTHORIZED" : 43,
"DOA_PICKUP_DENIED" : 44,
"DOA_RECEIVED_DAMAGED" : 45,
"DOA_LOST_IN_TRANSIT" : 46,
"DOA_RESHIPPED_RCVD_DAMAGED" : 47,
"DOA_REFUNDED_RCVD_DAMAGED" : 48,
"DOA_RESHIPPED_LOST_IN_TRANSIT" : 49,
"DOA_REFUNDED_LOST_IN_TRANSIT" : 50,
"RTO_RECEIVED_DAMAGED" : 51,
"RTO_LOST_IN_TRANSIT" : 52,
"RTO_DAMAGED_RESHIPPED" : 53,
"RTO_DAMAGED_REFUNDED" : 54,
"RTO_LOST_IN_TRANSIT_RESHIPPED" : 55,
"RTO_LOST_IN_TRANSIT_REFUNDED" : 56,
"RTO_INVENTORY_REVERSED" : 57,
"RET_REQUEST_RECEIVED" : 58,
"RET_REQUEST_AUTHORIZED" : 59,
"RET_PICKUP_REQUEST_RAISED" : 60,
"RET_PICKUP_DENIED" : 61,
"RET_PICKUP_CONFIRMED" : 62,
"RET_RETURN_IN_TRANSIT" : 63,
"RET_RECEIVED_PRESTINE" : 64,
"RET_RECEIVED_DAMAGED" : 65,
"RET_LOST_IN_TRANSIT" : 66,
"RET_PRODUCT_USABLE" : 67,
"RET_PRODUCT_UNUSABLE" : 68,
"RET_PRODUCT_USABLE_RESHIPPED" : 69,
"RET_PRODUCT_USABLE_REFUNDED" : 70,
"RET_PRODUCT_UNUSABLE_RESHIPPED" : 71,
"RET_PRODUCT_UNUSABLE_REFUNDED" : 72,
"RET_RESHIPPED_RCVD_DAMAGED" : 73,
"RET_REFUNDED_RCVD_DAMAGED" : 74,
"RET_RESHIPPED_LOST_IN_TRANSIT" : 75,
"RET_REFUNDED_LOST_IN_TRANSIT" : 76,
"LOST_IN_TRANSIT" : 77,
"LOST_IN_TRANSIT_RESHIPPED" : 78,
"LOST_IN_TRANSIT_REFUNDED" : 79,
"DELIVERED_AT_STORE" : 80,
"RECEIVED_AT_STORE" : 81}
headers = { 
           'User-agent':'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.56 Safari/535.11',
            'Accept' : 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',      
            'Accept-Language' : 'en-US,en;q=0.8',                     
            'Accept-Charset' : 'ISO-8859-1,utf-8;q=0.7,*;q=0.3'
        }
SAHOLIC_ORDER_URL=PythonPropertyReader.getConfig('SAHOLIC_ORDER_URL')
SAHOLIC_ORDER_URL_TR=PythonPropertyReader.getConfig('SAHOLIC_ORDER_URL_TR')
class Store(MStore):
    '''
    This is to map order statuses of our system to order statuses of snapdeal.
    And our statuses will change accordingly.
    
    '''
    OrderStatusMap = {
                      MStore.ORDER_PLACED : [2,3,4,5,6,7,8,13],
                      MStore.ORDER_DELIVERED : [12],
                      MStore.ORDER_SHIPPED : [9,10,16,17,20,21,81,80],
                      MStore.ORDER_CANCELLED : [6,11,14,15,18,19,31,28,53,54,55,56]
                      }
    
        
    def parseOrderRawHtml(self, orderId, subTagId, userId, rawHtml, orderSuccessUrl):
        resp = {}
        paymentId = int(re.findall(r'=(.*)?',orderSuccessUrl)[0])
        orderRequest = urllib2.Request(SAHOLIC_ORDER_URL %(paymentId), headers=headers)
        try:
            connection = urllib2.urlopen(orderRequest)
            response = connection.read()
            connection.close()
            response = json.loads(response)['response']
            payment = response['payment']
            subOrders = []
            orders = response['orders']
            items = response['itemsMap']
            merchantOrder = Order(orderId, userId, subTagId, self.store_id, orderSuccessUrl)
            merchantOrder.merchantOrderId = payment['merchantTxnId']
            merchantOrder.paidAmount = payment['amount']

            for o in orders:
                subOrders.append(self.createSubOrder(o, items))
            merchantOrder.subOrders = subOrders
            merchantOrder.placedOn = merchantOrder.subOrders[0].placedOn
            s = todict(merchantOrder)
            s['sUserId'] = orders[0]['customer_id']
            if self._saveToOrder(s):
                resp['result'] = 'ORDER_CREATED'
            else:
                #Order already created
                resp['result'] = 'ORDER_ALREADY_CREATED_IGNORED'
        except:
            traceback.print_exc()
            resp['result'] = 'ORDER_NOT_CREATED'
        return resp
    
    def createSubOrder(self, order, items):
            lineitem = order['lineitems'][0]
            
            item = items[str(lineitem['item_id'])]
            brand = lineitem.get('brand')
            modelNumber = lineitem.get('model_number')
            modelName = lineitem.get('model_name')
            color = lineitem.get('color')
            productTitle = brand + (" " + modelName if modelName else "") + (" "  + modelNumber if modelNumber is not None else "") + ("(" + color +")" if color else "")
            amountPaid = order['total_amount']- order['gvAmount']
            subOrder = SubOrder(productTitle, None, datetime.strftime(datetime.fromtimestamp(order['created_timestamp']/1000),"%d %B %Y"), amountPaid)
            subOrder.merchantSubOrderId = str(order['id'])
            subOrder.orderDetailUrl = "http://m.saholic.com/order/" + subOrder.merchantSubOrderId 
            
            subOrder.estimatedDeliveryDate = datetime.strftime(datetime.fromtimestamp(order['promised_delivery_time']/1000),"%d %B %Y")
            subOrder.imgUrl = item['imgUrl'] 
            subOrder.productUrl = "http://m.saholic.com/" + item['url']
            subOrder.productCode = item['url'].split('-')[-1]
            subOrder.detailedStatus = order['statusDescription']
            (cashbackAmount, percentage) = self.getCashbackAmount(subOrder.productCode, amountPaid)
            cashbackStatus = Store.CB_PENDING
            if cashbackAmount <= 0:
                cashbackStatus = Store.CB_NA
            subOrder.cashBackStatus = cashbackStatus
            subOrder.cashBackAmount = cashbackAmount
            if percentage > 0:
                subOrder.cashBackPercentage = percentage
            return subOrder
    def _getStatusFromDetailedStatus(self, detailedStatus):
        for key, value in Store.OrderStatusMap.iteritems():
            if detailedStatus in value:
                return key
        print "Detailed Status need to be mapped", detailedStatus
        raise ParseException("_getStatusFromDetailedStatus", "Found new order status" + detailedStatus)
    
    
    def scrapeStoreOrders(self,):
        trs = self._getActiveOrders(collectionMap={'merchantOrderId':1, 'sUserId':1})
        bulk = self.db.merchantOrder.initialize_ordered_bulk_op()
        for tr in trs:
            try:
                orderRequest = urllib2.Request(SAHOLIC_ORDER_URL_TR %(tr['merchantOrderId'], tr['sUserId']), headers=headers)
                response = urllib2.urlopen(orderRequest).read()
                print response
                response = json.loads(response)['response']
                items = response['itemsMap']
                orders = response['orders']
                closed = True
                for order in orders:
                    print "orderid---", order['id']
                    orderId = str(order['id'])
                    subOrder = self._isSubOrderActive(tr, orderId)
                    if subOrder:
                        if subOrder['closed']:
                            continue
                        else:
                            findMap = {"orderId": tr['orderId'], "subOrders.merchantSubOrderId": orderId}
                            updateMap = {}
                            updateMap["subOrders.$.detailedStatus"] = order['statusDescription']
                            status = self._getStatusFromDetailedStatus(ORDERSTATUS[order['status']]) 
                            closedStatus = status in [Store.ORDER_DELIVERED, Store.ORDER_CANCELLED]
                            print "status---", status, order['status']
                            updateMap["subOrders.$.status"] = status
                            if closedStatus:
                                #if status is closed then change the paybackStatus accordingly
                                updateMap["subOrders.$.closed"] = True
                                if status == Store.ORDER_DELIVERED:
                                    deliveredOn = datetime.strftime(datetime.fromtimestamp(order['delivery_timestamp']/1000),"%A %d %B %Y")
                                    updateMap['subOrders.$.deliveredOn'] = deliveredOn
                                    if subOrder.get("cashBackStatus") == Store.CB_PENDING:
                                        updateMap["subOrders.$.cashBackStatus"] = Store.CB_APPROVED
                                elif status == Store.ORDER_CANCELLED:
                                    if subOrder.get("cashBackStatus") == Store.CB_PENDING:
                                        updateMap["subOrders.$.cashBackStatus"] = Store.CB_CANCELLED
                            else:
                                expectedDelivery = datetime.strftime(datetime.fromtimestamp(order['promised_delivery_time']/1000),"%A %d %B %Y")
                                updateMap["subOrders.$.estimatedDeliveryDate"] = expectedDelivery
                                closed = False
                            bulk.find(findMap).update({'$set' : updateMap})
                    else:
                        subOrder = self.parseSubOrder(order, items)
                        self.db.merchantOrder.update({"orderId":tr['orderId']},{'$push':{"subOrders":todict(subOrder)}})
                        print "Added new suborder with subOrder Id:", subOrder.merchantSubOrderId
                        closed = False
                bulk.find({"orderId":tr['orderId']}).update({'$set' : {'closed':closed}})
            except:
                traceback.print_exc()
        try:
            bulk.execute()
        except:
            traceback.print_exc()
                        
                
                    
    
    def _saveToAffiliate(self, offers):
        if offers is None or len(offers)==0:
            print "no affiliate have been pushed"
            return
        collection = self.db.snapdealOrderAffiliateInfo
        try:
            collection.insert(offers,continue_on_error=True)
        except pymongo.errors.DuplicateKeyError as e:
            print e.details
            
    
    def covertToObj(self,offer):
        offerData = offer['Stat']
        offer1 = AffiliateInfo(offerData['affiliate_info1'], self.store_id, offerData['conversion_status'], offerData['ad_id'], 
                              offerData['datetime'], offerData['payout'], offer['Offer']['name'], offerData['ip'], offerData['conversion_sale_amount'])
        
        return offer1
def getPostData(token, page = 1, limit= 20, startDate=None, endDate=None):
    endDate=date.today() + timedelta(days=1)
    startDate=endDate - timedelta(days=31)

    parameters = (
        ("page",str(page)),
        ("limit",str(limit)),
        ("fields[]","Stat.offer_id"),
        ("fields[]","Stat.datetime"),
        ("fields[]","Offer.name"),
        ("fields[]","Stat.conversion_status"),
        ("fields[]","Stat.conversion_sale_amount"),
        ("fields[]","Stat.payout"),
        ("fields[]","Stat.ip"),
        ("fields[]","Stat.ad_id"),
        ("fields[]","Stat.affiliate_info1"),
        ("sort[Stat.datetime]","desc"),
        ("filters[Stat.date][conditional]","BETWEEN"),
        ("filters[Stat.date][values][]",startDate.strftime('%Y-%m-%d')),
        ("filters[Stat.date][values][]",endDate.strftime('%Y-%m-%d')),
        ("data_start",startDate.strftime('%Y-%m-%d')),
        ("data_end",endDate.strftime('%Y-%m-%d')),
        ("Method","getConversions"),
        ("NetworkId","jasper"),
        ("SessionToken",token),
    )
    #Encode the parameters
    return urllib.urlencode(parameters)

def main():
    
    store = getStore(4)
    #store.scrapeStoreOrders()
    #store._isSubOrderActive(8, "5970688907")
    #store.scrapeAffiliate()
    #store.parseOrderRawHtml(12345, "subtagId", 122323,  "html", 'http://www.saholic.com/pay-success?paymentId=1528903')
    print store.getCashbackAmount('1011378', 500)


if __name__ == '__main__':
    main()

def todict(obj, classkey=None):
    if isinstance(obj, dict):
        data = {}
        for (k, v) in obj.items():
            data[k] = todict(v, classkey)
        return data
    elif hasattr(obj, "_ast"):
        return todict(obj._ast())
    elif hasattr(obj, "__iter__"):
        return [todict(v, classkey) for v in obj]
    elif hasattr(obj, "__dict__"):
        data = dict([(key, todict(value, classkey)) 
            for key, value in obj.__dict__.iteritems() 
            if not callable(value) and not key.startswith('_')])
        if classkey is not None and hasattr(obj, "__class__"):
            data[classkey] = obj.__class__.__name__
        return data
    else:
        return obj