Subversion Repositories SmartDukaan

import StringIO

import base64

import gzip

import pymongo

import time

import urllib

import urllib2

import logging

from datetime import datetime

import random

#TODO Need to add messy stuff to conf.

con=None

headers = { 

            'User-agent':'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/37.0.2062.120 Safari/537.36',

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

            'Connection':'keep-alive',

            'Accept-Encoding' : 'gzip,deflate,sdch'

        }

PROXY_URL = "http://173.234.194.37:8800/"

PROXY_LIST = ['108.186.244.30:8800','108.186.244.39:8800','108.186.244.46:8800' \

              ,'166.88.107.119:8800','166.88.107.74:8800','108.186.244.40:8800' \

              ,'166.88.111.13:8800','192.126.186.135:8800','192.126.186.166:8800' \

              ,'166.88.111.49:8800']

PUSH_NOTIFICATION_URL='http://api.profittill.com/admin/users/push'

DTR_API_BASIC_AUTH = base64.encodestring('%s:%s' % ("dtr", "dtr18Feb2015")).replace('\n', '')

def get_mongo_connection(host='localhost', port=27017):

    global con

    if con is None:

        print "Establishing connection %s host and port %d" %(host,port)

        try:

            con = pymongo.MongoClient(host, port)

        except Exception, e:

            print e

            return None

    return con

def to_java_date(py_timestamp):

    try:

        java_date =  int(time.mktime(py_timestamp.timetuple())) * 1000 + py_timestamp.microsecond / 1000

        return java_date

    except:

        return None

def getCashBack(skuId, source_id, category_id, mc, mongoHost):

    if not bool(mc.get("category_cash_back")):

        populateCashBack(mc, mongoHost)

    itemCashBackMap = mc.get("item_cash_back")

    itemCashBack = itemCashBackMap.get(skuId)

    if itemCashBack is not None:

        return itemCashBack

    cashBackMap = mc.get("category_cash_back")

    sourceCashBack = cashBackMap.get(source_id)

    if sourceCashBack is not None and len(sourceCashBack) > 0:

        for cashBack in sourceCashBack:

            if cashBack.get(category_id) is None:

                continue

            else:

                return cashBack.get(category_id)

    else:

        return {}

def populateCashBack(mc, mongoHost):

    print "Populating cashback"

    cashBackMap = {}

    itemCashBackMap = {}

    cashBack = list(get_mongo_connection(host=mongoHost).Catalog.CategoryCashBack.find())

    for row in cashBack:

        temp_map = {}

        temp_list = []

        if cashBackMap.has_key(row['source_id']):

            arr = cashBackMap.get(row['source_id'])

            for val in arr:

                temp_list.append(val)

            temp_map[row['category_id']] = row

            temp_list.append(temp_map)

            cashBackMap[row['source_id']] = temp_list 

        else:

            temp_map[row['category_id']] = row

            temp_list.append(temp_map)

            cashBackMap[row['source_id']] = temp_list

    itemCashBack = list(get_mongo_connection(host=mongoHost).Catalog.ItemCashBack.find())

    for row in itemCashBack:

        if not itemCashBackMap.has_key(row['skuId']):

            itemCashBackMap[row['skuId']] = row

    mc.set("item_cash_back", itemCashBackMap, 24 * 60 * 60)

    mc.set("category_cash_back", cashBackMap, 24 * 60 * 60)

def ungzipResponse(r):

    headers = r.info()

    if headers.get('Content-Encoding')=='gzip':

        url_f = StringIO.StringIO(r.read())

        gz = gzip.GzipFile(fileobj=url_f)

        html = gz.read()

        gz.close()

        return html

    return r.read()

def fetchResponseUsingProxy(url, headers=headers):

    PROXY_URL = PROXY_LIST[random.randint(0, len(PROXY_LIST) -1)]

    print PROXY_URL

    proxy = urllib2.ProxyHandler({'http': PROXY_URL})

    opener = urllib2.build_opener(proxy)

    urllib2.install_opener(opener)

    req = urllib2.Request(url,headers=headers)

    response = urllib2.urlopen(req)

    response_data = ungzipResponse(response)

    response.close()

    return response_data

def sendNotification(userIds, campaignName, title, message,notificationtype, url):

    usertuples = ()

    count = -1

    for userId in userIds:

        count += 1

        usertuples += (("userIds[" + str(count) + "]", userId),)

    parameters = usertuples + (

                   ("User[name]", campaignName), 

                   ("User[title]", title ), 

                   ("User[message]", message), 

                   ("User[type]", notificationtype), 

                   ("User[url]", url),)

    parameters = urllib.urlencode(parameters)

    #print parameters

    pushpostrequest = urllib2.Request(PUSH_NOTIFICATION_URL, parameters, headers=headers)

    pushpostrequest.add_header("Authorization", "Basic %s" % DTR_API_BASIC_AUTH)

    urllib2.urlopen(pushpostrequest).read()

def getCurrTimeStamp():

    return toTimeStamp(datetime.now())

def toTimeStamp(dateTimeObj):

    return int(time.mktime(dateTimeObj.timetuple()))

def fromTimeStamp(timestamp):

    return datetime.fromtimestamp(timestamp)

def getNlcPoints(item, minNlc, maxNlc, available_price):

    if not(minNlc and maxNlc):

        raise

    if item.get('status') == 2:

        eolWeight = .60

    else:

        eolWeight = 1.0

    if item.get('category_id') == 3:

        basePointPercentage = 5.0

        maxNlcPoints = 200

    elif item.get('category_id') == 5:

        basePointPercentage = 8.0

        maxNlcPoints = 150

    else:

        basePointPercentage = 10.0

        maxNlcPoints = 150

    discFromMinNlc = float((minNlc - (available_price)))/(available_price) *100

    discFromMaxNlc = float((maxNlc - (available_price)))/(available_price) *100

    print discFromMinNlc

    print discFromMaxNlc

    if discFromMinNlc > 0:

        nlcPoints = 100/basePointPercentage * discFromMinNlc

    elif discFromMinNlc < 0 and discFromMaxNlc > 0:

        nlcPoints = 0

    else:

        nlcPoints = 100/basePointPercentage * discFromMinNlc

    if (min(nlcPoints,maxNlcPoints)) > 0:

        nlcPoints = (min(nlcPoints,maxNlcPoints)) * eolWeight

    else:

        nlcPoints = (min(nlcPoints,maxNlcPoints))

    return nlcPoints

    return datetime.fromtimestamp(timestamp)

def getLogger(filePath):

    lgr = logging.getLogger()

    lgr.setLevel(logging.DEBUG)

    fh = logging.FileHandler(filePath)

    fh.setLevel(logging.INFO)

    frmt = logging.Formatter('%(asctime)s - %(name)s - %(message)s')

    fh.setFormatter(frmt)

    lgr.addHandler(fh)

    return lgr