GY3RSTs0

1from __future__ import unicode_literals
2
3import config
4from html_strings import get_send_confirmation_mail_html
5
6import time
7import json
8import requests
9import re
10from mailin import Mailin
11import math
12import boto
13from bson.objectid import ObjectId
14import base64
15import hashlib
16import pyotp
17from Crypto import Random
18from Crypto.Cipher import AES
19
20if config.prod is False:
21    REGION_HOST = 's3.eu-central-1.amazonaws.com'
22    bucket_name = 'qa-otc-data'
23else:
24    REGION_HOST = 's3.eu-west-2.amazonaws.com'
25    bucket_name = 'otc-data'
26# s3_conn = boto.connect_s3(host=REGION_HOST)
27# bucket = s3_conn.get_bucket(bucket_name)
28# Create your models here.
29db_conn = config.mongo_conn().token_maker
30db_conn_wallet = config.mongo_conn().user_wallet
31redis_conn = config.redis_conn
32r = redis_conn()
33base_reference = 9000
34
35if config.prod is False:
36    couch_user = 'cas_exchange'
37    couch_pass = 'staging'
38    couch_ip = '167.99.207.134'
39else:
40    couch_user = 'cas_exchange'
41    couch_pass = '017ad4b9541'
42    couch_ip = '127.0.0.1'
43couch_base_url = 'http://' + couch_user + ':' + couch_pass + '@' + couch_ip + ':6984/'
44class AESCipher(object):
45
46    def __init__(self, key):
47        self.bs = 32
48        self.key = hashlib.sha256(key.encode()).digest()
49
50    def encrypt(self, raw):
51        raw = self._pad(raw)
52        iv = Random.new().read(AES.block_size)
53        cipher = AES.new(self.key, AES.MODE_CBC, iv)
54        return base64.b64encode(iv + cipher.encrypt(raw))
55
56    def decrypt(self, enc):
57        enc = base64.b64decode(enc)
58        iv = enc[:AES.block_size]
59        cipher = AES.new(self.key, AES.MODE_CBC, iv)
60        return self._unpad(cipher.decrypt(enc[AES.block_size:])).decode('utf-8')
61
62    def _pad(self, s):
63        return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs)
64
65    @staticmethod
66    def _unpad(s):
67        return s[:-ord(s[len(s)-1:])]
68
69
70def get_firebase_user_id():
71    res = db_conn.firebase_id.find_one({})
72    return res['firebase_user_id']
73
74def get_rates_model(token):
75    res = db_conn.token_rates.find({'token':token,'current':True})
76    rates_dict = {}
77    for data in res:
78        rates_dict[data['currency']] = data['value']
79    return rates_dict
80
81def insert_fiat_transaction_for_approval(str_id,payment_method,amount_deposited,transaction_id,bank):
82    _id = ObjectId(str_id)
83    update_dict = {
84        'payment_method':payment_method,
85        'amount_deposited_according_to_user':amount_deposited,
86        'transaction_id':transaction_id,
87        'bank':bank,
88        'status':1,
89        'transaction_status':'pending'
90    }
91    res = db_conn.unverified_transactions.update({'_id':_id},{"$set":update_dict})
92    return res
93
94def get_pending_fiat_transactions_model():
95    res = db_conn.unverified_transactions.find({'transaction_status':'pending','currency':'fiat'},
96                                               {'_id':1,'amount_deposited_according_to_user':1,'transaction_id':1,'bank':1,'payment_method':1})
97    return res
98
99def get_rate(timestamp,currency):
100    res = db_conn.token_rates.find_one({"from_date":{"$lte":timestamp},"to_date":{"$gte":timestamp}})
101    if res:
102        return res[currency]
103    else:
104        print 'using default rate:: '
105        res1 = db_conn.token_rates.find_one({'current':True})
106        print 'rrrr %s' %res1
107        print '1212 %s' %res1['default_' + currency]
108        return res1['default_' + currency]
109
110def get_total_tokens_sold():
111    res = db_conn.transaction_details.find({})
112    total_tokens = 0.0
113    for data in res:
114        if data.__contains__('no_of_tokens'):
115            total_tokens += float(data['no_of_tokens'])
116    return total_tokens
117
118def get_current_rate(total_tokens):
119    total_tokens += 1
120    res = db_conn.rate_card.find_one({'from':{"$lte":total_tokens},'to':{"$gte":total_tokens}})
121    return res['rate']
122
123def get_firebase_config():
124    res = db_conn.firebase_config.find_one({})
125    return res
126
127def get_price(tokens_to_buy,currency):
128    res = db_conn_wallet.btc_to_usd.find().sort("_id",-1).limit(1)
129    for data in res:
130        cashaa_btc = float(data['cashaa_btc'])
131        cashaa_eth = float(data['cashaa_eth'])
132    price_list = []
133    if currency == 'btc':
134        price_list.append([tokens_to_buy,cashaa_btc])
135    if currency == 'eth':
136        price_list.append([tokens_to_buy,cashaa_eth])
137    price = 0.0
138    for data in price_list:
139        price += float(data[0]) * float(data[1])
140    return price_list,round(price,8)
141
142def get_current_cashaa_price_model(currency):
143    res = db_conn_wallet.btc_to_usd.find().sort("_id",-1).limit(1)
144    for data in res:
145        cashaa_btc = float(data['cashaa_btc'])
146        cashaa_eth = float(data['cashaa_eth'])
147    if currency == 'btc':
148        return cashaa_btc
149    else:
150        return cashaa_eth
151
152def get_user_cas_bal(email):
153    tokens = 0.0
154    timeline_res = get_user_timeline_model(email)
155    for data in timeline_res:
156        if data.__contains__('token_purchased'):
157            tokens += int(float(data['token_purchased']))
158            print 'ttt tokens::: %s' %tokens
159        if data.__contains__('tokens_purchased'):
160            tokens += int(float(data['tokens_purchased']))
161            print 'ttt tokens::: %s' %tokens
162    cashaa_withdrawal_res = get_cashaa_withdrawal_details(email)
163    for data in cashaa_withdrawal_res:
164        tokens -= int(float(data['amount_withdrawn']))
165    print 'ppppp %s' %tokens
166    return int(tokens)
167
168def get_value_to_be_paid(address):
169    res = db_conn.unverified_transactions.find_one({'to_address':address})
170    return res['amount_to_pay']
171
172def get_price_distribution(address):
173    res = db_conn.unverified_transactions.find_one({'to_address':address})
174    return res['price_distribution']
175
176def get_cap(timestamp):
177    res = db_conn.cap.find_one({"from_date":{"$lte":timestamp},"to_date":{"$gte":timestamp}})
178    if res:
179        return float(res['min_cap']),float(res['max_cap'])
180    else:
181        print 'using default cap:::: '
182        res1 = db_conn.cap.find_one({'current':True})
183        return float(res1['default_min_cap']),float(res1['default_max_cap'])
184
185
186def get_erc_address(email):
187    res = db_conn.user_master.find_one({'email':email})
188    if res.__contains__('erc_address'):
189        return res['erc_address']
190    else:
191        return None
192
193def get_erc_wallet(email):
194    res = db_conn.user_master.find_one({'email':email})
195    if res.__contains__('eth_wallet'):
196        return res['eth_wallet']
197    else:
198        return None
199
200def get_email_id_model(address,currency):
201    if currency == 'btc':
202        res = db_conn.user_master.find_one({'btc_address_list':{"$elemMatch":{"$eq":address}}})
203        return res['email']
204    if currency == 'eth':
205        res = db_conn.user_master.find_one({'bid_id_list':{"$elemMatch":{"$eq":address}}})
206        return res['email']
207
208def get_admin_role(email):
209    res = db_conn.admin.find_one({'email':email})
210    if res.__contains__('role'):
211        return res['role']
212    return ['super_admin']
213
214def get_email_id_from_bid_id_model(bid_id):
215    res = db_conn.user_master.find_one({'bid_id_list':{"$elemMatch":{"$eq":bid_id}}})
216    if res:
217        return res['email']
218
219def get_referral_details_model(address,currency):
220    if currency == 'btc':
221        res = db_conn.user_master.find_one({'btc_address_list':{"$elemMatch":{"$eq":address}}})
222    else:
223        res = db_conn.user_master.find_one({'bid_id_list':{"$elemMatch":{"$eq":address}}})
224    return res['ref_id'],res['tnc']['name']
225
226def get_referral_details_model_fiat(str_id):
227    email = db_conn.unverified_transactions.find_one({'_id':ObjectId(str_id)})['email']
228    res = db_conn.user_master.find_one({'email':email})
229    return res['ref_id'],res['tnc']['name']
230
231
232def validate_user(email,password):
233    res = db_conn.user_master.find_one({'email':email,'password':hashlib.sha256(password).hexdigest()})
234    return res
235
236def update_recieve_transaction_btc_model(address,from_address,value,txid,confirmations,erc_address,erc_wallet):
237    # tokens_sold = get_total_tokens_sold()
238    already_exists_flag = db_conn.transaction_details.find_one({'txid':txid})
239    if already_exists_flag is None:
240        insert_dict = {
241            'to_address':address,
242            'from_address':from_address,
243            'value':value,
244            'txid':txid,
245            'currency':'btc',
246            'epoch':int(time.time()),
247            'erc_address':erc_address,
248            'erc_wallet':erc_wallet,
249            'confirmations':int(confirmations),
250        }
251        res = db_conn.user_master.find_one({'btc_address_list':{"$elemMatch":{"$eq":address}}})
252        insert_dict['email'] = res['email']
253        res1 = db_conn.unverified_transactions.find_one({'to_address':address})
254        if res1.__contains__('refund_address'):
255            insert_dict['btc_refund_address'] = res1['refund_address']
256        else:
257            insert_dict['btc_refund_address'] = 'na'
258        insert_dict['tokens_already_sold'] = res1['tokens_already_sold']
259        value_to_pay = float(res1['amount_to_pay'])
260        print 'value paid::: %s, value promised::: %s' %(value,value_to_pay)
261        if value == value_to_pay:
262            insert_dict['no_of_tokens'] = res1['no_of_tokens']
263            insert_dict['price'] = res1['price']
264            insert_dict['price_distribution'] = res1['price_distribution']
265        else:
266            price,price_distribution,no_of_tokens = back_calculation(value,value_to_pay,
267                                                     res1['price_distribution'])
268            insert_dict['no_of_tokens'] = no_of_tokens
269            insert_dict['price'] = price
270            insert_dict['price_distribution'] = price_distribution
271        res3 = db_conn.transaction_details.insert(insert_dict)
272        db_conn.unverified_transactions.update({'to_address':address},{"$set":{'status':3}})
273        # if int(confirmations) >= 3:
274        couch_json = {
275            'timestamp':int(time.time()),
276            'currency':'btc',
277            'type':'buy',
278            'volume':insert_dict['no_of_tokens'],
279            'exchange_rate':res1['exchange_rate']
280        }
281        insert_transaction_in_couch(couch_json)
282    else:
283        print 'txid already exists::: %s' %txid
284        insert_dict = {'no_of_tokens':already_exists_flag['no_of_tokens']}
285    return insert_dict['no_of_tokens']
286
287
288def insert_transaction_in_couch(couch_json):
289    """
290        ===================            One time only      ================================
291        Run this command manually to create table:
292            requests.put('http://couch_user:couch_pass@couch_ip:6984/live_orders_v1')
293        Run this command manually to create a new id and insert doocument:
294            re = requests.put('http://couch_user:couch_pass@couch_ip:6984/live_orders_v1/live_order_unique_id',data=json.dumps({'live_order_list':[]}))
295        Run this command to get _rev and hardcode it here:
296            re = requests.get('http://couch_user:couch_pass@couch_ip:6984/live_orders_v1/live_order_unique_id')
297    """
298    print '12311111111111111123123 insert_transaction_in_couch ================= '
299    id = 'live_order_unique_id'
300    collection = 'live_orders_v1'
301    couch_res = requests.get(couch_base_url + collection + '/' + id)
302    couch_jsonify = json.loads(couch_res.text)
303    _rev = couch_jsonify['_rev']
304    live_order_list = couch_jsonify['live_order_list']
305    if len(live_order_list) <= 20:
306        live_order_list = [couch_json] + live_order_list
307    else:
308        live_order_list = live_order_list[0:21]
309        live_order_list = [couch_json] + live_order_list
310    update_json = {'_rev':_rev,'live_order_list':live_order_list}
311    print 'updating oreder_list in couch::: %s, \nNew order list::::: %s' %(live_order_list,couch_json)
312    print '============================================================================================'
313    update_res = requests.put(couch_base_url + collection + '/' + id,data=json.dumps(update_json))
314    print 'uuuuuuuu %s' %update_res.text
315    # if update_res.status_code == 200:
316    #     print 'succ'
317
318def get_graph_data(from_timestamp,to_timestamp):
319    # print 'ff %s, tt %s' %(from_timestamp,to_timestamp)
320    res = db_conn_wallet.btc_to_usd.find({'timestamp':{'$gte':from_timestamp,'$lte':to_timestamp}})
321    return_list = []
322    for data in res:
323        # print 'dd %s' %data
324        return_list.append({'timestamp':data['timestamp'],'cashaa_eth':data['cashaa_eth'],'cashaa_btc':data['cashaa_btc']})
325    return return_list
326
327
328def update_recieve_transaction_eth_model(address,from_address,value,txid,confirmations,erc_address,erc_wallet,bid_id):
329    res1 = db_conn.transaction_details.find_one({'txid':txid})
330    if res1 is None:
331        insert_dict = {
332            'to_address':address,
333            'from_address':from_address,
334            'value':value,
335            'txid':txid,
336            'currency':'eth',
337            'epoch':int(time.time()),
338            'erc_address':erc_address,
339            'erc_wallet':erc_wallet,
340            'confirmations':int(confirmations),
341            'bid_id':bid_id
342        }
343        res = db_conn.user_master.find_one({'bid_id_list':{"$elemMatch":{"$eq":bid_id}}})
344        insert_dict['email'] = res['email']
345        res3 = db_conn.unverified_transactions.find_one({'bid_id':bid_id})
346        if res3.__contains__('eth_refund_address'):
347            insert_dict['eth_refund_address'] = res3['refund_address']
348        else:
349            insert_dict['eth_refund_address'] = 'na'
350        insert_dict['tokens_already_sold'] = res3['tokens_already_sold']
351        value_to_pay = float(res3['amount_to_pay'])
352        if value == value_to_pay:
353            insert_dict['no_of_tokens'] = res3['no_of_tokens']
354            insert_dict['price'] = res3['price']
355            insert_dict['price_distribution'] = res3['price_distribution']
356        else:
357            price,price_distribution,no_of_tokens = back_calculation(value,value_to_pay,
358                                                     res3['price_distribution'])
359            insert_dict['no_of_tokens'] = no_of_tokens
360            insert_dict['price'] = price
361            insert_dict['price_distribution'] = price_distribution
362        res2 = db_conn.transaction_details.insert(insert_dict)
363        db_conn.unverified_transactions.update({'bid_id':bid_id},{"$set":{'status':3}})
364        # if int(confirmations) >= 3:
365        print '++++++++++++++++++++++ cccccccccccccccccccc ===================='
366        couch_json = {
367            'timestamp':int(time.time()),
368            'currency':'eth',
369            'type':'buy',
370            'volume':insert_dict['no_of_tokens'],
371            'exchange_rate':res3['exchange_rate']
372        }
373        insert_transaction_in_couch(couch_json)
374        return insert_dict['no_of_tokens']
375    else:
376        no_of_tokens = res1['no_of_tokens']
377        return no_of_tokens
378
379
380def insert_into_invalid_bids(from_address,to_address,txid,value):
381    insert_dict = {
382        'from_address':from_address,
383        'to_address':to_address,
384        'txid':txid,
385        'value':value,
386        'timestamp':int(time.time())
387    }
388    res = db_conn.invalid_bids.find_one({'txid':txid})
389    if res is None:
390        db_conn.invalid_bids.insert(insert_dict)
391
392
393def back_calculation(value_paid,value_promised,price_list):
394    new_price_list = []
395    tokens_bought = int(math.floor(float(price_list[0][0]) / float(value_promised) * float(value_paid)))
396    new_price_list.append([tokens_bought,price_list[0][1]])
397    price = 0.0
398    for i in new_price_list:
399        price += i[0] * i [1]
400        # tokens_bought += i[0]
401    return price,new_price_list,tokens_bought
402
403
404
405def update_transaction_confirmations(txid):
406    res = db_conn.transaction_details.update({'txid':txid},{"$inc":{"confirmations":1}})
407    no_of_tokens = db_conn.transaction_details.find_one({'txid':txid})['no_of_tokens']
408    return no_of_tokens
409
410
411
412def update_fiat_transaction_flag(str_id):
413    _id = ObjectId(str_id)
414    res = db_conn.unverified_transactions.update({'_id':_id},{"$set":{'status':2,'transaction_status':'verified'}})
415    return res
416
417def reject_fiat_transaction_flag(str_id):
418    _id = ObjectId(str_id)
419    res = db_conn.unverified_transactions.update({'_id':_id},{"$set":{'status':-1,'transaction_status':'rejected'}})
420    print 'iii %s, res::: %s' %(_id,res)
421    return res
422
423def insert_fiat_transaction_in_transaction_details(str_id,email,timestamp,amount,erc_address,erc_wallet):
424    _id = ObjectId(str_id)
425    res1 = db_conn.unverified_transactions.find_one({'_id':_id})
426    insert_dict = {
427        'value':amount,
428        'currency':'fiat',
429        'epoch':int(timestamp),
430        'erc_address':erc_address,
431        'erc_wallet':erc_wallet,
432        'email':email
433    }
434    if res1.__contains__('eth_refund_address'):
435        insert_dict['eth_refund_address'] = res1['refund_address']
436    else:
437        insert_dict['eth_refund_address'] = 'na'
438    insert_dict['tokens_already_sold'] = res1['tokens_already_sold']
439    value_to_pay = float(res1['amount_to_pay'])
440    if amount == value_to_pay:
441        insert_dict['no_of_tokens'] = res1['no_of_tokens']
442        insert_dict['price'] = res1['price']
443        insert_dict['price_distribution'] = res1['price_distribution']
444    else:
445        price,price_distribution,no_of_tokens = back_calculation(amount,value_to_pay,
446                                                 res1['price_distribution'])
447        insert_dict['no_of_tokens'] = no_of_tokens
448        insert_dict['price'] = price
449        insert_dict['price_distribution'] = price_distribution
450    res2 = db_conn.transaction_details.insert(insert_dict)
451    insert_dict['unconfirmed_id'] = str_id
452    insert_dict['payment_method'] = res1['payment_method']
453    insert_dict['transaction_id'] = res1['transaction_id']
454    insert_dict['amount_deposited_according_to_user'] = res1['amount_deposited_according_to_user']
455    insert_dict['bank'] = res1['bank']
456    print 'ppp %s' %insert_dict
457    insert_dict['_id'] = None
458    res2 = db_conn.transaction_details.insert(insert_dict)
459    db_conn.unverified_transactions.update({'_id':_id},{"$set":{'status':3}})
460    return insert_dict['no_of_tokens']
461
462# def insert_fiat_transaction_in_rejected_transaction_details(str_id):
463#     _id = ObjectId(_id)
464#
465
466def user_existance(new_email,password):
467    print ("---------------->")
468    count = db_conn.user_master.find({}).count()
469    tmp_ref_id = str(base_reference + count)
470    if len(tmp_ref_id) == 4:
471        ref_id = '00' + tmp_ref_id
472    elif len(tmp_ref_id) == 5:
473        ref_id = '0' + tmp_ref_id
474    else:
475        ref_id = tmp_ref_id
476    json_obj = {"email":new_email,'ref_id':ref_id,'password':hashlib.sha256(password).hexdigest()}
477    model_insert(json_obj)
478    insert_in_referral_tree(new_email,ref_id)
479
480def insert_in_referral_tree(new_email,ref_id):
481    db_conn.referral_tree.insert({'email':new_email,'ref_id':ref_id,'parent':None,'child':[]})
482
483def validate_ref_id(ref_id):
484    res = db_conn.user_master.find_one({'ref_id':ref_id})
485    return res
486
487def insert_parent_ref_id(user_ref_id,ref_id):
488    db_conn.referral_tree.update({'ref_id':user_ref_id},{"$set":{'parent':ref_id}})
489
490def push_child_ref_id(user_ref_id,ref_id):
491    res = db_conn.referral_tree.find_one({'ref_id':ref_id})
492    if res.__contains__('child'):
493        if user_ref_id not in res['child']:
494            db_conn.referral_tree.update({'ref_id':ref_id},{"$push":{'child':user_ref_id}})
495    else:
496        db_conn.referral_tree.update({'ref_id':ref_id},{"$push":{'child':user_ref_id}})
497
498def get_ref_id(email):
499    res = db_conn.user_master.find_one({'email':email})
500    return res['ref_id']
501
502def calc_referal_bonus(ref_id, amount, name, currency):
503    # rate_arr = [0.05, 0.02, 0.02, 0.02, 0.01, 0.01, 0.005, 0.005, 0.005, 0.005]
504    rate_arr = [0.05]
505    flag = True
506    height = 0
507    # reward_arr = []
508    while  flag:
509        temp_json = {}
510        find_param = {'ref_id': ref_id}
511        ref_cursor = db_conn.referral_tree.find_one(find_param)
512        print "ref  ", ref_cursor
513        if ref_cursor['parent'] and (height < len(rate_arr)):
514            temp_json['bonus_refid'] = ref_cursor['parent']
515            temp_json['bonus_amount'] = float(amount) * float(rate_arr[height])
516            temp_json['height'] = height + 1
517            temp_json['from_ref_id'] = ref_id
518            temp_json['name'] = name
519            temp_json['currency'] = currency
520            temp_json['spent'] = False
521            db_conn.referral_bonus.insert(temp_json)
522            # reward_arr.append(temp_json)
523            ref_id = ref_cursor['parent']
524        else:
525            flag = False
526        height += 1
527    # return reward_arr
528
529def get_referral_list_model(ref_id):
530    res = db_conn.referral_bonus.find({'bonus_refid':ref_id})
531    return res
532
533def update_password_model(email,password):
534    res = db_conn.user_master.update({'email':email},{"$set":{'password':hashlib.sha256(password).hexdigest()}})
535    return res
536
537def get_withdraw_details(_id):
538    res = db_conn.cashaa_withdrawals.find_one({'_id':ObjectId(_id)})
539    return res
540
541def get_withdrawal_details_admin_model():
542    res = db_conn.admin_withdraw.find({})
543    return res
544
545def get_withdraw_details_from_admin_model(str_id):
546    _id = ObjectId(str_id)
547    res = db_conn.admin_withdraw.find_one({'_id':_id,'spent':False})
548    return res
549
550def get_otp_for_admin_model():
551    # r = redis_conn()
552    res = r.keys('*')
553    send_list = []
554    # print 'rrreee %s,%s' %(res,type(res))
555    for data in res:
556        details_dict = dict()
557        email_flag = re.search('^[\w\.=-]+@[\w\.-]+\.[\w]{1,5}$',data)
558        if email_flag:
559            otp = r.get(data)
560            details_dict['email'] = data
561            details_dict['otp'] = otp
562            send_list.append(details_dict)
563    return send_list
564
565def update_flag_in_admin_withdrawal(str_id,txid):
566    _id = ObjectId(str_id)
567    res = db_conn.admin_withdraw.update({'_id':_id},{"$set":{'spent':True,'txid':txid}})
568    return res
569
570def get_withdraw_details_model(ref_id):
571    res = db_conn.referral_bonus.find({'bonus_refid':ref_id})
572    withdrawn_btc = 0.0
573    pending_btc = 0.0
574    withdrawn_eth = 0.0
575    pending_eth = 0.0
576    for data in res:
577        if data['currency'] == 'btc':
578            if data['spent'] is False:
579                pending_btc += float(data['bonus_amount'])
580            else:
581                withdrawn_btc += float(data['bonus_amount'])
582        if data['currency'] == 'eth':
583            if data['spent'] is False:
584                pending_eth += float(data['bonus_amount'])
585            else:
586                withdrawn_eth += float(data['bonus_amount'])
587    return withdrawn_btc,pending_btc,withdrawn_eth,pending_eth
588
589def get_details_from_ref_tree(parents):
590    res = db_conn.referral_tree.find({'ref_id':{"$in":parents}})
591    return res
592
593def get_name(ref_id_list):
594    name_list = []
595    for ref_id in ref_id_list:
596        res = db_conn.user_master.find_one({'ref_id':ref_id})
597        # print 'nenenrnr %s' %res
598        if res:
599            name_list.append(res['tnc']['name'])
600    return name_list
601
602def get_user_name(email):
603    res = db_conn.user_master.find_one({'email':email})
604    # print "&*&&&&&&&&&&&&&&&&&************ name is %s" %res
605    return res['tnc']['name']
606
607def get_pending_amount(email,currency):
608    res = db_conn.user_master.find_one({'email':email})
609    ref_id = res['ref_id']
610    res1 = db_conn.referral_bonus.find({'bonus_refid':ref_id,'spent':False,'currency':currency})
611    pending_amount = 0.0
612    for data in res1:
613        pending_amount += float(data['bonus_amount'])
614    return pending_amount
615
616def insert_into_admin(email,refund_address,currency,pending_amount,ref_id):
617    insert_dict = {
618        'email':email,
619        'refund_address':refund_address,
620        'currency':currency,
621        'pending':round(pending_amount,6),
622        'ref_id':ref_id,
623        'spent':False
624    }
625    res = db_conn.admin_withdraw.insert(insert_dict)
626    return res
627
628
629
630def user_exists_model(email):
631    res = db_conn.user_master.find_one({'email':email})
632    return res
633
634def password_exists_model(email):
635    res = db_conn.user_master.find_one({'email':email,'password':{"$exists":True}})
636    return res
637
638def model_insert(json_obj):
639    db_conn.user_master.insert(json_obj)
640
641
642
643
644def otp_session(email,otp):
645    r.setex(email,600,otp)
646
647def set_admin_email_model(admin_email):
648    r.set('admin_email',admin_email)
649
650def get_admin_email_model():
651    admin_email = r.get('admin_email')
652    return admin_email
653
654def otp_verification(email,otp):
655    if 'withdraw_' in email:
656        email = email.split('_')[2]
657    res = db_conn.otp_details.find_one({'email':email,'current_flag':True})
658    print 'mmmmmmmmmm::::::::::::::: %s,%s,%s' %(email,otp,res)
659    if res:
660        otp_str = res['otp_str']
661        totp = pyotp.TOTP(otp_str)
662        if totp.verify(otp) is True:
663            flag = 1
664        else:
665            flag = 0
666    else:
667        val = r.get(email)
668        if val == otp:
669            flag = 1
670        else:
671            flag = 0
672    return flag
673
674def get_otp(email):
675    val = r.get(email)
676    return val
677
678def uuid_verification(unique_id,email):
679    # r = redis_conn()
680    val = r.get(unique_id)
681    print 'vvvv %s,%s,%s,%s' %(val,email,type(val),type(email))
682    if val == str(email):
683        print 'token match:::: '
684        r.setex(unique_id,10800,email)
685        flag = 1
686    else:
687        flag = 0
688    return flag
689
690def tnc_model(name,email):
691    date_time = int(time.time())
692    # print date_time
693    db_conn.user_master.update({'email':email},{'$set':{'tnc':{"time_stamp":date_time,"name":name}}})
694
695def verify_password_model(email,password):
696    res = db_conn.user_master.find_one({'email':email,'password':hashlib.sha256(password).hexdigest()})
697    return res
698
699def kyc_model(input_json,email):
700    db_conn.user_master.update({'email':email},{'$set':{'kyc':input_json}})
701    print("------------>")
702
703
704# def db_content(new_email):
705#     token =  db_conn.user_master.find_one( { "email": new_email } )   #email field contains new email or not
706#     return token
707
708
709
710def save_uuid(unique_id,email):
711    r.setex(unique_id,10800,email)   #2 hour
712
713def del_uuid_from_redis(unique_id):
714    r.delete(unique_id)
715
716def address_insertion_model(btc_address,eth_address,email):
717    db_conn.user_master.update({'email':email},{'$set':{'btc_address':btc_address,'eth_address':eth_address}})
718
719
720
721def admin_vefificatoin(email,pwd):
722    password = hashlib.sha256(pwd).hexdigest()
723    res = db_conn.admin.find_one( { "email": email,"password":password } )
724    # print res
725    return res
726
727
728def fetch_all():
729    count = db_conn.user_master.find({}).count()
730    return count
731
732
733def verified_docs_counts_():
734    count = db_conn.user_master.find({"kyc.status":"accepted"}).count()
735    return count
736
737def get_kyc_status(email):
738    res = db_conn.user_master.find_one({'email':email})
739    if res.__contains__('kyc'):
740        if res['kyc']['status'] == 'accepted':
741            return True
742    return False
743
744def rejected_docs_counts_():
745    count = db_conn.user_master.find({"kyc.status":"rejected"}).count()
746    return count
747
748
749
750def kyc_status_verify(email):
751    db_conn.user_master.update({'email':email},{'$set':{"kyc.status":"accepted"}})
752
753def pre_approve_kyc(email):
754    db_conn.user_master.update({'email':email},{"$set":{"kyc":{'status':'accepted','aadhar_card_details':[],'pan_card_details':[]}}})
755
756def kyc_status_reject(email,reason):
757    db_conn.user_master.update({'email':email},{'$set':{"kyc.status":"rejected","kyc.reason":reason}})
758
759def show_pending_model(page):
760    res = db_conn.user_master.find({"kyc.status":"pending"},{'kyc':1,'email':1,'_id':0}).skip((page - 1) * 10).limit(10)
761    count = db_conn.user_master.find({"kyc.status":"pending"}).count()
762    # print res
763    return res,count
764
765def get_all_users_model():
766    res = db_conn.user_master.find({},{'_id':0})
767    return res
768
769def get_user_kyc_details_model(email):
770    res = db_conn.user_master.find_one({'email':email},{'kyc':1,'_id':0})
771    return res
772
773def show_accepted_model(page):
774    res = db_conn.user_master.find({"kyc.status":"accepted"},{'kyc':1,'email':1,'_id':0}).skip((page - 1) * 10).limit(10)
775    count = db_conn.user_master.find({"kyc.status":"accepted"}).count()
776    # print res
777    return res,count
778
779
780def show_rejected_model(page):
781    res = db_conn.user_master.find({"kyc.status":"rejected"},{'kyc':1,'email':1,'_id':0}).skip((page - 1) * 10).limit(10)
782    count = db_conn.user_master.find({"kyc.status":"rejected"}).count()
783    # print res
784    return res,count
785
786
787def show_single_kyc_model(email):
788    return(db_conn.user_master.find({"email":email},{'kyc':1,'email':1,'_id':0}))
789
790
791def bank_transfer_model(list):
792    db_conn.fiat_transaction.insert(list)
793
794
795def bank_detail_model(insert_list):
796    db_conn.admin_bank_detail.insert(insert_list)
797
798
799def rate_conversion_model(input_json):
800    to_timestamp = int(time.time())
801    input_json['from_timestamp'] = int(time.time())
802
803    count = db_conn.token_rates.find({'token':input_json['token'],'currency':input_json['currency']}).count()
804    if count == 0:
805        res = db_conn.token_rates.insert(input_json)
806    else:
807        db_conn.token_rates.update({'current':True,"token":input_json["token"],'currency':input_json['currency']},{'$set':{"to_timestamp":to_timestamp,"current":False}})
808        res = db_conn.token_rates.insert(input_json)
809    print res
810    return res
811
812
813def model_token():
814    sold = db_conn.transaction_details.find({"token":"cashaa"})
815    return sold
816
817def insert_default_rate(default_btc,default_eth,default_fiat):
818    default_rates = {
819        'default_btc':default_btc,
820        'default_eth':default_eth,
821        'default_fiat':default_fiat,
822        'current':True,
823        'from_timestamp':int(time.time())
824    }
825    # res = db_conn.token_rates.find_one({'default_btc':{"$exists":True}})
826    # if res is None:
827    res = db_conn.token_rates.insert(default_rates)
828    return res
829
830def set_default_cap_model(default_min_cap,default_max_cap):
831    default_caps = {
832        'default_min_cap':default_min_cap,
833        'default_max_cap':default_max_cap,
834        'from_time_stamp':int(time.time()),
835        'current':True
836    }
837    res = db_conn.cap.insert(default_caps)
838    return res
839
840
841def update_default_rate_model(default_btc,default_eth,default_fiat):
842    update_res = db_conn.token_rates.update({'current':True},{"$set":{'current':False,'to_timestamp':int(time.time())}})
843    default_rates = {
844        'default_btc':default_btc,
845        'default_eth':default_eth,
846        'default_fiat':default_fiat,
847        'current':True,
848        'from_timestamp':int(time.time())
849    }
850    res = db_conn.token_rates.insert(default_rates)
851    return res
852
853def update_default_cap_model(default_min_cap,default_max_cap):
854    update_res = db_conn.cap.update({'current':True},{"$set":{'current':False,'to_timestamp':int(time.time())}})
855    default_caps = {
856        'default_min_cap':default_min_cap,
857        'default_max_cap':default_max_cap,
858        'current':True,
859        'from_timestamp':int(time.time())
860    }
861    res = db_conn.cap.insert(default_caps)
862    return res
863
864
865def insert_set_rate_model(from_date,to_date,btc_value,eth_value,fiat_value):
866    rates = {
867        'from_date':from_date,
868        'to_date':to_date,
869        'btc':btc_value,
870        'eth':eth_value,
871        'fiat':fiat_value
872    }
873    res = db_conn.token_rates.insert(rates)
874    return res
875
876def set_cap_model(from_date,to_date,min_cap,max_cap):
877    res = db_conn.cap.insert({'min_cap':min_cap,'max_cap':max_cap,'from_date':from_date,'to_date':to_date})
878    return res
879
880def get_default_rates():
881    res = db_conn.token_rates.find_one({'current':True})
882    return res
883
884def get_default_caps():
885    res = db_conn.cap.find_one({'current':True})
886    return res
887
888def get_rates():
889    res = db_conn.token_rates.find({"current":{'$exists':False}})
890    return res
891
892def get_caps():
893    res = db_conn.cap.find({"current":{"$exists":False}})
894    return res
895
896def remove_rate_model(str_id):
897    _id = ObjectId(str_id)
898    res = db_conn.token_rates.remove({'_id':_id})
899    return res
900
901def update_rates_model(str_id,update_dict):
902    _id = ObjectId(str_id)
903    res = db_conn.token_rates.update({'_id':_id},{"$set":update_dict})
904    return res
905
906def get_btc_transactions_model(btc_address):
907    res = db_conn.transaction_details.find({'from_address':btc_address})
908    return res
909
910def get_fiat_transactions_model(email):
911    res = db_conn.transaction_details.find({'email':email})
912    return res
913
914def create_erc_address_model(email,erc_address,eth_wallet):
915    res = db_conn.user_master.update({'email':email},{"$set":{'erc_address':erc_address,'eth_wallet':eth_wallet}})
916    return res
917
918
919
920def update_cap_model(min_cap,max_cap):
921    res = db_conn.cap.update({"$exists":{'min_cap':True}},{"$set":{'min_cap':min_cap,'max_cap':max_cap}})
922    return res
923
924
925def set_btc_refund_address_model(email,btc_refund_address):
926    res = db_conn.user_master.update({'email':email},{"$set":{'btc_refund_address':btc_refund_address}})
927    return res
928
929def get_docs_to_spend(email,currency):
930    res = db_conn.user_master.find_one({'email':email})
931    ref_id = res['ref_id']
932    res1 = db_conn.referral_bonus.find({'bonus_refid':ref_id,'spent':False,'currency':currency})
933    return res1
934
935def update_spent_flag(res):
936    for data in res:
937        db_conn.referral_bonus.update({'_id':data['_id']},{"$set":{'spent':True}})
938
939def set_eth_refund_address_model(email,refund_eth_address):
940    res = db_conn.user_master.update({'email':email},{"$set":{'eth_refund_address':refund_eth_address}})
941    return res
942
943def get_refund_address(address):
944    res = db_conn.unverified_transactions.find_one({'to_address':address})
945    if res.__contains__('refund_address'):
946        return res['refund_address']
947    else:
948        return None
949
950def get_refund_address_using_mail(email,currency):
951    if currency == 'btc':
952        res = db_conn.user_master.find_one({'email':email})
953        if 'btc_refund_address' in res:
954            return res['btc_refund_address']
955        else:
956            return None
957    if currency == 'eth':
958        res = db_conn.user_master.find_one({'email':email})
959        if 'eth_refund_address' in res:
960            return res['eth_refund_address']
961        else:
962            return None
963
964
965def insert_successful_btc_refund(btc_refund_dict):
966    db_conn.successful_btc_refunds.insert(btc_refund_dict)
967
968def insert_successful_eth_refund(eth_refund_dict):
969    db_conn.successful_btc_refunds.insert(eth_refund_dict)
970
971def insert_unsuccessful_btc_refund(btc_refund_dict):
972    db_conn.unsuccessful_btc_refunds.insert(btc_refund_dict)
973
974def insert_unsuccessful_eth_refund(eth_refund_dict):
975    db_conn.unsuccessful_btc_refunds.insert(eth_refund_dict)
976
977def get_btc_to_usd():
978    res = db_conn_wallet.btc_to_usd.find_one({})
979    return res['rate']
980
981def get_eth_to_usd():
982    res = db_conn_wallet.btc_to_usd.find_one({})
983    return res['eth_rate_float']
984
985def get_transacation_details_model(txid):
986    res = db_conn.transaction_details.find_one({'txid':txid})
987    return res
988
989def insert_multisig_details(email,to_address_json,to_address,redeem_script):
990    res = db_conn.multisig_details.insert({
991        'email':email,
992        'address':to_address,
993        'json_request':to_address_json,
994        'redeem_script':redeem_script,
995        'timestamp':int(time.time())
996    })
997    return res
998
999def insert_pay_click_model_btc(email,currency,token_amount,amount_to_pay,price,price_distribution,to_address,refund_address,btc_to_usd,erc_address,erc_wallet,bid_id,redeem_script,to_address_json):
1000    tokens_already_sold = get_total_tokens_sold()
1001    insert_dict = {
1002        'email':email,
1003        'currency':currency,
1004        'no_of_tokens':token_amount,
1005        'amount_to_pay':amount_to_pay,
1006        'price':price,
1007        'price_distribution':price_distribution,
1008        'erc_address':erc_address,
1009        'status':0,
1010        'to_address':to_address,
1011        'refund_address':refund_address,
1012        'exchange_rate':btc_to_usd,
1013        'tokens_already_sold':tokens_already_sold,
1014        'eth_wallet':erc_wallet,
1015        'timestamp':int(time.time()),
1016        'bid_id':bid_id,
1017        'redeem_script':redeem_script,
1018        'json_sent':to_address_json
1019    }
1020    res = db_conn.unverified_transactions.insert(insert_dict)
1021    return res
1022
1023def insert_bank_details(bank_name,bank_account_number):
1024    res = db_conn.bank_details.find_one({'bank_name':bank_name,'bank_account_number':bank_account_number})
1025    if res is None:
1026        db_conn.bank_details.insert({'bank_name':bank_name,'bank_account_number':bank_account_number})
1027    return res
1028
1029def get_bank_details():
1030    res = db_conn.bank_details.find({})
1031    return res
1032
1033def insert_pay_click_model(email,currency,token_amount,amount_to_pay,price,price_distribution,to_address,refund_address,exchange_rate,erc_address,erc_wallet,bid_id):
1034    tokens_already_sold = get_total_tokens_sold()
1035    insert_dict = {
1036        'email':email,
1037        'currency':currency,
1038        'no_of_tokens':token_amount,
1039        'amount_to_pay':amount_to_pay,
1040        'price':price,
1041        'price_distribution':price_distribution,
1042        'erc_address':erc_address,
1043        'status':0,
1044        'to_address':to_address,
1045        'refund_address':refund_address,
1046        'exchange_rate':exchange_rate,
1047        'tokens_already_sold':tokens_already_sold,
1048        'eth_wallet':erc_wallet,
1049        'timestamp':int(time.time()),
1050        'bid_id':bid_id
1051    }
1052    res = db_conn.unverified_transactions.insert(insert_dict)
1053    return res
1054
1055def insert_fiat_pay_click_model(email,currency,token_amount,rate,amount_to_pay):
1056    insert_dict = {
1057        'email':email,
1058        'currency':currency,
1059        'token_amount':token_amount,
1060        'amount_to_pay':amount_to_pay,
1061        'rate':rate,
1062        # 'erc_address':erc_address,
1063        'status':0,
1064        # 'eth_wallet':erc_wallet,
1065        'timestamp':int(time.time())
1066    }
1067    res = db_conn.unverified_transactions.insert(insert_dict)
1068    return res
1069
1070def update_pay_click_model(str_id,new_erc_address,new_erc_wallet):
1071    _id = ObjectId(str_id)
1072    res = db_conn.unverified_transactions.update({'_id':_id},{"$set":{'erc_address':new_erc_address,'eth_wallet':new_erc_wallet}})
1073    return res
1074
1075def update_unconfirmed_status_after_erc_review(str_id):
1076    _id = ObjectId(str_id)
1077    res = db_conn.unverified_transactions.update({'_id':_id},{"$set":{"status":1}})
1078    return res
1079
1080def update_unconfirmed_status_after_transaction(str_id):
1081    _id = ObjectId(str_id)
1082    res = db_conn.unverified_transactions.update({'_id':_id},{"$set":{"status":2}})
1083    return res
1084
1085def save_seed_hash_model(email,init_seed_hash,seeds):
1086    res = db_conn.user_master.update({'email':email},{"$set":{'seed_hash':init_seed_hash,'phrases':seeds}})
1087    return res
1088
1089def get_seed_hash(email):
1090    res = db_conn.user_master.find_one({'email':email})
1091    return res['seed_hash']
1092
1093def add_btc_address_to_user_master_model(email,to_address):
1094    res = db_conn.user_master.update({'email':email},{"$push":{'btc_address_list':to_address}})
1095    return res
1096
1097def add_eth_address_to_user_master_model(email,bid_id):
1098    res = db_conn.user_master.update({'email':email},{"$push":{'bid_id_list':bid_id}})
1099    return res
1100
1101def update_refund_address_in_unconfirmed_transaction(str_id,new_refund_address):
1102    _id = ObjectId(str_id)
1103    res = db_conn.unverified_transactions.update({'_id':_id},{"$set":{'refund_address':new_refund_address}})
1104    return res
1105
1106def get_generated_address(email,currency):
1107    res = db_conn.user_master.find_one({'email':email})
1108    if currency == 'btc':
1109        btc_address_list = res['btc_address_list']
1110        return btc_address_list[len(btc_address_list) - 1]
1111    else:
1112        eth_address_list = res['eth_address_list']
1113        return eth_address_list[len(eth_address_list) - 1]
1114
1115def update_unconfirmed_status_after_refund_review(str_id):
1116    _id = ObjectId(str_id)
1117    db_conn.unverified_transactions.update({'_id':_id},{"$set":{'status':2}})
1118
1119def update_erc_in_user_master(email,new_erc_address,new_erc_wallet):
1120    db_conn.user_master.update({'email':email},{"$set":{'erc_address':new_erc_address,'eth_wallet':new_erc_wallet}})
1121
1122def update_refund_address_in_user_master(email,new_refund_address,currency):
1123    if currency == 'eth':
1124        db_conn.user_master.update({'email':email},{"$set":{'eth_refund_address':new_refund_address}})
1125    else:
1126        db_conn.user_master.update({'email':email},{"$set":{'btc_refund_address':new_refund_address}})
1127
1128
1129def get_user_timeline_model(email):
1130    res = db_conn.user_timeline.find({'email':email},{'_id':0})
1131    return res
1132
1133def get_to_address_json(tmp_to_address,tmp_pub_key):
1134    key = 'tmp_key'
1135    enc_str = r.get('multisig_address')
1136    aes_instance = AESCipher(key)
1137    tmp_str = aes_instance.decrypt(enc_str)
1138    tmp_json = json.loads(tmp_str)
1139    tmp_json['pub_array'].append(tmp_pub_key)
1140    tmp_json['address_array'].append(tmp_to_address)
1141    tmp_json['pub_array'] = json.dumps(tmp_json['pub_array'])
1142    tmp_json['address_array'] = json.dumps(tmp_json['address_array'])
1143    # print 'ttt %s,%s' %(tmp_json,type(tmp_json))
1144    return tmp_json
1145
1146#user timelines
1147def enter_signup_in_user_timeline(email):
1148    insert_dict = {
1149        'email':email,
1150        'timestamp':int(time.time()),
1151        'content':'signup',
1152        'type':'text'
1153    }
1154    db_conn.user_timeline.insert(insert_dict)
1155
1156def enter_kyc_submit_in_user_timeline(email):
1157    insert_dict = {
1158        'email':email,
1159        'timestamp':int(time.time()),
1160        'content':'kyc_submitted',
1161        'type':'text'
1162    }
1163    db_conn.user_timeline.insert(insert_dict)
1164
1165def insert_withdraw_in_cashaa_withdrawals(email,from_address,to_address,value):
1166    insert_dict = {
1167        'email':email,
1168        'from_address':from_address,
1169        'to_address':to_address,
1170        'amount_withdrawn':value,
1171        'status':'pending'
1172    }
1173    db_conn.cashaa_withdrawals.insert(insert_dict)
1174
1175def get_cashaa_withdrawals_for_admin_model():
1176    res = db_conn.cashaa_withdrawals.find({})
1177    list_to_send = []
1178    for data in res:
1179        data['_id'] = str(data['_id'])
1180        list_to_send.append(data)
1181    return list_to_send
1182
1183def approve_cashaa_withdrawal_model(_id,txid):
1184    db_conn.cashaa_withdrawals.update({'_id':ObjectId(_id)},{"$set":{'status':'approved','txid':txid}})
1185
1186def reject_cashaa_withdrawal_model(_id):
1187    db_conn.cashaa_withdrawals.update({'_id':ObjectId(_id)},{"$set":{'status':'rejected'}})
1188
1189def get_cashaa_withdrawal_details(email):
1190    res = db_conn.cashaa_withdrawals.find({'email':email,'status':{"$in":['pending','approved']}})
1191    return res
1192
1193def enter_kyc_accept_in_user_time(email):
1194    insert_dict = {
1195        'email':email,
1196        'timestamp':int(time.time()),
1197        'content':'kyc_accepted',
1198        'type':'text'
1199    }
1200    db_conn.user_timeline.insert(insert_dict)
1201
1202def enter_kyc_reject_in_user_time(email):
1203    insert_dict = {
1204        'email':email,
1205        'timestamp':int(time.time()),
1206        'content':'kyc_rejected',
1207        'type':'text'
1208    }
1209    db_conn.user_timeline.insert(insert_dict)
1210
1211def insert_payment_initialization_in_user_timeline(email,currency,token_amount,price,amount_to_pay,bid_id):
1212    print 'insert payment init in user timeline'
1213    insert_dict = {
1214        'email':email,
1215        'timestamp':int(time.time()),
1216        'content':str(amount_to_pay) + ' ' + currency,
1217        'currency':currency,
1218        'no_of_tokens':token_amount,
1219        'price':price,
1220        'amount_to_pay':amount_to_pay,
1221        # 'erc_address':erc_address,
1222        'type':'payment_initiation',
1223        'bid_id':bid_id
1224    }
1225    db_conn.user_timeline.insert(insert_dict)
1226
1227def insert_zero_confirmation_in_user_timeline(email,currency,token_amount,price,bid_id):
1228    print 'insert payment init in user timeline'
1229    if currency == 'btc':
1230        tmp_type = 'btc_unprocessed'
1231    else:
1232        tmp_type = 'eth_unprocessed'
1233    insert_dict = {
1234        'email':email,
1235        'timestamp':int(time.time()),
1236        'content':str(price) + ' ' + currency,
1237        'currency':currency,
1238        'no_of_tokens':token_amount,
1239        'price':price,
1240        # 'erc_address':erc_address,
1241        'type':tmp_type,
1242        'bid_id':bid_id
1243    }
1244    db_conn.user_timeline.insert(insert_dict)
1245
1246def check_for_conformations(txid):
1247    res = db_conn.transaction_details.find_one({'txid':txid})
1248    return res
1249
1250def get_confirmed_transaction_details():
1251    res = db_conn.transaction_details.find({},{'_id':0})
1252    return res
1253
1254def send_confirmation_mail(email,no_of_tokens,value,currency):
1255    print 'sending eth confirmation mail:::::::::::::::::;;;;;::::::::::::::::: to email id $$$$$$4 %s' %email
1256    m = Mailin("https://api.sendinblue.com/v2.0", "rJ643MNKsOaTDqb2")
1257    name = get_user_name(email)
1258    email_dict = {
1259            "to": {email: email},
1260            "from": ["support@cashaa.com", "Cashaa Support"],
1261            "subject": str(no_of_tokens) + " CAS tokens purchased successfully",
1262            "html": get_send_confirmation_mail_html(name,str(no_of_tokens),str(value),currency)
1263            }
1264    result = m.send_email(email_dict)
1265    print 'rererererererererr %s' %result
1266
1267def insert_btc_transaction_in_user_timeline(email_id,address, from_address, value, txid,confirmations):
1268    # rate = float(get_rate(int(time.time()),'btc'))
1269    # tokens_purchased = rate * float(value)
1270    print 'inserting btc transaction in user timeline'
1271    res = db_conn.transaction_details.find_one({'to_address':address})
1272    tokens_purchased = int(res['no_of_tokens'])
1273    insert_dict = {
1274        'email':email_id,
1275        'timestamp':int(time.time()),
1276        'currency':'btc',
1277        'content':str(value) + ' btc , ' + str(tokens_purchased) + ' tokens',
1278        'to_address':address,
1279        'from_address':from_address,
1280        'txid':txid,
1281        'confirmations':confirmations,
1282        'tokens_purchased':tokens_purchased,
1283        'type':'btc_transaction',
1284        'exchange_rate':get_current_cashaa_price_model('btc')
1285    }
1286    res = db_conn.user_timeline.insert(insert_dict)
1287    print 'rrr %s' %res
1288    send_confirmation_mail(email_id,tokens_purchased,value,'BTC')
1289
1290def insert_eth_transaction_in_user_timeline(email_id,to_address, from_address, value, txid,confirmations,bid_id):
1291    # rate = float(get_rate(int(time.time()),'eth'))
1292    # tokens_purchased = rate * float(value)
1293    res = db_conn.transaction_details.find_one({'bid_id':bid_id})
1294    tokens_purchased = int(res['no_of_tokens'])
1295    insert_dict = {
1296        'email':email_id,
1297        'timestamp':int(time.time()),
1298        'currency':'eth',
1299        'content':str(value) + ' eth, ' + str(tokens_purchased) + ' tokens',
1300        'to_address':to_address,
1301        'from_address':from_address,
1302        'txid':txid,
1303        'confirmations':confirmations,
1304        'token_purchased':tokens_purchased,
1305        'type':'eth_transaction',
1306        'bid_id':bid_id,
1307        'exchange_rate':get_current_cashaa_price_model('eth')
1308    }
1309    db_conn.user_timeline.insert(insert_dict)
1310    send_confirmation_mail(email_id,tokens_purchased,value,'ETH')
1311
1312def get_user_flag(address):
1313    res = db_conn.user_timeline.find_one({'to_address':address})
1314    return res
1315
1316def get_user_flag_eth(bid_id):
1317    res = db_conn.user_timelne.find_one({'bid_id':bid_id})
1318    return res
1319
1320def insert_successful_fiat_transaction_in_user_timeline(str_id,timestamp,amount,email):
1321    # rate = get_pr
1322    res = db_conn.transaction_details.find_one({'unconfirmed_id':str_id})
1323    tokens_purchased = int(res['no_of_tokens'])
1324    insert_dict = {
1325        'email':res['email'],
1326        'timestamp':res['epoch'],
1327        'currency':'fiat',
1328        'content':str(res['value']) + ' fiat, ' + str(tokens_purchased) + ' tokens',
1329        'token_purchased':tokens_purchased,
1330        'type':'fiat_transaction',
1331        'unconfirmed_id':str_id
1332    }
1333    db_conn.user_timeline.insert(insert_dict)
1334    send_confirmation_mail(res['email'],tokens_purchased,amount,'FIAT')
1335
1336def insert_rejected_fiat_transaction_in_user_timeline(_id,email):
1337    insert_dict = {
1338        'email':email,
1339        'timestamp':int(time.time()),
1340        'unverified_id':_id,
1341        'type':'rejected_fiat_transaction',
1342        'content':None,
1343        'currency':'fiat'
1344    }
1345    db_conn.user_timeline.insert(insert_dict)
1346
1347def add_category_model(category):
1348    res = db_conn.categories.insert({'category':category})
1349    return res
1350
1351def update_category_model(new_category,_id):
1352    res = db_conn.categories.update({'_id':ObjectId(_id)},{'$set':{'category':new_category}})
1353    return res
1354
1355def delete_category_model(_id):
1356    res = db_conn.categories.remove({'_id':ObjectId(_id)})
1357    return res
1358
1359def display_category_model():
1360    res = db_conn.categories.find({})
1361    return res
1362
1363def raise_ticket_model(email,issue_category,subject,phone,description):
1364    insert_dict = {
1365        'email':email,
1366        'category':issue_category,
1367        'subject':subject,
1368        'phone':phone,
1369        'description':description,
1370        'timestamp':int(time.time()),
1371        'status':'open'
1372    }
1373    res = db_conn.tickets.insert(insert_dict)
1374    db_conn.ticket_chats.insert({'ticket_no':str(res)})
1375    return res
1376
1377def display_ticket_to_user_model(email):
1378    res = db_conn.tickets.find({'email':email})
1379    return res
1380
1381def display_ticket_to_admin_model():
1382    res = db_conn.tickets.find()
1383    return res
1384
1385def insert_in_otp(email,otp_str):
1386    res = db_conn.otp_details.find_one({'email':email,'otp_flag':True})
1387    if not res:
1388        insert_res = db_conn.otp_details.insert({'email':email,'otp_str':otp_str,
1389                                          'timestamp':int(time.time()),'otp_flag':False,
1390                                          'current_flag':False})
1391    return insert_res
1392
1393def get_otp_str(email,disable=None):
1394    res = db_conn.otp_details.find_one({'email':email,'current_flag':False})
1395    if disable:
1396        res = db_conn.otp_details.find_one({'email':email,'current_flag':True})
1397    return res
1398
1399def get_otp_str_model(email):
1400    res = db_conn.otp_details.find_one({'email':email})
1401    return res
1402
1403def update_current_otp_flag(email):
1404    res = db_conn.otp_details.update({'email':email},
1405                                    {"$set":{'current_flag':True,'otp_flag':True}})
1406
1407def check_2fa_status(email):
1408    res = db_conn.otp_details.find_one({'email':email})
1409    if res:
1410        return res['current_flag']
1411
1412def disable_current_otp_flag(email):
1413    res = db_conn.otp_details.update({'email':email},{"$set":{'current_flag':False}})
1414
1415def close_ticket_model(_id):
1416    res = db_conn.tickets.find_one({'_id':ObjectId(_id)})
1417    res1 = db_conn.tickets.update({'_id':ObjectId(_id)},{"$set":{'status':'close'}})
1418    return res
1419
1420def reopen_ticket_model(_id):
1421    res = db_conn.tickets.find_one({'_id':ObjectId(_id)})
1422    res1 = db_conn.tickets.update({'_id':ObjectId(_id)},{"$set":{'status':'open'}})
1423    return res
1424
1425def insert_user_message_model(message,ticket_no):
1426    res = db_conn.tickets.update({"_id":ObjectId(ticket_no)},{"$set":{"chat_status":"user_answered","last_modified":int(time.time())}})
1427    print 'iiiiii %s,%s,%s' %(message,ticket_no,res)
1428    return res
1429
1430def insert_admin_message_model(message,ticket_no):
1431    # res = db_conn.ticket_chats.update({'ticket_no':ticket_no},{"$push":{"messages":{'message':message,'timestamp':int(time.time()),'sent_by':'admin'}}})
1432    res= db_conn.tickets.update({"_id":ObjectId(ticket_no)},{"$set":{"chat_status":"admin_answered","last_modified":int(time.time())}})
1433    return res
1434
1435
1436def get_ticket_chat_notifications_model():
1437    res = db_conn.tickets.find({"status" : "open"})
1438    list_to_send = []
1439    for data in res:
1440        insert_dict = dict()
1441        insert_dict['ticket_no'] = str(data['_id'])
1442        message_length = 0
1443        res1 = db_conn.ticket_chats.find_one({'ticket_no':str(data['_id'])})
1444        if res1.__contains__('messages'):
1445            message_list = res1['messages']
1446            for message in message_list:
1447                if message['sent_by'] == 'user':
1448                    message_length += 1
1449        insert_dict['messages'] = message_length
1450        list_to_send.append(insert_dict)
1451    return list_to_send
1452
1453def get_ticket_chat_notifications_from_admin_model(email):
1454    res = db_conn.tickets.find({"status" : "open",'email':email})
1455    list_to_send = []
1456    for data in res:
1457        insert_dict = dict()
1458        insert_dict['ticket_no'] = str(data['_id'])
1459        message_length = 0
1460        res1 = db_conn.ticket_chats.find_one({'ticket_no':str(data['_id'])})
1461        if res1.__contains__('messages'):
1462            message_list = res1['messages']
1463            for message in message_list:
1464                if message['sent_by'] == 'admin':
1465                    message_length += 1
1466        insert_dict['messages'] = message_length
1467        list_to_send.append(insert_dict)
1468    return list_to_send
1469
1470
1471def get_chat_details_model(ticket_no):
1472    res = db_conn.ticket_chats.find_one({'ticket_no':ticket_no})
1473    return res
1474
1475
1476
1477
1478# db.transaction_details.find({epoch: {$gte:"1526807411",$lte:"1526807419"}},{email: 1, epoch: 1,no_of_tokens: 1,value :1,txid :1,currency:1 ,_id:0})
1479
1480def get_detail_data_from_to_date_model(from_date,to_date): 
1481    res = db_conn.transaction_details.find({"epoch": {'$gte':from_date,'$lte':to_date}},{"email": 1, "epoch": 1,"no_of_tokens": 1,"value" :1,"txid" :1,"currency":1 ,"_id":0})
1482    # print res
1483    ret_arr =[]
1484    if res:
1485        for data in res:
1486            epoch_to_date = time.strftime("%d %b, %Y", time.localtime(data["epoch"]))
1487            data["human_time"]=epoch_to_date
1488            ret_arr.append(data)
1489    
1490    return ret_arr
1491
1492
1493
1494def get_summary_data_from_to_date_model(from_date, to_date):
1495    res = db_conn.transaction_details.find({},{"no_of_tokens": 1, "currency": 1,"value": 1})
1496    btc_value = 0
1497    eth_value = 0
1498    cas_token = 0
1499    for data in res:
1500        print "*************************%s " %data 
1501        if data['currency'] == 'eth':
1502            eth_value += eth_value + float(data['value'])
1503        if data['currency'] == 'btc':
1504            btc_value += btc_value + float(data['value'])
1505        cas_token += float(cas_token + data['no_of_tokens'])
1506    
1507    return btc_value,eth_value,cas_token