Subversion Repositories SmartDukaan

from elixir import *
from shop2020.model.v1.catalog.impl import DataService
from shop2020.model.v1.catalog.impl.DataService import Item, Tag_Listing, \
    Tag_Ranking, PrivateDeals
from shop2020.thriftpy.model.v1.catalog.ttypes import status
from sqlalchemy.sql.expression import or_, desc
from sqlalchemy.sql.functions import now
import json
import optparse
import os
import pymongo
import pysolr
import shutil
import traceback
import urllib2
from dtr.utils.utils import to_java_date
import urllib2
import StringIO
# import pymongo
# import pysolr

CATEGORY_MASTER = [10006, 10010, 14202, 14203]
parser = optparse.OptionParser()
parser.add_option("-d", "--d", dest="dbHost",
                  default="127.0.0.1",
                  type="string", help="The HOST where the mysql server is running",
                  metavar="DBHOST")
parser.add_option("-s", "--s", dest="solrPath",
                  default="http://localhost:8984/solr/demo",
                  type="string", help="Complete solr path",
                  metavar="SOLRHOST")
parser.add_option("-m", "--m", dest="mongoHost",
                  default="localhost",
                  type="string", help="Complete solr path",
                  metavar="HOST")

(options, args) = parser.parse_args()

con = None

DataService.initialize(db_hostname=options.dbHost)
solr = pysolr.Solr(options.solrPath, always_commit=True, timeout=10)


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


class __SkuInfo:

    def __init__(self, id, ids, brand, model_name, category_id, subCategoryId, thumbnail, title, brand_synonyms, model_name_synonyms, source_product_names, \
                 category, subCategory):
        # Skubundle id
        self.id = id
        # _id of skus
        self.ids = ids
        self.brand = brand
        self.model_name = model_name
        self.category_id = category_id
        self.subCategoryId = subCategoryId
        self.thumbnail = thumbnail
        self.title = title
        self.brand_synonyms = brand_synonyms
        self.model_name_synonyms = model_name_synonyms
        self.source_product_names = source_product_names
        self.category = category
        self.subCategory = subCategory

    def toJSON(self):
        return json.dumps(self, default=lambda o: o.__dict__,
                          sort_keys=True, indent=4)


class __Catalog:

    def __init__(self, id, rank, title, items):
        # Skubundle id
        self.id = id
        self.rank = rank
        self.title = title
        self._childDocuments_ = items

    def toJSON(self):
        return json.dumps(self, default=lambda o: o.__dict__)


class __Item:

    def __init__(self, id, color, tags):
        self.id = id
        self.color = color
        self._childDocuments_ = tags

        def toJSON(self):
            return json.dumps(self, default=lambda o: o.__dict__)


class __Tag:

    def __init__(self, id, sellingPrice, mop):
        self.id = id
        self.sellingPrice = sellingPrice
        self.mop = mop

# solr = pysolr.Solr(options.solrPath, timeout=10)


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 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 getAvailabilityJSON():
    url = "http://50.116.10.120/reports/run.php?execute_mode=EXECUTE&xmlin=warehousecisnew.xml&project=FOCOR&project_password=focor&target_format=JSON"
    req = urllib2.Request(url, headers={})
    response = urllib2.urlopen(req)
    response_data = ungzipResponse(response)
    response.close()
    return json.loads(response_data)['data']


def getPendingPOJSON():
    url = "http://50.116.10.120/reports/run.php?execute_mode=EXECUTE&xmlin=UnfulfilledPOItemsNew.xml&project=FOCOR&project_password=focor&target_format=JSON"
    req = urllib2.Request(url, headers={})
    response = urllib2.urlopen(req)
    response_data = ungzipResponse(response)
    response.close()
    return json.loads(response_data)['data']


