Subversion Repositories SmartDukaan

Rev

Rev 19463 | Rev 19470 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
18272 kshitij.so 1 
from bson import json_util
15081 amit.gupta 2 
from bson.json_util import dumps
15096 amit.gupta 3 
from datetime import datetime, timedelta
15534 amit.gupta 4 
from pyshorteners.shorteners  import Shortener
13582 amit.gupta 5 
from dtr import main
15081 amit.gupta 6 
from dtr.config import PythonPropertyReader
13629 kshitij.so 7 
from dtr.storage import Mongo
15132 amit.gupta 8 
from dtr.storage.DataService import Retailers, Users, CallHistory, RetryConfig, \
15254 amit.gupta 9 
    RetailerLinks, Activation_Codes, Agents, Agent_Roles, AgentLoginTimings, \
15676 amit.gupta 10 
    FetchDataHistory, RetailerContacts, Orders, OnboardedRetailerChecklists,\
17467 manas 11 
    RetailerAddresses, Pincodeavailability, app_offers, appmasters, user_app_cashbacks, user_app_installs,\
18350 manas 12 
    Postoffices, UserCrmCallingData, CallHistoryCrm, ProductPricingInputs
15358 amit.gupta 13 
from dtr.storage.Mongo import get_mongo_connection
14 
from dtr.storage.Mysql import fetchResult
15081 amit.gupta 15 
from dtr.utils import FetchLivePrices, DealSheet as X_DealSheet, \
18629 manas 16 
    UserSpecificDeals, utils
18256 manas 17 
from dtr.utils.utils import getLogger,encryptMessage,decryptMessage,\
18 
    get_mongo_connection_dtr_data, to_java_date
15081 amit.gupta 19 
from elixir import *
15254 amit.gupta 20 
from operator import and_
16714 manish.sha 21 
from sqlalchemy.sql.expression import func, func, or_, desc, asc, case
15132 amit.gupta 22 
from urllib import urlencode
23 
import contextlib
13827 kshitij.so 24 
import falcon
15081 amit.gupta 25 
import json
15358 amit.gupta 26 
import re
15254 amit.gupta 27 
import string
15081 amit.gupta 28 
import traceback
15132 amit.gupta 29 
import urllib
30 
import urllib2
31 
import uuid
15465 amit.gupta 32 
import gdshortener
16727 manish.sha 33 
from dtr.dao import AppOfferObj, UserAppBatchDrillDown, UserAppBatchDateDrillDown
18097 manas 34 
import base64
18272 kshitij.so 35 
from falcon.util.uri import decode
18266 manas 36 
import MySQLdb
18792 manas 37 
from shop2020.clients.CatalogClient import CatalogClient
18896 amit.gupta 38 
from pyquery import PyQuery as pq
19463 manas 39 
import time
18896 amit.gupta 40 
 
15207 amit.gupta 41 
alphalist = list(string.uppercase)
42 
alphalist.remove('O')
43 
numList = ['1','2','3','4','5','6','7','8','9']
44 
codesys = [alphalist, alphalist, numList, numList, numList]
15312 amit.gupta 45 
CONTACT_PRIORITY = ['sms', 'called', 'ringing']
15368 amit.gupta 46 
RETRY_MAP = {'fresh':'retry', 'followup':'fretry', 'onboarding':'oretry'}
15358 amit.gupta 47 
ASSIGN_MAP = {'retry':'assigned', 'fretry':'fassigned', 'oretry':'oassigned'}
15207 amit.gupta 48 
 
16882 amit.gupta 49 
sticky_agents = [17]
50 
 
15207 amit.gupta 51 
def getNextCode(codesys, code=None):
52 
    if code is None:
53 
        code = []
54 
        for charcode in codesys:
55 
            code.append(charcode[0])
56 
        return string.join(code, '')
57 
    carry = True
58 
    code = list(code)
59 
    lastindex = len(codesys) - 1
60 
    while carry:
61 
        listChar = codesys[lastindex]
62 
        newIndex = (listChar.index(code[lastindex])+1)%len(listChar)
63 
        print newIndex
64 
        code[lastindex] = listChar[newIndex]
65 
        if newIndex != 0:
66 
            carry = False
67 
        lastindex -= 1
68 
        if lastindex ==-1:
69 
            raise BaseException("All codes are exhausted")
70 
 
71 
    return string.join(code, '')
72 
 
18397 manas 73 
 
15081 amit.gupta 74 
global RETAILER_DETAIL_CALL_COUNTER
75 
RETAILER_DETAIL_CALL_COUNTER = 0
18329 manas 76 
global USER_DETAIL_MAP
18332 manas 77 
USER_DETAIL_MAP={}
18329 manas 78 
USER_DETAIL_MAP['accs_cart']=0
79 
USER_DETAIL_MAP['accs_active']=0
80 
USER_DETAIL_MAP['accs_order']=0
19442 manas 81 
USER_DETAIL_MAP['accs_cashback_scheme']=0
15168 amit.gupta 82 
lgr = getLogger('/var/log/retailer-acquisition-api.log')
15081 amit.gupta 83 
DEALER_RETRY_FACTOR = int(PythonPropertyReader.getConfig('DEALER_RETRY_FACTOR'))
16886 amit.gupta 84 
DEALER_FRESH_FACTOR = int(PythonPropertyReader.getConfig('DEALER_FRESH_FACTOR'))
18329 manas 85 
USER_CRM_DEFAULT_RETRY_FACTOR = int(PythonPropertyReader.getConfig('USER_CRM_DEFAULT_RETRY_FACTOR'))
86 
USER_CRM_DEFAULT_FRESH_FACTOR = int(PythonPropertyReader.getConfig('USER_CRM_DEFAULT_FRESH_FACTOR'))
87 
TOTAL = DEALER_RETRY_FACTOR + DEALER_FRESH_FACTOR
88 
TOTAL_USER = USER_CRM_DEFAULT_FRESH_FACTOR + USER_CRM_DEFAULT_RETRY_FACTOR
13572 kshitij.so 89 
class CategoryDiscountInfo(object):
90 
 
91 
    def on_get(self, req, resp):
92 
 
13629 kshitij.so 93 
        result = Mongo.getAllCategoryDiscount()
94 
        json_docs = [json.dumps(doc, default=json_util.default) for doc in result]
95 
        resp.body = json.dumps(json_docs, encoding='utf-8')
13572 kshitij.so 96 
 
97 
    def on_post(self, req, resp):
98 
        try:
99 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
100 
        except ValueError:
101 
            raise falcon.HTTPError(falcon.HTTP_400,
102 
                'Malformed JSON',
103 
                'Could not decode the request body. The '
104 
                'JSON was incorrect.')
105 
 
106 
        result = Mongo.addCategoryDiscount(result_json)
107 
        resp.body = json.dumps(result, encoding='utf-8')
13969 kshitij.so 108 
 
109 
    def on_put(self, req, resp, _id):
13970 kshitij.so 110 
        try:
111 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
112 
        except ValueError:
113 
            raise falcon.HTTPError(falcon.HTTP_400,
114 
                'Malformed JSON',
115 
                'Could not decode the request body. The '
116 
                'JSON was incorrect.')
117 
 
118 
        result = Mongo.updateCategoryDiscount(result_json, _id)
119 
        resp.body = json.dumps(result, encoding='utf-8')
120 
 
13966 kshitij.so 121 
 
13969 kshitij.so 122 
 
13572 kshitij.so 123 
class SkuSchemeDetails(object):
124 
 
125 
    def on_get(self, req, resp):
13629 kshitij.so 126 
 
14070 kshitij.so 127 
        offset = req.get_param_as_int("offset")
128 
        limit = req.get_param_as_int("limit")
129 
 
130 
        result = Mongo.getAllSkuWiseSchemeDetails(offset, limit)
13629 kshitij.so 131 
        json_docs = [json.dumps(doc, default=json_util.default) for doc in result]
132 
        resp.body = json.dumps(json_docs, encoding='utf-8')
13572 kshitij.so 133 
 
134 
 
135 
    def on_post(self, req, resp):
136 
 
14552 kshitij.so 137 
        multi = req.get_param_as_int("multi")
138 
 
13572 kshitij.so 139 
        try:
140 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
141 
        except ValueError:
142 
            raise falcon.HTTPError(falcon.HTTP_400,
143 
                'Malformed JSON',
144 
                'Could not decode the request body. The '
145 
                'JSON was incorrect.')
146 
 
15852 kshitij.so 147 
        result = Mongo.addSchemeDetailsForSku(result_json)
13572 kshitij.so 148 
        resp.body = json.dumps(result, encoding='utf-8')
149 
 
150 
class SkuDiscountInfo():
151 
 
152 
    def on_get(self, req, resp):
13629 kshitij.so 153 
 
13970 kshitij.so 154 
        offset = req.get_param_as_int("offset")
155 
        limit = req.get_param_as_int("limit")
156 
        result = Mongo.getallSkuDiscountInfo(offset,limit)
13629 kshitij.so 157 
        json_docs = [json.dumps(doc, default=json_util.default) for doc in result]
158 
        resp.body = json.dumps(json_docs, encoding='utf-8')
13572 kshitij.so 159 
 
160 
 
161 
    def on_post(self, req, resp):
162 
 
14552 kshitij.so 163 
        multi = req.get_param_as_int("multi")
164 
 
13572 kshitij.so 165 
        try:
166 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
167 
        except ValueError:
168 
            raise falcon.HTTPError(falcon.HTTP_400,
169 
                'Malformed JSON',
170 
                'Could not decode the request body. The '
171 
                'JSON was incorrect.')
172 
 
15852 kshitij.so 173 
        result = Mongo.addSkuDiscountInfo(result_json)
13572 kshitij.so 174 
        resp.body = json.dumps(result, encoding='utf-8')
13970 kshitij.so 175 
 
176 
    def on_put(self, req, resp, _id):
177 
        try:
178 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
179 
        except ValueError:
180 
            raise falcon.HTTPError(falcon.HTTP_400,
181 
                'Malformed JSON',
182 
                'Could not decode the request body. The '
183 
                'JSON was incorrect.')
184 
 
185 
        result = Mongo.updateSkuDiscount(result_json, _id)
186 
        resp.body = json.dumps(result, encoding='utf-8')
13572 kshitij.so 187 
 
188 
class ExceptionalNlc():
189 
 
190 
    def on_get(self, req, resp):
13629 kshitij.so 191 
 
13970 kshitij.so 192 
        offset = req.get_param_as_int("offset")
193 
        limit = req.get_param_as_int("limit")
194 
 
195 
        result = Mongo.getAllExceptionlNlcItems(offset, limit)
13629 kshitij.so 196 
        json_docs = [json.dumps(doc, default=json_util.default) for doc in result]
197 
        resp.body = json.dumps(json_docs, encoding='utf-8')
13572 kshitij.so 198 
 
199 
    def on_post(self, req, resp):
200 
 
14552 kshitij.so 201 
        multi = req.get_param_as_int("multi")
202 
 
13572 kshitij.so 203 
        try:
204 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
205 
        except ValueError:
206 
            raise falcon.HTTPError(falcon.HTTP_400,
207 
                'Malformed JSON',
208 
                'Could not decode the request body. The '
209 
                'JSON was incorrect.')
210 
 
15852 kshitij.so 211 
        result = Mongo.addExceptionalNlc(result_json)
13572 kshitij.so 212 
        resp.body = json.dumps(result, encoding='utf-8')
13970 kshitij.so 213 
 
214 
    def on_put(self, req, resp, _id):
215 
        try:
216 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
217 
        except ValueError:
218 
            raise falcon.HTTPError(falcon.HTTP_400,
219 
                'Malformed JSON',
220 
                'Could not decode the request body. The '
221 
                'JSON was incorrect.')
222 
 
223 
        result = Mongo.updateExceptionalNlc(result_json, _id)
224 
        resp.body = json.dumps(result, encoding='utf-8')
13572 kshitij.so 225 
 
13772 kshitij.so 226 
class Deals():
13779 kshitij.so 227 
    def on_get(self,req, resp, userId):
228 
        categoryId = req.get_param_as_int("categoryId")
229 
        offset = req.get_param_as_int("offset")
230 
        limit = req.get_param_as_int("limit")
13798 kshitij.so 231 
        sort = req.get_param("sort")
13802 kshitij.so 232 
        direction = req.get_param_as_int("direction")
14853 kshitij.so 233 
        filterData = req.get_param('filterData')
19469 manas 234 
        if categoryId!=6:
235 
            result = Mongo.getNewDeals(int(userId), categoryId, offset, limit, sort, direction, filterData)
236 
        else:
237 
            result = Mongo.getAccesoryDeals(int(userId), categoryId, offset, limit, sort, direction, filterData)
16078 kshitij.so 238 
        resp.body = dumps(result)
19440 kshitij.so 239 
 
13790 kshitij.so 240 
class MasterData():
241 
    def on_get(self,req, resp, skuId):
16223 kshitij.so 242 
        showDp = req.get_param_as_int("showDp")
16221 kshitij.so 243 
        result = Mongo.getItem(skuId, showDp)
13798 kshitij.so 244 
        try:
245 
            json_docs = [json.dumps(doc, default=json_util.default) for doc in result]
13966 kshitij.so 246 
            resp.body = json.dumps(json_docs, encoding='utf-8')
13798 kshitij.so 247 
        except:
248 
            json_docs = [json.dumps(doc, default=json_util.default) for doc in result]
13966 kshitij.so 249 
            resp.body = json.dumps(json_docs, encoding='utf-8')
13790 kshitij.so 250 
 
14586 kshitij.so 251 
    def on_post(self,req, resp):
252 
 
253 
        addNew = req.get_param_as_int("addNew")
254 
        update = req.get_param_as_int("update")
255 
        addToExisting = req.get_param_as_int("addToExisting")
256 
        multi = req.get_param_as_int("multi")
257 
 
14589 kshitij.so 258 
        try:
14592 kshitij.so 259 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
260 
        except ValueError:
261 
            raise falcon.HTTPError(falcon.HTTP_400,
262 
                'Malformed JSON',
263 
                'Could not decode the request body. The '
264 
                'JSON was incorrect.')
265 
 
266 
        if addNew == 1:
267 
            result = Mongo.addNewItem(result_json)
268 
        elif update == 1:
269 
            result = Mongo.updateMaster(result_json, multi)
270 
        elif addToExisting == 1:
271 
            result = Mongo.addItemToExistingBundle(result_json)
272 
        else:
273 
            raise
274 
        resp.body = dumps(result)
14586 kshitij.so 275 
 
13827 kshitij.so 276 
class LiveData():
277 
    def on_get(self,req, resp):
13865 kshitij.so 278 
        if req.get_param_as_int("id") is not None:
279 
            print "****getting only for id"
280 
            id = req.get_param_as_int("id")
281 
            try:
282 
                result = FetchLivePrices.getLatestPriceById(id)
13867 kshitij.so 283 
                json_docs = json.dumps(result, default=json_util.default)
13966 kshitij.so 284 
                resp.body = json.dumps(json_docs, encoding='utf-8')
13865 kshitij.so 285 
            except:
286 
                json_docs = json.dumps({}, default=json_util.default)
13966 kshitij.so 287 
                resp.body = json.dumps(json_docs, encoding='utf-8')
13834 kshitij.so 288 
 
13865 kshitij.so 289 
        else:
290 
            print "****getting only for skuId"
291 
            skuBundleId = req.get_param_as_int("skuBundleId")
292 
            source_id = req.get_param_as_int("source_id")
293 
            try:
294 
                result = FetchLivePrices.getLatestPrice(skuBundleId, source_id)
295 
                json_docs = [json.dumps(doc, default=json_util.default) for doc in result]
13966 kshitij.so 296 
                resp.body = json.dumps(json_docs, encoding='utf-8')
13865 kshitij.so 297 
            except:
298 
                json_docs = [json.dumps(doc, default=json_util.default) for doc in [{}]]
13966 kshitij.so 299 
                resp.body = json.dumps(json_docs, encoding='utf-8')
13865 kshitij.so 300 
 
13834 kshitij.so 301 
class CashBack():
302 
    def on_get(self,req, resp):
303 
        identifier = req.get_param("identifier")
304 
        source_id = req.get_param_as_int("source_id")
305 
        try:
13838 kshitij.so 306 
            result = Mongo.getCashBackDetails(identifier, source_id)
13837 kshitij.so 307 
            json_docs = json.dumps(result, default=json_util.default)
13964 kshitij.so 308 
            resp.body = json_docs
13834 kshitij.so 309 
        except:
13837 kshitij.so 310 
            json_docs = json.dumps({}, default=json_util.default)
13963 kshitij.so 311 
            resp.body = json_docs
13892 kshitij.so 312 
 
14398 amit.gupta 313 
class ImgSrc():
314 
    def on_get(self,req, resp):
315 
        identifier = req.get_param("identifier")
316 
        source_id = req.get_param_as_int("source_id")
317 
        try:
318 
            result = Mongo.getImgSrc(identifier, source_id)
319 
            json_docs = json.dumps(result, default=json_util.default)
