Subversion Repositories SmartDukaan

'''
Created on Feb 12, 2015

@author: amit
'''
from dtr import main
from datetime import datetime
from dtr.main import tprint
from dtr.storage import Mongo, Mysql
from dtr.utils import utils
import falcon
import json
import os.path
import re
import traceback
import urlparse
import xlrd
import cgi
from dtr.utils.utils import find_between


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