Subversion Repositories SmartDukaan

Rev

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

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