320 
            resp.body = json_docs
321 
        except:
322 
            json_docs = json.dumps({}, default=json_util.default)
323 
            resp.body = json_docs
324 
 
13892 kshitij.so 325 
class DealSheet():
326 
    def on_get(self,req, resp):
13895 kshitij.so 327 
        X_DealSheet.sendMail()
13897 kshitij.so 328 
        json_docs = json.dumps({'True':'Sheet generated, mail sent.'}, default=json_util.default)
13966 kshitij.so 329 
        resp.body = json.dumps(json_docs, encoding='utf-8')
13892 kshitij.so 330 
 
13970 kshitij.so 331 
class DealerPrice():
332 
 
333 
    def on_get(self, req, resp):
334 
 
335 
        offset = req.get_param_as_int("offset")
336 
        limit = req.get_param_as_int("limit")
337 
        result = Mongo.getAllDealerPrices(offset,limit)
338 
        json_docs = [json.dumps(doc, default=json_util.default) for doc in result]
339 
        resp.body = json.dumps(json_docs, encoding='utf-8')
340 
 
341 
    def on_post(self, req, resp):
342 
 
14552 kshitij.so 343 
        multi = req.get_param_as_int("multi")
344 
 
13970 kshitij.so 345 
        try:
346 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
347 
        except ValueError:
348 
            raise falcon.HTTPError(falcon.HTTP_400,
349 
                'Malformed JSON',
350 
                'Could not decode the request body. The '
351 
                'JSON was incorrect.')
352 
 
15852 kshitij.so 353 
        result = Mongo.addSkuDealerPrice(result_json)
13970 kshitij.so 354 
        resp.body = json.dumps(result, encoding='utf-8')
355 
 
356 
    def on_put(self, req, resp, _id):
357 
        try:
358 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
359 
        except ValueError:
360 
            raise falcon.HTTPError(falcon.HTTP_400,
361 
                'Malformed JSON',
362 
                'Could not decode the request body. The '
363 
                'JSON was incorrect.')
364 
 
365 
        result = Mongo.updateSkuDealerPrice(result_json, _id)
366 
        resp.body = json.dumps(result, encoding='utf-8')
367 
 
368 
 
14041 kshitij.so 369 
class ResetCache():
370 
 
371 
    def on_get(self,req, resp, userId):
14044 kshitij.so 372 
        result = Mongo.resetCache(userId)
14046 kshitij.so 373 
        resp.body = json.dumps(result, encoding='utf-8')
374 
 
375 
class UserDeals():
376 
    def on_get(self,req,resp,userId):
377 
        UserSpecificDeals.generateSheet(userId)
378 
        json_docs = json.dumps({'True':'Sheet generated, mail sent.'}, default=json_util.default)
379 
        resp.body = json.dumps(json_docs, encoding='utf-8')
14075 kshitij.so 380 
 
381 
class CommonUpdate():
382 
 
383 
    def on_post(self,req,resp):
14575 kshitij.so 384 
 
385 
        multi = req.get_param_as_int("multi")
386 
 
14075 kshitij.so 387 
        try:
388 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
389 
        except ValueError:
390 
            raise falcon.HTTPError(falcon.HTTP_400,
391 
                'Malformed JSON',
392 
                'Could not decode the request body. The '
393 
                'JSON was incorrect.')
394 
 
15852 kshitij.so 395 
        result = Mongo.updateCollection(result_json)
14075 kshitij.so 396 
        resp.body = json.dumps(result, encoding='utf-8')
14106 kshitij.so 397 
        resp.content_type = "application/json; charset=utf-8"
14481 kshitij.so 398 
 
399 
class NegativeDeals():
400 
 
401 
    def on_get(self, req, resp):
402 
 
403 
        offset = req.get_param_as_int("offset")
404 
        limit = req.get_param_as_int("limit")
405 
 
406 
        result = Mongo.getAllNegativeDeals(offset, limit)
14483 kshitij.so 407 
        resp.body = dumps(result)
14481 kshitij.so 408 
 
409 
 
410 
    def on_post(self, req, resp):
411 
 
14552 kshitij.so 412 
        multi = req.get_param_as_int("multi")
413 
 
14481 kshitij.so 414 
        try:
415 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
416 
        except ValueError:
417 
            raise falcon.HTTPError(falcon.HTTP_400,
418 
                'Malformed JSON',
419 
                'Could not decode the request body. The '
420 
                'JSON was incorrect.')
421 
 
14552 kshitij.so 422 
        result = Mongo.addNegativeDeals(result_json, multi)
14481 kshitij.so 423 
        resp.body = json.dumps(result, encoding='utf-8')
424 
 
425 
class ManualDeals():
426 
 
427 
    def on_get(self, req, resp):
428 
 
429 
        offset = req.get_param_as_int("offset")
430 
        limit = req.get_param_as_int("limit")
431 
 
432 
        result = Mongo.getAllManualDeals(offset, limit)
14483 kshitij.so 433 
        resp.body = dumps(result)
14481 kshitij.so 434 
 
435 
 
436 
    def on_post(self, req, resp):
437 
 
14552 kshitij.so 438 
        multi = req.get_param_as_int("multi")
439 
 
14481 kshitij.so 440 
        try:
441 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
442 
        except ValueError:
443 
            raise falcon.HTTPError(falcon.HTTP_400,
444 
                'Malformed JSON',
445 
                'Could not decode the request body. The '
446 
                'JSON was incorrect.')
447 
 
14552 kshitij.so 448 
        result = Mongo.addManualDeal(result_json, multi)
14481 kshitij.so 449 
        resp.body = json.dumps(result, encoding='utf-8')
450 
 
451 
class CommonDelete():
14482 kshitij.so 452 
 
14481 kshitij.so 453 
    def on_post(self,req,resp):
454 
        try:
455 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
456 
        except ValueError:
457 
            raise falcon.HTTPError(falcon.HTTP_400,
458 
                'Malformed JSON',
459 
                'Could not decode the request body. The '
460 
                'JSON was incorrect.')
461 
 
462 
        result = Mongo.deleteDocument(result_json)
463 
        resp.body = json.dumps(result, encoding='utf-8')
464 
        resp.content_type = "application/json; charset=utf-8"
14482 kshitij.so 465 
 
466 
class SearchProduct():
467 
 
468 
    def on_get(self,req,resp):
469 
        offset = req.get_param_as_int("offset")
470 
        limit = req.get_param_as_int("limit")
471 
        search_term = req.get_param("search")
472 
 
473 
        result = Mongo.searchMaster(offset, limit, search_term)
14483 kshitij.so 474 
        resp.body = dumps(result)
14482 kshitij.so 475 
 
476 
 
14495 kshitij.so 477 
class FeaturedDeals():
14482 kshitij.so 478 
 
14495 kshitij.so 479 
    def on_get(self, req, resp):
480 
 
481 
        offset = req.get_param_as_int("offset")
482 
        limit = req.get_param_as_int("limit")
483 
 
484 
        result = Mongo.getAllFeaturedDeals(offset, limit)
485 
        resp.body = dumps(result)
486 
 
487 
 
488 
    def on_post(self, req, resp):
489 
 
14552 kshitij.so 490 
        multi = req.get_param_as_int("multi")
491 
 
14495 kshitij.so 492 
        try:
493 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
494 
        except ValueError:
495 
            raise falcon.HTTPError(falcon.HTTP_400,
496 
                'Malformed JSON',
497 
                'Could not decode the request body. The '
498 
                'JSON was incorrect.')
499 
 
14552 kshitij.so 500 
        result = Mongo.addFeaturedDeal(result_json, multi)
14495 kshitij.so 501 
        resp.body = json.dumps(result, encoding='utf-8')
502 
 
14497 kshitij.so 503 
 
504 
class CommonSearch():
14495 kshitij.so 505 
 
14497 kshitij.so 506 
    def on_get(self,req,resp):
507 
        class_name = req.get_param("class")
508 
        sku = req.get_param_as_int("sku")
509 
        skuBundleId = req.get_param_as_int("skuBundleId")
14499 kshitij.so 510 
 
511 
        result = Mongo.searchCollection(class_name, sku, skuBundleId)
14497 kshitij.so 512 
        resp.body = dumps(result)
14619 kshitij.so 513 
 
514 
class CricScore():
515 
 
516 
    def on_get(self,req,resp):
517 
 
518 
        result = Mongo.getLiveCricScore()
14853 kshitij.so 519 
        resp.body = dumps(result)
520 
 
521 
class Notification():
522 
 
523 
    def on_post(self, req, resp):
524 
 
525 
        try:
526 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
527 
        except ValueError:
528 
            raise falcon.HTTPError(falcon.HTTP_400,
529 
                'Malformed JSON',
530 
                'Could not decode the request body. The '
531 
                'JSON was incorrect.')
532 
 
533 
        result = Mongo.addBundleToNotification(result_json)
534 
        resp.body = json.dumps(result, encoding='utf-8')
535 
 
536 
    def on_get(self, req, resp):
537 
 
538 
        offset = req.get_param_as_int("offset")
539 
        limit = req.get_param_as_int("limit")
540 
 
541 
        result = Mongo.getAllNotifications(offset, limit)
542 
        resp.body = dumps(result)
543 
 
14998 kshitij.so 544 
class DealBrands():
14853 kshitij.so 545 
 
14998 kshitij.so 546 
    def on_get(self, req, resp):
547 
 
548 
        category_id = req.get_param_as_int("category_id")
549 
        result = Mongo.getBrandsForFilter(category_id)
14999 kshitij.so 550 
        resp.body = dumps(result)
15161 kshitij.so 551 
 
552 
class DealRank():
14998 kshitij.so 553 
 
15161 kshitij.so 554 
    def on_get(self, req, resp):
555 
        identifier = req.get_param("identifier")
556 
        source_id = req.get_param_as_int("source_id")
557 
        user_id = req.get_param_as_int("user_id")
558 
        result = Mongo.getDealRank(identifier, source_id, user_id)
559 
        json_docs = json.dumps(result, default=json_util.default)
560 
        resp.body = json_docs
561 
 
562 
 
16560 amit.gupta 563 
class OrderedOffers():
564 
    def on_get(self, req, resp, storeId, storeSku):
565 
        storeId = int(storeId)
16563 amit.gupta 566 
        result = Mongo.getBundleBySourceSku(storeId, storeSku)
567 
        json_docs = json.dumps(result, default=json_util.default)
568 
        resp.body = json_docs
569 
 
15081 amit.gupta 570 
class RetailerDetail():
571 
    global RETAILER_DETAIL_CALL_COUNTER
15105 amit.gupta 572 
    def getRetryRetailer(self,failback=True):
15358 amit.gupta 573 
        status = RETRY_MAP.get(self.callType)
17089 amit.gupta 574 
        retailer = session.query(Retailers).filter_by(status=status).filter(Retailers.next_call_time<=datetime.now()).filter(or_(Retailers.agent_id==self.agentId, Retailers.agent_id==None)).order_by(Retailers.agent_id.desc(),Retailers.call_priority).order_by(Retailers.next_call_time).with_lockmode("update").first()
17029 amit.gupta 575 
 
15239 amit.gupta 576 
        if retailer is not None:
577 
            lgr.info( "getRetryRetailer " + str(retailer.id))
578 
        else:
579 
            if failback:
580 
                retailer = self.getNewRetailer(False)
581 
                return retailer
16371 amit.gupta 582 
            else:
583 
                #No further calls for now
584 
                return None
15358 amit.gupta 585 
        retailer.status = ASSIGN_MAP.get(status)
16371 amit.gupta 586 
        retailer.next_call_time = None
15239 amit.gupta 587 
        lgr.info( "getRetryRetailer " + str(retailer.id))
15081 amit.gupta 588 
        return retailer
589 
 
15662 amit.gupta 590 
    def getNotActiveRetailer(self):
591 
        try:
15716 amit.gupta 592 
            user = session.query(Users).filter_by(activated=0).filter_by(status=1).filter(Users.mobile_number != None).filter(~Users.mobile_number.like("0%")).filter(Users.created>datetime(2015,06,29)).order_by(Users.created.desc()).with_lockmode("update").first()
15662 amit.gupta 593 
            if user is None:
594 
                return None
595 
            else:
596 
                retailerContact = session.query(RetailerContacts).filter_by(mobile_number=user.mobile_number).first()
597 
                if retailerContact is not None:
598 
                    retailer = session.query(Retailers).filter_by(id=retailerContact.retailer_id).first()
599 
                else:
600 
                    retailer = session.query(Retailers).filter_by(contact1=user.mobile_number).first()
601 
                    if retailer is None:
602 
                        retailer = session.query(Retailers).filter_by(contact2=user.mobile_number).first()
603 
                        if retailer is None:
604 
                            retailer = Retailers()
605 
                            retailer.contact1 = user.mobile_number
606 
                            retailer.status = 'assigned'
15672 amit.gupta 607 
                            retailer.retry_count = 0
15673 amit.gupta 608 
                            retailer.invalid_retry_count = 0
15699 amit.gupta 609 
                            retailer.is_elavated=1
15662 amit.gupta 610 
                user.status = 2
611 
                session.commit()
612 
                print "retailer id", retailer.id
613 
                retailer.contact = user.mobile_number
614 
                return retailer
615 
        finally:
616 
            session.close()
617 
 
15081 amit.gupta 618 
    def getNewRetailer(self,failback=True):
15663 amit.gupta 619 
        if self.callType == 'fresh':
620 
            retailer = self.getNotActiveRetailer()
621 
            if retailer is not None:
622 
                return retailer
15081 amit.gupta 623 
        retry = True
624 
        retailer = None
625 
        try:
626 
            while(retry):
15168 amit.gupta 627 
                lgr.info( "Calltype " + self.callType)
15081 amit.gupta 628 
                status=self.callType
15545 amit.gupta 629 
                query = session.query(Retailers).filter(Retailers.status==status).filter(or_(Retailers.agent_id==self.agentId, Retailers.agent_id==None))
15081 amit.gupta 630 
                if status=='fresh':
17030 amit.gupta 631 
                    query = query.filter_by(is_or=False, is_std=False).filter(Retailers.pin==Pincodeavailability.code).filter(Pincodeavailability.amount > 19999).order_by(Retailers.is_elavated.desc(), Retailers.agent_id.desc())
15358 amit.gupta 632 
                elif status=='followup':
15546 amit.gupta 633 
                    query = query.filter(Retailers.next_call_time<=datetime.now()).order_by(Retailers.agent_id.desc(),Retailers.next_call_time)
15162 amit.gupta 634 
                else:
15546 amit.gupta 635 
                    query = query.filter(Retailers.modified<=datetime.now()).order_by(Retailers.agent_id.desc(), Retailers.modified)
15358 amit.gupta 636 
 
15081 amit.gupta 637 
                retailer = query.with_lockmode("update").first()
638 
                if retailer is not None:
15168 amit.gupta 639 
                    lgr.info( "retailer " +str(retailer.id))
15081 amit.gupta 640 
                    if status=="fresh":
641 
                        userquery = session.query(Users)
642 
                        if retailer.contact2 is not None:
643 
                            userquery = userquery.filter(Users.mobile_number.in_([retailer.contact1,retailer.contact2]))
644 
                        else:
645 
                            userquery = userquery.filter_by(mobile_number=retailer.contact1)
646 
                        user = userquery.first()
647 
                        if user is not None:
648 
                            retailer.status = 'alreadyuser'
15168 amit.gupta 649 
                            lgr.info( "retailer.status " + retailer.status)
15081 amit.gupta 650 
                            session.commit()
651 
                            continue
652 
                        retailer.status = 'assigned'
15358 amit.gupta 653 
                    elif status=='followup':
15276 amit.gupta 654 
                        if isActivated(retailer.id):
655 
                            print "Retailer Already %d activated and marked onboarded"%(retailer.id)
656 
                            continue
15081 amit.gupta 657 
                        retailer.status = 'fassigned'
15358 amit.gupta 658 
                    else:
659 
                        retailer.status = 'oassigned'
15081 amit.gupta 660 
                    retailer.retry_count = 0
15123 amit.gupta 661 
                    retailer.invalid_retry_count = 0
15168 amit.gupta 662 
                    lgr.info( "Found Retailer " +  str(retailer.id) + " with status " + status + " assigned to " + str(self.agentId))
15081 amit.gupta 663 
 
664 
                else:
15168 amit.gupta 665 
                    lgr.info( "No fresh/followup retailers found")
15081 amit.gupta 666 
                    if failback:
667 
                        retailer = self.getRetryRetailer(False)
15104 amit.gupta 668 
                        return retailer
15148 amit.gupta 669 
                retry=False
15081 amit.gupta 670 
        except:
671 
            print traceback.print_exc()
672 
        return retailer
673 
 
15132 amit.gupta 674 
    def on_get(self, req, resp, agentId, callType=None, retailerId=None):
16927 amit.gupta 675 
        try:
676 
            global RETAILER_DETAIL_CALL_COUNTER
677 
            RETAILER_DETAIL_CALL_COUNTER += 1