def getItemMap():
    rawAvailabilityList = getAvailabilityJSON()
    rawPendingPoList = getPendingPOJSON()
    availabilityItemMap = {}
    # {"Warehouseid":"8468","Warehousefrom":"7573","Itemid":"29591","Availability":"8","Reserved":"0","Netavailability":"8"}
    for rawAvailability in rawAvailabilityList:
        if not availabilityItemMap.has_key(rawAvailability['Itemid']):
            availabilityItemMap[rawAvailability['Itemid']] = {}
        if not availabilityItemMap[rawAvailability['Itemid']].has_key(rawAvailability['Warehouseid']):
            availabilityItemMap[rawAvailability['Itemid']][rawAvailability['Warehouseid']] = {"netAvailability":0, "netPo":0}

        availabilityItemMap[rawAvailability['Itemid']][rawAvailability['Warehouseid']]['netAvailability'] += int(rawAvailability['Netavailability'])

    for rawPendingPo in rawPendingPoList:
        if not availabilityItemMap.has_key(rawPendingPo['Itemid']):
            availabilityItemMap[rawPendingPo['Itemid']] = {}
        if not availabilityItemMap[rawPendingPo['Itemid']].has_key(rawPendingPo['Warehouseid']):
            availabilityItemMap[rawPendingPo['Itemid']][rawPendingPo['Warehouseid']] = {"netAvailability":0, "netPo":0}
        availabilityItemMap[rawPendingPo['Itemid']][rawPendingPo['Warehouseid']]['netPo'] += int(rawPendingPo['Unfulfilled'])

    return availabilityItemMap


