Subversion Repositories SmartDukaan

'''

Created on Feb 12, 2015

@author: amit

'''

from datetime import datetime

from dtr import main

from dtr.main import tprint

from dtr.storage import Mongo, Mysql

from dtr.utils import utils

from dtr.utils.utils import find_between

import cgi

import falcon

import json

import logging

import os.path

import re

import traceback

import urlparse

import xlrd

logging.basicConfig(filename='/var/log/uwsgi/order.log',level=logging.DEBUG)

order_fliters = {

                 "monitor":{

                    "trackingurlmissing":  {

                                                "displaylabel":"Tracking Url Missing",

                                                "query":{"subOrders.closed":False,"subOrders.trackingUrl":{"$exists":False}, "subOrders.trackMissing":True}

                                            }, 

                     "orderuntrackable":    {

                                                "displaylabel":"Untrackable Orders",   

                                                "query":{"trackError":True, "storeId":1, "subOrders.closed":False}

                                            },

                     "prematurelyclosed" :  {

                                                "displaylabel": "Prematurely Closed Orders",

                                                "query":{"closed":True, "subOrders.closed":False}

                                            },

                     "parsefailed":         {   

                                                "displaylabel": "Failed to Parse Orders",

                                                "query":{"subOrders":{"$exists": False}, "status":"parse_failed"}

                                            }

                     },

                 "user":{}

                 }

class StoreOrder():

    def on_post(self, req, resp):

        try:

            string1 = req.stream.read()

            req_json = json.loads(string1, encoding='utf-8')

            print "req_json",req_json

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

        store = main.getStore(int(req_json['sourceId']))

        result = store.parseOrderRawHtml(int(req_json['orderId']), req_json['subTagId'], int(req_json['userId']), req_json['rawHtml'], req_json['orderSuccessUrl'])

        resp.body = json.dumps(result, encoding='utf-8')

    def on_get(self, req, resp, userId):

        page = req.get_param_as_int("page")

        window = req.get_param_as_int("window")

        string1 = req.get_param("searchMap")

        orderType = req.get_param("type")

        searchMap={}

        if orderType is not None and orderType != "":

            if orderType in ['needamazonorderdetail','needamazonordertrack']:

                searchMap={"$or":[{"subOrders.closed":False,"subOrders.trackingUrl":{"$exists":False},"subOrders.trackAfter":{"$lt":utils.getCurrTimeStamp()}}, {"status":"html_required"}], "storeId":1}

        elif string1 is not None and string1 != "":

            try:

                searchMap = json.loads(string1, encoding='utf-8')

            except:

                raise falcon.HTTPError(falcon.HTTP_400,

                    'Malformed JSON',

                    'Could not decode the request body. The '

                    'JSON was incorrect.')

        result = Mongo.getMerchantOrdersByUser(int(userId), page, window, searchMap)

        resp.body = json.dumps(result, encoding='utf-8')

class OrderFilters():

    def on_get(self, req, resp):

        filter_type = req.get_param("type")

        result = order_fliters.get(filter_type)

        resp.body = json.dumps(result, encoding='utf-8')

class Orders():

    def on_get(self, req, resp):

        page = req.get_param_as_int("page")

        window = req.get_param_as_int("window")

        string1 = req.get_param("searchMap")

        orderFilter = req.get_param("filter")

        filterType = req.get_param("filtertype")

        searchMap={}

        if filter and filterType:

            try:

                searchMap = order_fliters[filterType][orderFilter]['query']

            except:

                pass

        elif string1:

            try:

                searchMap = json.loads(string1, encoding='utf-8')

            except:

                raise falcon.HTTPError(falcon.HTTP_400,

                    'Malformed JSON',

                    'Could not decode the request body. The '

                    'JSON was incorrect.')

        result = Mongo.getMerchantOrdersByUser(None, page, window, searchMap)

        resp.body = json.dumps(result, encoding='utf-8')

class Track():

    def on_post(self, req, resp, userId):

        try:

            string1 = req.stream.read()

            req_obj = urlparse.parse_qs(string1)

            logging.info(string1)

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

        try:

            store = main.getStore(req.get_param_as_int("storeId"))

            print "req_obj",req_obj

            result = store.trackOrdersForUser(int(userId),req_obj['url'][0],req_obj['html'][0])

            resp.body = json.dumps({'result':result}, encoding='utf-8')

            '''

            elif req.get_param_as_int("storeId") == 7:

                if 'myprofile' in req_obj['url'][0]:

                    result = store.parseMyProfileForEmailId(int(userId),req_obj['url'][0],req_obj['html'][0])

                else:

                    result = store.parseMyOrdersForEmailId(int(userId),req_obj['url'][0],req_obj['html'][0])

                resp.body = json.dumps({'result':result}, encoding='utf-8')

            '''

        except:

            traceback.print_exc()

            resp.body = json.dumps({'result':'PARSE_ERROR'}, encoding='utf-8')

    def on_get(self, req, resp, userId):

        try:

            storeId = req.get_param_as_int("storeId")

            result = main.getStore(storeId).getTrackingUrls(int(userId))

            resp.body = json.dumps({'result':result}, encoding='utf-8')

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