678 
            lgr.info( "RETAILER_DETAIL_CALL_COUNTER " +  str(RETAILER_DETAIL_CALL_COUNTER))
679 
            self.agentId = int(agentId)
680 
            self.callType = callType
681 
            if retailerId is not None:
682 
                self.retailerId = int(retailerId)
683 
                retailerLink = session.query(RetailerLinks).filter_by(retailer_id=self.retailerId).first()
684 
                if retailerLink is not None:
685 
                    code = retailerLink.code
686 
                else:
687 
                    code = self.getCode()
688 
                    retailerLink = RetailerLinks()
689 
                    retailerLink.code = code
690 
                    retailerLink.agent_id = self.agentId
691 
                    retailerLink.retailer_id = self.retailerId
692 
 
693 
                    activationCode=Activation_Codes()
694 
                    activationCode.code = code
695 
                    session.commit()
696 
                session.close()
697 
                resp.body =  json.dumps({"result":{"code":code,"link":make_tiny(code)}}, encoding='utf-8')
698 
                return
699 
            retryFlag = False
700 
            if RETAILER_DETAIL_CALL_COUNTER % TOTAL >= DEALER_FRESH_FACTOR:
701 
                retryFlag=True
702 
            try:
703 
                if retryFlag:
704 
                    retailer = self.getRetryRetailer()
705 
                else:
706 
                    retailer = self.getNewRetailer()
707 
                if retailer is None:
708 
                    resp.body = "{}"
709 
                    return
710 
                fetchInfo = FetchDataHistory()
711 
                fetchInfo.agent_id = self.agentId
712 
                fetchInfo.call_type = self.callType
713 
                agent = session.query(Agents).filter_by(id=self.agentId).first()
714 
                last_disposition = session.query(CallHistory).filter_by(agent_id=self.agentId).order_by(CallHistory.id.desc()).first()
715 
                if last_disposition is None or last_disposition.created < agent.last_login:
716 
                    fetchInfo.last_action = 'login'
717 
                    fetchInfo.last_action_time = agent.last_login
718 
                else:
719 
                    fetchInfo.last_action = 'disposition'
720 
                    fetchInfo.last_action_time = last_disposition.created
721 
                fetchInfo.retailer_id = retailer.id
722 
                session.commit()
15135 amit.gupta 723 
 
16927 amit.gupta 724 
                otherContacts = [r for r, in session.query(RetailerContacts.mobile_number).filter_by(retailer_id=retailer.id).order_by(RetailerContacts.contact_type).all()]
725 
                resp.body = json.dumps(todict(getRetailerObj(retailer, otherContacts, self.callType)), encoding='utf-8')
726 
 
727 
                return
728 
 
729 
            finally:
730 
                session.close()
731 
 
15343 amit.gupta 732 
            if retailer is None:
733 
                resp.body = "{}"
15239 amit.gupta 734 
            else:
16927 amit.gupta 735 
                print "It should never come here"
736 
                resp.body = json.dumps(todict(getRetailerObj(retailer)), encoding='utf-8')
15239 amit.gupta 737 
        finally:
738 
            session.close()
15081 amit.gupta 739 
 
740 
    def on_post(self, req, resp, agentId, callType):
15112 amit.gupta 741 
        returned = False
15081 amit.gupta 742 
        self.agentId = int(agentId)
743 
        self.callType = callType
744 
        jsonReq = json.loads(req.stream.read(), encoding='utf-8')
15169 amit.gupta 745 
        lgr.info( "Request ----\n"  + str(jsonReq))
15091 amit.gupta 746 
        self.jsonReq = jsonReq
747 
        invalidNumber = self.invalidNumber
748 
        callLater = self.callLater
15096 amit.gupta 749 
        alreadyUser = self.alReadyUser
15091 amit.gupta 750 
        verifiedLinkSent = self.verifiedLinkSent
15368 amit.gupta 751 
        onboarded = self.onboarded
15278 amit.gupta 752 
        self.address = jsonReq.get('address')
15096 amit.gupta 753 
        self.retailerId = int(jsonReq.get('retailerid'))
15671 amit.gupta 754 
        self.smsNumber = jsonReq.get('smsnumber')
755 
        if self.smsNumber is not None:
756 
            self.smsNumber = self.smsNumber.strip().lstrip("0")
15112 amit.gupta 757 
        try:
758 
            self.retailer = session.query(Retailers).filter_by(id=self.retailerId).first()
15281 amit.gupta 759 
            if self.address:
15278 amit.gupta 760 
                self.retailer.address_new = self.address
15112 amit.gupta 761 
            self.callDisposition = jsonReq.get('calldispositiontype')
762 
            self.callHistory = CallHistory()
763 
            self.callHistory.agent_id=self.agentId
764 
            self.callHistory.call_disposition = self.callDisposition
765 
            self.callHistory.retailer_id=self.retailerId
15115 amit.gupta 766 
            self.callHistory.call_type=self.callType
15112 amit.gupta 767 
            self.callHistory.duration_sec = int(jsonReq.get("callduration"))
768 
            self.callHistory.disposition_description = jsonReq.get('calldispositiondescritption')
15200 manas 769 
            self.callHistory.disposition_comments = jsonReq.get('calldispositioncomments')
770 
            lgr.info(self.callHistory.disposition_comments)
15112 amit.gupta 771 
            self.callHistory.call_time = datetime.strptime(jsonReq.get("calltime"), '%d/%m/%Y %H:%M:%S')
772 
            self.callHistory.mobile_number = jsonReq.get('number')
15145 amit.gupta 773 
            self.callHistory.sms_verified = int(jsonReq.get("verified"))
15234 amit.gupta 774 
            lastFetchData = session.query(FetchDataHistory).filter_by(agent_id=self.agentId).order_by(FetchDataHistory.id.desc()).first()
15368 amit.gupta 775 
            if self.callDisposition == 'onboarded':
776 
                self.checkList = jsonReq.get('checklist')
777 
 
15234 amit.gupta 778 
            if lastFetchData is None:
779 
                raise
780 
            self.callHistory.last_fetch_time= lastFetchData.created
15112 amit.gupta 781 
 
782 
            dispositionMap = {  'call_later':callLater,
783 
                        'ringing_no_answer':callLater,
784 
                        'not_reachable':callLater,
785 
                        'switch_off':callLater,
15202 manas 786 
                        'not_retailer':invalidNumber,
15112 amit.gupta 787 
                        'invalid_no':invalidNumber,
788 
                        'wrong_no':invalidNumber,
789 
                        'hang_up':invalidNumber,
790 
                        'retailer_not_interested':invalidNumber,
15200 manas 791 
                        'recharge_retailer':invalidNumber,
792 
                        'accessory_retailer':invalidNumber,
793 
                        'service_center_retailer':invalidNumber,
15112 amit.gupta 794 
                        'alreadyuser':alreadyUser,
15368 amit.gupta 795 
                        'verified_link_sent':verifiedLinkSent,
796 
                        'onboarded':onboarded
15112 amit.gupta 797 
                      }
798 
            returned = dispositionMap[jsonReq.get('calldispositiontype')]()
799 
        finally:
800 
            session.close()
15096 amit.gupta 801 
 
15112 amit.gupta 802 
        if returned:
803 
            resp.body = "{\"result\":\"success\"}"
804 
        else:
805 
            resp.body = "{\"result\":\"failed\"}"
15081 amit.gupta 806 
 
15091 amit.gupta 807 
    def invalidNumber(self,):
15108 manas 808 
        #self.retailer.status = 'retry' if self.callType == 'fresh' else 'fretry'
809 
        if self.callDisposition == 'invalid_no':
810 
            self.retailer.status='failed'
811 
            self.callHistory.disposition_description = 'Invalid Number'
812 
        elif self.callDisposition == 'wrong_no':
15111 manas 813 
            self.retailer.status='failed'
814 
            self.callHistory.disposition_description = 'Wrong Number'
815 
        elif self.callDisposition == 'hang_up':
816 
            self.retailer.status='failed'
817 
            self.callHistory.disposition_description = 'Hang Up'
818 
        elif self.callDisposition == 'retailer_not_interested':
819 
            self.retailer.status='failed'
820 
            if self.callHistory.disposition_description is None:
821 
                self.callHistory.disposition_description = 'NA'
15200 manas 822 
            self.callHistory.disposition_description = 'Reason Retailer Not Interested ' + self.callHistory.disposition_description
823 
        elif self.callDisposition == 'recharge_retailer':
824 
            self.retailer.status='failed'
825 
            self.callHistory.disposition_description = 'Recharge related. Not a retailer '
826 
        elif self.callDisposition == 'accessory_retailer':
827 
            self.retailer.status='failed'
828 
            self.callHistory.disposition_description = 'Accessory related. Not a retailer'
829 
        elif self.callDisposition == 'service_center_retailer':
830 
            self.retailer.status='failed'
831 
            self.callHistory.disposition_description = 'Service Center related. Not a retailer'
15202 manas 832 
        elif self.callDisposition == 'not_retailer':
833 
            self.retailer.status='failed'
834 
            self.callHistory.disposition_description = 'Not a retailer'
15108 manas 835 
        session.commit()
836 
        return True
837 
 
15132 amit.gupta 838 
    def getCode(self,):
15207 amit.gupta 839 
        newCode = None
840 
        lastLink = session.query(RetailerLinks).order_by(RetailerLinks.id.desc()).with_lockmode("update").first()
841 
        if lastLink is not None:
842 
            if len(lastLink.code)==len(codesys):
843 
                newCode=lastLink.code
844 
        return getNextCode(codesys, newCode)
15108 manas 845 
 
15254 amit.gupta 846 
 
15091 amit.gupta 847 
    def callLater(self,):
15368 amit.gupta 848 
        self.retailer.status = RETRY_MAP.get(self.callType)
15100 amit.gupta 849 
        self.retailer.call_priority = None
15096 amit.gupta 850 
        if self.callDisposition == 'call_later':
15100 amit.gupta 851 
            if self.callHistory.disposition_description is not None:
15102 amit.gupta 852 
                self.retailer.call_priority = 'user_initiated'
15096 amit.gupta 853 
                self.retailer.next_call_time = datetime.strptime(self.callHistory.disposition_description, '%d/%m/%Y %H:%M:%S')
854 
                self.callHistory.disposition_description = 'User requested to call on ' + self.callHistory.disposition_description
855 
            else:
15102 amit.gupta 856 
                self.retailer.call_priority = 'system_initiated'
15096 amit.gupta 857 
                self.retailer.next_call_time = self.callHistory.call_time + timedelta(days=1)
15112 amit.gupta 858 
                self.callHistory.disposition_description = 'Call scheduled on ' + datetime.strftime(self.retailer.next_call_time, '%d/%m/%Y %H:%M:%S')
859 
        else:
860 
            if self.callDisposition == 'ringing_no_answer':
861 
                if self.retailer.disposition == 'ringing_no_answer':
862 
                    self.retailer.retry_count += 1
863 
                else:
864 
                    self.retailer.disposition = 'ringing_no_answer'
865 
                    self.retailer.retry_count = 1
866 
            else:
867 
                if self.retailer.disposition == 'ringing_no_answer':
15122 amit.gupta 868 
                    pass
15112 amit.gupta 869 
                else:
15119 amit.gupta 870 
                    self.retailer.disposition = 'not_reachable'
15122 amit.gupta 871 
                self.retailer.retry_count += 1
872 
                self.retailer.invalid_retry_count += 1
15119 amit.gupta 873 
 
15122 amit.gupta 874 
            retryConfig = session.query(RetryConfig).filter_by(call_type=self.callType, disposition_type=self.retailer.disposition, retry_count=self.retailer.retry_count).first()
15112 amit.gupta 875 
            if retryConfig is not None:
876 
                self.retailer.next_call_time = self.callHistory.call_time + timedelta(minutes = retryConfig.minutes_ahead)
15119 amit.gupta 877 
                self.callHistory.disposition_description = 'Call scheduled on ' + datetime.strftime(self.retailer.next_call_time, '%d/%m/%Y %H:%M:%S')
15112 amit.gupta 878 
            else:
879 
                self.retailer.status = 'failed'
880 
                self.callHistory.disposition_description = 'Call failed as all attempts exhausted'
15119 amit.gupta 881 
 
15101 amit.gupta 882 
        session.commit()
883 
        return True
15096 amit.gupta 884 
 
15100 amit.gupta 885 
 
15091 amit.gupta 886 
    def alReadyUser(self,):
15112 amit.gupta 887 
        self.retailer.status = self.callDisposition
15117 amit.gupta 888 
        if self.callHistory.disposition_description is None:
889 
            self.callHistory.disposition_description = 'Retailer already user'
15112 amit.gupta 890 
        session.commit()
891 
        return True
15091 amit.gupta 892 
    def verifiedLinkSent(self,):
15147 amit.gupta 893 
        if self.callType == 'fresh':
894 
            self.retailer.status = 'followup'
16882 amit.gupta 895 
            if self.retailer.agent_id not in sticky_agents:
896 
                self.retailer.agent_id = None
15147 amit.gupta 897 
            self.retailer.next_call_time = self.callHistory.call_time + timedelta(days=1)
898 
            self.callHistory.disposition_description = 'App link sent via ' + self.callHistory.disposition_description+ '. followup on' + datetime.strftime(self.retailer.next_call_time, '%d/%m/%Y %H:%M:%S')
899 
        else:
15224 amit.gupta 900 
            self.retailer.status = 'followup'
16882 amit.gupta 901 
            if self.retailer.agent_id not in sticky_agents:
902 
                self.retailer.agent_id = None
15147 amit.gupta 903 
            self.retailer.next_call_time = self.callHistory.call_time + timedelta(days=7)
15254 amit.gupta 904 
            self.callHistory.disposition_description = 'App link sent via' + self.callHistory.disposition_description + '. Followup again on ' + datetime.strftime(self.retailer.next_call_time, '%d/%m/%Y %H:%M:%S')
15328 amit.gupta 905 
        addContactToRetailer(self.agentId, self.retailerId, self.smsNumber, self.callType, 'sms')
15146 amit.gupta 906 
        session.commit()
907 
        return True
15368 amit.gupta 908 
    def onboarded(self,):
909 
        self.retailer.status = self.callDisposition
910 
        checkList = OnboardedRetailerChecklists()
911 
        checkList.contact_us = self.checkList.get('contactus')
15390 amit.gupta 912 
        checkList.doa_return_policy = self.checkList.get('doareturnpolicy')
15368 amit.gupta 913 
        checkList.number_verification = self.checkList.get('numberverification')
914 
        checkList.payment_option = self.checkList.get('paymentoption')
915 
        checkList.preferences = self.checkList.get('preferences')
916 
        checkList.product_info = self.checkList.get('productinfo')
15372 amit.gupta 917 
        checkList.redeem = self.checkList.get('redeem')
15368 amit.gupta 918 
        checkList.retailer_id = self.retailerId
919 
        session.commit()
920 
        return True
921 
 
922 
 
15254 amit.gupta 923 
def isActivated(retailerId):
15276 amit.gupta 924 
    retailerLink = session.query(RetailerLinks).filter_by(retailer_id=retailerId).first()
15448 amit.gupta 925 
    user = session.query(Users).filter(or_(func.lower(Users.referrer)==retailerLink.code.lower(), Users.utm_campaign==retailerLink.code)).first()
15276 amit.gupta 926 
    if user is None:
927 
        mobileNumbers = list(session.query(RetailerContacts.mobile_number).filter_by(retailer_id=retailerId).all())
928 
        user = session.query(Users).filter(Users.mobile_number.in_(mobileNumbers)).first()
15254 amit.gupta 929 
        if user is None:
15332 amit.gupta 930 
            if retailerLink.created < datetime(2015,5,26):
15333 amit.gupta 931 
                historyNumbers = [number for number, in session.query(CallHistory.mobile_number).filter_by(retailer_id = retailerId).all()]
15476 amit.gupta 932 
                user = session.query(Users).filter(Users.mobile_number.in_(historyNumbers)).first()
15332 amit.gupta 933 
                if user is None:
934 
                    return False
15334 amit.gupta 935 
                else:
936 
                    mapped_with = 'contact'
15332 amit.gupta 937 
            else:
938 
                return False
15276 amit.gupta 939 
        else:
940 
            mapped_with = 'contact'
941 
    else:
942 
        mapped_with = 'code'
943 
    retailerLink.mapped_with = mapped_with
15388 amit.gupta 944 
    if user.activation_time is not None:
15448 amit.gupta 945 
        retailerLink.activated = user.activation_time
946 
    retailerLink.activated = user.created
15276 amit.gupta 947 
    retailerLink.user_id = user.id
15291 amit.gupta 948 
    retailer = session.query(Retailers).filter_by(id=retailerId).first()
15574 amit.gupta 949 
    if retailer.status == 'followup' or retailer.status == 'fretry':
15389 amit.gupta 950 
        retailer.status = 'onboarding'
16882 amit.gupta 951 
        if retailer.agent_id not in sticky_agents:
