Subversion Repositories SmartDukaan

from datetime import datetime

from email import encoders

from email.mime.base import MIMEBase

from email.mime.multipart import MIMEMultipart

from email.mime.text import MIMEText

from paramiko.client import SSHClient

import StringIO

import base64

import gzip

import logging

import os

import paramiko

import pymongo

import random

import smtplib

import socket

import time

import urllib

import urllib2

import urlparse

from Crypto.Hash import MD5

from Crypto.Cipher import DES

import string

from dtr.utils.MailSender import Email

#TODO Need to add messy stuff to conf.

SENDER = "cnc.center@shop2020.in"

PASSWORD = "5h0p2o2o"

SMTP_SERVER = "smtp.gmail.com"

SMTP_PORT = 587    

_password = 'dtr18Feb2015'

_salt = '\xA9\x9B\xC8\x32\x56\x35\xE3\x03'

_iterations = 19

ALPHABET = string.ascii_uppercase + string.ascii_lowercase + \

           string.digits + '-_'

ALPHABET_REVERSE = dict((c, i) for (i, c) in enumerate(ALPHABET))

BASE = len(ALPHABET)

SIGN_CHARACTER = '$'

con=None

conDtrData = None

conCms = 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 = "ch.proxymesh.com:31280"

PROXY_MESH_GENERAL = "de.proxymesh.com:31280"

PROXY_FLIPKART = "117.240.187.35:3128"

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

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

EMAIL_CRM_PUSH_URL = 'http://staging.profittill.com/feedbacks/crm_mail'

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

SOURCE_MAP = {'AMAZON':1,'FLIPKART':2,'SNAPDEAL':3,'SAHOLIC':4, 'SHOPCLUES.COM':5,'PAYTM.COM':6, 'HOMESHOP18.COM':7}

REVERSE_SOURCE_MAP = {1:"Amazon", 2:"Flipkart", 3:"Snapdeal", 4:"Spice", 5:"Shopclues", 6:"Paytm", 7:"HomeShop18"}

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"

CREDIT_TYPE_REFUND = "Refund"

CREDIT_TYPE_OFFER = "Offer"

CREDIT_TYPE_ADJUSTMENT = "Adjustment"

SUB_CATEGORY_MAP = {7:'Memory Card',8:'Cable',9:'USB Lights',10:"Screen Magnifier",11:"Car Charger",12:"Power Bank",13:"Pendrive",14:"Combo",15:"Charger",16:"Bluetooth Headset",17:"Speaker", \

                    18:"Adapter",19:"Cases",20:"Screen Guard",21:"Earphone",22:"Card Reader",23:"Mobile Holder",24:"AUX Cable",25:"OTG Cable",26:"Selfie Stick",27:"Back Cover",28:"Tempered Glass",29:"Battery", \

                    30:"Usb Hub",31:"Portable Music Player",32:"Smart Watch",33:'Flip Cover',34:'Connector',35:'TV Remote',36:'Bumper Case'}

CATEGORY_MAP = {3:'Mobiles',5:'Tablets',6:'Accessories'}

REFUND_ADJUSTMENT_MAP={0:'Pending',1:'Approved',2:'Cancelled',3:'Credited'}

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 get_mongo_connection_dtr_data(host='45.33.50.227', port=27017):

    global conDtrData

    if conDtrData is None:

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

        try:

            conDtrData = pymongo.MongoClient(host, port)

        except Exception, e:

            print e

            return None

    return conDtrData

def get_mongo_connection_cms(host, port=27017):

    global conCms

    if conCms is None:

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

        try:

            conCms = pymongo.MongoClient(host, port)

        except Exception, e:

            print e

            return None

    return conCms

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 mc.get("category_cash_back") is None or 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, flipkart=False):

    if livePricing is None:

        PROXY_URL = PROXY_MESH_GENERAL

    elif flipkart:

        PROXY_URL = PROXY_FLIPKART

    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 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 sendmail(email, message, title, *varargs):

    if email == "":

        return

    mailServer = smtplib.SMTP(SMTP_SERVER, SMTP_PORT)

    mailServer.ehlo()

    mailServer.starttls()

    mailServer.ehlo()

    # Create the container (outer) email message.

    msg = MIMEMultipart()

    msg['Subject'] = title

    msg.preamble = title

    html_msg = MIMEText(message, 'html')

    msg.attach(html_msg)

    #snapdeal more to be added here

    for fileName in varargs:

        snapdeal = MIMEBase('application', 'vnd.ms-excel')

        snapdeal.set_payload(file(fileName).read())

        encoders.encode_base64(snapdeal)

        snapdeal.add_header('Content-Disposition', 'attachment;filename=' + fileName)

        msg.attach(snapdeal)

    MAILTO = email 

    mailServer.login(SENDER, PASSWORD)

    mailServer.sendmail(PASSWORD, MAILTO, msg.as_string())

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