class Refunds():

    def on_get(self, req, resp, userId):

        try:

            page = req.get_param_as_int("page")

            window = req.get_param_as_int("window")

            result = Mongo.getRefunds(int(userId),page,window)

            resp.body = json.dumps(result, encoding='utf-8')

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

class Transactions():

    def on_get(self, req, resp):

        try:

            page = req.get_param_as_int("page")

            window = req.get_param_as_int("window")

            user = req.get_param("user")

            status = req.get_param("status")

            source = req.get_param("source")

            if user == "" :

                user = None

            if status == "" :

                status = None

            result = Mysql.getOrders(page, window,status,user,source)

            resp.body = result

            resp.content_type = 'text/html'

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

class Rejects():

    def on_get(self, req, resp):

        try:

            result="""<html><head><title>Upload Rejects</title></head><body>

            <h1>Upload rejects</h1>

            <form action="rejects" method="POST" enctype="multipart/form-data">

              <input type="file" name="rejects" accept=".xlsx, .xls">

              <input type="submit">

            </form>

            </body></html>"""

            resp.body = result

            resp.content_type = 'text/html'

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

    def on_post(self, request, resp):

        res = None

        try:

            boundary = request.content_type.split(";")[1].strip().split("=")[1]

            pdict= {'boundary':boundary}

            filepath = "/tmp/rejectfile"

            with open(filepath, 'wb') as image_file:

                while True:

                    chunk = request.stream.read(4096)

                    if not chunk:

                        break

                    image_file.write(chunk)

            with open(filepath, 'r') as image_file:

                res = cgi.parse_multipart(image_file, pdict)['rejects'][0]

            if res:

                with open(filepath, 'wb') as image_file:

                    image_file.write(res)

                rejectCount = process_rejects(filepath)

                resp.content_type = 'text/html'

                resp.body = """

                    <html><head><title>Upload Rejects</title></head><body>

                <h1>Reject Successful</h1>

                <h2> %d orders rejected</h2>

                </body></html>

                    """%(rejectCount) 

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

def process_rejects(filepath):

    rejectCount = 0

    workbook = xlrd.open_workbook(filepath)

    sheet = workbook.sheet_by_index(0)

    num_rows = sheet.nrows

    for rownum in range(1, num_rows):

        try:

            orderId, userId, merchantOrderId, subOrderId  = sheet.row_values(rownum)[0:4]

            rejectCount += Mongo.rejectCashback(int(orderId), subOrderId)

        except:

            traceback.print_exc()

    return rejectCount

class SnapShot():

    def on_get(self, req, resp):

        try:

            resp.content_type = 'text/html'

            user = req.get_param_as_int("user")

            file = req.get_param("file") 

            if  file is not None:

                #fetch the page and return html

                with open ("/AmazonTrack/User%d/%s"%(user, file), "r") as myfile:

                    resp.body=myfile.read() 

            else:

                #return user specific urls

                resp.body=getUserUrls(user)

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

def getUserUrls(user):

    pass

class RawHtml():

    def on_get(self, req, resp, orderId):

        try:

            result = Mysql.getOrderHtml(orderId)

            if req.get_param("show") is None:

                result = re.subn(r'(src|href|style)=\s?(\'|").*?\2(?s)', '', re.subn(r'<(script|style).*?</\1>(?s)', '', result)[0])[0]

            resp.body = result

            resp.content_type = 'text/html'

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

class PendingRefunds():

    def on_get(self, req, resp,userId):

        try:

            result = Mongo.getPendingRefunds(int(userId))

            resp.body = json.dumps(result, encoding='utf-8')

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

class AmazonSummary():

    def on_get(self, req, resp,userId):

        try:

            result = getSummary(userId, req)

            if result:

                resp.body = result

            else:

                resp.body = ''

            resp.content_type = 'text/html'

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

def getSummary(userId, req):

    directory = "/AmazonTrack/User" + userId

    date1 = datetime(2015,1,1)

    finalFile = None

    str1 = None

    try:

        for file in os.listdir(directory):

            if file.startswith("orderSummary"):

                date2 = datetime.strptime("2015-" + file.split("orderSummary")[1].split(":")[0], "%Y-%d-%m")

                if date2 > date1:

                    date1 = date2

                    finalFile=file

        result = open(directory + "/" + finalFile).read()

        if req.get_param("show") is None:

            result = re.subn(r'(src|href|style)=\s?(\'|").*?\2(?s)', '', re.subn(r'<(script|style).*?</\1>(?s)', '', result)[0])[0]

        return result

    except:

        print "Missing directory"

    return str1

class PendingCashBacks():

    def on_get(self, req, resp,userId):

        try:

            result = Mongo.getPendingCashbacks(int(userId))

            resp.body = json.dumps(result, encoding='utf-8')

        except ValueError:

            raise falcon.HTTPError(falcon.HTTP_400,

                'Malformed JSON',

                'Could not decode the request body. The '

                'JSON was incorrect.')

def tprint(*msg):

    print datetime.now(), "-", msg