952 
                retailer.agent_id = None
15391 amit.gupta 953 
        retailer.call_priority = None
954 
        retailer.next_call_time = None
955 
        retailer.retry_count = 0
956 
        retailer.invalid_retry_count = 0
15276 amit.gupta 957 
    session.commit()
15287 amit.gupta 958 
    print "retailerLink.retailer_id", retailerLink.retailer_id
15700 amit.gupta 959 
    print "retailer", retailer.id
15276 amit.gupta 960 
    session.close()
961 
    return True
15254 amit.gupta 962 
 
963 
class AddContactToRetailer():
964 
    def on_post(self,req,resp, agentId):
965 
        agentId = int(agentId)
966 
        try:
967 
            jsonReq = json.loads(req.stream.read(), encoding='utf-8')
968 
            retailerId = int(jsonReq.get("retailerid"))
969 
            mobile = jsonReq.get("mobile")
970 
            callType = jsonReq.get("calltype")
971 
            contactType = jsonReq.get("contacttype")
972 
            addContactToRetailer(agentId, retailerId, mobile, callType, contactType)
973 
            session.commit()
974 
        finally:
975 
            session.close()
15676 amit.gupta 976 
 
15677 amit.gupta 977 
class AddAddressToRetailer():
15676 amit.gupta 978 
    def on_post(self,req,resp, agentId):
979 
        agentId = int(agentId)
15678 amit.gupta 980 
        jsonReq = json.loads(req.stream.read(), encoding='utf-8')
981 
        retailerId = int(jsonReq.get("retailerid"))
15684 amit.gupta 982 
        address = str(jsonReq.get("address"))
983 
        storeName = str(jsonReq.get("storename"))
984 
        pin = str(jsonReq.get("pin"))
985 
        city = str(jsonReq.get("city"))
986 
        state = str(jsonReq.get("state"))
987 
        updateType = str(jsonReq.get("updatetype"))
15678 amit.gupta 988 
        addAddressToRetailer(agentId, retailerId, address, storeName, pin, city,state, updateType)
15254 amit.gupta 989 
 
990 
def addContactToRetailer(agentId, retailerId, mobile, callType, contactType):
15312 amit.gupta 991 
    retailerContact = session.query(RetailerContacts).filter_by(retailer_id=retailerId).filter_by(mobile_number=mobile).first()
992 
    if retailerContact is None:
15254 amit.gupta 993 
        retailerContact = RetailerContacts()
15256 amit.gupta 994 
        retailerContact.retailer_id = retailerId
15254 amit.gupta 995 
        retailerContact.agent_id = agentId
996 
        retailerContact.call_type = callType
997 
        retailerContact.contact_type = contactType
998 
        retailerContact.mobile_number = mobile
15312 amit.gupta 999 
    else:
15327 amit.gupta 1000 
        if CONTACT_PRIORITY.index(retailerContact.contact_type) > CONTACT_PRIORITY.index(contactType):
15358 amit.gupta 1001 
            retailerContact.contact_type = contactType
15676 amit.gupta 1002 
 
1003 
def addAddressToRetailer(agentId, retailerId, address, storeName, pin, city,state, updateType):
15679 amit.gupta 1004 
    print "I am in addAddress"
15682 amit.gupta 1005 
    print agentId, retailerId, address, storeName, pin, city, state, updateType
15679 amit.gupta 1006 
    try:
1007 
        if updateType=='new':
15685 amit.gupta 1008 
            retailer = session.query(Retailers).filter_by(id=retailerId).first()
15679 amit.gupta 1009 
            retailer.address = address
1010 
            retailer.title = storeName
1011 
            retailer.city = city
1012 
            retailer.state = state
1013 
            retailer.pin = pin
1014 
        raddress = RetailerAddresses()
1015 
        raddress.address = address
15682 amit.gupta 1016 
        raddress.title = storeName
15679 amit.gupta 1017 
        raddress.agent_id = agentId
1018 
        raddress.city = city
1019 
        raddress.pin = pin
1020 
        raddress.retailer_id = retailerId
1021 
        raddress.state = state
1022 
        session.commit()
1023 
    finally:
1024 
        session.close()
15254 amit.gupta 1025 
 
15312 amit.gupta 1026 
 
15189 manas 1027 
class Login():
1028 
 
1029 
    def on_get(self, req, resp, agentId, role):
1030 
        try:
15198 manas 1031 
            self.agentId = int(agentId)
1032 
            self.role = role
1033 
            print str(self.agentId) + self.role;
15199 manas 1034 
            agents=AgentLoginTimings()
1035 
            lastLoginTime = session.query(Agents).filter(Agents.id==self.agentId).first()
1036 
            print 'lastLogintime' + str(lastLoginTime)
1037 
            agents.loginTime=lastLoginTime.last_login
1038 
            agents.logoutTime=datetime.now()
1039 
            agents.role =self.role
15282 amit.gupta 1040 
            agents.agent_id = self.agentId
15199 manas 1041 
            session.add(agents)
1042 
            session.commit()
1043 
            resp.body =  json.dumps({"result":{"success":"true","message":"Success"}}, encoding='utf-8')
15189 manas 1044 
        finally:
1045 
            session.close()
15112 amit.gupta 1046 
 
15189 manas 1047 
    def on_post(self,req,resp):
1048 
        try:
1049 
            jsonReq = json.loads(req.stream.read(), encoding='utf-8')
1050 
            lgr.info( "Request ----\n"  + str(jsonReq))
1051 
            email=jsonReq.get('email')
1052 
            password = jsonReq.get('password')
1053 
            role=jsonReq.get('role')
15531 amit.gupta 1054 
            agent = session.query(Agents).filter(and_(Agents.email==email,Agents.password==password)).first()
1055 
            if agent is None:
15189 manas 1056 
                resp.body =  json.dumps({"result":{"success":"false","message":"Invalid User"}}, encoding='utf-8')
1057 
            else:
15531 amit.gupta 1058 
                print agent.id
1059 
                checkRole = session.query(Agent_Roles.id).filter(and_(Agent_Roles.agent_id==agent.id,Agent_Roles.role==role)).first()
15189 manas 1060 
                if checkRole is None:
1061 
                    resp.body =  json.dumps({"result":{"success":"false","message":"Invalid Role"}}, encoding='utf-8')
1062 
                else:
15531 amit.gupta 1063 
                    agent.last_login = datetime.now()
1064 
                    agent.login_type = role
1065 
                    resp.body =  json.dumps({"result":{"success":"true","message":"Valid User","id":agent.id}}, encoding='utf-8')
1066 
                    session.commit()
15195 manas 1067 
                    #session.query(Agents).filter_by(id = checkUser[0]).
15189 manas 1068 
        finally:
1069 
            session.close()
1070 
 
15195 manas 1071 
    def test(self,email,password,role):
15189 manas 1072 
        checkUser = session.query(Agents.id).filter(and_(Agents.email==email,Agents.password==password)).first()
1073 
        if checkUser is None:
1074 
            print checkUser
15195 manas 1075 
 
15189 manas 1076 
        else:
1077 
            print checkUser[0]
1078 
            checkRole = session.query(Agent_Roles.id).filter(and_(Agent_Roles.agent_id==checkUser[0],Agent_Roles.role==role)).first()
1079 
            if checkRole is None:
15195 manas 1080 
                pass
15189 manas 1081 
            else:
15195 manas 1082 
                agents=AgentLoginTimings()
1083 
                agents.loginTime=datetime.now()
1084 
                agents.logoutTime=datetime.now()
1085 
                agents.role =role
1086 
                agents.agent_id = 2
1087 
                #session.query(AgentLoginTimings).filter_by(id = checkUser[0]).update({"last_login":datetime.now()}, synchronize_session=False)
1088 
                session.add(agents)
1089 
                session.commit()
1090 
                session.close()
1091 
 
1092 
                #session.query(Agents).filter(Agents.id==checkUser[0]).update({"last_login":Agents.last_login})
15275 amit.gupta 1093 
 
1094 
class RetailerActivation():
1095 
    def on_get(self, req, resp, userId):
15351 amit.gupta 1096 
        res =  markDealerActivation(int(userId))
1097 
        if res:
1098 
            resp.body = "{\"activated\":true}"
1099 
        else:
1100 
            resp.body = "{\"activated\":false}"
1101 
 
15275 amit.gupta 1102 
 
1103 
def markDealerActivation(userId):
1104 
    try:
15343 amit.gupta 1105 
        user = session.query(Users).filter_by(id=userId).first()
15275 amit.gupta 1106 
        result = False
1107 
        mappedWith = 'contact'
15534 amit.gupta 1108 
        retailer = None
15275 amit.gupta 1109 
        if user is not None:
15454 amit.gupta 1110 
            referrer = None if user.referrer is None else user.referrer.upper()
1111 
            retailerLink = session.query(RetailerLinks).filter(or_(RetailerLinks.code==referrer, RetailerLinks.code==user.utm_campaign)).first()
15275 amit.gupta 1112 
            if retailerLink is None:
15501 amit.gupta 1113 
                if user.mobile_number is not None:
1114 
                    retailerContact = session.query(RetailerContacts).filter_by(mobile_number=user.mobile_number).first()
1115 
                    if retailerContact is None:
15613 amit.gupta 1116 
                        retailer = session.query(Retailers).filter(Retailers.status.in_(['followup', 'fretry', 'fdone'])).filter(or_(Retailers.contact1==user.mobile_number,Retailers.contact2==user.mobile_number)).first()
15501 amit.gupta 1117 
                    else:
1118 
                        retailer = session.query(Retailers).filter_by(id = retailerContact.retailer_id).first()
15275 amit.gupta 1119 
            else:
1120 
                retailer = session.query(Retailers).filter_by(id = retailerLink.retailer_id).first()
1121 
                mappedWith='code'
1122 
            if retailer is not None:
1123 
                retailerLink = session.query(RetailerLinks).filter_by(retailer_id=retailer.id).first()
1124 
                if retailerLink is not None:
1125 
                    retailerLink.user_id = user.id
1126 
                    retailerLink.mapped_with=mappedWith
15358 amit.gupta 1127 
                    retailer.status = 'onboarding'
15275 amit.gupta 1128 
                    result = True
1129 
                    session.commit()
15574 amit.gupta 1130 
        return result
15275 amit.gupta 1131 
    finally:
1132 
        session.close()
1133 
 
15189 manas 1134 
 
15081 amit.gupta 1135 
def todict(obj, classkey=None):
1136 
    if isinstance(obj, dict):
1137 
        data = {}
1138 
        for (k, v) in obj.items():
1139 
            data[k] = todict(v, classkey)
1140 
        return data
1141 
    elif hasattr(obj, "_ast"):
1142 
        return todict(obj._ast())
1143 
    elif hasattr(obj, "__iter__"):
1144 
        return [todict(v, classkey) for v in obj]
1145 
    elif hasattr(obj, "__dict__"):
1146 
        data = dict([(key, todict(value, classkey))
1147 
            for key, value in obj.__dict__.iteritems()
1148 
            if not callable(value) and not key.startswith('_')])
1149 
        if classkey is not None and hasattr(obj, "__class__"):
1150 
            data[classkey] = obj.__class__.__name__
1151 
        return data
1152 
    else:
1153 
        return obj
18256 manas 1154 
 
15358 amit.gupta 1155 
def getRetailerObj(retailer, otherContacts1=None, callType=None):
15324 amit.gupta 1156 
    print "before otherContacts1",otherContacts1
1157 
    otherContacts = [] if otherContacts1 is None else otherContacts1
15662 amit.gupta 1158 
    print "after otherContacts1",otherContacts
15081 amit.gupta 1159 
    obj = Mock()
15280 amit.gupta 1160 
    obj.id = retailer.id
15686 amit.gupta 1161 
 
1162 
 
15314 amit.gupta 1163 
    if retailer.contact1 is not None and retailer.contact1 not in otherContacts:
15315 amit.gupta 1164 
        otherContacts.append(retailer.contact1)
15314 amit.gupta 1165 
    if retailer.contact2 is not None and retailer.contact2 not in otherContacts:
15315 amit.gupta 1166 
        otherContacts.append(retailer.contact2)
15323 amit.gupta 1167 
    obj.contact1 = None if len(otherContacts)==0 else otherContacts[0]
15325 amit.gupta 1168 
    if obj.contact1 is not None:
1169 
        obj.contact2 = None if len(otherContacts)==1 else otherContacts[1]
15096 amit.gupta 1170 
    obj.scheduled = (retailer.call_priority is not None)
15686 amit.gupta 1171 
    address = None
1172 
    try:
1173 
        address = session.query(RetailerAddresses).filter_by(retailer_id=retailer.id).order_by(RetailerAddresses.created.desc()).first()
1174 
    finally:
1175 
        session.close()
1176 
    if address is not None:
1177 
        obj.address = address.address
1178 
        obj.title = address.title
1179 
        obj.city = address.city
1180 
        obj.state = address.state
1181 
        obj.pin = address.pin
1182 
    else:
1183 
        obj.address = retailer.address_new if retailer.address_new is not None else retailer.address
1184 
        obj.title = retailer.title
1185 
        obj.city = retailer.city
1186 
        obj.state = retailer.state
1187 
        obj.pin = retailer.pin
15699 amit.gupta 1188 
    obj.status = retailer.status
15686 amit.gupta 1189 
 
15662 amit.gupta 1190 
    if hasattr(retailer, 'contact'):
1191 
        obj.contact = retailer.contact
15358 amit.gupta 1192 
    if callType == 'onboarding':
1193 
        try:
15364 amit.gupta 1194 
            userId, activatedTime = session.query(RetailerLinks.user_id, RetailerLinks.activated).filter(RetailerLinks.retailer_id==retailer.id).first()
15366 amit.gupta 1195 
            activated, = session.query(Users.activation_time).filter(Users.id==userId).first()
15364 amit.gupta 1196 
            if activated is not None:
15366 amit.gupta 1197 
                activatedTime = activated
15362 amit.gupta 1198 
            obj.user_id = userId
15364 amit.gupta 1199 
            obj.created = datetime.strftime(activatedTime, '%d/%m/%Y %H:%M:%S')
15358 amit.gupta 1200 
            result = fetchResult("select * from useractive where user_id=%d"%(userId))
1201 
            if result == ():
1202 
                obj.last_active = None
1203 
            else:
15360 amit.gupta 1204 
                obj.last_active =datetime.strftime(result[0][1], '%d/%m/%Y %H:%M:%S')
15361 amit.gupta 1205 
            ordersCount = session.query(Orders).filter_by(user_id = userId).filter(~Orders.status.in_(['ORDER_NOT_CREATED_KNOWN', 'ORDER_ALREADY_CREATED_IGNORED'])).count()
15358 amit.gupta 1206 
            obj.orders = ordersCount
1207 
        finally:
1208 
            session.close()
15081 amit.gupta 1209 
    return obj
15091 amit.gupta 1210 
 
15132 amit.gupta 1211 
def make_tiny(code):
16939 manish.sha 1212 
    url = 'https://play.google.com/store/apps/details?id=com.saholic.profittill&referrer=utm_source%3D0%26utm_medium%3DCRM%26utm_term%3D001%26utm_campaign%3D' + code
16881 manas 1213 
    #url='https://play.google.com/store/apps/details?id=com.saholic.profittill&referrer=utm_source=0&utm_medium=CRM&utm_term=001&utm_campaign='+code
16939 manish.sha 1214 
    #marketUrl='market://details?id=com.saholic.profittill&referrer=utm_source=0&utm_medium=CRM&utm_term=001&utm_campaign='+code
1215 
    #url = urllib.quote(marketUrl)
15465 amit.gupta 1216 
    #request_url = ('http://tinyurl.com/api-create.php?' + urlencode({'url':url}))
1217 
    #filehandle = urllib2.Request(request_url)
1218 
    #x= urllib2.urlopen(filehandle)
15546 amit.gupta 1219 
    try:
1220 
        shortener = Shortener('TinyurlShortener')
1221 
        returnUrl =  shortener.short(url)
1222 
    except:
1223 
        shortener = Shortener('SentalaShortener')
1224 
        returnlUrl =  shortener.short(url)
1225 
    return returnUrl
15171 amit.gupta 1226 
 
15285 manas 1227 
class SearchUser():
1228 
 
1229 
    def on_post(self, req, resp, agentId, searchType):
15314 amit.gupta 1230 
        retailersJsonArray = []
15285 manas 1231 
        try:
1232 
            jsonReq = json.loads(req.stream.read(), encoding='utf-8')
1233 
            lgr.info( "Request in Search----\n"  + str(jsonReq))
15302 amit.gupta 1234 
            contact=jsonReq.get('searchTerm')
15285 manas 1235 
            if(searchType=="number"):
15312 amit.gupta 1236 
                retailer_ids = session.query(RetailerContacts.retailer_id).filter_by(mobile_number=contact).all()
1237 
                retailer_ids = [r for r, in retailer_ids]
1238 
                anotherCondition = or_(Retailers.contact1==contact,Retailers.contact2==contact, Retailers.id.in_(retailer_ids))
