Subversion Repositories SmartDukaan

Rev

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