def populateTagItems():
    availabilityItemMap = getItemMap()
    tagRankingList = session.query(Tag_Ranking).order_by(desc(Tag_Ranking.rankPoints)).all()
    rankingList = []
    featureMap = {}
    for tagRanking in tagRankingList:
        rankingList.append(tagRanking.catalogItemId)
        featureMap[tagRanking.catalogItemId] = tagRanking.feature
    catalogMap = {}
    # stmt = session.query(PrivateDeals).filter_by(isActive=1).filter(now().between(PrivateDeals.startDate, PrivateDeals.endDate)).subquery()
    # query = session.query(Item, privateDealAlias.dealPrice).outerjoin((privateDealAlias, Item.id==privateDealAlias.item_id)).filter(Item.status != status.PHASED_OUT)
    tuples = session.query(Tag_Listing, Item).join((Item, Item.id == Tag_Listing.item_id)).filter(or_(Item.status == status.ACTIVE, Item.status == status.PAUSED_BY_RISK, Item.status == status.PARTIALLY_ACTIVE))
    projection = {'defaultImageUrl':1}
    excludeBrands = ["Live Demo", "Dummy", "FOC HANDSET"]
    for tag, item in tuples:
        if item.brand in excludeBrands:
            continue
        if not catalogMap.has_key(item.catalog_item_id):
            catalogObj = {}
            catalogObj['feature'] = ""
            catalogObj['title'] = " ".join(filter(None, [item.brand, item.model_name, item.model_number]))
            catalogObj['brand'] = (item.brand)
            if item.brand == 'Huawei' or item.brand == 'Honor':
                catalogObj['brand'] = ('Huawei', 'Honor')
            if item.brand == 'Mi' or item.brand == 'Xiaomi' or item.brand == 'Redmi':
                catalogObj['brand'] = ('Mi', 'Xiaomi', 'Redmi')
            catalogObj['identifier'] = item.catalog_item_id
            catalogObj['items'] = {}
            filterMap = {"_id":item.catalog_item_id}
            # Dont include it catalog not available
            try:
                catalogObj['imageUrl'] = get_mongo_connection(options.mongoHost).CONTENT.siteContent.find_one(filterMap, projection)['defaultImageUrl']
                print catalogObj['imageUrl']
            except:
                try:
                    catalogObj['imageUrl'] = 'https://images.smartdukaan.com/uploads/campaigns/' + str(item.catalog_item_id) + '.jpg'
                except:
                    traceback.print_exc()
            try:
                catalogObj['rank'] = rankingList.index(item.catalog_item_id)
            except:
                # A very big number
                traceback.print_exc()
                catalogObj['rank'] = 50000000
            if featureMap.has_key(item.catalog_item_id) and featureMap.get(item.catalog_item_id) is not None:
                catalogObj['feature'] = featureMap.get(item.catalog_item_id)
            # Mobile and tablets are showcased in same category
            catalogObj['categoryId'] = item.category if item.category in CATEGORY_MASTER else 6
            # Temporay change need to be removed  
            if item.category == 10006:
                catalogObj['categoryId'] = 3
            catalogObj['subCategoryId'] = item.category
            catalogObj['create_timestamp'] = to_java_date(tag.create_timestamp)
            catalogMap[item.catalog_item_id] = catalogObj
            catalogObj['avColor'] = {}

        catalogObj = catalogMap.get(item.catalog_item_id)
        if availabilityItemMap.has_key(str(item.id)):
            for warehouseId, avMap in availabilityItemMap[str(item.id)].iteritems():
                print warehouseId, avMap, item.color, item.brand, item.model_name, item.model_number, item.catalog_item_id
                if not catalogObj['avColor'].has_key(int(warehouseId)):
                    catalogObj['avColor'][int(warehouseId)] = 0

                color = catalogObj['avColor'][int(warehouseId)]
                if avMap['netAvailability'] > 0:
                    color = 2
                elif avMap['netAvailability'] + avMap['netPo']:
                    color = max(color, 1)
                else:
                    color = max(color, 0)
                catalogObj['avColor'][int(warehouseId)] = color

        if not catalogObj['items'].has_key(item.id):
            catalogObj['items'][item.id] = {'color': item.color.replace("f_", ""), 'tagPricing':[]}
            itemMap = catalogObj['items'].get(item.id)
            itemMap['tagPricing'].append(tag)

    catalogObjs = []
    for catalogId, catalogMap in catalogMap.iteritems():
        print "catalogMap", catalogMap
        active = False
        itemsMap = catalogMap['items']
        itemObjs = []
        mop = 0
        for itemId, itemMap in itemsMap.iteritems():
            tags = itemMap.pop('tagPricing')

            for tag in tags:
                active = active or tag.active
                itemObj = {'id':('itemtag-%s-%s' % (itemId, tag.tag_id)), 'color_s':itemMap['color'], 'itemId_i': itemId, 'tagId_i':tag.tag_id,
                           'mrp_f':tag.mrp, 'mop_f': tag.mop, 'sellingPrice_f': tag.selling_price, 'active_b' : tag.active, 'hot_deal_b': tag.hot_deals}
                mop = tag.mop
            itemObjs.append(itemObj)
        catalogObj = {'id':'catalog' + str(catalogId), 'rank_i':catalogMap['rank'], 'title_s': catalogMap['title'],
                      '_childDocuments_':itemObjs,
                      'child_b' : len(itemObjs) > 0,
                      'catalogId_i':catalogId,
                      'imageUrl_s': catalogMap['imageUrl'].replace("saholic", "smartdukaan"),
                      'feature_s':catalogMap['feature'],
                      'brand_ss': catalogMap['brand'], 'create_s':catalogMap['create_timestamp'],
                      'categoryId_i':catalogMap['categoryId'],
                      'subCategoryId_i':catalogMap['subCategoryId'],
                      'w7573_i':0,
                      'w7678_i':0,
                      'w7720_i':0,
                      'w8468_i':0,
                      'w8889_i':0,
                      'w8947_i':0,
                      'w9213_i':0,
                      'w9203_i':0,
                      'show_default_b': "FOC" in catalogMap['brand'],
                      'mop_f': mop
                      }
        for whId, color in catalogMap['avColor'].iteritems():
            print catalogId, whId, color, catalogMap['title']
            catalogObj['w%d_i'%(whId)] = color
        catalogObj['active_b'] = active
        catalogObjs.append(catalogObj)
    solr.delete(q='*:*')
    solr.add(catalogObjs)
    #print catalogObjs
    #for catalogObj in catalogObjs:
#    solr.add(catalogObj)


def pushData():
    populateTagItems()


if __name__ == '__main__':
    pushData()