1239 
            else:
1240 
                m = re.match("(.*?)(\d{6})(.*?)", contact)
1241 
                if m is not None:
1242 
                    pin = m.group(2)
1243 
                    contact = m.group(1) if m.group(1) != '' else m.group(3)
15313 amit.gupta 1244 
                    anotherCondition = and_(Retailers.title.ilike('%%%s%%'%(contact)), Retailers.pin==pin)
15312 amit.gupta 1245 
                else:
1246 
                    anotherCondition = Retailers.title.ilike('%%%s%%'%(contact))
15297 amit.gupta 1247 
 
15326 amit.gupta 1248 
            retailers = session.query(Retailers).filter(anotherCondition).limit(20).all()
15312 amit.gupta 1249 
            if retailers is None:
15285 manas 1250 
                resp.body = json.dumps("{}")
15312 amit.gupta 1251 
            else:
1252 
                for retailer in retailers:
15326 amit.gupta 1253 
                    otherContacts = [r for r, in session.query(RetailerContacts.mobile_number).filter_by(retailer_id=retailer.id).order_by(RetailerContacts.contact_type).all()]
15314 amit.gupta 1254 
                    retailersJsonArray.append(todict(getRetailerObj(retailer, otherContacts)))
1255 
            resp.body = json.dumps({"Retailers":retailersJsonArray}, encoding='utf-8')
15312 amit.gupta 1256 
            return
15285 manas 1257 
        finally:
1258 
            session.close()
15171 amit.gupta 1259 
 
15081 amit.gupta 1260 
 
1261 
class Mock(object):
1262 
    pass
15189 manas 1263 
 
15312 amit.gupta 1264 
def tagActivatedReatilers():
15613 amit.gupta 1265 
    retailerIds = [r for  r, in session.query(RetailerLinks.retailer_id).filter_by(user_id = None).all()]
15312 amit.gupta 1266 
    session.close()
15288 amit.gupta 1267 
    for retailerId in retailerIds:
1268 
        isActivated(retailerId)
15312 amit.gupta 1269 
    session.close()
15374 kshitij.so 1270 
 
1271 
class StaticDeals():
1272 
 
1273 
    def on_get(self, req, resp):
1274 
 
1275 
        offset = req.get_param_as_int("offset")
1276 
        limit = req.get_param_as_int("limit")
1277 
        categoryId = req.get_param_as_int("categoryId")
15458 kshitij.so 1278 
        direction = req.get_param_as_int("direction")
15374 kshitij.so 1279 
 
15458 kshitij.so 1280 
        result = Mongo.getStaticDeals(offset, limit, categoryId, direction)
15374 kshitij.so 1281 
        resp.body = dumps(result)
1282 
 
16366 kshitij.so 1283 
class DealNotification():
1284 
 
1285 
    def on_get(self,req,resp,skuBundleIds):
1286 
        result = Mongo.getDealsForNotification(skuBundleIds)
1287 
        resp.body = dumps(result)
16487 kshitij.so 1288 
 
1289 
class DealPoints():
1290 
 
1291 
    def on_get(self, req, resp):
16366 kshitij.so 1292 
 
16487 kshitij.so 1293 
        offset = req.get_param_as_int("offset")
1294 
        limit = req.get_param_as_int("limit")
1295 
 
1296 
        result = Mongo.getAllBundlesWithDealPoints(offset, limit)
1297 
        resp.body = dumps(result)
15374 kshitij.so 1298 
 
16487 kshitij.so 1299 
 
1300 
    def on_post(self, req, resp):
1301 
 
1302 
 
1303 
        try:
1304 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
1305 
        except ValueError:
1306 
            raise falcon.HTTPError(falcon.HTTP_400,
1307 
                'Malformed JSON',
1308 
                'Could not decode the request body. The '
1309 
                'JSON was incorrect.')
1310 
 
1311 
        result = Mongo.addDealPoints(result_json)
1312 
        resp.body = json.dumps(result, encoding='utf-8')
15374 kshitij.so 1313 
 
16545 kshitij.so 1314 
class AppAffiliates():
1315 
 
1316 
    def on_get(self, req, resp, retailerId, appId):
1317 
        retailerId = int(retailerId)
1318 
        appId = int(appId)
16554 kshitij.so 1319 
        call_back = req.get_param("callback")
16545 kshitij.so 1320 
        result = Mongo.generateRedirectUrl(retailerId, appId)
16555 kshitij.so 1321 
        resp.body = call_back+'('+str(result)+')'
16557 kshitij.so 1322 
 
1323 
class AffiliatePayout():
1324 
    def on_get(self, req, resp):
1325 
        payout = req.get_param("payout")
1326 
        transaction_id = req.get_param("transaction_id")
1327 
        result = Mongo.addPayout(payout, transaction_id)
1328 
        resp.body = str(result)
1329 
 
16581 manish.sha 1330 
class AppOffers():
1331 
    def on_get(self, req, resp, retailerId):
16895 manish.sha 1332 
        try:
1333 
            result = Mongo.getAppOffers(retailerId)
1334 
            offerids = result.values()
1335 
            if offerids is None or len(offerids)==0:
16887 kshitij.so 1336 
                resp.body = json.dumps("{}")
1337 
            else:
16941 manish.sha 1338 
                appOffers = session.query(app_offers.id,app_offers.appmaster_id, app_offers.app_name, app_offers.affiliate_offer_id, app_offers.image_url, app_offers.downloads, app_offers.link, app_offers.offer_price, app_offers.offerCategory, app_offers.package_name, app_offers.promoImage, app_offers.ratings, case([(app_offers.override_payout == True, app_offers.overriden_payout)], else_=app_offers.user_payout).label('user_payout'), case([(appmasters.shortDescription != None, appmasters.shortDescription)], else_=None).label('shortDescription'), case([(appmasters.longDescription != None, appmasters.longDescription)], else_=None).label('longDescription'), appmasters.customerOneLiner, appmasters.retailerOneLiner,appmasters.rank, app_offers.offerCondition, app_offers.location).join((appmasters,appmasters.id==app_offers.appmaster_id)).filter(app_offers.id.in_(tuple(offerids))).all()
16895 manish.sha 1339 
                appOffersMap = {}
1340 
                jsonOffersArray=[]
1341 
                for offer in appOffers:
1342 
                    appOffersMap[long(offer[0])]= AppOfferObj(offer[0], offer[1], offer[2], offer[3], offer[4], offer[5], offer[6], offer[7], offer[8], offer[9], offer[10], offer[11], offer[12], offer[13], offer[14], offer[15], offer[16], offer[17], offer[18], offer[19]).__dict__
1343 
                for rank in sorted(result):
1344 
                    print 'Rank', rank, 'Data', appOffersMap[result[rank]]
1345 
                    jsonOffersArray.append(appOffersMap[result[rank]])
1346 
 
1347 
            resp.body = json.dumps({"AppOffers":jsonOffersArray}, encoding='latin1')
16887 kshitij.so 1348 
        finally:
1349 
            session.close()
1350 
 
16727 manish.sha 1351 
 
1352 
class AppUserBatchRefund():
1353 
    def on_get(self, req, resp, batchId, userId):
16887 kshitij.so 1354 
        try:
1355 
            batchId = long(batchId)
1356 
            userId = long(userId)
1357 
            userBatchCashback = user_app_cashbacks.get_by(user_id=userId, batchCreditId=batchId)
1358 
            if userBatchCashback is None:
1359 
                resp.body = json.dumps("{}")
1360 
            else:
16905 manish.sha 1361 
                if userBatchCashback.creditedDate is not None:
1362 
                    userBatchCashback.creditedDate = str(userBatchCashback.creditedDate)
16887 kshitij.so 1363 
                resp.body = json.dumps(todict(userBatchCashback), encoding='utf-8')
1364 
        finally:
1365 
            session.close()
16727 manish.sha 1366 
 
1367 
class AppUserBatchDrillDown():
16777 manish.sha 1368 
    def on_get(self, req, resp, fortNightOfYear, userId, yearVal):
16887 kshitij.so 1369 
        try:
1370 
            fortNightOfYear = long(fortNightOfYear)
1371 
            userId = long(userId)
1372 
            yearVal = long(yearVal)
1373 
            appUserBatchDrillDown = session.query(user_app_installs.transaction_date, func.sum(user_app_installs.installCount).label('downloads'), func.sum(user_app_installs.payoutAmount).label('amount')).join((user_app_cashbacks,user_app_cashbacks.user_id==user_app_installs.user_id)).filter(user_app_cashbacks.fortnightOfYear==user_app_installs.fortnightOfYear).filter(user_app_cashbacks.user_id==userId).filter(user_app_cashbacks.yearVal==yearVal).filter(user_app_cashbacks.fortnightOfYear==fortNightOfYear).group_by(user_app_installs.transaction_date).all()
1374 
            cashbackArray = []
1375 
            if appUserBatchDrillDown is None or len(appUserBatchDrillDown)==0:
1376 
                resp.body = json.dumps("{}")
1377 
            else:
1378 
                for appcashBack in appUserBatchDrillDown:
1379 
                    userAppBatchDrillDown = UserAppBatchDrillDown(str(appcashBack[0]),long(appcashBack[1]), long(appcashBack[2]))
1380 
                    cashbackArray.append(todict(userAppBatchDrillDown))
1381 
                resp.body = json.dumps({"UserAppCashBackInBatch":cashbackArray}, encoding='utf-8')
1382 
        finally:
1383 
            session.close()
16727 manish.sha 1384 
 
1385 
class AppUserBatchDateDrillDown():
1386 
    def on_get(self, req, resp, userId, date):
16887 kshitij.so 1387 
        try:
1388 
            userId = long(userId)
1389 
            date = str(date)
1390 
            date = datetime.strptime(date, '%Y-%m-%d')
1391 
            appUserBatchDateDrillDown = session.query(user_app_installs.app_name, func.sum(user_app_installs.installCount).label('downloads'), func.sum(user_app_installs.payoutAmount).label('amount')).filter(user_app_installs.user_id==userId).filter(user_app_installs.transaction_date==date).group_by(user_app_installs.app_name).all()
1392 
            cashbackArray = []
1393 
            if appUserBatchDateDrillDown is None or len(appUserBatchDateDrillDown)==0:
1394 
                resp.body = json.dumps("{}")
1395 
            else:
1396 
                for appcashBack in appUserBatchDateDrillDown:
1397 
                    userAppBatchDateDrillDown = UserAppBatchDateDrillDown(str(appcashBack[0]),long(appcashBack[1]),long(appcashBack[2]))
1398 
                    cashbackArray.append(todict(userAppBatchDateDrillDown))
1399 
                resp.body = json.dumps({"UserAppCashBackDateWise":cashbackArray}, encoding='utf-8')
1400 
        finally:
1401 
            session.close()
16739 manish.sha 1402 
 
16748 manish.sha 1403 
class AppUserCashBack():
1404 
    def on_get(self, req, resp, userId, status):
16887 kshitij.so 1405 
        try:
1406 
            userId = long(userId)
1407 
            status = str(status)
1408 
            appUserApprovedCashBacks = user_app_cashbacks.query.filter(user_app_cashbacks.user_id==userId).filter(user_app_cashbacks.status==status).all()
1409 
            cashbackArray = []
1410 
            if appUserApprovedCashBacks is None or len(appUserApprovedCashBacks)==0:
1411 
                resp.body = json.dumps("{}")
1412 
            else:
1413 
                totalAmount = 0
1414 
                for appUserApprovedCashBack in appUserApprovedCashBacks:
1415 
                    totalAmount = totalAmount + appUserApprovedCashBack.amount
16895 manish.sha 1416 
                    if appUserApprovedCashBack.creditedDate is not None:
1417 
                        appUserApprovedCashBack.creditedDate = str(appUserApprovedCashBack.creditedDate)
16905 manish.sha 1418 
                    cashbackArray.append(todict(appUserApprovedCashBack))
1419 
 
16887 kshitij.so 1420 
                resp.body = json.dumps({"UserAppCashBack":cashbackArray,"TotalAmount":totalAmount}, encoding='utf-8')
1421 
        finally:
1422 
            session.close()
17278 naman 1423 
 
1424 
class GetSaleDetail():
1425 
    def on_get(self,req,res,date_val):
1426 
        try:
1427 
                db = get_mongo_connection()
1428 
                sum=0
1429 
                count=0
1430 
                #print date_val, type(date_val)
1431 
                #cursor = db.Dtr.merchantOrder.find({'createdOnInt':{'$lt':long(date_val)},'subOrders':{'$exists':True}})
17315 naman 1432 
                cursor = db.Dtr.merchantOrder.find({"$and": [ { "createdOnInt":{"$gt":long(date_val)} }, {"createdOnInt":{"$lt":long(date_val)+86401} } ],"subOrders":{"$exists":True}})
17278 naman 1433 
 
1434 
                for document in cursor:
1435 
                    for doc in document['subOrders']:
1436 
                        sum = sum + float(doc['amountPaid'])
1437 
                        count = count + int(doc['quantity'])
1438 
 
1439 
                data = {"amount":sum , "quantity":count}
1440 
 
1441 
                res.body= json.dumps(data,encoding='utf-8')
1442 
        finally:
1443 
                session.close()
1444 
 
17301 kshitij.so 1445 
class DummyDeals():
17304 kshitij.so 1446 
    def on_get(self,req, resp):
17301 kshitij.so 1447 
        categoryId = req.get_param_as_int("categoryId")
1448 
        offset = req.get_param_as_int("offset")
1449 
        limit = req.get_param_as_int("limit")
1450 
        result = Mongo.getDummyDeals(categoryId, offset, limit)
17556 kshitij.so 1451 
        resp.body = dumps(result)
17301 kshitij.so 1452 
 
17467 manas 1453 
class PincodeValidation():
17498 amit.gupta 1454 
    def on_get(self,req,resp,pincode):
17467 manas 1455 
        json_data={}
1456 
        cities=[]
1457 
        print pincode
1458 
        if len(str(pincode)) ==6:
19391 amit.gupta 1459 
            listCities = list(session.query(Postoffices.taluk,Postoffices.state).distinct().filter(Postoffices.pincode==pincode).all())
17467 manas 1460 
            if len(listCities)>0:
1461 
                for j in listCities:
19391 amit.gupta 1462 
                    if j.taluk != 'NA':
1463 
                        cities.append(j.taluk)
17467 manas 1464 
                json_data['cities'] = cities
1465 
                json_data['state'] = listCities[0][1]
1466 
                resp.body =  json.dumps(json_data)
1467 
            else:
1468 
                resp.body = json.dumps("{}")
1469 
        else:
1470 
            resp.body = json.dumps("{}")
1471 
        session.close()
17301 kshitij.so 1472 
 
17556 kshitij.so 1473 
class SearchDummyDeals():
1474 
    def on_get(self,req,resp):
1475 
        offset = req.get_param_as_int("offset")
1476 
        limit = req.get_param_as_int("limit")
1477 
        searchTerm = req.get_param("searchTerm")
1478 
        result = Mongo.searchDummyDeals(searchTerm, limit, offset)
1479 
        resp.body = dumps(result)
1480 
 
1481 
class DummyPricing:
17560 kshitij.so 1482 
    def on_get(self, req, resp):
17556 kshitij.so 1483 
        skuBundleId = req.get_param_as_int("skuBundleId")
1484 
        result = Mongo.getDummyPricing(skuBundleId)
1485 
        resp.body = dumps(result)
1486 
 
1487 
class DealObject:
17560 kshitij.so 1488 
    def on_post(self, req, resp):
17569 kshitij.so 1489 
        update = req.get_param_as_int("update")
17556 kshitij.so 1490 
        try:
1491 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
1492 
        except ValueError:
1493 
            raise falcon.HTTPError(falcon.HTTP_400,
1494 
                'Malformed JSON',
1495 
                'Could not decode the request body. The '
1496 
                'JSON was incorrect.')
17569 kshitij.so 1497 
        if update is None:
1498 
            result = Mongo.addDealObject(result_json)
1499 
        else:
1500 
            result = Mongo.updateDealObject(result_json)
1501 
 
17556 kshitij.so 1502 
        resp.body = dumps(result)
17569 kshitij.so 1503 
 
17556 kshitij.so 1504 
 
17560 kshitij.so 1505 
    def on_get(self, req, resp):
17567 kshitij.so 1506 
        edit = req.get_param_as_int("edit")
1507 
        if edit is None:
1508 
            offset = req.get_param_as_int("offset")
1509 
            limit = req.get_param_as_int("limit")
17560 kshitij.so 1510 
 
17567 kshitij.so 1511 
            result = Mongo.getAllDealObjects(offset, limit)
1512 
            resp.body = dumps(result)
1513 
        else:
1514 
            id = req.get_param_as_int("id")
1515 
            result = Mongo.getDealObjectById(id)
1516 
            resp.body = dumps(result)
17560 kshitij.so 1517 
 
17563 kshitij.so 1518 
class DeleteDealObject:
1519 
    def on_get(self, req, resp, id):
