Subversion Repositories SmartDukaan

Rev

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