Subversion Repositories SmartDukaan

from datetime import datetime

from paramiko.client import SSHClient

import StringIO

import base64

import gzip

import logging

import os

import paramiko

import pymongo

import random

import socket

import time

import urllib

import urllib2

import urlparse

#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_MESH_LIVE = "us.proxymesh.com:31280"

PROXY_MESH_GENERAL = "us-il.proxymesh.com:31280"

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

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

statusMap = {1:'Active',2:'EOL',3:'In Process',4:'Exclusive'}

CB_INIT = 'Waiting Confirmation'

CB_PENDING = 'Pending'

CB_CREDIT_IN_PROCESS = 'Credit in process'

CB_CREDITED = 'Credited to wallet'

CB_NA = 'Not Applicable'

CB_APPROVED = 'Approved'

CB_REJECTED = 'Rejected'

CB_ONHOLD = 'On hold'

CB_CANCELLED = 'Cancelled'

ORDER_PLACED = 'Order Placed'

ORDER_DELIVERED = 'Delivered'

ORDER_SHIPPED = 'Shipped' #Lets see if we can make use of it

ORDER_CANCELLED = 'Cancelled'

AFFILIATE_OFFER_API= {1:"https://www.spicesafar.com/FreeBapp/fetchOffersSM?deviceId=%s&retailerCode=%d"}

AFFILIATE_OFFER_DESC_API = {1:"https://www.spicesafar.com/FreeBapp/individualOffersSM?deviceId=%s&offerId=%s&retailerCode=%d"}

CREDIT_TYPE_ORDER = "Order"

CREDIT_TYPE_APP = "App"

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 to_py_date(java_timestamp):

    try:

        date = datetime.fromtimestamp(java_timestamp / 1e3)

    except:

        return None

    return date

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, livePricing=None, proxy=True):

#    if livePricing is None:

#        PROXY_URL = PROXY_MESH_GENERAL

#    else:

#        PROXY_URL = PROXY_MESH_LIVE

#    if proxy:

#        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, expiresat='2999-01-01'):

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

                   ("User[expiresat]", expiresat),)

    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(deal):

    if not(deal.get('minNlc') and deal.get('maxNlc')):

        print "Raising exception minNlc, maxNlc not found for %d"%(deal.get('_id'))

        raise

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

        eolWeight = .60

    else:

        eolWeight = 1.0

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

        basePointPercentage = 5.0

        maxNlcPoints = 200

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

        basePointPercentage = 8.0

        maxNlcPoints = 150

    else:

        basePointPercentage = 10.0

        maxNlcPoints = 150

    discFromMinNlc = float((deal.get('minNlc') - (deal.get('available_price'))))/(deal.get('available_price')) *100

    discFromMaxNlc = float((deal.get('maxNlc') - (deal.get('available_price'))))/(deal.get('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

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

def removePriceFormatting(price_string):

    return price_string.strip().replace('Rs.', '').replace('Rs', '').replace(',', '').replace(' ', '').replace(' ', '').split('.')[0]

def transformUrl(url,source_id):

    if source_id == 5:

        finalUrl = urlparse.urlparse(url)

        return finalUrl._replace(netloc=finalUrl.netloc.replace(finalUrl.hostname, 'm.shopclues.com')).geturl()

    elif source_id ==1:

        return url

    elif source_id == 2:

        finalUrl = urlparse.urlparse(url)

        return finalUrl._replace(netloc=finalUrl.netloc.replace(finalUrl.hostname, socket.gethostbyname(finalUrl.hostname))).geturl()

    elif source_id == 7:

        productId = url.split('product:')[1].split('/')[0]

        finalUrl = 'http://m.homeshop18.com/product.mobi?productId='+str(productId)

        return finalUrl

def find_between( s, first, last ):

    try:

        start = s.find( first ) + len( first )

        end = s.rfind( last, start )

        if start ==-1 or end ==-1:

            return ""

        return s[start:end]

    except ValueError:

        return ""

if __name__ == '__main__':

    print transformUrl("http://www.flipkart.com/redmi-2/p/itme8ygtcfax6w39",2)

def readSSh(fileName):

    try:

        str1 = open(fileName).read()

        return str1

    except:

        ssh_client = SSHClient()

        str1 = ""

        ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

        ssh_client.connect('dtr', 22, 'root', 'ecip$dtrMay2014')

        sftp_client = ssh_client.open_sftp()

        try:

            if not os.path.exists(os.path.dirname(fileName)):

                os.makedirs(os.path.dirname(fileName))

            sftp_client.get(fileName, fileName)

            try:

                str1 = open(fileName).read()

                return str1

            finally:

                pass

        except:

            "could not read"

        return str1