1520 
        result = Mongo.deleteDealObject(int(id))
1521 
        resp.body = dumps(result)
1522 
 
17611 kshitij.so 1523 
class FeaturedDealObject:
1524 
    def on_get(self, req, resp):
1525 
 
1526 
        offset = req.get_param_as_int("offset")
1527 
        limit = req.get_param_as_int("limit")
1528 
 
1529 
        result = Mongo.getAllFeaturedDealsForDealObject(offset, limit)
1530 
        resp.body = dumps(result)
1531 
 
17556 kshitij.so 1532 
 
17611 kshitij.so 1533 
    def on_post(self, req, resp):
1534 
 
1535 
 
1536 
        try:
1537 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
1538 
        except ValueError:
1539 
            raise falcon.HTTPError(falcon.HTTP_400,
1540 
                'Malformed JSON',
1541 
                'Could not decode the request body. The '
1542 
                'JSON was incorrect.')
1543 
 
17613 kshitij.so 1544 
        result = Mongo.addFeaturedDealForDealObject(result_json)
17611 kshitij.so 1545 
        resp.body = json.dumps(result, encoding='utf-8')
1546 
 
17615 kshitij.so 1547 
class DeleteFeaturedDealObject:
1548 
    def on_get(self, req, resp, id):
1549 
        result = Mongo.deleteFeaturedDealObject(int(id))
1550 
        resp.body = dumps(result)
17611 kshitij.so 1551 
 
17653 kshitij.so 1552 
class SubCategoryFilter:
1553 
    def on_get(self, req, resp):
1554 
        category_id = req.get_param_as_int("category_id")
1555 
        result = Mongo.getSubCategoryForFilter(category_id)
1556 
        resp.body = dumps(result)
1557 
 
17726 kshitij.so 1558 
class DummyLogin:
1559 
    def on_post(self,req,resp):
1560 
        try:
1561 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
1562 
        except ValueError:
1563 
            raise falcon.HTTPError(falcon.HTTP_400,
1564 
                'Malformed JSON',
1565 
                'Could not decode the request body. The '
1566 
                'JSON was incorrect.')
1567 
 
1568 
        result = Mongo.dummyLogin(result_json)
1569 
        resp.body = json.dumps(result, encoding='utf-8')
17653 kshitij.so 1570 
 
17726 kshitij.so 1571 
class DummyRegister:
1572 
    def on_post(self,req,resp):
1573 
        try:
1574 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
1575 
        except ValueError:
1576 
            raise falcon.HTTPError(falcon.HTTP_400,
1577 
                'Malformed JSON',
1578 
                'Could not decode the request body. The '
1579 
                'JSON was incorrect.')
1580 
 
1581 
        result = Mongo.dummyRegister(result_json)
1582 
        resp.body = json.dumps(result, encoding='utf-8')
1583 
 
18896 amit.gupta 1584 
class TinSearch:
1585 
    def on_get(self,req,resp):
1586 
        tin = req.get_param("tin")
1587 
        result = getTinInfo(tin)
1588 
        resp.body = json.dumps(result, encoding='utf-8')
1589 
 
1590 
 
1591 
def getTinInfo(tin):
18905 amit.gupta 1592 
    tinInfo = {"isError":False}
18896 amit.gupta 1593 
    try:
18902 amit.gupta 1594 
        params = ['tin','cst','counter_name','counter_address','state','pan','registered_on','cst_status','valid_since']
18896 amit.gupta 1595 
        url  = "http://www.tinxsys.com/TinxsysInternetWeb/dealerControllerServlet?tinNumber=" + tin + "&searchBy=TIN"
1596 
        req = urllib2.Request(url)
18995 amit.gupta 1597 
        try:
1598 
            connection = urllib2.urlopen(req, timeout=10)
1599 
        except:
1600 
            tinInfo = {"isError":True,
1601 
                    "errorMsg": "Some problem occurred. Try again after some time"
1602 
            }
18996 amit.gupta 1603 
            return tinInfo
18896 amit.gupta 1604 
        pageHtml = connection.read()
1605 
        connection.close()
1606 
        doc = pq(pageHtml)
1607 
        index=-1
1608 
        for ele in pq(doc.find('table')[2])('tr td:nth-child(2)'):
1609 
            index += 1
1610 
            text = pq(ele).text().strip()
1611 
            if not text:
1612 
                text = pq(ele)('div').text().strip()
1613 
            tinInfo[params[index]] = text
18901 amit.gupta 1614 
        print index, "index"
1615 
        if index != 8:
18896 amit.gupta 1616 
            raise
19000 amit.gupta 1617 
        if not get_mongo_connection().Dtr.tin.find({"tin":tinInfo['tin']}):
1618 
            get_mongo_connection().Dtr.tin.insert(tinInfo)
18932 amit.gupta 1619 
        address = tinInfo['counter_address']
1620 
        m = re.match(".*?(\d{6}).*?", address)
1621 
        if m:
1622 
            tinInfo['pin'] = m.group(1)
18936 amit.gupta 1623 
            tinInfo['pin_required'] = False
18932 amit.gupta 1624 
        else:
18936 amit.gupta 1625 
            tinInfo['pin_required'] = True
18932 amit.gupta 1626 
 
18896 amit.gupta 1627 
        print "TinNumber: Successfully fetched details", tin
1628 
    except:
18901 amit.gupta 1629 
        traceback.print_exc()
18896 amit.gupta 1630 
        tinInfo = {"isError":True,
1631 
                    "errorMsg": "Could not find tin"
1632 
        }
1633 
        print "TinNumber: Problem fetching details", tin
1634 
    return tinInfo
1635 
 
1636 
 
17730 kshitij.so 1637 
class UpdateUser:
1638 
    def on_post(self,req,resp):
1639 
        try:
1640 
            result_json = json.loads(req.stream.read(), encoding='utf-8')
1641 
        except ValueError:
1642 
            raise falcon.HTTPError(falcon.HTTP_400,
1643 
                'Malformed JSON',
1644 
                'Could not decode the request body. The '
1645 
                'JSON was incorrect.')
1646 
 
1647 
        result = Mongo.updateDummyUser(result_json)
1648 
        resp.body = json.dumps(result, encoding='utf-8')
1649 
 
1650 
class FetchUser:
1651 
    def on_get(self,req,resp):
1652 
        user_id = req.get_param_as_int("user_id")
1653 
        result = Mongo.getDummyUser(user_id)
1654 
        resp.body = json.dumps(result, encoding='utf-8')
17928 kshitij.so 1655 
 
1656 
class SearchSubCategory:
1657 
    def on_get(self,req, resp):
18088 kshitij.so 1658 
        subCategoryIds = req.get_param("subCategoryId")
17928 kshitij.so 1659 
        searchTerm = req.get_param("searchTerm")
1660 
        offset = req.get_param_as_int("offset")
1661 
        limit = req.get_param_as_int("limit")
17730 kshitij.so 1662 
 
18088 kshitij.so 1663 
        result = Mongo.getDealsForSearchText(subCategoryIds, searchTerm,offset, limit)
17928 kshitij.so 1664 
        resp.body = json.dumps(result, encoding='utf-8')
1665 
 
1666 
class SearchSubCategoryCount:
1667 
    def on_get(self,req, resp):
18088 kshitij.so 1668 
        subCategoryIds = req.get_param("subCategoryId")
17928 kshitij.so 1669 
        searchTerm = req.get_param("searchTerm")
18088 kshitij.so 1670 
        result = Mongo.getCountForSearchText(subCategoryIds, searchTerm)
17928 kshitij.so 1671 
        resp.body = json.dumps(result, encoding='utf-8')
18090 manas 1672 
 
1673 
class MessageEncryption:
1674 
 
1675 
    def on_get(self,req,resp):
1676 
        message_type = req.get_param("type")
18093 manas 1677 
        if message_type == 'encrypt':
18090 manas 1678 
            encryption_data = req.get_param("data")
18101 manas 1679 
            encrypted_data = encryptMessage(base64.decodestring(encryption_data))
18090 manas 1680 
            resp.body =  json.dumps({"result":{"value":encrypted_data}}, encoding='utf-8')
1681 
 
18093 manas 1682 
        elif message_type == 'decrypt':
18090 manas 1683 
            decryption_data = req.get_param("data")
1684 
            decrypted_data = decryptMessage(decryption_data)
1685 
            resp.body =  json.dumps({"result":{"value":decrypted_data}}, encoding='utf-8')
1686 
 
1687 
        else:
1688 
            resp.body = json.dumps({}, encoding='utf-8')
18256 manas 1689 
 
1690 
class GetUserCrmApplication:
19442 manas 1691 
 
18256 manas 1692 
    def on_get(self,req,resp):
18329 manas 1693 
        global USER_DETAIL_MAP
18256 manas 1694 
        project_name = req.get_param("project_name")
18329 manas 1695 
        USER_DETAIL_MAP[project_name]+=1
18386 manas 1696 
        lgr.info( "USER_DETAIL_CALL_COUNTER " +  str(USER_DETAIL_MAP[project_name]))
18329 manas 1697 
        retryFlag=False
1698 
        if USER_DETAIL_MAP[project_name] % TOTAL_USER >= USER_CRM_DEFAULT_FRESH_FACTOR:
1699 
                retryFlag=True
1700 
        if project_name == 'accs_cart':
18792 manas 1701 
            project_id=1
1702 
        elif project_name == 'accs_active':
1703 
            project_id=2
1704 
        elif project_name == 'accs_order':
1705 
            project_id=3
19442 manas 1706 
        elif project_name == 'accs_cashback_scheme':
1707 
            project_id=4
18792 manas 1708 
        if retryFlag:
1709 
            user = self.getRetryUser(project_id)
1710 
        else:
1711 
            user = self.getNewUser(project_id)
1712 
 
1713 
        if user is None:
1714 
            resp.body ={}
1715 
        else:
1716 
            user.status =  'assigned'
1717 
            user.agent_id = req.get_param("agent_id")
1718 
            user.counter=1
1719 
            user.modified = datetime.now()
1720 
            session.commit()
1721 
            resp.body = json.dumps(todict(getUserObject(user)), encoding='utf-8')
1722 
            session.close()
18620 manas 1723 
 
18329 manas 1724 
    def getRetryUser(self,projectId,failback=True):
1725 
        status = "retry"
18367 manas 1726 
        user = session.query(UserCrmCallingData).filter_by(status=status,project_id=projectId).filter(UserCrmCallingData.next_call_time<=datetime.now()).filter(~(UserCrmCallingData.contact1).like('')).order_by(UserCrmCallingData.next_call_time).with_lockmode("update").first()
18329 manas 1727 
 
1728 
        if user is not None:
18334 manas 1729 
            lgr.info( "getRetryUser " + str(user.id))
18329 manas 1730 
        else:
1731 
            if failback:
18334 manas 1732 
                user = self.getNewUser(projectId,False)
18329 manas 1733 
                return user
1734 
            else:
1735 
                return None
1736 
        return user
18291 manas 1737 
 
18329 manas 1738 
 
18331 manas 1739 
    def getNewUser(self,projectId,failback=True):
18329 manas 1740 
            user = None
1741 
            try:
18416 manas 1742 
                user = session.query(UserCrmCallingData).filter_by(project_id=projectId).filter(UserCrmCallingData.status=='new').filter(UserCrmCallingData.pincode_servicable==True).filter(UserCrmCallingData.user_available==0).filter(UserCrmCallingData.contact1!=None).filter(~(UserCrmCallingData.contact1).like('')).order_by(UserCrmCallingData.next_call_time).order_by(UserCrmCallingData.id).with_lockmode("update").first()
18334 manas 1743 
                if user is None:
1744 
                    insertUserCrmData(projectId)
18416 manas 1745 
                    user = session.query(UserCrmCallingData).filter_by(project_id=projectId).filter(UserCrmCallingData.status=='new').filter(UserCrmCallingData.pincode_servicable==True).filter(~(UserCrmCallingData.contact1).like('')).filter(UserCrmCallingData.user_available==0).filter(UserCrmCallingData.contact1!=None).order_by(UserCrmCallingData.next_call_time).order_by(UserCrmCallingData.id).with_lockmode("update").first()
18334 manas 1746 
                    if user is not None:
1747 
                        lgr.info( "getNewUser " + str(user.id))
1748 
                    else:
1749 
                        if failback:
1750 
                            user = self.getRetryUser(projectId,False)
1751 
                            return user
1752 
                        else:
1753 
                            return None
18329 manas 1754 
            except:
1755 
                print traceback.print_exc()
1756 
            return user
18386 manas 1757 
 
18291 manas 1758 
    def on_post(self, req, resp):
1759 
        returned = False
1760 
        self.agentId = req.get_param("agent_id")
1761 
        project_name = req.get_param("project_name")
18637 manas 1762 
 
18329 manas 1763 
        if project_name == 'accs_cart':
18637 manas 1764 
            project_id=1
1765 
        elif project_name == 'accs_active':
1766 
            project_id=2
1767 
        elif project_name == 'accs_order':
1768 
            project_id=3
19442 manas 1769 
        elif project_name == 'accs_cashback_scheme':
1770 
            project_id=4
1771 
 
18637 manas 1772 
        jsonReq = json.loads(req.stream.read(), encoding='utf-8')
1773 
        lgr.info( "Request ----\n"  + str(jsonReq))
1774 
        self.jsonReq = jsonReq
1775 
        self.callType="default"
1776 
        callLaterAccs = self.callLaterAccs
1777 
        accsDisposition = self.accsDisposition
1778 
        accsOrderDisposition=self.accsOrderDisposition
1779 
        self.userId = int(jsonReq.get('user_id'))
1780 
        try:
1781 
            self.user = session.query(UserCrmCallingData).filter_by(user_id=self.userId).filter(UserCrmCallingData.project_id==project_id).first()
1782 
            self.callDisposition = jsonReq.get('calldispositiontype')
1783 
            self.callHistoryCrm = CallHistoryCrm()
1784 
            self.callHistoryCrm.agent_id=self.agentId
1785 
            self.callHistoryCrm.project_id = project_id
1786 
            self.callHistoryCrm.call_disposition = self.callDisposition
1787 
            self.callHistoryCrm.user_id=self.userId
1788 
            self.callHistoryCrm.duration_sec = int(jsonReq.get("callduration"))
1789 
            self.callHistoryCrm.disposition_comments = jsonReq.get('calldispositioncomments')
1790 
            self.callHistoryCrm.call_time = datetime.strptime(jsonReq.get("calltime"), '%d/%m/%Y %H:%M:%S')
1791 
            self.callHistoryCrm.mobile_number = jsonReq.get('number')
1792 
            self.inputs = jsonReq.get("inputs")
1793 
            dispositionMap = {  'call_later':callLaterAccs,
1794 
                        'ringing_no_answer':callLaterAccs,
1795 
                        'not_reachable':callLaterAccs,
1796 
                        'switch_off':callLaterAccs,
1797 
                        'technical_issue':accsDisposition,
1798 
                        'pricing_issue':accsDisposition,
1799 
                        'shipping_issue':accsDisposition,
1800 
                        'internet_issue':accsDisposition,
1801 
                        'checking_price':accsDisposition,
1802 
                        'order_process':accsDisposition,
1803 
                        'placed_order':accsDisposition,
1804 
                        'place_order':accsDisposition,
1805 
                        'product_availability':accsOrderDisposition,
1806 
                        'return_replacement':accsOrderDisposition,
1807 
                        'already_purchased':accsOrderDisposition,
1808 
                        'product_quality_issue':accsOrderDisposition,
1809 
                        'delayed_delivery':accsOrderDisposition,
18671 manas 1810 
                        'other_complaint':accsOrderDisposition,
19442 manas 1811 
                        'scheme_not_clear':accsOrderDisposition,
18671 manas 1812 
                        'not_dealing_accessories':accsOrderDisposition
18637 manas 1813 
                      }
1814 
            returned = dispositionMap[jsonReq.get('calldispositiontype')]()
1815 
        finally:
1816 
            session.close()
1817 
 
1818 
        if returned:
1819 
            resp.body = "{\"result\":\"success\"}"
1820 
        else:
1821 
            resp.body = "{\"result\":\"failed\"}"
1822 
 
18628 manas 1823 
    def accsOrderDisposition(self):
1824 
        self.user.status='done'
1825 
        self.user.user_available = 1
1826 
        self.user.disposition=self.callDisposition
1827 
        self.user.modified = datetime.now()
18712 manas 1828 
        a = CrmTicketDtr()
18628 manas 1829 
        if self.callDisposition == 'product_availability':
1830 
            self.callHistoryCrm.disposition_description='Product Not available'
1831 
        elif self.callDisposition == 'return_replacement':
1832 
            self.callHistoryCrm.disposition_description='Return or replacement pending'
18923 manas 1833 
            #utils.sendCrmProjectMail(self.userId,self.callHistoryCrm.disposition_description,self.callHistoryCrm.disposition_comments)
18713 manas 1834 
            a.addTicket(self.userId, self.callHistoryCrm.disposition_description, self.callHistoryCrm.disposition_comments)
