API tools faq
paste
parishilan

ico_with_bid_models.py

parishilan
Feb 28th, 2019
106
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 72.28 KB | None | 0 0
raw download clone embed print report
  1. from __future__ import unicode_literals
  2.  
  3. import config
  4. from html_strings import get_send_confirmation_mail_html
  5.  
  6. import time
  7. import json
  8. import requests
  9. import re
  10. from mailin import Mailin
  11. import math
  12. import boto
  13. from bson.objectid import ObjectId
  14. import base64
  15. import hashlib
  16. import pyotp
  17. from Crypto import Random
  18. from Crypto.Cipher import AES
  19. import jwt
  20. from bson import ObjectId
  21.  
  22. jwt_secret = '5bbe6e102446498e814822b2c686fe359eb6944a0c6a48a8940b44879b1b30510bf23e9de83d4ab28d01227d649297d2fb2807ad74fd4bc2825174d2cb542714'
  23.  
  24. if config.prod is False:
  25. REGION_HOST = 's3.eu-central-1.amazonaws.com'
  26. bucket_name = 'bubblo-kyc-data'
  27. else:
  28. REGION_HOST = 's3.eu-west-2.amazonaws.com'
  29. bucket_name = 'otc-data'
  30. # s3_conn = boto.connect_s3(host=REGION_HOST)
  31. # bucket = s3_conn.get_bucket(bucket_name)
  32. # Create your models here.
  33. db_conn = config.mongo_conn().bubblo_ico
  34. db_conn_wallet = config.mongo_conn().bubblo_wallet
  35. redis_conn = config.redis_conn
  36. r = redis_conn()
  37. base_reference = 9000
  38.  
  39. if config.prod is False:
  40. couch_user = 'cas_exchange'
  41. couch_pass = 'staging'
  42. couch_ip = '167.99.207.134'
  43. else:
  44. couch_user = 'cas_exchange'
  45. couch_pass = '017ad4b9541'
  46. couch_ip = '127.0.0.1'
  47. couch_base_url = 'http://' + couch_user + ':' + couch_pass + '@' + couch_ip + ':6984/'
  48.  
  49.  
  50. def create_jwt(email):
  51. # if r.get('active_emails_' + email) is None:
  52. # return 0
  53. res = db_conn.user_master.find_one({'email': email, 'status': {"$exists": True}})
  54. if res:
  55. return 'inactive_account'
  56. encoded_token = jwt.encode({"email": email, 'time': time.time()}, jwt_secret, algorithm="HS384")
  57. print "-------------->jwt"
  58. print encoded_token
  59. r.setex(encoded_token, 10800, email)
  60. return encoded_token
  61.  
  62.  
  63. class AESCipher(object):
  64.  
  65. def __init__(self, key):
  66. self.bs = 32
  67. self.key = hashlib.sha256(key.encode()).digest()
  68.  
  69. def encrypt(self, raw):
  70. raw = self._pad(raw)
  71. iv = Random.new().read(AES.block_size)
  72. cipher = AES.new(self.key, AES.MODE_CBC, iv)
  73. return base64.b64encode(iv + cipher.encrypt(raw))
  74.  
  75. def decrypt(self, enc):
  76. enc = base64.b64decode(enc)
  77. iv = enc[:AES.block_size]
  78. cipher = AES.new(self.key, AES.MODE_CBC, iv)
  79. return self._unpad(cipher.decrypt(enc[AES.block_size:])).decode('utf-8')
  80.  
  81. def _pad(self, s):
  82. return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs)
  83.  
  84. @staticmethod
  85. def _unpad(s):
  86. return s[:-ord(s[len(s) - 1:])]
  87.  
  88.  
  89. def get_firebase_user_id():
  90. res = db_conn.firebase_id.find_one({})
  91. return res['firebase_user_id']
  92.  
  93.  
  94. def get_rates_model(token):
  95. res = db_conn.token_rates.find({'token': token, 'current': True})
  96. rates_dict = {}
  97. for data in res:
  98. rates_dict[data['currency']] = data['value']
  99. return rates_dict
  100.  
  101.  
  102. def insert_fiat_transaction_for_approval(amount_deposited,date,transaction_id,bank,email,exchange_rate,type,currency):
  103. insert_dict = {
  104.  
  105. 'amount_deposited_according_to_user': amount_deposited,
  106. 'transaction_id': transaction_id,
  107. 'bank': bank,
  108. 'status': 1,
  109. 'transaction_status': 'pending',
  110. 'date': date,
  111. 'currency': currency,
  112. 'email': email,
  113. 'exchange_rate':exchange_rate,
  114. 'type':'wire_transfer',
  115. 'time':int(time.time())
  116.  
  117.  
  118. }
  119. db_conn.unverified_transactions.insert(insert_dict)
  120.  
  121.  
  122.  
  123. def get_pending_fiat_transactions_model():
  124. res = db_conn.unverified_transactions.find({'type':'wire_transfer'}, {"_id": 0})
  125. return res
  126.  
  127.  
  128. def get_final_fiat_data(email, transaction_id):
  129. res = db_conn.unverified_transactions.find_one(
  130. {'email': email, 'currency': 'usd', 'transaction_id': transaction_id}, {"_id": 0})
  131. print"asdfasdfa%s" % res
  132. return res
  133.  
  134.  
  135. def update_fiat_transaction_admin(**update_json):
  136. find_param = {"email": update_json["email"], "currency": "usd"}
  137. update_params = {'admin_receive_date': update_json['admin_receive_date'],
  138. 'admin_receive_time': update_json['admin_receive_time'],
  139. 'admin_received_amount': update_json['admin_received_amount'],
  140. 'admin_send_token': update_json['admin_send_token'],
  141. "transaction_status": update_json['transaction_status']}
  142. db_conn.unverified_transactions.update(find_param, {"$set": update_params})
  143.  
  144.  
  145. # oid_str = '555fc7956cda204928c9dbab'
  146. # oid2 = ObjectId(oid_str)
  147. # print(repr(oid2))
  148.  
  149. def update_txid_cas_model(_id, txid):
  150. find_params = {"_id": ObjectId(_id)}
  151. resp = db_conn.unverified_transactions.update(find_params, {"$set": {"txid": txid}})
  152. print resp
  153.  
  154.  
  155. def get_rate(timestamp, currency):
  156. res = db_conn.token_rates.find_one({"from_date": {"$lte": timestamp}, "to_date": {"$gte": timestamp}})
  157. if res:
  158. return res[currency]
  159. else:
  160. print 'using default rate:: '
  161. res1 = db_conn.token_rates.find_one({'current': True})
  162. print 'rrrr %s' % res1
  163. print '1212 %s' % res1['default_' + currency]
  164. return res1['default_' + currency]
  165.  
  166.  
  167. def get_total_tokens_sold():
  168. res = db_conn.transaction_details.find({})
  169. total_tokens = 0.0
  170. for data in res:
  171. if data.__contains__('no_of_tokens'):
  172. total_tokens += float(data['no_of_tokens'])
  173. return total_tokens
  174.  
  175.  
  176. def get_current_rate(total_tokens):
  177. total_tokens += 1
  178. res = db_conn.rate_card.find_one({'from': {"$lte": total_tokens}, 'to': {"$gte": total_tokens}})
  179. return res['rate']
  180.  
  181.  
  182. def get_firebase_config():
  183. res = db_conn.firebase_config.find_one({})
  184. return res
  185.  
  186.  
  187. # btc_to_usd --> renamed to rate_conversion
  188.  
  189. # db_conn_wallet.rate_conversion
  190.  
  191.  
  192. def get_price(tokens_to_buy, currency):
  193. res = db_conn_wallet.rate_conversion.find_one()
  194. bubblo_btc = float(res['bubblo_btc'])
  195. bubblo_eth = float(res['bubblo_eth'])
  196. bubblo_usd = float(res['bubblo_usd'])
  197. bubblo_cas = float(res['bubblo_cas'])
  198. price_list = []
  199. if currency == 'btc':
  200. price_list.append([tokens_to_buy, bubblo_btc])
  201. if currency == 'eth':
  202. price_list.append([tokens_to_buy, bubblo_eth])
  203. if currency == 'usd':
  204. price_list.append([tokens_to_buy, bubblo_usd])
  205. if currency == "cas":
  206. price_list.append([tokens_to_buy, bubblo_cas])
  207. price = 0.0
  208. for data in price_list:
  209. price += float(data[0]) * float(data[1])
  210. return price_list, round(price, 8)
  211.  
  212.  
  213. def get_usd_rate():
  214. res = db_conn_wallet.rate_conversion.find_one()
  215. bubblo_usd = float(res['bubblo_usd'])
  216. return bubblo_usd
  217.  
  218.  
  219. def get_current_bubblo_price_model(currency):
  220. res = db_conn_wallet.rate_conversion.find_one()
  221. bubblo_btc = float(res['bubblo_btc'])
  222. bubblo_eth = float(res['bubblo_eth'])
  223. bubblo_cas = float(res['bubblo_eth'])
  224. if currency == 'btc':
  225. return bubblo_btc
  226. elif currency == 'eth':
  227. return bubblo_eth
  228. else:
  229. return bubblo_cas
  230.  
  231.  
  232. def get_current_cashaa_price_model(currency):
  233. res = db_conn_wallet.rate_conversion.find_one()
  234. bubblo_btc = float(res['bubblo_btc'])
  235. bubblo_eth = float(res['bubblo_eth'])
  236. if currency == 'btc':
  237. return bubblo_btc
  238. else:
  239. return bubblo_eth
  240.  
  241.  
  242. def get_user_cas_bal(email):
  243. tokens = 0.0
  244. timeline_res = get_user_timeline_model(email)
  245. for data in timeline_res:
  246. if data.__contains__('token_purchased'):
  247. tokens += int(float(data['token_purchased']))
  248. print 'ttt tokens::: %s' % tokens
  249. if data.__contains__('tokens_purchased'):
  250. tokens += int(float(data['tokens_purchased']))
  251. print 'ttt tokens::: %s' % tokens
  252. cashaa_withdrawal_res = get_cashaa_withdrawal_details(email)
  253. for data in cashaa_withdrawal_res:
  254. tokens -= int(float(data['amount_withdrawn']))
  255. print 'ppppp %s' % tokens
  256. return int(tokens)
  257.  
  258.  
  259. def get_value_to_be_paid(address):
  260. res = db_conn.unverified_transactions.find_one({'to_address': address})
  261. return res['amount_to_pay']
  262.  
  263.  
  264. def get_price_distribution(address):
  265. res = db_conn.unverified_transactions.find_one({'to_address': address})
  266. return res['price_distribution']
  267.  
  268.  
  269. def get_cap(timestamp):
  270. res = db_conn.cap.find_one({"from_date": {"$lte": timestamp}, "to_date": {"$gte": timestamp}})
  271. if res:
  272. return float(res['min_cap']), float(res['max_cap'])
  273. else:
  274. print 'using default cap:::: '
  275. res1 = db_conn.cap.find_one({'current': True})
  276. return float(res1['default_min_cap']), float(res1['default_max_cap'])
  277.  
  278.  
  279. def get_erc_address(email):
  280. res = db_conn.user_master.find_one({'email': email})
  281. if res.__contains__('erc_address'):
  282. return res['erc_address']
  283. else:
  284. return None
  285.  
  286.  
  287. def get_erc_wallet(email):
  288. res = db_conn.user_master.find_one({'email': email})
  289. if res.__contains__('eth_wallet'):
  290. return res['eth_wallet']
  291. else:
  292. return None
  293.  
  294.  
  295. def get_email_id_model(address, currency):
  296. if currency == 'btc':
  297. res = db_conn.user_master.find_one({'btc_address_list': {"$elemMatch": {"$eq": address}}})
  298. return res['email']
  299. if currency == 'eth':
  300. res = db_conn.user_master.find_one({'bid_id_list': {"$elemMatch": {"$eq": address}}})
  301. return res['email']
  302.  
  303.  
  304. def get_admin_role(email):
  305. res = db_conn.admin.find_one({'email': email})
  306. if res.__contains__('role'):
  307. return res['role']
  308. return ['super_admin']
  309.  
  310.  
  311. def get_email_id_from_bid_id_model(bid_id):
  312. res = db_conn.user_master.find_one({'bid_id_list': {"$elemMatch": {"$eq": bid_id}}})
  313. if res:
  314. return res['email']
  315.  
  316.  
  317. def get_email_id_from_to_address_model(to_address):
  318. res = db_conn.user_master.find_one({'eth_address_list': {"$elemMatch": {"$eq": to_address}}})
  319. if res:
  320. return res['email']
  321.  
  322.  
  323. def get_referral_details_model(address, currency):
  324. if currency == 'btc':
  325. res = db_conn.user_master.find_one({'btc_address_list': {"$elemMatch": {"$eq": address}}})
  326. else:
  327. res = db_conn.user_master.find_one({'eth_address_list': {"$elemMatch": {"$eq": address}}})
  328. return res['ref_id'], res['tnc']['name']
  329.  
  330.  
  331. def get_referral_details_model_fiat(str_id):
  332. email = db_conn.unverified_transactions.find_one({'_id': ObjectId(str_id)})['email']
  333. res = db_conn.user_master.find_one({'email': email})
  334. return res['ref_id'], res['tnc']['name']
  335.  
  336.  
  337. def get_inr_referral_details_model_fiat(email):
  338. res = db_conn.user_master.find_one({"email": email})
  339. if res:
  340. return res['ref_id'], res['tnc']['name']
  341.  
  342.  
  343. def validate_user(email, password):
  344. res = db_conn.user_master.find_one({'email': email, 'password': hashlib.sha256(password).hexdigest()})
  345. return res
  346.  
  347.  
  348. def update_transaction_details(to_address, from_address, value, txid, confirmations):
  349. txid_exists_flag = db_conn.transaction_details.find_one({'txid': txid})
  350.  
  351. if txid_exists_flag is None:
  352. insert_dict = {
  353. 'to_address': to_address,
  354. 'from_address': from_address,
  355. 'value': value,
  356. 'txid': txid,
  357. 'currency': 'btc',
  358. 'epoch': int(time.time()),
  359. 'confirmations': int(confirmations)
  360. }
  361.  
  362. res = db_conn.user_master.find_one({'btc_address_list': {"$elemMatch": {"$eq": to_address}}})
  363. insert_dict['email'] = res['email']
  364. no_of_tokens, exchange_rate = calculate_token_from_price(value, "btc")
  365.  
  366. insert_dict['no_of_tokens'] = no_of_tokens
  367. insert_dict['exchange_rate'] = exchange_rate
  368.  
  369. print "inseting in transaction details"
  370. print insert_dict
  371.  
  372. db_conn.transaction_details.insert(insert_dict)
  373.  
  374.  
  375.  
  376. else:
  377. print "txid exist in transaction details"
  378. old_confirmations = int(txid_exists_flag["confirmations"])
  379. if old_confirmations < 3:
  380. db_conn.transaction_details.update({"txid": txid}, {"$set": {"confirmations": int(confirmations)}})
  381.  
  382.  
  383. def calculate_token_from_price(value, currency):
  384. rate_from_db = db_conn_wallet.rate_conversion.find_one()
  385. if currency == "btc":
  386. btc_xal = rate_from_db["bubblo_btc"]
  387. no_of_tokens = round(float(value / btc_xal), 3)
  388. return no_of_tokens, btc_xal
  389. if currency == "eth":
  390. eth_xal = rate_from_db["bubblo_eth"]
  391. no_of_tokens = round(float(value / eth_xal), 3)
  392. return no_of_tokens, eth_xal
  393.  
  394.  
  395. def get_no_of_token_allocated(email, txid):
  396. resp = db_conn.transaction_details.find_one({"email": email, "txid": txid})
  397. allocated_tokens = float(resp["no_of_tokens"])
  398. exchange_rate = resp["exchange_rate"]
  399. return allocated_tokens, exchange_rate
  400.  
  401.  
  402. def insert_transaction_in_couch(couch_json):
  403. """
  404. =================== One time only ================================
  405. Run this command manually to create table:
  406. requests.put('http://couch_user:couch_pass@couch_ip:6984/live_orders_v1')
  407. Run this command manually to create a new id and insert doocument:
  408. re = requests.put('http://couch_user:couch_pass@couch_ip:6984/live_orders_v1/live_order_unique_id',data=json.dumps({'live_order_list':[]}))
  409. Run this command to get _rev and hardcode it here:
  410. re = requests.get('http://couch_user:couch_pass@couch_ip:6984/live_orders_v1/live_order_unique_id')
  411. """
  412. print '12311111111111111123123 insert_transaction_in_couch ================= '
  413. id = 'live_order_unique_id'
  414. collection = 'live_orders_v1'
  415. couch_res = requests.get(couch_base_url + collection + '/' + id)
  416. couch_jsonify = json.loads(couch_res.text)
  417. _rev = couch_jsonify['_rev']
  418. live_order_list = couch_jsonify['live_order_list']
  419. if len(live_order_list) <= 20:
  420. live_order_list = [couch_json] + live_order_list
  421. else:
  422. live_order_list = live_order_list[0:21]
  423. live_order_list = [couch_json] + live_order_list
  424. update_json = {'_rev': _rev, 'live_order_list': live_order_list}
  425. print 'updating oreder_list in couch::: %s, \nNew order list::::: %s' % (live_order_list, couch_json)
  426. print '============================================================================================'
  427. update_res = requests.put(couch_base_url + collection + '/' + id, data=json.dumps(update_json))
  428. print 'uuuuuuuu %s' % update_res.text
  429. # if update_res.status_code == 200:
  430. # print 'succ'
  431.  
  432.  
  433. def get_graph_data(from_timestamp, to_timestamp):
  434. # print 'ff %s, tt %s' %(from_timestamp,to_timestamp)
  435. res = db_conn_wallet.rate_conversion.find({'timestamp': {'$gte': from_timestamp, '$lte': to_timestamp}})
  436. return_list = []
  437. for data in res:
  438. # print 'dd %s' %data
  439. return_list.append(
  440. {'timestamp': data['timestamp'], 'cashaa_eth': data['cashaa_eth'], 'cashaa_btc': data['cashaa_btc']})
  441. return return_list
  442.  
  443.  
  444. def update_recieve_transaction_eth_model(email, address, from_address, value, txid, confirmations, erc_address,
  445. erc_wallet):
  446. txid_exist = db_conn.transaction_details.find_one({'txid': txid})
  447.  
  448. if not txid_exist:
  449. insert_dict = {
  450. 'email': email,
  451. 'to_address': address,
  452. 'from_address': from_address,
  453. 'value': value,
  454. 'txid': txid,
  455. 'currency': 'eth',
  456. 'epoch': int(time.time()),
  457. 'erc_address': erc_address,
  458. 'erc_wallet': erc_wallet,
  459. 'confirmations': confirmations
  460. }
  461.  
  462. no_of_tokens, exchange_rate = calculate_token_from_price(value, "eth")
  463.  
  464. insert_dict['no_of_tokens'] = no_of_tokens
  465. insert_dict['exchange_rate'] = exchange_rate
  466.  
  467. db_conn.transaction_details.insert(insert_dict)
  468. print "inserting in transaction master %s" %insert_dict
  469. return True
  470.  
  471.  
  472. else:
  473. print "txid exist in transaction details"
  474. old_confirmations = int(txid_exist["confirmations"])
  475. if old_confirmations < 3 and old_confirmations < confirmations:
  476. db_conn.transaction_details.update({"txid": txid}, {"$set": {"confirmations": int(confirmations)}})
  477. return False
  478.  
  479.  
  480. def insert_into_invalid_bids(from_address, to_address, txid, value):
  481. insert_dict = {
  482. 'from_address': from_address,
  483. 'to_address': to_address,
  484. 'txid': txid,
  485. 'value': value,
  486. 'timestamp': int(time.time())
  487. }
  488. res = db_conn.invalid_bids.find_one({'txid': txid})
  489. if res is None:
  490. db_conn.invalid_bids.insert(insert_dict)
  491.  
  492.  
  493. def back_calculation(value_paid, value_promised, price_list):
  494. new_price_list = []
  495. tokens_bought = int(math.floor(float(price_list[0][0]) / float(value_promised) * float(value_paid)))
  496. new_price_list.append([tokens_bought, price_list[0][1]])
  497. price = 0.0
  498. for i in new_price_list:
  499. price += i[0] * i[1]
  500. # tokens_bought += i[0]
  501. return price, new_price_list, tokens_bought
  502.  
  503.  
  504. def update_transaction_confirmations(txid):
  505. res = db_conn.transaction_details.update({'txid': txid}, {"$inc": {"confirmations": 1}})
  506. no_of_tokens = db_conn.transaction_details.find_one({'txid': txid})['no_of_tokens']
  507. return no_of_tokens
  508.  
  509.  
  510. def update_fiat_transaction_flag(str_id):
  511. _id = ObjectId(str_id)
  512. res = db_conn.unverified_transactions.update({'_id': _id},
  513. {"$set": {'status': 2, 'transaction_status': 'verified'}})
  514. return res
  515.  
  516.  
  517. def reject_fiat_transaction_flag(str_id):
  518. _id = ObjectId(str_id)
  519. res = db_conn.unverified_transactions.update({'_id': _id},
  520. {"$set": {'status': -1, 'transaction_status': 'rejected'}})
  521. return res
  522.  
  523.  
  524. def insert_fiat_transaction_in_transaction_details(email, transaction_id):
  525. prev_data = db_conn.unverified_transactions.find_one(
  526. {"transaction_id": transaction_id, "email": email, "transaction_status": "approve"}, {"_id": 0})
  527. insert_json = {'email': prev_data['email'], 'time': prev_data['time'],
  528. 'no_of_tokens': prev_data['admin_send_token'], 'txid': prev_data['transaction_id'],
  529. 'value': prev_data['admin_received_amount'], 'price': prev_data['exchange_rate'], 'currency': 'usd'}
  530. db_conn.transaction_details.insert(insert_json)
  531.  
  532.  
  533. def user_existance(new_email, password):
  534. count = db_conn.user_master.find({}).count()
  535. tmp_ref_id = str(base_reference + count)
  536. if len(tmp_ref_id) == 4:
  537. ref_id = '00' + tmp_ref_id
  538. elif len(tmp_ref_id) == 5:
  539. ref_id = '0' + tmp_ref_id
  540. else:
  541. ref_id = tmp_ref_id
  542. json_obj = {"email": new_email, 'ref_id': ref_id, 'password': hashlib.sha256(password).hexdigest()}
  543.  
  544. db_conn.user_master.insert(json_obj)
  545. print "entering new user uin user timeline%s" % json_obj
  546. insert_in_referral_tree(new_email, ref_id)
  547. print "entering email %s with ref id %s in ref tree" %(new_email,ref_id)
  548.  
  549.  
  550. def insert_in_referral_tree(new_email, ref_id):
  551. db_conn.referral_tree.insert({'email': new_email, 'ref_id': ref_id, 'parent': None, 'child': []})
  552.  
  553.  
  554. def validate_ref_id(ref_id):
  555. res = db_conn.user_master.find_one({'ref_id': ref_id})
  556. return res
  557.  
  558.  
  559. def insert_parent_ref_id(user_ref_id, ref_id):
  560. db_conn.referral_tree.update({'ref_id': user_ref_id}, {"$set": {'parent': ref_id}})
  561.  
  562.  
  563. def push_child_ref_id(user_ref_id, ref_id):
  564. res = db_conn.referral_tree.find_one({'ref_id': ref_id})
  565. if res.__contains__('child'):
  566. if user_ref_id not in res['child']:
  567. db_conn.referral_tree.update({'ref_id': ref_id}, {"$push": {'child': user_ref_id}})
  568. else:
  569. db_conn.referral_tree.update({'ref_id': ref_id}, {"$push": {'child': user_ref_id}})
  570.  
  571.  
  572. def get_ref_id(email):
  573. res = db_conn.user_master.find_one({'email': email})
  574. return res['ref_id']
  575.  
  576.  
  577. # this is of udasi
  578. def calc_referal_bonus(ref_id, amount, name, currency):
  579. # rate_arr = [0.05, 0.02, 0.02, 0.02, 0.01, 0.01, 0.005, 0.005, 0.005, 0.005]
  580. rate_arr = [0.05]
  581. flag = True
  582. height = 0
  583. # reward_arr = []
  584. while flag:
  585. temp_json = {}
  586. find_param = {'ref_id': ref_id}
  587. ref_cursor = db_conn.referral_tree.find_one(find_param)
  588. print "ref ", ref_cursor
  589. if ref_cursor['parent'] and (height < len(rate_arr)):
  590. temp_json['bonus_refid'] = ref_cursor['parent']
  591. temp_json['bonus_amount'] = float(amount) * float(rate_arr[height])
  592. temp_json['height'] = height + 1
  593. temp_json['from_ref_id'] = ref_id
  594. temp_json['name'] = name
  595. temp_json['currency'] = currency
  596. temp_json['spent'] = False
  597. db_conn.referral_bonus.insert(temp_json)
  598. # reward_arr.append(temp_json)
  599. ref_id = ref_cursor['parent']
  600. else:
  601. flag = False
  602. height += 1
  603. # return reward_arr
  604.  
  605.  
  606. ##this functino is made to do refereal bonus changes according to that of auxledger ico
  607. # in case it is called from eth: to_address = bid_id
  608. def calc_referal_bonus_auxledger(ref_id, amount, name, currency, to_address, txid, email):
  609. rate_arr = [0.05]
  610. flag = False
  611. height = 0
  612. # reward_arr = []
  613. exist_flag = db_conn.referral_bonus.find_one({"txid": txid})
  614. if exist_flag is None:
  615. flag = True
  616.  
  617. if flag:
  618. temp_json = {}
  619. find_param = {'ref_id': ref_id}
  620. ref_cursor = db_conn.referral_tree.find_one(find_param)
  621.  
  622. if ref_cursor['parent'] and (height < len(rate_arr)):
  623. temp_json['bonus_refid'] = ref_cursor['parent']
  624. bonus_amount = round(float(get_token_purched(to_address, txid, currency)) * float(rate_arr[height]), 3)
  625. temp_json['child_email'] = email
  626. temp_json['bonus_amount'] = bonus_amount
  627. temp_json['height'] = height + 1
  628. temp_json['from_ref_id'] = ref_id
  629. temp_json['name'] = name
  630. temp_json['currency'] = currency
  631. temp_json['spent'] = False
  632. temp_json['txid'] = txid
  633.  
  634. get_parent_details = db_conn.user_master.find_one({"ref_id": ref_cursor['parent']})
  635.  
  636. temp_json['email_id'] = get_parent_details["email"]
  637.  
  638. db_conn.referral_bonus.insert(temp_json)
  639. # db_conn.update_user
  640. insert_ref_bonus_in_user_timeline(get_parent_details["email"], txid, email, bonus_amount)
  641.  
  642. else:
  643. flag = False
  644. height += 1
  645.  
  646.  
  647. def insert_ref_bonus_in_user_timeline(parent_email, txid, source_email, bonus_amount):
  648. insert_dict = {
  649. "email": parent_email,
  650. "txid": txid,
  651. "child_email": source_email,
  652. "tokens_purchased": bonus_amount,
  653. "type": "ref_bonus",
  654. "timestamp": time.time()
  655. }
  656. db_conn.user_timeline.insert(insert_dict)
  657.  
  658.  
  659. def get_token_purched(address, txid, currency):
  660. if currency == "btc" or currency == "BTC":
  661. res = db_conn.transaction_details.find_one({'to_address': address, 'txid': txid})
  662. tokens_purchased = float(res['no_of_tokens'])
  663. return tokens_purchased
  664. elif currency == "INR" or currency == "inr":
  665. res = db_conn.transaction_details.find_one({'txid': txid})
  666. tokens_purchased = float(res['no_of_tokens'])
  667. return tokens_purchased
  668. else:
  669. res = db_conn.transaction_details.find_one({'to_address': address, 'txid': txid})
  670. tokens_purchased = float(res['no_of_tokens'])
  671. return tokens_purchased
  672.  
  673.  
  674. def get_referral_list_model(ref_id):
  675. res = db_conn.referral_bonus.find({'bonus_refid': ref_id})
  676. return res
  677.  
  678.  
  679. def update_password_model(email, password):
  680. res = db_conn.user_master.update({'email': email}, {"$set": {'password': hashlib.sha256(password).hexdigest()}})
  681. return res
  682.  
  683.  
  684. def get_withdraw_details(_id):
  685. res = db_conn.cashaa_withdrawals.find_one({'_id': ObjectId(_id)})
  686. return res
  687.  
  688.  
  689. def get_withdrawal_details_admin_model():
  690. res = db_conn.admin_withdraw.find({})
  691. return res
  692.  
  693.  
  694. def get_withdraw_details_from_admin_model(str_id):
  695. _id = ObjectId(str_id)
  696. res = db_conn.admin_withdraw.find_one({'_id': _id, 'spent': False})
  697. return res
  698.  
  699.  
  700. def get_otp_for_admin_model():
  701. # r = redis_conn()
  702. res = r.keys('*')
  703. send_list = []
  704. # print 'rrreee %s,%s' %(res,type(res))
  705. for data in res:
  706. details_dict = dict()
  707. email_flag = re.search('^[\w\.=-]+@[\w\.-]+\.[\w]{1,5}$', data)
  708. if email_flag:
  709. otp = r.get(data)
  710. details_dict['email'] = data
  711. details_dict['otp'] = otp
  712. send_list.append(details_dict)
  713. return send_list
  714.  
  715.  
  716. def update_flag_in_admin_withdrawal(str_id, txid):
  717. _id = ObjectId(str_id)
  718. res = db_conn.admin_withdraw.update({'_id': _id}, {"$set": {'spent': True, 'txid': txid}})
  719. return res
  720.  
  721.  
  722. def get_withdraw_details_model(ref_id):
  723. res = db_conn.referral_bonus.find({'bonus_refid': ref_id})
  724. withdrawn_btc = 0.0
  725. pending_btc = 0.0
  726. withdrawn_eth = 0.0
  727. pending_eth = 0.0
  728. for data in res:
  729. if data['currency'] == 'btc':
  730. if data['spent'] is False:
  731. pending_btc += float(data['bonus_amount'])
  732. else:
  733. withdrawn_btc += float(data['bonus_amount'])
  734. if data['currency'] == 'eth':
  735. if data['spent'] is False:
  736. pending_eth += float(data['bonus_amount'])
  737. else:
  738. withdrawn_eth += float(data['bonus_amount'])
  739. return withdrawn_btc, pending_btc, withdrawn_eth, pending_eth
  740.  
  741.  
  742. def get_details_from_ref_tree(parents):
  743. res = db_conn.referral_tree.find({'ref_id': {"$in": parents}})
  744. return res
  745.  
  746.  
  747. def get_name(ref_id_list):
  748. name_list = []
  749. for ref_id in ref_id_list:
  750. res = db_conn.user_master.find_one({'ref_id': ref_id})
  751. # print 'nenenrnr %s' %res
  752. if res:
  753. name_list.append(res['tnc']['name'])
  754. return name_list
  755.  
  756.  
  757. def get_user_name(email):
  758. res = db_conn.user_master.find_one({'email': email})
  759. # print "&*&&&&&&&&&&&&&&&&&************ name is %s" %res
  760. return res['tnc']['name']
  761.  
  762.  
  763. def get_pending_amount(email, currency):
  764. res = db_conn.user_master.find_one({'email': email})
  765. ref_id = res['ref_id']
  766. res1 = db_conn.referral_bonus.find({'bonus_refid': ref_id, 'spent': False, 'currency': currency})
  767. pending_amount = 0.0
  768. for data in res1:
  769. pending_amount += float(data['bonus_amount'])
  770. return pending_amount
  771.  
  772.  
  773. def insert_into_admin(email, refund_address, currency, pending_amount, ref_id):
  774. insert_dict = {
  775. 'email': email,
  776. 'refund_address': refund_address,
  777. 'currency': currency,
  778. 'pending': round(pending_amount, 6),
  779. 'ref_id': ref_id,
  780. 'spent': False
  781. }
  782. res = db_conn.admin_withdraw.insert(insert_dict)
  783. return res
  784.  
  785.  
  786. def user_exists_model(email):
  787. res = db_conn.user_master.find_one({'email': email})
  788. print res
  789. return res
  790.  
  791.  
  792. def password_exists_model(email):
  793. res = db_conn.user_master.find_one({'email': email, 'password': {"$exists": True}})
  794. return res
  795.  
  796.  
  797. def model_insert(json_obj):
  798. db_conn.user_master.insert(json_obj)
  799.  
  800.  
  801. def otp_session(email, otp):
  802. r.setex(email, 600, otp)
  803.  
  804.  
  805. def set_admin_email_model(admin_email):
  806. r.set('admin_email', admin_email)
  807.  
  808.  
  809. def get_admin_email_model():
  810. admin_email = r.get('admin_email')
  811. return admin_email
  812.  
  813.  
  814. def otp_verification(email, otp):
  815. if 'withdraw_' in email:
  816. email = email.split('_')[2]
  817. res = db_conn.otp_details.find_one({'email': email, 'current_flag': True})
  818. # print 'mmmmmmmmmm::::::::::::::: %s,%s,%s' %(email,otp,res)
  819. if res:
  820. otp_str = res['otp_str']
  821. totp = pyotp.TOTP(otp_str)
  822. if totp.verify(otp) is True:
  823. flag = 1
  824. else:
  825. flag = 0
  826. else:
  827. val = r.get(email)
  828. if val == otp:
  829. flag = 1
  830. else:
  831. flag = 0
  832. return flag
  833.  
  834.  
  835. def get_otp(email):
  836. val = r.get(email)
  837. return val
  838.  
  839.  
  840. def uuid_verification(unique_id, email):
  841. # r = redis_conn()
  842. val = r.get(unique_id)
  843. if val == str(email):
  844. # print 'token match:::: '
  845. r.setex(unique_id, 10800, email)
  846. flag = 1
  847. else:
  848. flag = 0
  849. return flag
  850.  
  851.  
  852. def tnc_model(name, email):
  853. date_time = int(time.time())
  854. # print date_time
  855. db_conn.user_master.update({'email': email}, {'$set': {'tnc': {"time_stamp": date_time, "name": name}}})
  856.  
  857.  
  858. def verify_password_model(email, password):
  859. res = db_conn.user_master.find_one({'email': email, 'password': hashlib.sha256(password).hexdigest()})
  860. return res
  861.  
  862.  
  863. def kyc_model(input_json, email):
  864. db_conn.user_master.update({'email': email}, {'$set': {'kyc': input_json}})
  865.  
  866.  
  867. # def db_content(new_email):
  868. # token = db_conn.user_master.find_one( { "email": new_email } ) #email field contains new email or not
  869. # return token
  870.  
  871.  
  872. def save_uuid(unique_id, email):
  873. r.setex(unique_id, 10800, email) # 2 hour
  874.  
  875.  
  876. def del_uuid_from_redis(unique_id):
  877. r.delete(unique_id)
  878.  
  879.  
  880. def address_insertion_model(btc_address, eth_address, email):
  881. db_conn.user_master.update({'email': email}, {'$set': {'btc_address': btc_address, 'eth_address': eth_address}})
  882.  
  883.  
  884. def admin_vefificatoin(email, pwd):
  885. password = hashlib.sha256(pwd).hexdigest()
  886. res = db_conn.admin.find_one({"email": email, "password": password})
  887. # print res
  888. return res
  889.  
  890.  
  891. def total_user_count():
  892. count = db_conn.user_master.find({}).count()
  893. return count
  894.  
  895.  
  896. def verified_docs_counts_():
  897. count = db_conn.user_master.find({"kyc.status": "accepted"}).count()
  898. return count
  899.  
  900.  
  901. def get_kyc_status(email):
  902. res = db_conn.user_master.find_one({'email': email})
  903. if res.__contains__('kyc'):
  904. if res['kyc']['status'] == 'accepted':
  905. return True
  906. return False
  907.  
  908.  
  909. def rejected_docs_counts_():
  910. count = db_conn.user_master.find({"kyc.status": "rejected"}).count()
  911. return count
  912.  
  913.  
  914. def kyc_status_verify(email):
  915. db_conn.user_master.update({'email': email}, {'$set': {"kyc.status": "accepted"}})
  916.  
  917.  
  918. def pre_approve_kyc(email):
  919. db_conn.user_master.update({'email': email}, {
  920. "$set": {"kyc": {'status': 'accepted', 'aadhar_card_details': [], 'pan_card_details': []}}})
  921.  
  922.  
  923. def kyc_status_reject(email, reason):
  924. db_conn.user_master.update({'email': email}, {'$set': {"kyc.status": "rejected", "kyc.reason": reason}})
  925.  
  926.  
  927. def show_pending_model(page):
  928. res = db_conn.user_master.find({"kyc.status": "pending"}, {'kyc': 1, 'email': 1, '_id': 0}).skip(
  929. (page - 1) * 10).limit(10)
  930. count = db_conn.user_master.find({"kyc.status": "pending"}).count()
  931. # print res
  932. return res, count
  933.  
  934.  
  935. def get_all_users_model():
  936. res = db_conn.user_master.find({}, {'_id': 0})
  937. return res
  938.  
  939.  
  940. def get_user_kyc_details_model(email):
  941. res = db_conn.user_master.find_one({'email': email}, {'kyc': 1})
  942. return res
  943.  
  944.  
  945. def show_accepted_model(page):
  946. res = db_conn.user_master.find({"kyc.status": "accepted"}, {'kyc': 1, 'email': 1, '_id': 0}).skip(
  947. (page - 1) * 10).limit(10)
  948. count = db_conn.user_master.find({"kyc.status": "accepted"}).count()
  949. # print res
  950. return res, count
  951.  
  952.  
  953. def show_rejected_model(page):
  954. res = db_conn.user_master.find({"kyc.status": "rejected"}, {'kyc': 1, 'email': 1, '_id': 0}).skip(
  955. (page - 1) * 10).limit(10)
  956. count = db_conn.user_master.find({"kyc.status": "rejected"}).count()
  957. # print res
  958. return res, count
  959.  
  960.  
  961. def show_single_kyc_model(email):
  962. return (db_conn.user_master.find({"email": email}, {'kyc': 1, 'email': 1, '_id': 0}))
  963.  
  964.  
  965. def bank_transfer_model(list):
  966. db_conn.fiat_transaction.insert(list)
  967.  
  968.  
  969. def bank_detail_model(insert_list):
  970. db_conn.admin_bank_detail.insert(insert_list)
  971.  
  972.  
  973. def fetch_bank_detail_model():
  974. resp = db_conn.admin_bank_detail.find({}, {"_id": 0})
  975. temp_arr = []
  976. for data in resp:
  977. temp_arr.append(data)
  978. return temp_arr
  979.  
  980.  
  981. def rate_conversion_model(input_json):
  982. to_timestamp = int(time.time())
  983. input_json['from_timestamp'] = int(time.time())
  984.  
  985. count = db_conn.token_rates.find({'token': input_json['token'], 'currency': input_json['currency']}).count()
  986. if count == 0:
  987. res = db_conn.token_rates.insert(input_json)
  988. else:
  989. db_conn.token_rates.update({'current': True, "token": input_json["token"], 'currency': input_json['currency']},
  990. {'$set': {"to_timestamp": to_timestamp, "current": False}})
  991. res = db_conn.token_rates.insert(input_json)
  992. print res
  993. return res
  994.  
  995.  
  996. def model_token():
  997. sold = db_conn.transaction_details.find({}, {"no_of_tokens": 1})
  998. sold_tokens = 0.0
  999. for data in sold:
  1000. sold_tokens += data["no_of_tokens"]
  1001. return sold
  1002.  
  1003.  
  1004. def insert_default_rate(default_btc, default_eth, default_fiat):
  1005. default_rates = {
  1006. 'default_btc': default_btc,
  1007. 'default_eth': default_eth,
  1008. 'default_fiat': default_fiat,
  1009. 'current': True,
  1010. 'from_timestamp': int(time.time())
  1011. }
  1012. # res = db_conn.token_rates.find_one({'default_btc':{"$exists":True}})
  1013. # if res is None:
  1014. res = db_conn.token_rates.insert(default_rates)
  1015. return res
  1016.  
  1017.  
  1018. def set_default_cap_model(default_min_cap, default_max_cap):
  1019. default_caps = {
  1020. 'default_min_cap': default_min_cap,
  1021. 'default_max_cap': default_max_cap,
  1022. 'from_time_stamp': int(time.time()),
  1023. 'current': True
  1024. }
  1025. res = db_conn.cap.insert(default_caps)
  1026. return res
  1027.  
  1028.  
  1029. def update_default_rate_model(default_btc, default_eth, default_fiat):
  1030. update_res = db_conn.token_rates.update({'current': True},
  1031. {"$set": {'current': False, 'to_timestamp': int(time.time())}})
  1032. default_rates = {
  1033. 'default_btc': default_btc,
  1034. 'default_eth': default_eth,
  1035. 'default_fiat': default_fiat,
  1036. 'current': True,
  1037. 'from_timestamp': int(time.time())
  1038. }
  1039. res = db_conn.token_rates.insert(default_rates)
  1040. return res
  1041.  
  1042.  
  1043. def update_default_cap_model(default_min_cap, default_max_cap):
  1044. update_res = db_conn.cap.update({'current': True}, {"$set": {'current': False, 'to_timestamp': int(time.time())}})
  1045. default_caps = {
  1046. 'default_min_cap': default_min_cap,
  1047. 'default_max_cap': default_max_cap,
  1048. 'current': True,
  1049. 'from_timestamp': int(time.time())
  1050. }
  1051. res = db_conn.cap.insert(default_caps)
  1052. return res
  1053.  
  1054.  
  1055. def insert_set_rate_model(from_date, to_date, btc_value, eth_value, fiat_value):
  1056. rates = {
  1057. 'from_date': from_date,
  1058. 'to_date': to_date,
  1059. 'btc': btc_value,
  1060. 'eth': eth_value,
  1061. 'fiat': fiat_value
  1062. }
  1063. res = db_conn.token_rates.insert(rates)
  1064. return res
  1065.  
  1066.  
  1067. def set_cap_model(from_date, to_date, min_cap, max_cap):
  1068. res = db_conn.cap.insert({'min_cap': min_cap, 'max_cap': max_cap, 'from_date': from_date, 'to_date': to_date})
  1069. return res
  1070.  
  1071.  
  1072. def get_default_rates():
  1073. res = db_conn.token_rates.find_one({'current': True})
  1074. return res
  1075.  
  1076.  
  1077. def get_default_caps():
  1078. res = db_conn.cap.find_one({'current': True})
  1079. return res
  1080.  
  1081.  
  1082. def get_rates():
  1083. res = db_conn.token_rates.find({"current": {'$exists': False}})
  1084. return res
  1085.  
  1086.  
  1087. def get_caps():
  1088. res = db_conn.cap.find({"current": {"$exists": False}})
  1089. return res
  1090.  
  1091.  
  1092. def remove_rate_model(str_id):
  1093. _id = ObjectId(str_id)
  1094. res = db_conn.token_rates.remove({'_id': _id})
  1095. return res
  1096.  
  1097.  
  1098. def update_rates_model(str_id, update_dict):
  1099. _id = ObjectId(str_id)
  1100. res = db_conn.token_rates.update({'_id': _id}, {"$set": update_dict})
  1101. return res
  1102.  
  1103.  
  1104. def get_btc_transactions_model(btc_address):
  1105. res = db_conn.transaction_details.find({'from_address': btc_address})
  1106. return res
  1107.  
  1108.  
  1109. def get_fiat_transactions_model(email):
  1110. res = db_conn.transaction_details.find({'email': email})
  1111. return res
  1112.  
  1113.  
  1114. def create_erc_address_model(email, erc_address, eth_wallet):
  1115. res = db_conn.user_master.update({'email': email}, {"$set": {'erc_address': erc_address, 'eth_wallet': eth_wallet}})
  1116. return res
  1117.  
  1118.  
  1119. def update_cap_model(min_cap, max_cap):
  1120. res = db_conn.cap.update({"$exists": {'min_cap': True}}, {"$set": {'min_cap': min_cap, 'max_cap': max_cap}})
  1121. return res
  1122.  
  1123.  
  1124. def set_btc_refund_address_model(email, btc_refund_address):
  1125. res = db_conn.user_master.update({'email': email}, {"$set": {'btc_refund_address': btc_refund_address}})
  1126. return res
  1127.  
  1128.  
  1129. def get_docs_to_spend(email, currency):
  1130. res = db_conn.user_master.find_one({'email': email})
  1131. ref_id = res['ref_id']
  1132. res1 = db_conn.referral_bonus.find({'bonus_refid': ref_id, 'spent': False, 'currency': currency})
  1133. return res1
  1134.  
  1135.  
  1136. def update_spent_flag(res):
  1137. for data in res:
  1138. db_conn.referral_bonus.update({'_id': data['_id']}, {"$set": {'spent': True}})
  1139.  
  1140.  
  1141. def set_eth_refund_address_model(email, refund_eth_address):
  1142. res = db_conn.user_master.update({'email': email}, {"$set": {'eth_refund_address': refund_eth_address}})
  1143. return res
  1144.  
  1145.  
  1146. def get_refund_address(address):
  1147. res = db_conn.unverified_transactions.find_one({'to_address': address})
  1148. if res.__contains__('refund_address'):
  1149. return res['refund_address']
  1150. else:
  1151. return None
  1152.  
  1153.  
  1154. def get_refund_address_using_mail(email, currency):
  1155. if currency == 'btc':
  1156. res = db_conn.user_master.find_one({'email': email})
  1157. if 'btc_refund_address' in res:
  1158. return res['btc_refund_address']
  1159. else:
  1160. return None
  1161. else:
  1162. res = db_conn.user_master.find_one({'email': email})
  1163. if 'eth_refund_address' in res:
  1164. return res['eth_refund_address']
  1165. else:
  1166. return None
  1167.  
  1168.  
  1169. def insert_successful_btc_refund(btc_refund_dict):
  1170. db_conn.successful_btc_refunds.insert(btc_refund_dict)
  1171.  
  1172.  
  1173. def insert_successful_eth_refund(eth_refund_dict):
  1174. db_conn.successful_btc_refunds.insert(eth_refund_dict)
  1175.  
  1176.  
  1177. def insert_unsuccessful_btc_refund(btc_refund_dict):
  1178. db_conn.unsuccessful_btc_refunds.insert(btc_refund_dict)
  1179.  
  1180.  
  1181. def insert_unsuccessful_eth_refund(eth_refund_dict):
  1182. db_conn.unsuccessful_btc_refunds.insert(eth_refund_dict)
  1183.  
  1184.  
  1185. def get_btc_to_usd():
  1186. res = db_conn_wallet.rate_conversion.find_one({})
  1187. return res['btc_usd']
  1188.  
  1189.  
  1190. def get_eth_to_usd():
  1191. res = db_conn_wallet.rate_conversion.find_one({})
  1192. return res['eth_usd']
  1193.  
  1194.  
  1195. def get_transacation_details_model(txid):
  1196. res = db_conn.transaction_details.find_one({'txid': txid})
  1197. return res
  1198.  
  1199.  
  1200. def insert_multisig_details(email, to_address_json, to_address, redeem_script):
  1201. res = db_conn.multisig_details.insert({
  1202. 'email': email,
  1203. 'address': to_address,
  1204. 'json_request': to_address_json,
  1205. 'redeem_script': redeem_script,
  1206. 'timestamp': int(time.time())
  1207. })
  1208. return res
  1209.  
  1210.  
  1211. def insert_pay_click_model_btc(email, currency, token_amount, amount_to_pay, price, price_distribution, to_address,
  1212. btc_to_usd, bid_id, redeem_script, to_address_json):
  1213. tokens_already_sold = get_total_tokens_sold()
  1214. insert_dict = {
  1215. 'email': email,
  1216. 'currency': currency,
  1217. 'no_of_tokens': token_amount,
  1218. 'amount_to_pay': amount_to_pay,
  1219. 'price': price,
  1220. 'price_distribution': price_distribution,
  1221. 'status': 0,
  1222. 'to_address': to_address,
  1223. 'exchange_rate': btc_to_usd,
  1224. 'tokens_already_sold': tokens_already_sold,
  1225. 'timestamp': int(time.time()),
  1226. 'bid_id': bid_id,
  1227. 'redeem_script': redeem_script,
  1228. 'json_sent': to_address_json
  1229. }
  1230. res = db_conn.unverified_transactions.insert(insert_dict)
  1231. return res
  1232.  
  1233.  
  1234. def insert_bank_details(bank_name, bank_account_number):
  1235. res = db_conn.bank_details.find_one({'bank_name': bank_name, 'bank_account_number': bank_account_number})
  1236. if res is None:
  1237. db_conn.bank_details.insert({'bank_name': bank_name, 'bank_account_number': bank_account_number})
  1238. return res
  1239.  
  1240.  
  1241. def get_bank_details():
  1242. res = db_conn.bank_details.find({})
  1243. return res
  1244.  
  1245.  
  1246. def insert_unverified_transaction(email, currency, token_amount, amount_to_pay, price, price_distribution, to_address,
  1247. exchange_rate, bid_id):
  1248. tokens_already_sold = get_total_tokens_sold()
  1249.  
  1250. insert_dict = {
  1251. 'email': email,
  1252. 'currency': currency,
  1253. 'no_of_tokens': token_amount,
  1254. 'amount_to_pay': amount_to_pay,
  1255. 'price': price,
  1256. 'price_distribution': price_distribution,
  1257. 'status': 0,
  1258. 'to_address': to_address,
  1259. 'exchange_rate': exchange_rate,
  1260. 'tokens_already_sold': tokens_already_sold,
  1261. 'timestamp': int(time.time()),
  1262. 'bid_id': bid_id
  1263. }
  1264.  
  1265. db_conn.unverified_transactions.insert(insert_dict)
  1266. print "inserted unverified transaction model %s" % insert_dict
  1267.  
  1268.  
  1269. def insert_pay_click_model_cas(email, currency, token_amount, amount_to_pay, price, price_distribution, cas_to_usd,
  1270. to_address):
  1271. tokens_already_sold = get_total_tokens_sold()
  1272. insert_dict = {
  1273. 'email': email,
  1274. 'currency': currency,
  1275. 'no_of_tokens': token_amount,
  1276. 'amount_to_pay': amount_to_pay,
  1277. 'price': price,
  1278. 'price_distribution': price_distribution,
  1279. 'to_address': to_address,
  1280. 'exchange_rate': cas_to_usd,
  1281. 'tokens_already_sold': tokens_already_sold,
  1282. 'timestamp': int(time.time()),
  1283. 'transaction_status': 'pending'
  1284. }
  1285.  
  1286. res = db_conn.unverified_transactions.insert(insert_dict)
  1287. return res
  1288.  
  1289.  
  1290. def insert_pay_click_model_fiat(email, currency, token_amount, amount_to_pay, price, price_distribution, exchange_rate):
  1291. tokens_already_sold = get_total_tokens_sold()
  1292. insert_dict = {
  1293. 'email': email,
  1294. 'currency': currency,
  1295. 'no_of_tokens': token_amount,
  1296. 'amount_to_pay': amount_to_pay,
  1297. 'price': price,
  1298. 'exchange_rate': exchange_rate,
  1299. 'price_distribution': price_distribution,
  1300. 'status': 0,
  1301. 'tokens_already_sold': tokens_already_sold,
  1302. 'timestamp': int(time.time()),
  1303.  
  1304. }
  1305.  
  1306. res = db_conn.unverified_transactions.insert(insert_dict)
  1307. return res
  1308.  
  1309.  
  1310. def insert_fiat_pay_click_model(email, currency, token_amount, rate, amount_to_pay):
  1311. insert_dict = {
  1312. 'email': email,
  1313. 'currency': currency,
  1314. 'token_amount': token_amount,
  1315. 'amount_to_pay': amount_to_pay,
  1316. 'rate': rate,
  1317. # 'erc_address':erc_address,
  1318. 'status': 0,
  1319. # 'eth_wallet':erc_wallet,
  1320. 'timestamp': int(time.time())
  1321. }
  1322. res = db_conn.unverified_transactions.insert(insert_dict)
  1323. return res
  1324.  
  1325.  
  1326. def update_pay_click_model(str_id, new_erc_address, new_erc_wallet):
  1327. _id = ObjectId(str_id)
  1328. res = db_conn.unverified_transactions.update({'_id': _id}, {
  1329. "$set": {'erc_address': new_erc_address, 'eth_wallet': new_erc_wallet}})
  1330. return res
  1331.  
  1332.  
  1333. def update_unconfirmed_status_after_erc_review(str_id):
  1334. _id = ObjectId(str_id)
  1335. res = db_conn.unverified_transactions.update({'_id': _id}, {"$set": {"status": 1}})
  1336. return res
  1337.  
  1338.  
  1339. def update_unconfirmed_status_after_transaction(str_id):
  1340. _id = ObjectId(str_id)
  1341. res = db_conn.unverified_transactions.update({'_id': _id}, {"$set": {"status": 2}})
  1342. return res
  1343.  
  1344.  
  1345. def save_seed_hash_model(email, init_seed_hash, seeds):
  1346. res = db_conn.user_master.update({'email': email}, {"$set": {'seed_hash': init_seed_hash, 'phrases': seeds}})
  1347. return res
  1348.  
  1349.  
  1350. def get_seed_hash(email):
  1351. res = db_conn.user_master.find_one({'email': email})
  1352. return res['seed_hash']
  1353.  
  1354.  
  1355. def add_btc_address_to_user_master_model(email, to_address):
  1356. res = db_conn.user_master.update({'email': email}, {"$push": {'btc_address_list': to_address}})
  1357. return res
  1358.  
  1359.  
  1360. def add_eth_address_to_user_master_model(email, to_address):
  1361. res = db_conn.user_master.update({'email': email}, {"$push": {'eth_address_list': to_address}})
  1362. return res
  1363.  
  1364.  
  1365. def update_refund_address_in_unconfirmed_transaction(str_id, new_refund_address):
  1366. _id = ObjectId(str_id)
  1367. res = db_conn.unverified_transactions.update({'_id': _id}, {"$set": {'refund_address': new_refund_address}})
  1368. return res
  1369.  
  1370.  
  1371. def get_generated_address(email, currency):
  1372. res = db_conn.user_master.find_one({'email': email})
  1373. if currency == 'btc':
  1374. if res.__contains__('btc_address_list'):
  1375. btc_address_list = res['btc_address_list']
  1376. return btc_address_list[len(btc_address_list) - 1]
  1377. else:
  1378. if res.__contains__('eth_address_list'):
  1379. eth_address_list = res['eth_address_list']
  1380. return eth_address_list[len(eth_address_list) - 1]
  1381.  
  1382.  
  1383. def update_unconfirmed_status_after_refund_review(str_id):
  1384. _id = ObjectId(str_id)
  1385. db_conn.unverified_transactions.update({'_id': _id}, {"$set": {'status': 2}})
  1386.  
  1387.  
  1388. def update_erc_in_user_master(email, new_erc_address, new_erc_wallet):
  1389. db_conn.user_master.update({'email': email},
  1390. {"$set": {'erc_address': new_erc_address, 'eth_wallet': new_erc_wallet}})
  1391.  
  1392.  
  1393. def update_refund_address_in_user_master(email, new_refund_address, currency):
  1394. if currency == 'eth':
  1395. db_conn.user_master.update({'email': email}, {"$set": {'eth_refund_address': new_refund_address}})
  1396. else:
  1397. db_conn.user_master.update({'email': email}, {"$set": {'btc_refund_address': new_refund_address}})
  1398.  
  1399.  
  1400. def get_user_timeline_model(email):
  1401. res = db_conn.user_timeline.find({'email': email}, {'_id': 0})
  1402. return res
  1403.  
  1404.  
  1405. def get_to_address_json(tmp_to_address, tmp_pub_key):
  1406. key = 'tmp_key'
  1407. aes_instance = AESCipher(key)
  1408. enc_str = r.get('multisig_address')
  1409. tmp_str = aes_instance.decrypt(enc_str)
  1410. tmp_json = json.loads(tmp_str)
  1411. tmp_json['pub_array'].append(tmp_pub_key)
  1412. tmp_json['address_array'].append(tmp_to_address)
  1413. tmp_json['pub_array'] = json.dumps(tmp_json['pub_array'])
  1414. tmp_json['address_array'] = json.dumps(tmp_json['address_array'])
  1415. return tmp_json
  1416.  
  1417.  
  1418. # def get_multisig_json(tmp_to_address,tmp_pub_key):
  1419. # address_array = ['1KZQt1xsQKe2zJfUkdqJuER25BKicmjKX7','3EMcbjCMk2oS4qfHqVzkmhv5CiVz6PyHzR','39W4h8K3EdNhRjMhojmwThxgMj31wMrwAR','1ALd9XaC7fTEQuJpwqtU8F7YWy65m3gaiQ']
  1420. # pub_key_array = ['02FB4C9B85593FFFDFA9F2D211D6DF22BEA3B62CD2B50A657C6732570CDB363EF2','xpub6CZSh3cr8DsUwRaNxJhyUCFp3kCFEQyjyYwYoZXuRU8vXhabKM9X9qbxZbA2vyrcgLBTBxDHXgz3fnsuoi5F1CzGhw8AwQ3zcEeyrCQ5pGp','xpub6CZSh3cr8DsUwRaNxJhyUCFp3kCFEQyjyYwYoZXuRU8vXhabKM9X9qbxZbA2vyrcgLBTBxDHXgz3fnsuoi5F1CzGhw8AwQ3zcEeyrCQ5pGp','0219833147C46F0E6D0B98915564E26CFD7DE45B13B438022339EDC3B6147FA189']
  1421. # address_array.append(tmp_to_address)
  1422. # pub_key_array.append(tmp_pub_key)
  1423. # multisig_json = {'pub_arr':pub_key_array,'add_arr':address_array,'m':3,'n':5}
  1424.  
  1425.  
  1426. # def get_multisig_json(tmp_to_address,tmp_pub_key):
  1427. # address_array = ['2Mv68zoTBLTN7qMmmWVSry4wBLa78FMUwMm','2NBZynLBFQjawrKS815oKcZAgYbZL71ETct','2MvWJrMn3uBUZWCBchWeNrmmYHJiS86P4Yw']
  1428. # pub_key_array = ['02cb5c2f73fd7a76acf81423fb17ac89d06389d96f0d72502891e0be30247e1031','0288f5baece14afd1d5e3f0222305d4da874cd9b517039f27477a83841bfedf2ae','030aaa17cdce7bb34af2d126ff7a9cc7339bdb1701ddeb4aec9e3c271fdf2b5914']
  1429. # # address_array.append(tmp_to_address)
  1430. # # pub_key_array.append(tmp_pub_key)
  1431. # multisig_json = {'pub_arr':pub_key_array,'add_arr':address_array,'m':2,'n':3}
  1432. # return multisig_json
  1433.  
  1434.  
  1435. def get_multisig_json(tmp_to_address, tmp_pub_key):
  1436. print "tmp_address -->%s temp_pub_key ---> %s" % (tmp_to_address, tmp_pub_key)
  1437. address_array = ['1KZQt1xsQKe2zJfUkdqJuER25BKicmjKX7', '1DtQxefYPMU8AJHpg7mMPBXADqkyZDURsL',
  1438. '19N2qaxyayDkuBr3f4ZGp9Ejo8GcxbBRX5', '1ALd9XaC7fTEQuJpwqtU8F7YWy65m3gaiQ']
  1439. pub_key_array = ['02fb4c9b85593fffdfa9f2d211d6df22bea3b62cd2b50a657c6732570cdb363ef2',
  1440. '026799bc9c5e649d29a7c630e3a8534d91d4fe9b4afc5fb883eac09c7b74018a6d',
  1441. '03719362d1d1e9561e9a9dd672e42f237a69351ae0b3fcf98195299e1c8ed2f9bb',
  1442. '0219833147c46f0e6d0b98915564e26cfd7de45b13b438022339edc3b6147fa189']
  1443. address_array.append(tmp_to_address)
  1444. pub_key_array.append(tmp_pub_key)
  1445. multisig_json = {'pub_array': json.dumps(pub_key_array), 'address_array': json.dumps(address_array), 'm': 3, 'n': 5,
  1446. 'type': 'multisig'}
  1447. return multisig_json
  1448.  
  1449.  
  1450. # user timelines
  1451. def enter_signup_in_user_timeline(email):
  1452. insert_dict = {
  1453. 'email': email,
  1454. 'timestamp': int(time.time()),
  1455. 'content': 'signup',
  1456. 'type': 'text'
  1457. }
  1458. db_conn.user_timeline.insert(insert_dict)
  1459.  
  1460.  
  1461. def enter_kyc_submit_in_user_timeline(email):
  1462. insert_dict = {
  1463. 'email': email,
  1464. 'timestamp': int(time.time()),
  1465. 'content': 'kyc_submitted',
  1466. 'type': 'text'
  1467. }
  1468. db_conn.user_timeline.insert(insert_dict)
  1469.  
  1470.  
  1471. def insert_withdraw_in_cashaa_withdrawals(email, from_address, to_address, value):
  1472. insert_dict = {
  1473. 'email': email,
  1474. 'from_address': from_address,
  1475. 'to_address': to_address,
  1476. 'amount_withdrawn': value,
  1477. 'status': 'pending'
  1478. }
  1479. db_conn.cashaa_withdrawals.insert(insert_dict)
  1480.  
  1481.  
  1482. def get_cashaa_withdrawals_for_admin_model():
  1483. res = db_conn.cashaa_withdrawals.find({})
  1484. list_to_send = []
  1485. for data in res:
  1486. data['_id'] = str(data['_id'])
  1487. list_to_send.append(data)
  1488. return list_to_send
  1489.  
  1490.  
  1491. def approve_cashaa_withdrawal_model(_id, txid):
  1492. db_conn.cashaa_withdrawals.update({'_id': ObjectId(_id)}, {"$set": {'status': 'approved', 'txid': txid}})
  1493.  
  1494.  
  1495. def reject_cashaa_withdrawal_model(_id):
  1496. db_conn.cashaa_withdrawals.update({'_id': ObjectId(_id)}, {"$set": {'status': 'rejected'}})
  1497.  
  1498.  
  1499. def get_cashaa_withdrawal_details(email):
  1500. res = db_conn.cashaa_withdrawals.find({'email': email, 'status': {"$in": ['pending', 'approved']}})
  1501. return res
  1502.  
  1503.  
  1504. def enter_kyc_accept_in_user_time(email):
  1505. insert_dict = {
  1506. 'email': email,
  1507. 'timestamp': int(time.time()),
  1508. 'content': 'kyc_accepted',
  1509. 'type': 'text'
  1510. }
  1511. db_conn.user_timeline.insert(insert_dict)
  1512.  
  1513.  
  1514. def enter_kyc_reject_in_user_time(email):
  1515. insert_dict = {
  1516. 'email': email,
  1517. 'timestamp': int(time.time()),
  1518. 'content': 'kyc_rejected',
  1519. 'type': 'text'
  1520. }
  1521. db_conn.user_timeline.insert(insert_dict)
  1522.  
  1523.  
  1524. def insert_payment_initialization_in_user_timeline(email, currency, token_amount, price, amount_to_pay, bid_id):
  1525. insert_dict = {
  1526. 'email': email,
  1527. 'timestamp': int(time.time()),
  1528. 'content': str(amount_to_pay) + ' ' + currency,
  1529. 'currency': currency,
  1530. 'no_of_tokens': token_amount,
  1531. 'price': price,
  1532. 'amount_to_pay': amount_to_pay,
  1533. 'type': 'payment_initiation'
  1534.  
  1535. }
  1536. db_conn.user_timeline.insert(insert_dict)
  1537. print "inserted in 'type':'payment_initiation' in user timeline %s" % insert_dict
  1538.  
  1539.  
  1540. def wire_insert_payment_initialization_in_user_timeline(email,amount_to_pay,currency):
  1541. insert_dict = {
  1542. 'email': email,
  1543. 'amount_to_pay': amount_to_pay,
  1544. 'type': 'wire_payment_initiation',
  1545. 'status':'pending',
  1546. 'currency':currency,
  1547. 'timestamp': int(time.time())
  1548. }
  1549. db_conn.user_timeline.insert(insert_dict)
  1550. print "inserted in 'type':'payment_initiation' in user timeline %s" % insert_dict
  1551.  
  1552.  
  1553.  
  1554.  
  1555. def insert_zero_confirmation_in_user_timeline(email, currency, no_of_token_allocated, value, to_address, txid):
  1556. if currency == 'btc' or currency == 'BTC':
  1557. tmp_type = 'btc_unprocessed'
  1558. else:
  1559. tmp_type = 'eth_unprocessed'
  1560.  
  1561. duplicate_entry = db_conn.user_timeline.find_one({"type": tmp_type, "txid": txid})
  1562.  
  1563. if duplicate_entry:
  1564. print "duplicate entry about 0th conf in user_timeline"
  1565. return False
  1566.  
  1567. if not duplicate_entry:
  1568. insert_dict = {
  1569. 'email': email,
  1570. 'timestamp': int(time.time()),
  1571. 'content': str(value) + ' ' + currency,
  1572. 'currency': currency,
  1573. 'no_of_tokens': no_of_token_allocated,
  1574. 'price': value,
  1575. 'type': tmp_type,
  1576. 'to_address': to_address,
  1577. 'txid': txid
  1578. }
  1579. print "inserting in user_timeline"
  1580. print insert_dict
  1581. db_conn.user_timeline.insert(insert_dict)
  1582. return True
  1583.  
  1584.  
  1585. def check_for_conformations(txid, email):
  1586. res = db_conn.transaction_details.find_one({'txid': txid, 'email': email})
  1587. if res:
  1588. return int(res["confirmations"])
  1589. else:
  1590. print "not exist in old confirmations"
  1591. return None
  1592.  
  1593.  
  1594. def get_confirmed_transaction_details():
  1595. res = db_conn.transaction_details.find({}, {'_id': 0})
  1596. return res
  1597.  
  1598.  
  1599. # def get_summary_data_from_to_date_model(from_date, to_date):
  1600. # res = db_conn.transaction_details.find({"epoch":{"$gte":from_date,"$lte":to_date}},{"no_of_tokens": 1, "currency": 1,"value": 1})
  1601. # btc_value = 0
  1602. # eth_value = 0
  1603. # cas_token = 0
  1604. # for data in res:
  1605. # print "*************************%s " %data
  1606. # if data['currency'] == 'eth':
  1607. # eth_value += float(data['value'])
  1608. # if data['currency'] == 'btc':
  1609. # btc_value += float(data['value'])
  1610. # cas_token += float(data['no_of_tokens'])
  1611.  
  1612. # return btc_value,eth_value,cas_token
  1613.  
  1614. def get_confirmed_transaction_details_graph(from_date, to_date):
  1615. res = db_conn.transaction_details.find({"epoch": {"$gte": from_date, "$lte": to_date}},
  1616. {"no_of_tokens": 1, "epoch": 1})
  1617. return res
  1618.  
  1619.  
  1620. def send_confirmation_mail(email, no_of_tokens, value, currency):
  1621. m = Mailin("https://api.sendinblue.com/v2.0", "RSv3VdkQOEmC8AUj")
  1622. name = get_user_name(email)
  1623. email_dict = {
  1624. "to": {email: email},
  1625. "from": ["support@auxledger.com"],
  1626. "subject": str(no_of_tokens) + " XAL tokens purchased successfully",
  1627. "html": get_send_confirmation_mail_html(name, str(no_of_tokens), str(value), currency)
  1628. }
  1629.  
  1630. result = m.send_email(email_dict)
  1631. print result
  1632.  
  1633.  
  1634. def insert_btc_transaction_in_user_timeline(email_id, address, from_address, value, txid, confirmations):
  1635. old_confirmations = db_conn.user_timeline.find_one({"email": email_id, "txid": txid, "type": "btc_transaction"},
  1636. {"confirmations": 1, "_id": -1})
  1637. if not old_confirmations:
  1638. res = db_conn.transaction_details.find_one({'to_address': address, 'txid': txid})
  1639. if res:
  1640. tokens_purchased = float(res['no_of_tokens'])
  1641. insert_dict = {
  1642. 'email': email_id,
  1643. 'timestamp': int(time.time()),
  1644. 'currency': 'btc',
  1645. 'content': str(value) + ' btc , ' + str(tokens_purchased) + ' tokens',
  1646. 'to_address': address,
  1647. 'from_address': from_address,
  1648. 'txid': txid,
  1649. 'confirmations': confirmations,
  1650. 'tokens_purchased': tokens_purchased,
  1651. 'type': 'btc_transaction',
  1652. 'exchange_rate': res["exchange_rate"]
  1653. }
  1654.  
  1655. print "inserting btc_transaction in user timeline"
  1656. print insert_dict
  1657. db_conn.user_timeline.insert(insert_dict)
  1658. return True
  1659. else:
  1660. print "duplicate entry of btc_transaction in user timeline"
  1661. old_confirmations = old_confirmations["confirmations"]
  1662. if old_confirmations < confirmations:
  1663. db_conn.user_timeline.update({"txid": txid, "email": email_id, "type": "btc_transaction"},
  1664. {"$set": {"confirmations": int(confirmations)}})
  1665. print "updating confirmations"
  1666. return False
  1667.  
  1668.  
  1669. def insert_eth_transaction_in_user_timeline(email_id, to_address, from_address, value, txid, confirmations):
  1670. old_confirmations = db_conn.user_timeline.find_one({"email": email_id, "txid": txid, "type": "eth_transaction"},
  1671. {"confirmations": 1, "_id": -1})
  1672.  
  1673. if not old_confirmations:
  1674. res = db_conn.transaction_details.find_one({'to_address': to_address, 'txid': txid})
  1675. tokens_purchased = res['no_of_tokens']
  1676.  
  1677. insert_dict = {
  1678. 'email': email_id,
  1679. 'timestamp': int(time.time()),
  1680. 'currency': 'eth',
  1681. 'content': str(value) + ' eth, ' + str(tokens_purchased) + ' tokens',
  1682. 'to_address': to_address,
  1683. 'from_address': from_address,
  1684. 'txid': txid,
  1685. 'confirmations': confirmations,
  1686. 'tokens_purchased': tokens_purchased,
  1687. 'type': 'eth_transaction',
  1688. 'exchange_rate': get_current_cashaa_price_model('eth')
  1689. }
  1690.  
  1691. db_conn.user_timeline.insert(insert_dict)
  1692. return True
  1693. else:
  1694. print "duplicate entry of eth_transaction in user timeline"
  1695. old_confirmations = old_confirmations["confirmations"]
  1696. if old_confirmations < confirmations and old_confirmations < 3:
  1697. db_conn.user_timeline.update({"txid": txid, "email": email_id, "type": "eth_transaction"},
  1698. {"$set": {"confirmations": int(confirmations)}})
  1699. print "updating confirmations"
  1700. return False
  1701.  
  1702.  
  1703. def get_user_flag(address, txid):
  1704. res = db_conn.user_timeline.find_one({'to_address': address, 'txid': txid})
  1705. return res
  1706.  
  1707.  
  1708. def get_user_flag_eth(bid_id):
  1709. res = db_conn.user_timelne.find_one({'bid_id': bid_id})
  1710. return res
  1711.  
  1712.  
  1713. def insert_successful_fiat_transaction_in_user_timeline(str_id, timestamp, amount, email):
  1714. # rate = get_pr
  1715. res = db_conn.transaction_details.find_one({'unconfirmed_id': str_id})
  1716. tokens_purchased = int(res['no_of_tokens'])
  1717. insert_dict = {
  1718. 'email': res['email'],
  1719. 'timestamp': res['epoch'],
  1720. 'currency': 'fiat',
  1721. 'content': str(res['value']) + ' fiat, ' + str(tokens_purchased) + ' tokens',
  1722. 'token_purchased': tokens_purchased,
  1723. 'type': 'fiat_transaction',
  1724. 'unconfirmed_id': str_id
  1725. }
  1726. db_conn.user_timeline.insert(insert_dict)
  1727. send_confirmation_mail(res['email'], tokens_purchased, amount, 'FIAT')
  1728.  
  1729.  
  1730. def insert_rejected_fiat_transaction_in_user_timeline(_id, email):
  1731. insert_dict = {
  1732. 'email': email,
  1733. 'timestamp': int(time.time()),
  1734. 'unverified_id': _id,
  1735. 'type': 'rejected_fiat_transaction',
  1736. 'content': None,
  1737. 'currency': 'fiat'
  1738. }
  1739. db_conn.user_timeline.insert(insert_dict)
  1740.  
  1741.  
  1742. def add_category_model(category):
  1743. res = db_conn.categories.insert({'category': category})
  1744. return res
  1745.  
  1746.  
  1747. def update_category_model(new_category, _id):
  1748. res = db_conn.categories.update({'_id': ObjectId(_id)}, {'$set': {'category': new_category}})
  1749. return res
  1750.  
  1751.  
  1752. def delete_category_model(_id):
  1753. res = db_conn.categories.remove({'_id': ObjectId(_id)})
  1754. return res
  1755.  
  1756.  
  1757. def display_category_model():
  1758. res = db_conn.categories.find()
  1759. return res
  1760.  
  1761.  
  1762. def raise_ticket_model(email, issue_category, subject, phone, description):
  1763. insert_dict = {
  1764. 'email': email,
  1765. 'category': issue_category,
  1766. 'subject': subject,
  1767. 'phone': phone,
  1768. 'description': description,
  1769. 'timestamp': int(time.time()),
  1770. 'status': 'open'
  1771. }
  1772. res = db_conn.tickets.insert(insert_dict)
  1773. db_conn.ticket_chats.insert({'ticket_no': str(res)})
  1774. return res
  1775.  
  1776.  
  1777. def display_ticket_to_user_model(email):
  1778. res = db_conn.tickets.find({'email': email})
  1779. return res
  1780.  
  1781.  
  1782. def display_ticket_to_admin_model():
  1783. res = db_conn.tickets.find()
  1784. return res
  1785.  
  1786.  
  1787. def insert_in_otp(email, otp_str):
  1788. res = db_conn.otp_details.find_one({'email': email, 'otp_flag': True})
  1789. if not res:
  1790. insert_res = db_conn.otp_details.insert({'email': email, 'otp_str': otp_str,
  1791. 'timestamp': int(time.time()), 'otp_flag': False,
  1792. 'current_flag': False})
  1793. return insert_res
  1794.  
  1795.  
  1796. def get_otp_str(email, disable=None):
  1797. res = db_conn.otp_details.find_one({'email': email, 'current_flag': False})
  1798. if disable:
  1799. res = db_conn.otp_details.find_one({'email': email, 'current_flag': True})
  1800. return res
  1801.  
  1802.  
  1803. def get_otp_str_model(email):
  1804. res = db_conn.otp_details.find_one({'email': email})
  1805. return res
  1806.  
  1807.  
  1808. def update_current_otp_flag(email):
  1809. res = db_conn.otp_details.update({'email': email},
  1810. {"$set": {'current_flag': True, 'otp_flag': True}})
  1811.  
  1812.  
  1813. def check_2fa_status(email):
  1814. res = db_conn.otp_details.find_one({'email': email})
  1815. if res:
  1816. return res['current_flag']
  1817.  
  1818.  
  1819. def disable_current_otp_flag(email):
  1820. res = db_conn.otp_details.update({'email': email}, {"$set": {'current_flag': False}})
  1821.  
  1822.  
  1823. def close_ticket_model(_id):
  1824. res = db_conn.tickets.find_one({'_id': ObjectId(_id)})
  1825. res1 = db_conn.tickets.update({'_id': ObjectId(_id)}, {"$set": {'status': 'close'}})
  1826. return res
  1827.  
  1828.  
  1829. def reopen_ticket_model(_id):
  1830. res = db_conn.tickets.find_one({'_id': ObjectId(_id)})
  1831. res1 = db_conn.tickets.update({'_id': ObjectId(_id)}, {"$set": {'status': 'open'}})
  1832. return res
  1833.  
  1834.  
  1835. def insert_user_message_model(message, ticket_no):
  1836. res = db_conn.ticket_chats.update({'ticket_no': ticket_no}, {
  1837. "$push": {"messages": {'message': message, 'timestamp': int(time.time()), 'sent_by': 'user'}}})
  1838. res = db_conn.tickets.update({"_id": ObjectId(ticket_no)},
  1839. {"$set": {"chat_status": "user_answered", "last_modified": int(time.time())}})
  1840. print 'iiiiii %s,%s,%s' % (message, ticket_no, res)
  1841. return res
  1842.  
  1843.  
  1844. def insert_admin_message_model(message, ticket_no):
  1845. res = db_conn.ticket_chats.update({'ticket_no': ticket_no}, {
  1846. "$push": {"messages": {'message': message, 'timestamp': int(time.time()), 'sent_by': 'admin'}}})
  1847. res = db_conn.tickets.update({"_id": ObjectId(ticket_no)},
  1848. {"$set": {"chat_status": "admin_answered", "last_modified": int(time.time())}})
  1849. return res
  1850.  
  1851.  
  1852. def get_ticket_chat_notifications_model():
  1853. res = db_conn.tickets.find({"status": "open"})
  1854. list_to_send = []
  1855. for data in res:
  1856. insert_dict = dict()
  1857. insert_dict['ticket_no'] = str(data['_id'])
  1858. message_length = 0
  1859. res1 = db_conn.ticket_chats.find_one({'ticket_no': str(data['_id'])})
  1860. if res1.__contains__('messages'):
  1861. message_list = res1['messages']
  1862. for message in message_list:
  1863. if message['sent_by'] == 'user':
  1864. message_length += 1
  1865. insert_dict['messages'] = message_length
  1866. list_to_send.append(insert_dict)
  1867. return list_to_send
  1868.  
  1869.  
  1870. def get_ticket_chat_notifications_from_admin_model(email):
  1871. res = db_conn.tickets.find({"status": "open", 'email': email})
  1872. list_to_send = []
  1873. for data in res:
  1874. insert_dict = dict()
  1875. insert_dict['ticket_no'] = str(data['_id'])
  1876. message_length = 0
  1877. res1 = db_conn.ticket_chats.find_one({'ticket_no': str(data['_id'])})
  1878. if res1.__contains__('messages'):
  1879. message_list = res1['messages']
  1880. for message in message_list:
  1881. if message['sent_by'] == 'admin':
  1882. message_length += 1
  1883. insert_dict['messages'] = message_length
  1884. list_to_send.append(insert_dict)
  1885. return list_to_send
  1886.  
  1887.  
  1888. def get_chat_details_model(ticket_no):
  1889. res = db_conn.ticket_chats.find_one({'ticket_no': ticket_no})
  1890. return res
  1891.  
  1892.  
  1893. # 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})
  1894.  
  1895.  
  1896. def get_detail_data_from_to_date_model(from_date, to_date):
  1897. res = db_conn.transaction_details.find({"epoch": {'$gte': from_date, '$lte': to_date}},
  1898. {"email": 1, "epoch": 1, "no_of_tokens": 1, "value": 1, "txid": 1,
  1899. "currency": 1, "_id": 0})
  1900. # print res
  1901. ret_arr = []
  1902. url = "https://api.coinmarketcap.com/v2/ticker/?convert=BTC&limit=2"
  1903. resp = (requests.get(url)).json()
  1904. btc_usd_rate = float(resp["data"]["1"]["quotes"]["USD"]["price"])
  1905. eth_usd_rate = float(resp["data"]["1027"]["quotes"]["USD"]["price"])
  1906. if res:
  1907. for data in res:
  1908. epoch_to_date = time.strftime("%d %b, %Y", time.localtime(data["epoch"]))
  1909. data["human_time"] = epoch_to_date
  1910.  
  1911. if data["currency"] == "btc":
  1912. data["usd_eqv"] = btc_usd_rate * data["value"]
  1913. else:
  1914. data["usd_eqv"] = eth_usd_rate * data["value"]
  1915.  
  1916. print data
  1917. ret_arr.append(data)
  1918.  
  1919. return ret_arr
  1920.  
  1921.  
  1922. def get_summary_data_from_to_date_model(from_date, to_date):
  1923. res = db_conn.transaction_details.find({}, {"no_of_tokens": 1, "currency": 1, "value": 1})
  1924. btc_value = 0
  1925. eth_value = 0
  1926. cas_token = 0
  1927. for data in res:
  1928. if data['currency'] == 'eth':
  1929. eth_value += eth_value + float(data['value'])
  1930. if data['currency'] == 'btc':
  1931. btc_value += btc_value + float(data['value'])
  1932. cas_token += float(cas_token + data['no_of_tokens'])
  1933.  
  1934. return btc_value, eth_value, cas_token
  1935.  
  1936.  
  1937. def get_rate_conversion_model():
  1938. res = db_conn_wallet.rate_conversion.find_one({}, {"_id": 0})
  1939. return res
  1940.  
  1941.  
  1942. def user_kyc_details_model(insert_flag=0, **kwargs): # flag = 0 for fetch, 1 for insert
  1943. if kwargs is not None:
  1944. if insert_flag == 1:
  1945. find_params = {"email": kwargs["email"]}
  1946. insert_params = {"first_name": kwargs["first_name"], "last_name": kwargs["last_name"],
  1947. "address_1": kwargs["address_1"],
  1948. "address_2": kwargs["address_2"], "city": kwargs["city"], "state": kwargs["state"],
  1949. "country": kwargs["country"],
  1950. "pin_code": kwargs["pin_code"], "dob": kwargs["dob"], "gender": kwargs["gender"]}
  1951. db_exist = db_conn.kyc_details.find_one(find_params)
  1952. if db_exist:
  1953. db_resp = db_conn.kyc_details.update(find_params, {"$set": insert_params})
  1954. else:
  1955. insert_params["email"] = kwargs["email"]
  1956. db_resp = db_conn.kyc_details.insert(insert_params)
  1957. if insert_flag == 0:
  1958. db_resp = db_conn.kyc_details.find_one({"email": kwargs["email"]}, {"_id": 0})
  1959. return db_resp
  1960.  
  1961.  
  1962. def subscribed_email_model(email):
  1963. email_exist = db_conn.subscribed_email.find_one({"email": email})
  1964. if not email_exist:
  1965. db_conn.subscribed_email.insert({"email": email})
  1966. return 0
  1967. else:
  1968. return 1
  1969.  
  1970.  
  1971. def insert_address_in_cashaa_wallet(email, address, wallet_id, currency):
  1972. insert_dict = {"email": email, "to_address": address, "wallet_id": wallet_id, "currency": currency}
  1973. db_conn.cashaa_wallet.insert(insert_dict)
  1974.  
  1975.  
  1976. def check_if_wallet_present(email, currency):
  1977. data = db_conn.cashaa_wallet.find_one({"email": email, "currency": currency})
  1978. if data:
  1979. return data["to_address"]
  1980. else:
  1981. return False
  1982.  
  1983.  
  1984. def get_obj_id(email, amount):
  1985. print "into get obj id"
  1986. data = db_conn.unverified_transactions.find({"email": email, "status": 2, "price": amount}, {"_id": 1}).sort("_id",
  1987. -1)
  1988. print "data ---------------------"
  1989. data_ = str(data[0]["_id"])
  1990. print "data_ "
  1991. print data_
  1992. return data_
  1993.  
  1994.  
  1995. # db.unverified_transactions.find({"email":"abhinay@cashaa.com","status":2,"price":0.075756},{"_id":1})
  1996.  
  1997.  
  1998. def get_obj_id__(email, amount):
  1999. try:
  2000. print "into get obj id"
  2001. data = db_conn.unverified_transactions.find({"email": email, "status": 3, "price": amount}, {"_id": 1}).sort(
  2002. "_id", -1)
  2003. data_ = str(data[0]["_id"])
  2004. print "data_ "
  2005. print data_
  2006. return data_
  2007.  
  2008. except Exception as e:
  2009. print "into get obj id exception"
  2010. data = db_conn.unverified_transactions.find({"email": email, "status": 2, "price": amount}, {"_id": 1}).sort(
  2011. "_id", -1)
  2012. data_ = str(data[0]["_id"])
  2013. print "data_ "
  2014. print data_
  2015. return data_
  2016.  
  2017.  
  2018. # from_ref_id
  2019. def total_xal_earned_via_referial(email):
  2020. db_data = db_conn.referral_bonus.find({"email_id": email}, {"_id": 0})
  2021. sum = 0.0
  2022. total_data = []
  2023. if db_data:
  2024. for data in db_data:
  2025. from_ref_id = data["from_ref_id"]
  2026. source_email_data = db_conn.user_master.find_one({"ref_id": from_ref_id}, {"email": 1})
  2027. data["source_email"] = source_email_data["email"]
  2028. total_data.append(data)
  2029. sum = sum + data["bonus_amount"]
  2030. sum = round(sum, 3)
  2031.  
  2032. return sum, total_data
  2033.  
  2034.  
  2035. def insert_pay_inr_to_transaction_details(user_email, currency, payment_id, payment_amount, xal_amount, resp):
  2036. insert_dict = {
  2037. 'email': user_email,
  2038. 'currency': currency,
  2039. 'no_of_tokens': xal_amount,
  2040. 'value': payment_amount,
  2041. 'txid': payment_id,
  2042. 'payment_details': resp,
  2043. 'timestamp': int(time.time())
  2044. }
  2045. res = db_conn.transaction_details.insert(insert_dict)
  2046. return res
  2047.  
  2048.  
  2049. def insert_pay_inr_to_user_timeline(user_email, currency, xal_amount, payment_id, type_, amount):
  2050. insert_dict = {
  2051. 'email': user_email,
  2052. 'currency': currency,
  2053. 'tokens_purchased': xal_amount,
  2054. 'txid': payment_id,
  2055. 'type': "inr_transfer",
  2056. 'timestamp': int(time.time()),
  2057. 'price': amount,
  2058. 'amount': amount
  2059. }
  2060. res = db_conn.user_timeline.insert(insert_dict)
  2061. return res
  2062.  
  2063. def total_sold_tokens():
  2064. sold_tokens_data = db_conn.transaction_details.find()
  2065. sold_tokens = 0.0
  2066. for data in sold_tokens_data:
  2067. sold_tokens = sold_tokens+float(data["no_of_tokens"])
  2068. return round(float(sold_tokens),3)
  2069.  
  2070.  
  2071. def admin_dashboard_data():
  2072. total_count = total_user_count()
  2073. sold_tokens = total_sold_tokens()
  2074. btc_transaction_count = db_conn.transaction_details.find({"currency":"btc"}).count()
  2075. eth_transaction_count = db_conn.transaction_details.find({"currency":"eth"}).count()
  2076. inr_transaction_count = db_conn.transaction_details.find({"currency": "INR"}).count()
  2077. wire_transaction_count = db_conn.unverified_transactions.find({"type":"wire_transfer"}).count()
  2078. ret_dict = {
  2079. 'total_sold_tokens':sold_tokens,
  2080. 'btc_transaction_count':btc_transaction_count,
  2081. 'eth_transaction_count':eth_transaction_count,
  2082. 'inr_transaction_count':inr_transaction_count,
  2083. 'wire_transaction_count':wire_transaction_count,
  2084. 'total_count':total_count
  2085. }
  2086. print ret_dict
  2087. return ret_dict
  2088.  
  2089.  
  2090. def get_admin_referral_details():
  2091. ref_data = db_conn.referral_bonus.find()
  2092. temp_arr = []
  2093. total_referral_earned = 0.0
  2094.  
  2095. for data in ref_data:
  2096. temp_json = {}
  2097. bonus_amount = data['bonus_amount']
  2098. total_referral_earned = total_referral_earned+ bonus_amount
  2099. temp_json['ref_earned'] = bonus_amount
  2100. temp_json['email'] = data['email_id']
  2101. temp_json['child_email'] = data['child_email']
  2102. temp_arr.append(temp_json)
  2103.  
  2104. return temp_arr,total_referral_earned
  2105.  
  2106.  
  2107.  
  2108.  
  2109.  
  2110.  
  2111.  
  2112. def get_email_from_obj_id(ticket_no):
  2113. id = ObjectId(ticket_no)
  2114. email_data = db_conn.tickets.find_one({'_id':id})
  2115. if email_data:
  2116. return email_data['email']
  2117.  
  2118.  
  2119.  
  2120. def get_referral_status(ref_id):
  2121. send_dict = {'was_referred':False}
  2122.  
  2123. find_param = {'ref_id': ref_id}
  2124. ref_cursor = db_conn.referral_tree.find_one(find_param)
  2125. if ref_cursor:
  2126. if ref_cursor['parent']:
  2127. send_dict['was_referred'] = True
  2128. get_parent_details = db_conn.user_master.find_one({"ref_id": ref_cursor['parent']})
  2129. send_dict['referred_by'] = get_parent_details["email"]
  2130.  
  2131. return send_dict
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!