Subversion Repositories SmartDukaan

Rev

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

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