18628 manas 1835 
        elif self.callDisposition == 'already_purchased':
1836 
            self.callHistoryCrm.disposition_description='Already purchased required stock'
19442 manas 1837 
        elif self.callDisposition == 'scheme_not_clear':
1838 
            self.callHistoryCrm.disposition_description='Scheme Not Clear to the User'
18628 manas 1839 
        elif self.callDisposition == 'product_quality_issue':
1840 
            self.callHistoryCrm.disposition_description='Product Quality issue'
18923 manas 1841 
            #utils.sendCrmProjectMail(self.userId,self.callHistoryCrm.disposition_description,self.callHistoryCrm.disposition_comments)
18713 manas 1842 
            a.addTicket(self.userId, self.callHistoryCrm.disposition_description, self.callHistoryCrm.disposition_comments)
18628 manas 1843 
        elif self.callDisposition == 'delayed_delivery':
18637 manas 1844 
            self.callHistoryCrm.disposition_description='Delayed Delivery'
18923 manas 1845 
            #utils.sendCrmProjectMail(self.userId,self.callHistoryCrm.disposition_description,self.callHistoryCrm.disposition_comments)
18713 manas 1846 
            a.addTicket(self.userId, self.callHistoryCrm.disposition_description, self.callHistoryCrm.disposition_comments)
18628 manas 1847 
        elif self.callDisposition == 'other_complaint':
18637 manas 1848 
            self.callHistoryCrm.disposition_description='Other complaint with profitmandi'
18923 manas 1849 
            #utils.sendCrmProjectMail(self.userId,self.callHistoryCrm.disposition_description,self.callHistoryCrm.disposition_comments)
18713 manas 1850 
            a.addTicket(self.userId, self.callHistoryCrm.disposition_description, self.callHistoryCrm.disposition_comments)
18671 manas 1851 
        elif self.callDisposition == 'not_dealing_accessories':
1852 
            self.callHistoryCrm.disposition_description='Not Dealing in Accessories/Not Interested'
18628 manas 1853 
        session.commit()
1854 
        jdata = self.inputs
1855 
        jdata = json.loads(jdata)
1856 
        if jdata:
1857 
            for d in jdata:
1858 
                for key, value in d.iteritems():
1859 
                    productpricingInputs = ProductPricingInputs()
1860 
                    productpricingInputs.user_id = self.callHistoryCrm.user_id
1861 
                    productpricingInputs.agent_id = self.callHistoryCrm.agent_id
1862 
                    productpricingInputs.disposition_id = self.callHistoryCrm.id
1863 
                    productpricingInputs.user_id = self.callHistoryCrm.user_id
1864 
                    productpricingInputs.call_disposition = self.callHistoryCrm.call_disposition
1865 
                    productpricingInputs.project_id = self.callHistoryCrm.project_id
1866 
                    productpricingInputs.product_input = key
1867 
                    productpricingInputs.pricing_input = value
1868 
            session.commit()
1869 
        return True
1870 
 
18291 manas 1871 
    def accsDisposition(self):
1872 
        self.user.status='done'
1873 
        self.user.user_available = 1
1874 
        self.user.disposition=self.callDisposition
1875 
        self.user.modified = datetime.now()
1876 
        if self.callDisposition == 'technical_issue':
1877 
            self.callHistoryCrm.disposition_description='Technical issue at Profitmandi'
18923 manas 1878 
            #utils.sendCrmProjectMail(self.userId,self.callHistoryCrm.disposition_description,self.callHistoryCrm.disposition_comments)
18716 manas 1879 
            a = CrmTicketDtr()
1880 
            a.addTicket(self.userId, self.callHistoryCrm.disposition_description, self.callHistoryCrm.disposition_comments)
18291 manas 1881 
        elif self.callDisposition == 'pricing_issue':
1882 
            self.callHistoryCrm.disposition_description='Pricing Issue(High)'
1883 
        elif self.callDisposition == 'shipping_issue':
1884 
            self.callHistoryCrm.disposition_description='Shipping charges related issue'
1885 
        elif self.callDisposition == 'internet_issue':
1886 
            self.callHistoryCrm.disposition_description='Internet issue at user end'
1887 
        elif self.callDisposition == 'checking_price':
1888 
            self.callHistoryCrm.disposition_description='Checking price'
1889 
        elif self.callDisposition == 'order_process':
1890 
            self.callHistoryCrm.disposition_description='Order Process inquery'
1891 
        elif self.callDisposition == 'placed_order':
1892 
            self.callHistoryCrm.disposition_description='Placed Order from Different Account'
1893 
        elif self.callDisposition == 'place_order':
1894 
            self.callHistoryCrm.disposition_description='Will Place Order'
1895 
        session.commit()
18360 manas 1896 
        jdata = self.inputs
18361 manas 1897 
        jdata = json.loads(jdata)
18350 manas 1898 
        if jdata:
1899 
            for d in jdata:
18360 manas 1900 
                for key, value in d.iteritems():
18350 manas 1901 
                    productpricingInputs = ProductPricingInputs()
1902 
                    productpricingInputs.user_id = self.callHistoryCrm.user_id
1903 
                    productpricingInputs.agent_id = self.callHistoryCrm.agent_id
1904 
                    productpricingInputs.disposition_id = self.callHistoryCrm.id
1905 
                    productpricingInputs.user_id = self.callHistoryCrm.user_id
1906 
                    productpricingInputs.call_disposition = self.callHistoryCrm.call_disposition
1907 
                    productpricingInputs.project_id = self.callHistoryCrm.project_id
1908 
                    productpricingInputs.product_input = key
1909 
                    productpricingInputs.pricing_input = value
1910 
            session.commit()
18291 manas 1911 
        return True
1912 
 
1913 
    def callLaterAccs(self):
18329 manas 1914 
        self.user.status='retry'
1915 
        self.user.modified = datetime.now()
18291 manas 1916 
        if self.callDisposition == 'call_later':
18310 manas 1917 
            if self.callHistoryCrm.disposition_comments is not None:
18321 manas 1918 
                self.user.next_call_time = datetime.strptime(self.callHistoryCrm.disposition_comments, '%d/%m/%Y %H:%M:%S')
18310 manas 1919 
                self.callHistoryCrm.disposition_description = 'User requested to call'
1920 
                self.callHistoryCrm.disposition_comments = self.callHistoryCrm.disposition_comments
18291 manas 1921 
            else:
1922 
                self.user.next_call_time = self.callHistoryCrm.call_time + timedelta(days=1)
18310 manas 1923 
                self.callHistoryCrm.disposition_description = 'Call Scheduled'
1924 
                self.callHistoryCrm.disposition_comments = datetime.strftime(self.user.next_call_time, '%d/%m/%Y %H:%M:%S')
18291 manas 1925 
        else:
18310 manas 1926 
            self.callHistoryCrm.disposition_description = 'User was not contactable'
18291 manas 1927 
            if self.callDisposition == 'ringing_no_answer':
1928 
                if self.user.disposition == 'ringing_no_answer':
1929 
                    self.user.retry_count += 1
1930 
                else:
1931 
                    self.user.disposition = 'ringing_no_answer'
1932 
                    self.user.retry_count = 1
1933 
            else:
1934 
                if self.user.disposition == 'ringing_no_answer':
1935 
                    pass
1936 
                else:
1937 
                    self.user.disposition = 'not_reachable'
1938 
                self.user.retry_count += 1
1939 
                self.user.invalid_retry_count += 1
1940 
 
18306 manas 1941 
            retryConfig = session.query(RetryConfig).filter_by(call_type=self.callType, disposition_type=self.user.disposition, retry_count=self.user.retry_count).first()
1942 
            if retryConfig is not None:
1943 
                self.user.next_call_time = self.callHistoryCrm.call_time + timedelta(minutes = retryConfig.minutes_ahead)
1944 
                self.callHistoryCrm.disposition_description = 'Call scheduled on ' + datetime.strftime(self.user.next_call_time, '%d/%m/%Y %H:%M:%S')
1945 
            else:
1946 
                self.user.status = 'failed'
18335 manas 1947 
                self.user.user_available=1
18306 manas 1948 
                self.callHistoryCrm.disposition_description = 'Call failed as all attempts exhausted'
18329 manas 1949 
        self.user.disposition=self.callDisposition
18291 manas 1950 
        session.commit()
18347 manas 1951 
        jdata =self.inputs
18361 manas 1952 
        jdata = json.loads(jdata)
18350 manas 1953 
        if jdata:
1954 
            for d in jdata:
18360 manas 1955 
                for key, value in d.iteritems():
18350 manas 1956 
                    productpricingInputs = ProductPricingInputs()
1957 
                    productpricingInputs.user_id = self.callHistoryCrm.user_id
1958 
                    productpricingInputs.agent_id = self.callHistoryCrm.agent_id
1959 
                    productpricingInputs.disposition_id = self.callHistoryCrm.id
1960 
                    productpricingInputs.user_id = self.callHistoryCrm.user_id
1961 
                    productpricingInputs.call_disposition = self.callHistoryCrm.call_disposition
1962 
                    productpricingInputs.project_id = self.callHistoryCrm.project_id
1963 
                    productpricingInputs.product_input = key
1964 
                    productpricingInputs.pricing_input = value
1965 
            session.commit()
18291 manas 1966 
        return True
1967 
 
18266 manas 1968 
def insertUserCrmData(project_id):
1969 
    if project_id==1:
1970 
        getCartDetailsUser()
18386 manas 1971 
    if project_id==2:
1972 
        getCartTabsUser()
18620 manas 1973 
    if project_id==3:
1974 
        getAccsRepeatUsers(project_id)
19442 manas 1975 
    if project_id==4:
1976 
        getAccsSchemeCashback(project_id)
1977 
 
1978 
def getAccsSchemeCashback(project_id):
1979 
    userMasterMap={}
1980 
    skipUserList=[]
19444 manas 1981 
    query = "select id from users where lower(referrer) in ('emp01','emp99','emp88')"
19442 manas 1982 
    skipUsersresult = fetchResult(query)
1983 
    for skipUser in skipUsersresult:
1984 
        skipUserList.append(skipUser[0])
1985 
    queryFilter = {"user_id":{"$nin":skipUserList}}
1986 
    result = get_mongo_connection().Catalog.PromoOffer.find(queryFilter)
1987 
    userMasterList =[]
1988 
    for r in result:
1989 
        userMasterList.append(r.get('user_id'))
1990 
    queryfilter ={"url":{"$regex" : "http://api.profittill.com/categories/target"}}
1991 
    result = get_mongo_connection_dtr_data().User.browsinghistories.find(queryfilter).distinct('user_id')
1992 
    userSeenList=[]
1993 
    for r in result:
1994 
        userSeenList.append(r)
1995 
    finalUserList  = list(set(userMasterList) - set(userSeenList))
1996 
    queryFilter = {"user_id":{"$in":finalUserList}}
1997 
    result = get_mongo_connection().Catalog.PromoOffer.find(queryFilter)
1998 
    for r in result:
1999 
        userMasterMap[r.get('user_id')] = r.get('target2')
2000 
    d_sorted = sorted(zip(userMasterMap.values(), userMasterMap.keys()),reverse=True)
2001 
    counter=0
2002 
    for i in d_sorted:
2003 
        try:
2004 
            userId=i[1]
2005 
            if counter==20:
2006 
                break
2007 
            userPresent = session.query(UserCrmCallingData).filter_by(user_id=userId).order_by(desc(UserCrmCallingData.modified)).first()
2008 
            if userPresent is not None:
2009 
                if userPresent.user_available==1:
2010 
                    if userPresent.project_id==project_id:
2011 
                        continue
2012 
                    elif userPresent.modified.date()>=(datetime.now().date()-timedelta(days=30)):
2013 
                        continue
2014 
                else:
2015 
                    continue
2016 
            counter=counter+1
2017 
            userMasterData = UserCrmCallingData()
2018 
            userMasterData.user_id = userId
2019 
            userMasterData.name =getUsername(userId)
2020 
            userMasterData.project_id = project_id
2021 
            userMasterData.user_available=0
2022 
            userMasterData.contact1 = getUserContactDetails(userId)
2023 
            userMasterData.counter = 0
2024 
            userMasterData.retry_count=0
2025 
            userMasterData.invalid_retry_count=0
2026 
            userMasterData.created = datetime.now()
2027 
            userMasterData.modified = datetime.now()
2028 
            userMasterData.status = 'new'
2029 
            userMasterData.pincode_servicable = checkPincodeServicable(userId)
2030 
            session.commit()
2031 
        except:
2032 
            print traceback.print_exc()
2033 
        finally:
2034 
            session.close()
2035 
 
18620 manas 2036 
def getAccsRepeatUsers(project_id):
2037 
 
2038 
    usersMasterList=[]
2039 
    ACCS_ALL_ORDERS = "select distinct user_id from allorder where category in ('Accs','Accessories') and store_id='spice';"
2040 
    result = fetchResult(ACCS_ALL_ORDERS)
2041 
    for r in result:
2042 
        usersMasterList.append(r[0])
2043 
 
2044 
    ACCS_LAST_FIFTEEN_DAYS = "select distinct user_id from allorder where category in ('Accs','Accessories') and store_id='spice' and (date(created_on) between date(curdate() - interval 15 day) and date(curdate())) order by user_id;"
2045 
    result = fetchResult(ACCS_LAST_FIFTEEN_DAYS)
2046 
    for r in result:
2047 
        if r[0] in usersMasterList:
2048 
            usersMasterList.remove(r[0])
2049 
 
2050 
    PRIOPRITIZING_USER_QUERY = "select user_id from allorder where category in ('Accs','Accessories')and store_id ='spice' and user_id in (%s)" % ",".join(map(str,usersMasterList)) + "group by user_id order by sum(amount_paid) desc;"
2051 
    userFinalList=[]
2052 
    result = fetchResult(PRIOPRITIZING_USER_QUERY)
2053 
    for r in result:
2054 
        userFinalList.append(r[0])
2055 
 
2056 
    counter=0
2057 
    for i in userFinalList:
2058 
        try:
2059 
            userId=i
18628 manas 2060 
            if counter==20:
18620 manas 2061 
                break
2062 
            userPresent = session.query(UserCrmCallingData).filter_by(user_id=userId).order_by(desc(UserCrmCallingData.modified)).first()
2063 
            if userPresent is not None:
2064 
                if userPresent.user_available==1:
2065 
                    if userPresent.project_id==project_id:
2066 
                        if userPresent.modified.date()>=(datetime.now().date()-timedelta(days=30)):
2067 
                            continue
2068 
                        else:
2069 
                            pass
18792 manas 2070 
                    elif userPresent.modified.date()>=(datetime.now().date()-timedelta(days=30)):
18620 manas 2071 
                        continue
2072 
                else:
2073 
                    continue
2074 
            counter=counter+1
2075 
            userMasterData = UserCrmCallingData()
2076 
            userMasterData.user_id = userId
2077 
            userMasterData.name =getUsername(userId)
2078 
            userMasterData.project_id = project_id
2079 
            userMasterData.user_available=0
2080 
            userMasterData.contact1 = getUserContactDetails(userId)
2081 
            userMasterData.counter = 0
2082 
            userMasterData.retry_count=0
2083 
            userMasterData.invalid_retry_count=0
2084 
            userMasterData.created = datetime.now()
2085 
            userMasterData.modified = datetime.now()
2086 
            userMasterData.status = 'new'
2087 
            userMasterData.pincode_servicable = checkPincodeServicable(userId)
2088 
            session.commit()
2089 
        except:
2090 
            print traceback.print_exc()
2091 
        finally:
2092 
            session.close()
2093 
 
18256 manas 2094 
def getCartDetailsUser():
2095 
    userList=[]
2096 
    orderUserList=[]
18818 manas 2097 
    #userMasterMap={}
18256 manas 2098 
    queryfilter = {"$and":
2099 
                   [
18792 manas 2100 
                    {'created':{"$gte":(to_java_date(datetime.now())-3*86400000)}},
18256 manas 2101 
                    {'created':{"$lte":(to_java_date(datetime.now())- 43200000)}},
2102 
                    {"url":{"$regex" : "http://api.profittill.com/cartdetails"}}
2103 
                    ]
2104 
                   }
2105 
    result = get_mongo_connection_dtr_data().User.browsinghistories.find(queryfilter).distinct('user_id')
2106 
 
2107 
    for r in result:
2108 
        userList.append(r)
2109 
 
18301 manas 2110 
    myquery = "select a.user_id from allorder a join users u on a.user_id=u.id where a.store_id='spice' and (a.category='Accs' or a.category='Accessories') and u.referrer not like 'emp%%' and u.mobile_number IS NOT NULL and a.user_id in (%s)" % ",".join(map(str,userList)) + " UNION select id from users where lower(referrer) like 'emp%'"
2111 
 
18256 manas 2112 
    result = fetchResult(myquery)
2113 
    for r in result:
18301 manas 2114 
        orderUserList.append(r[0])
18256 manas 2115 
    finalUserList  = list(set(userList) - set(orderUserList))