def encryptMessage(plaintext_to_encrypt1):

    hasher = MD5.new()

    hasher.update(_password)

    hasher.update(_salt)

    result = hasher.digest()

    for i in range(1, _iterations):

        hasher = MD5.new()

        hasher.update(result)

        result = hasher.digest()

    padding = 8 - len(plaintext_to_encrypt1) % 8

    plaintext_to_encrypt1 += chr(padding) * padding

    encoder = DES.new(result[:8], DES.MODE_CBC, result[8:16])

    encrypted = encoder.encrypt(plaintext_to_encrypt1)

    check1 =  encrypted.encode('base64')

    return check1

def decryptMessage(encryptedData):

    padding = 8 - len(encryptedData) % 8

    encryptedData += chr(padding) * padding

    hasher = MD5.new()

    hasher.update(_password)

    hasher.update(_salt)

    result = hasher.digest()

    for i in range(1, _iterations):

        hasher = MD5.new()

        hasher.update(result)

        result = hasher.digest()

    encoder2 = DES.new(result[:8], DES.MODE_CBC, result[8:16])

    decodeString =  encoder2.decrypt(encryptedData.decode('base64'))

    return ''.join(e for e in decodeString if e.isalnum() or e is '/' or e is ':' or e is ',' or e is '.' or e is '=' or e is '?' or e is '_')

def num_encode(n):

    if n < 0:

        return SIGN_CHARACTER + num_encode(-n)

    s = []

    while True:

        n, r = divmod(n, BASE)

        s.append(ALPHABET[r])

        if n == 0: break

    return ''.join(reversed(s))

def num_decode(s):

    if s[0] == SIGN_CHARACTER:

        return -num_decode(s[1:])

    n = 0

    for c in s:

        n = n * BASE + ALPHABET_REVERSE[c]

    return n    

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

def getSkuData(storeId, identifier):

    if storeId in (1,2,4,5,6):

        skuData = get_mongo_connection().Catalog.MasterData.find_one({'identifier':identifier, 'source_id':storeId})

    elif storeId == 3:

        skuData = get_mongo_connection().Catalog.MasterData.find_one({'secondaryIdentifier':identifier, 'source_id':storeId})

    return skuData

def sendCrmProjectMail(userId,disposition_description,disposition_comments):

    parameters = ("user_id", userId),("subject", disposition_description),("message",disposition_comments)

    parameters = urllib.urlencode(parameters)

    emailpushrequest = urllib2.Request(EMAIL_CRM_PUSH_URL, parameters, headers=headers)

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

    connection = urllib2.urlopen(emailpushrequest)

    connection.close()

def sendCrmProjectMailByDtr(customerFeedback):

    mailServer = smtplib.SMTP(SMTP_SERVER, SMTP_PORT)

    mailServer.ehlo()

    mailServer.starttls()

    mailServer.ehlo()

    title=customerFeedback.get('subject')    

    msg = MIMEMultipart()

    msg['Subject'] = title

    msg.preamble = title

    message="User Id : " + str(customerFeedback.get('user_id'))

    message1="Email : " + str(customerFeedback.get('email'))

    message2="Mobile Number : " + str(customerFeedback.get('mobile_number'))

    message3="Subject : " + str(customerFeedback.get('subject'))

    message4="Message : " + str(customerFeedback.get('message'))

    html_msg = MIMEText(message+"<br><br>"+message1+"<br><br>"+message2+"<br><br>"+message3+"<br><br>"+message4, 'html')

    msg.attach(html_msg)

    MAILTO = ['rajneesh.arora@shop2020.in','amit.sirohi@shop2020.in','shailesh.kumar@shop2020.in','sandeep.sachdeva@shop2020.in','manas.kapoor@shop2020.in','chaitnaya.vats@shop2020.in','amit.gupta@shop2020.in']

    #MAILTO = ['manas.kapoor@saholic.com']

    mailServer.login(SENDER, PASSWORD)

    try:

        mailServer.sendmail(SENDER, MAILTO, msg.as_string())

    except:

        m = Email('localhost')

        mFrom = "dtr@shop2020.in"

        m.setFrom(mFrom)

        for receipient in MAILTO:

            m.addRecipient(receipient)

        m.setSubject(title)

        m.send()

    return