2116 
 
18792 manas 2117 
    userCartIdMap={}
2118 
    fetchCartId = "select user_id,account_key from user_accounts where account_type='cartId' and user_id in (%s)" % ",".join(map(str,finalUserList))
2119 
    result = fetchResult(fetchCartId)
2120 
    for r in result:
18818 manas 2121 
        userCartIdMap[long(r[1])] = long(r[0])
18843 manas 2122 
    client = CatalogClient("catalog_service_server_host_prod","catalog_service_server_port").get_client()
18792 manas 2123 
    userMapReturned = client.getCartByValue(userCartIdMap.keys())
18818 manas 2124 
    userFinalList=[]
2125 
    for i in userMapReturned:
2126 
        userFinalList.append(userCartIdMap.get(i))
18792 manas 2127 
#     queryfilternew = {"$and":
2128 
#                    [
2129 
#                     {'user_id':{"$in":finalUserList}},
2130 
#                     {'created':{"$gte":(to_java_date(datetime.now())-2*86400000)}},
2131 
#                     {'created':{"$lte":(to_java_date(datetime.now())- 43200000)}},
2132 
#                     {"url":{"$regex" : "http://api.profittill.com/cartdetails"}}
2133 
#                     ]
2134 
#                    }
2135 
#     itemIds = list(get_mongo_connection_dtr_data().User.browsinghistories.find(queryfilternew))
2136 
#
2137 
#     for i in itemIds:
2138 
#         if(userMasterMap.has_key(i.get('user_id'))):
2139 
#             if userMasterMap.get(i.get('user_id')) > i.get('created'):
2140 
#                 userMasterMap[i.get('user_id')]=i.get('created')
2141 
#         else:
2142 
#             userMasterMap[i.get('user_id')]=i.get('created')
2143 
#
2144 
#     d_sorted = sorted(zip(userMasterMap.values(), userMasterMap.keys()))
18818 manas 2145 
    addUserToTable(userFinalList,1)
18256 manas 2146 
 
18301 manas 2147 
def addUserToTable(userList,projectId):
18266 manas 2148 
    counter=0
18301 manas 2149 
    for i in userList:
2150 
        try:
18792 manas 2151 
            userId=i
18412 manas 2152 
            if counter==20:
18301 manas 2153 
                break
2154 
            userPresent = session.query(UserCrmCallingData).filter_by(user_id=userId).order_by(desc(UserCrmCallingData.modified)).first()
2155 
            if userPresent is not None:
2156 
                if userPresent.user_available==1:
2157 
                    if userPresent.project_id==projectId:
2158 
                        continue
18792 manas 2159 
                    elif userPresent.modified.date()>=(datetime.now().date()-timedelta(days=30)):
18301 manas 2160 
                        continue
18306 manas 2161 
                else:
2162 
                    continue
18266 manas 2163 
            counter=counter+1
2164 
            userMasterData = UserCrmCallingData()
2165 
            userMasterData.user_id = userId
2166 
            userMasterData.name =getUsername(userId)
18301 manas 2167 
            userMasterData.project_id = projectId
18277 manas 2168 
            userMasterData.user_available=0
18266 manas 2169 
            userMasterData.contact1 = getUserContactDetails(userId)
2170 
            userMasterData.counter = 0
18318 manas 2171 
            userMasterData.retry_count=0
2172 
            userMasterData.invalid_retry_count=0
18266 manas 2173 
            userMasterData.created = datetime.now()
2174 
            userMasterData.modified = datetime.now()
2175 
            userMasterData.status = 'new'
2176 
            userMasterData.pincode_servicable = checkPincodeServicable(userId)
2177 
            session.commit()
18301 manas 2178 
        except:
2179 
            print traceback.print_exc()
2180 
        finally:
2181 
            session.close()
2182 
 
18256 manas 2183 
def getCartTabsUser():
18346 manas 2184 
    userMasterList=[]
2185 
    userList = []
18256 manas 2186 
    userMasterMap={}
2187 
    queryfilter = {"$and":
2188 
                   [
2189 
                    {'created':{"$gte":(to_java_date(datetime.now())-2*86400000)}},
2190 
                    {'created':{"$lte":(to_java_date(datetime.now())- 43200000)}},
2191 
                    {"url":{"$regex" : "http://api.profittill.com/category/6"}}
2192 
                    ]
2193 
                   }
2194 
    result = get_mongo_connection_dtr_data().User.browsinghistories.find(queryfilter).distinct('user_id')
2195 
 
2196 
    for r in result:
18346 manas 2197 
        userMasterList.append(r)
2198 
 
2199 
    queryfilterVisistedCart = {"$and":
2200 
                   [
18386 manas 2201 
                    {'user_id':{"$in":userMasterList}},
18346 manas 2202 
                    {"url":{"$regex" : "http://api.profittill.com/cartdetails"}}
2203 
                    ]
2204 
                  }
18386 manas 2205 
    result = get_mongo_connection_dtr_data().User.browsinghistories.find(queryfilterVisistedCart).distinct('user_id')
18346 manas 2206 
    for r in result:
18256 manas 2207 
        userList.append(r)
2208 
 
18416 manas 2209 
    myquery = "select user_id from allorder where store_id='spice' and (category='Accs' or category='Accessories') and user_id in (%s)" % ",".join(map(str,userMasterList)) + " UNION select id from users where lower(referrer) like 'emp%'"
18256 manas 2210 
 
2211 
    result = fetchResult(myquery)
2212 
    for r in result:
18346 manas 2213 
        if r[0] in userList:
2214 
            continue
2215 
        userList.append(r[0])
18386 manas 2216 
 
18346 manas 2217 
    finalUserList  = list(set(userMasterList) - set(userList))
18386 manas 2218 
 
18256 manas 2219 
    queryfilternew = {"$and":
2220 
                   [
2221 
                    {'user_id':{"$in":finalUserList}},
2222 
                    {'created':{"$gte":(to_java_date(datetime.now())-2*86400000)}},
2223 
                    {'created':{"$lte":(to_java_date(datetime.now())- 43200000)}},
2224 
                    {"url":{"$regex" : "http://api.profittill.com/category/6"}}
2225 
                    ]
2226 
                   }
2227 
    itemIds = list(get_mongo_connection_dtr_data().User.browsinghistories.find(queryfilternew))
2228 
 
2229 
    for i in itemIds:
2230 
        if(userMasterMap.has_key(i.get('user_id'))):
2231 
            if userMasterMap.get(i.get('user_id')) > i.get('created'):
2232 
                userMasterMap[i.get('user_id')]=i.get('created')
2233 
        else:
2234 
            userMasterMap[i.get('user_id')]=i.get('created')
2235 
 
2236 
    d_sorted = sorted(zip(userMasterMap.values(), userMasterMap.keys()))
18792 manas 2237 
    userFinalList=[]
2238 
    for i in d_sorted:
2239 
        userFinalList.append(i[1])
2240 
    addUserToTable(userFinalList,2)
18346 manas 2241 
 
18266 manas 2242 
def getUserContactDetails(userId):
18792 manas 2243 
    r = session.query(Users.mobile_number).filter_by(id=userId).first()
2244 
    if r is None:
2245 
        return None
2246 
    else:
2247 
        return r[0]
18712 manas 2248 
 
18266 manas 2249 
def getUsername(userId):
18792 manas 2250 
    r = session.query(Users.first_name).filter_by(id=userId).first()
2251 
    if r is None:
2252 
        return None
2253 
    else:
2254 
        return r[0]
2255 
 
18266 manas 2256 
def checkPincodeServicable(userId):
2257 
    checkAddressUser = "select distinct pincode from all_user_addresses where user_id= (%s)"
2258 
    result = fetchResult(checkAddressUser,userId)
2259 
    if len(result)==0:
2260 
        return True
2261 
    else:
2262 
        myquery = "select count(*) from (select distinct pincode from all_user_addresses where user_id= (%s))a join pincodeavailability p on a.pincode=p.code"
2263 
        result = fetchResult(myquery,userId)
2264 
        if result[0][0]==0:
2265 
            return False
2266 
        else:
2267 
            return True
2268 
 
2269 
def getUserObject(user):
2270 
    obj = Mock()
2271 
    obj.user_id = user.user_id
2272 
    result = fetchResult("select * from useractive where user_id=%d"%(user.user_id))
2273 
    if result == ():
2274 
        obj.last_active = None
2275 
    else:
2276 
        obj.last_active =datetime.strftime(result[0][1], '%d/%m/%Y %H:%M:%S')
18269 manas 2277 
    obj.name = user.name
18266 manas 2278 
    obj.contact = user.contact1
18275 manas 2279 
    obj.lastOrderTimestamp=None
18256 manas 2280 
 
18275 manas 2281 
    details = session.query(Orders).filter_by(user_id = user.user_id).filter(~Orders.status.in_(['ORDER_NOT_CREATED_KNOWN','ORDER_NOT_CREATED_UNKNOWN', 'ORDER_ALREADY_CREATED_IGNORED'])).order_by(desc(Orders.created)).first()
18266 manas 2282 
    if details is None:
18275 manas 2283 
        obj.lastOrderTimestamp =None
18266 manas 2284 
    else:
18366 manas 2285 
        obj.lastOrderTimestamp =datetime.strftime(details.created, '%d/%m/%Y %H:%M:%S')
18275 manas 2286 
    obj.totalOrders = session.query(Orders).filter_by(user_id = user.user_id).filter(~Orders.status.in_(['ORDER_NOT_CREATED_KNOWN','ORDER_NOT_CREATED_UNKNOWN', 'ORDER_ALREADY_CREATED_IGNORED'])).count()
18266 manas 2287 
 
18275 manas 2288 
    cartResult = fetchResult("select account_key from user_accounts where account_type ='cartId' and user_id=%d"%(user.user_id))
18266 manas 2289 
    if cartResult == ():
18268 manas 2290 
        obj.lastActiveCartTime = None
18266 manas 2291 
    else:
2292 
        conn = MySQLdb.connect("192.168.190.114", "root","shop2020", "user")
2293 
        cursor = conn.cursor()
18275 manas 2294 
        cursor.execute("select updated_on from cart where id=%s",(cartResult[0][0]))
18266 manas 2295 
        result = cursor.fetchall()
2296 
        if result ==():
18268 manas 2297 
            obj.lastActiveCartTime = None
18266 manas 2298 
        else:
2299 
            print result
18275 manas 2300 
            obj.lastActiveCartTime =datetime.strftime(result[0][0], '%d/%m/%Y %H:%M:%S')
18712 manas 2301 
        conn.close()
2302 
 
2303 
    session.close()
18266 manas 2304 
    return obj
2305 
 
18709 manas 2306 
class CrmTicketDtr():
2307 
    def on_post(self,req,resp):
18712 manas 2308 
        try:
2309 
            customerFeedbackBackMap = {}
2310 
            customerFeedbackBackMap['user_id']=req.get_param("user_id")
2311 
            user = session.query(Users).filter_by(id=customerFeedbackBackMap.get('user_id')).first()
2312 
            if user is not None:
2313 
                customerFeedbackBackMap['email']=user.email
2314 
                customerFeedbackBackMap['mobile_number']=user.mobile_number
2315 
                customerFeedbackBackMap['customer_name']=user.first_name + ' ' + user.last_name
2316 
                customerFeedbackBackMap['subject'] = req.get_param("subject")
2317 
                customerFeedbackBackMap['message'] = req.get_param("message")
2318 
                customerFeedbackBackMap['created'] = datetime.now()
2319 
                if utils.generateCrmTicket(customerFeedbackBackMap):
2320 
                    resp.body={"result":"success"}
2321 
                else:
2322 
                    resp.body={"result":"failure"}
18709 manas 2323 
            else:
18712 manas 2324 
                resp.body={"result":"failure"}
2325 
        except:
2326 
            print traceback.print_exc()
2327 
        finally:
2328 
            session.close()
18709 manas 2329 
    def addTicket(self,user_id,subject,message):
18712 manas 2330 
        try:
2331 
            customerFeedbackBackMap = {}
2332 
            customerFeedbackBackMap['user_id']=user_id
2333 
            user = session.query(Users).filter_by(id=user_id).first()
2334 
            if user is not None:
2335 
                customerFeedbackBackMap['email']=user.email
2336 
                customerFeedbackBackMap['mobile_number']=user.mobile_number
2337 
                customerFeedbackBackMap['customer_name']=user.first_name + ' ' + user.last_name
2338 
                customerFeedbackBackMap['subject'] = subject
2339 
                customerFeedbackBackMap['message'] = message
2340 
                customerFeedbackBackMap['created'] = datetime.now()
2341 
                utils.generateCrmTicket(customerFeedbackBackMap)
2342 
            else:
2343 
                print 'User is not present'
2344 
        except:
18926 manas 2345 
            print traceback.print_exc()
2346 
 
18272 kshitij.so 2347 
class UnitDeal():
2348 
    def on_get(self,req,resp, id):
2349 
        result = Mongo.getDealById(id)
2350 
        resp.body = dumps(result)
19290 kshitij.so 2351 
 
2352 
class SpecialOffer():
2353 
    def on_get(self,req,resp):
2354 
        user_id = req.get_param_as_int('user_id')
2355 
        result = Mongo.getOfferForUser(user_id)
2356 
        resp.body = dumps(result)
19388 kshitij.so 2357 
 
2358 
class BrandSubCatFilter():
2359 
    def on_get(self, req, resp):
2360 
        category_id = req.get_param_as_int('category_id')
2361 
        id_list = req.get_param('id_list')
2362 
        type = req.get_param('type')
2363 
        result = Mongo.getBrandSubCategoryInfo(category_id, id_list, type)
2364 
        resp.body = dumps(result)
19444 manas 2365 
 
19451 manas 2366 
class RefundAmountWallet():
2367 
    def on_post(self,req,resp):
2368 
        jsonReq = json.loads(req.stream.read(), encoding='utf-8')
2369 
        if Mongo.refundAmountInWallet(jsonReq):
2370 
            resp.body = "{\"result\":\"success\"}"
2371 
        else:
2372 
            resp.body = "{\"result\":\"failed\"}"
2373 
 
2374 
    def on_get(self,req,resp):
2375 
        offset = req.get_param_as_int("offset")
2376 
        limit = req.get_param_as_int("limit")
2377 
        status = req.get_param("status")
19469 manas 2378 
        userRefundDetails = Mongo.fetchCrmRefundUsers(status,offset,limit)
19454 manas 2379 
        if userRefundDetails is not None:
19457 manas 2380 
            resp.body = dumps(userRefundDetails)
19454 manas 2381 
        else:
2382 
            resp.body ="{}"
19463 manas 2383 
 
2384 
class RefundWalletStatus():
2385 
    def on_post(self,req,resp):
2386 
        status = req.get_param('status')
2387 
        jsonReq = json.loads(req.stream.read(), encoding='utf-8')
19469 manas 2388 
        print jsonReq
19463 manas 2389 
        userId = jsonReq.get('user_id')
2390 
        _id = jsonReq.get('_id')
19469 manas 2391 
        conn = get_mongo_connection()
19463 manas 2392 
        if status == utils.REFUND_ADJUSTMENT_MAP.get(1):
2393 
            Mongo.updateCrmWalletStatus(status, _id,userId)
19469 manas 2394 
            value = jsonReq.get('amount')
2395 
            datetimeNow = datetime.now()
2396 
            batchId = int(time.mktime(datetimeNow.timetuple()))
2397 
            user_id = jsonReq.get('user_id')
2398 
            value = jsonReq.get('amount')
2399 
            type = jsonReq.get('type')
2400 
            conn.refund.insert({"userId": user_id, "batch":batchId, "userAmount":value, "timestamp":datetime.strftime(datetimeNow,"%Y-%m-%d %H:%M:%S"), "type":type})
2401 
            conn.Dtr.user.update({"userId":user_id}, {"$inc": { "credited": value, type:value}}, upsert=True)
2402 
            resp.body = "{\"result\":\"success\"}"
19463 manas 2403 
        elif status == utils.REFUND_ADJUSTMENT_MAP.get(2):
2404 
            Mongo.updateCrmWalletStatus(status, _id,userId)
19469 manas 2405 
            resp.body = "{\"result\":\"success\"}"
2406 
        else:
2407 
            resp.body = "{\"result\":\"failed\"}"
2408 
 
19463 manas 2409 
 
15312 amit.gupta 2410 
def main():
18386 manas 2411 
    a = RetailerDetail()
2412 
    retailer = a.getNotActiveRetailer()
2413 
    otherContacts = [r for r, in session.query(RetailerContacts.mobile_number).filter_by(retailer_id=retailer.id).order_by(RetailerContacts.contact_type).all()]
2414 
    print json.dumps(todict(getRetailerObj(retailer, otherContacts, 'fresh')), encoding='utf-8')
15195 manas 2415 
 
15081 amit.gupta 2416 
if __name__ == '__main__':
18901 amit.gupta 2417 
    #main()
19391 amit.gupta 2418 
    print getTinInfo('07740388453')
15091 amit.gupta 2419