async def create_or_fetch_user(user_id, user_name): logger.info('attempting to fetch user %s ...', user_id) user = db.get_user_by_id(user_id) if user is None: logger.info('user %s does not exist. creating new user ...', user_id) wallet_command = {'identifier': wallet, 'password': settings.node_pass} action = "actor/wallet/address" outputText = await communicate_wallet_async(wallet_command,action) wallet_output = json.loads(outputText) address = wallet_output['address'] #pulowi claim wallet_command = {'identifier': wallet, 'password': settings.node_pass,'address': address,'amount': 100} action = "actor/wallet/reward" outputText = await communicate_wallet_async(wallet_command,action) wallet_output = json.loads(outputText) reward_block = wallet_output['reward_block'] logger.info('user Reward complete "reward_block": %s', reward_block) #pulowi por el momento no se necesita #wallet_command = {'action': 'account_representative_set', 'wallet': wallet, 'account':address, 'representative':settings.representative } #await communicate_wallet_async(wallet_command) user = db.create_user(user_id=user_id, user_name=user_name, wallet_address=address) logger.info('user %s created.', user_id) logger_newuser.info('user_id: %s, user_name: %s, wallet_address: %s', user_id, user_name, address) return user else: logger.info('user %s fetched.', user_id) return user
def get_current_user(self): user_cookie = self.get_secure_cookie('user_id') if user_cookie: user_id = int(user_cookie) return db.get_user_by_id(user_id) else: return None
async def withdraw(message): if message.channel.is_private: try: withdraw_address = find_address(message.content) user = db.get_user_by_id(message.author.id) if user is None: return source_id = user.user_id source_address = user.wallet_address balance = await wallet.get_balance(user) amount = balance['available'] if amount == 0: await post_response(message, WITHDRAW_NO_BALANCE_TEXT) else: uid = str(uuid.uuid4()) await wallet.make_transaction_to_address(user, amount, withdraw_address, uid, verify_address=True) await post_response(message, WITHDRAW_SUCCESS_TEXT) except util.TipBotException as e: if e.error_type == "address_not_found": await post_response(message, WITHDRAW_ADDRESS_NOT_FOUND_TEXT) elif e.error_type == "invalid_address": await post_response(message, WITHDRAW_INVALID_ADDRESS_TEXT) elif e.error_type == "balance_error": await post_response(message, INSUFFICIENT_FUNDS_TEXT) elif e.error_type == "error": await post_response(message, WITHDRAW_ERROR_TEXT)
def portfolio_transactions(user_id: int, portfolio_id: int): retVal = {'error': 'none'} if g.user is None: retVal['error'] = "not logged in" return json.dumps(retVal) accessed_user: db.User = db.get_user_by_id(user_id) if accessed_user is None: retVal['error'] = "user does not exist" return json.dumps(retVal) if (not g.user.is_admin) and g.user.id != user_id: retVal['error'] = "logged in user must be admin or owner of portfolio" return json.dumps(retVal) accessed_portfolio: db.Portfolio = accessed_user.get_portfolio_by_id(portfolio_id) if accessed_portfolio is None: retVal['error'] = "portfolio does not exist" return json.dumps(retVal) print(accessed_portfolio.display_name) print(accessed_portfolio.get_transactions()) return render_template('transactions.html', values={ "user": accessed_user, "portfolio": accessed_portfolio, "transactions": accessed_portfolio.get_transactions() })
def lambda_handler(event, context): """Update a users current location Parameters ---------- event: dict, required API Gateway Lambda Proxy Input Format context: object, required Lambda Context runtime methods and attributes Returns ------ API Gateway Lambda Proxy Output Format: dict """ try: request = decode(event) except (json.JSONDecodeError, ValidationError): return responses.invalid() users = db.get_user_by_id(request.user_id) if len(users) == 0: return responses.not_found(request.user_id) if len(users) > 1: return responses.server_error() db.update_user_loc(request.user_id, request.lat, request.lon) return responses.success()
async def create_or_fetch_user(user_id, user_name): logger.info('attempting to fetch user %s ...', user_id) user = db.get_user_by_id(user_id) if user is None: logger.info('user %s does not exist. creating new user ...', user_id) wallet_command = {'action': 'account_create', 'wallet': wallet} wallet_output = await communicate_wallet_async(wallet_command) address = wallet_output['account'] wallet_command = { 'action': 'account_representative_set', 'wallet': wallet, 'account': address, 'representative': settings.representative } await communicate_wallet_async(wallet_command) user = db.create_user(user_id=user_id, user_name=user_name, wallet_address=address) logger.info('user %s created.', user_id) logger_newuser.info('user_id: %s, user_name: %s, wallet_address: %s', user_id, user_name, address) return user else: logger.info('user %s fetched.', user_id) return user
def load_logged_in_user(): user_id = session.get('user_id') if user_id is None: g.user = None else: g.user = db.get_user_by_id(user_id)
def users_update(): if request.method == 'POST': user_data = request.form.to_dict() db.user_update(user_data) return redirect('/users/') id = request.args.get('id') user = db.get_user_by_id(id) return render_template('user_modify.html', user=user)
async def givearai(message): if message.channel.is_private: return try: # One giveaway at a time if db.is_active_giveaway(): await post_dm(message.author, GIVEAWAY_EXISTS) return split_content = message.content.split(' ') if len(split_content) > 2: amount = find_amount(split_content[1]) fee = find_amount(split_content[2]) else: raise util.TipBotException("usage_error") if amount < GIVEAWAY_MINIMUM: raise util.TipBotException("usage_error") max_fee = int(0.05 * amount) if fee > max_fee: await post_response(message, GIVEAWAY_MAX_FEE) return if 0 > fee: raise util.TipBotException("usage_error") user = db.get_user_by_id(message.author.id) if user is None: return balance = await wallet.get_balance(user) user_balance = balance['available'] if user_balance < amount: await add_x_reaction(message) await post_dm(message.author, INSUFFICIENT_FUNDS_TEXT) return end_time = datetime.datetime.now() + datetime.timedelta( minutes=GIVEAWAY_DURATION) nano_amt = amount / 1000000 giveaway = db.start_giveaway(message.author.id, message.author.name, nano_amt, end_time, message.channel.id, entry_fee=fee) uid = str(uuid.uuid4()) await wallet.make_transaction_to_address(user, amount, None, uid, giveaway_id=giveaway.id) if fee > 0: await post_response(message, GIVEAWAY_STARTED_FEE, message.author.name, nano_amt, fee, fee) else: await post_response(message, GIVEAWAY_STARTED, message.author.name, nano_amt) asyncio.get_event_loop().create_task(start_giveaway_timer()) db.update_tip_stats(user, amount) db.add_contestant(message.author.id, override_ban=True) except util.TipBotException as e: if e.error_type == "amount_not_found" or e.error_type == "usage_error": await post_dm(message.author, GIVEAWAY_USAGE)
def users_update(): if request.method == 'POST': user_data = request.form.to_dict() db.user_update(user_data) return json.dumps({"status":0, "msg":"update success!"}) # return redirect('/users/') id = request.args.get('id') user = db.get_user_by_id(id) return render_template('user_modify.html', user=user, session={'user': session.get('username')})
def get_balance(user_id: int) -> float: logger.info('getting balance for user %s', user_id) user = db.get_user_by_id(user_id) if user is None: logger.info('user %s does not exist.', user_id) return float(0) else: logger.info('balance for %s fetched successfully.', user_id) return float(user.balance)
async def tipsplit(message): if message.channel.is_private: return try: amount = find_amount(message.content) # Make sure amount is valid and at least 1 user is mentioned if amount < 1 or len(message.mentions) < 1: raise util.TipBotException("usage_error") if int(amount / len(message.mentions)) < 1: raise util.TipBotException("invalid_tipsplit") # Create tip list users_to_tip = [] for member in message.mentions: # Disregard mentions of self and exempt users if member.id not in settings.exempt_users and member.id != message.author.id and not db.is_banned( member.id) and not member.bot: users_to_tip.append(member) if len(users_to_tip) < 1: raise util.TipBotException("no_valid_recipient") # Remove duplicates users_to_tip = list(set(users_to_tip)) # Make sure user has enough in their balance user = db.get_user_by_id(message.author.id) if user is None: return balance = await wallet.get_balance(user) user_balance = balance['available'] if user_balance < amount: await add_x_reaction(ctx.message) await post_dm(message.author, INSUFFICIENT_FUNDS_TEXT) return # Distribute tips tip_amount = int(amount / len(users_to_tip)) # Recalculate amount as it may be different since truncating decimal real_amount = tip_amount * len(users_to_tip) for member in users_to_tip: uid = str(uuid.uuid4()) actual_amt = await wallet.make_transaction_to_user( user, tip_amount, member.id, member.name, uid) # Tip didn't go through if actual_amt == 0: amount -= tip_amount else: await post_dm(member, TIP_RECEIVED_TEXT, tip_amount, message.author.name) await react_to_message(message, amount) db.update_tip_stats(user, real_amount) except util.TipBotException as e: if e.error_type == "amount_not_found" or e.error_type == "usage_error": await post_dm(message.author, TIPSPLIT_USAGE) elif e.error_type == "invalid_tipsplit": await post_dm(message.author, TIPSPLIT_SMALL) elif e.error_type == "no_valid_recipient": await post_dm(message.author, TIP_SELF) else: await post_response(message, TIP_ERROR_TEXT)
def time(body, ack, say): ack() user_id = body['user']['id'] selected_time = body['actions'][0]['selected_time'] db.upsert_user_data(user_id, time_of_flex=selected_time) user = db.get_user_by_id(user_id) app.client.chat_postMessage( channel='C01KHB3H77Z', text= f"Утре в {selected_time} <@{user_id}> ще черпи {user.location_of_flex}" )
def users_update(): if request.method == 'GET': id = request.args.get('id') user = db.get_user_by_id(id) user.pop('create_time') user.pop('last_time') return json.dumps(dict(user)) else: userinfo = request.form.to_dict() data = db.user_update(userinfo['name'], userinfo) return json.dumps(data)
def users_update(): if request.method == 'GET': id = request.args.get('id') user = db.get_user_by_id(id) user.pop('create_time') user.pop('last_time') return json.dumps(dict(user)) else: userinfo = request.form.to_dict() data = db.user_update(userinfo['name'], userinfo) util.WriteLog('infoLogger').info('%s changed userinfo %s' % (session['username'], userinfo['name'])) return json.dumps(data)
def users_update(): if request.method == 'GET': id = request.args.get('id') user = db.get_user_by_id(id) user.pop('create_time') user.pop('last_time') return json.dumps(dict(user)) else: userinfo = request.form.to_dict() data = db.user_update(userinfo['name'], userinfo) util.WriteLog('infoLogger').info( '%s changed userinfo %s' % (session['username'], userinfo['name'])) return json.dumps(data)
def make_transaction_to_user(user_id, amount, target_user_id, target_user_name): if check_balance(user_id, amount): target_user = create_or_fetch_user(target_user_id, target_user_name) user = db.get_user_by_id(user_id) if db.move_funds(user, amount, target_user): logger.info('tip successful. (from: %s, to: %s, amount: %.3f)', user_id, target_user.user_id, amount) return else: raise util.TipBotException("error") else: raise util.TipBotException("insufficient_funds")
async def tip(message): if message.channel.is_private: return try: amount = find_amount(message.content) # Make sure amount is valid and at least 1 user is mentioned if amount < 1 or len(message.mentions) < 1: raise util.TipBotException("usage_error") # Create tip list users_to_tip = [] for member in message.mentions: # Disregard mentions of exempt users and self if member.id not in settings.exempt_users and member.id != message.author.id and not db.is_banned( member.id) and not member.bot: users_to_tip.append(member) if len(users_to_tip) < 1: raise util.TipBotException("no_valid_recipient") # Cut out duplicate mentions users_to_tip = list(set(users_to_tip)) # Make sure this user has enough in their balance to complete this tip required_amt = amount * len(users_to_tip) user = db.get_user_by_id(message.author.id) balance = await wallet.get_balance(user) user_balance = balance['available'] if user_balance < required_amt: await add_x_reaction(message) await post_dm(message.author, INSUFFICIENT_FUNDS_TEXT) return # Distribute tips for member in users_to_tip: uid = str(uuid.uuid4()) actual_amt = await wallet.make_transaction_to_user( user, amount, member.id, member.name, uid) # Something went wrong, tip didn't go through if actual_amt == 0: required_amt -= amount else: await post_dm(member, TIP_RECEIVED_TEXT, actual_amt, message.author.name) # Post message reactions await react_to_message(message, required_amt) # Update tip stats db.update_tip_stats(user, required_amt) except util.TipBotException as e: if e.error_type == "amount_not_found" or e.error_type == "usage_error": await post_dm(message.author, TIP_USAGE) elif e.error_type == "no_valid_recipient": await post_dm(message.author, TIP_SELF) else: await post_response(message, TIP_ERROR_TEXT)
async def dailies(message): if message.channel.is_private: try: ## check for join date if int(datetime.datetime.now() - message.author.created_at).total_seconds() < faucet_settings.min_account_age: # raise util.TipBotException("not_eligible") await post_response(message, NOT_ELIGIBLE); return # check time since last faucet request, daily_wait set in faucet_settings.py if int(datetime.datetime.now() - faucet_db.get_last_request(message.author)).total_seconds() < faucet_settings.daily_wait: # raise util.TipBotException("not_eligible") await post_response(message, NOT_ELIGIBLE); return # throw if first of last 4 faucet request timestamps within last 24 hours, daily_max set in faucet_settings.py if int(datetime.datetime.now() - faucet_db.get_first_request(message.author)).total_seconds < 60*60*24: # raise util.TipBotException("not_eligible") await post_response(message, NOT_ELIGIBLE); return # add new request faucet_db.add_new_request(message.author); # start faucet withdraw withdraw_address = find_address(message.content) botuser = db.get_user_by_id(faucet_settings.discord_bot_id, faucet_settings.discord_bot_name) if botuser is None: return source_id = botuser.user_id source_address = botuser.wallet_address balance = await wallet.get_balance(botuser) amount = balance['available'] if amount == 0: await post_response(message, FAUCET_DRY); else: uid = str(uuid.uuid4()) await wallet.make_transaction_to_address(botuser, faucet_settings.amount, withdraw_address, uid,verify_address = True) await post_response(message, WITHDRAW_SUCCESS_TEXT) except util.TipBotException as e: if e.error_type == "not_eligible": await post_response(message, NOT_ELIGIBLE) if e.error_type == "address_not_found": await post_response(message, WITHDRAW_ADDRESS_NOT_FOUND_TEXT) elif e.error_type == "invalid_address": await post_response(message, WITHDRAW_INVALID_ADDRESS_TEXT) elif e.error_type == "balance_error": await post_response(message, FAUCET_DRY) elif e.error_type == "error": await post_response(message, WITHDRAW_ERROR_TEXT)
def show_employment(): jobsRow = db.get_all_jobs() jobs = [] for job in jobsRow: jobs.append(convert_job(job)) if jobs is not None: session["jobs"] = jobs uid = session.get("user_id") if uid is not None: user = db.get_user_by_id(uid) session['employer'] = user['isEmployer'] != 0 return render_template('employment.html')
def create_or_fetch_user(user_id, user_name): logger.info('attempting to fetch user %s ...', user_id) user = db.get_user_by_id(user_id) if user is None: logger.info('user %s does not exist. creating new user ...', user_id) commands = [["getnewaddress", "tippbot", "bech32"]] rpc_connection = connect() result = rpc_connection.batch_(commands) address = result[0] user = db.create_user(user_id=user_id, user_name=user_name, wallet_address=address) logger.info('user %s created.', user_id) return user else: logger.info('user %s fetched.', user_id) return user
async def create_or_fetch_user(user_id, user_name): logger.info('attempting to fetch user %s ...', user_id) user = db.get_user_by_id(user_id) if user is None: logger.info('user %s does not exist. creating new user ...', user_id) wallet_command = {'action': 'account_create', 'wallet': wallet} wallet_output = await asyncio.get_event_loop().run_in_executor( None, communicate_wallet, wallet_command) address = wallet_output['account'] user = db.create_user(user_id=user_id, user_name=user_name, wallet_address=address) logger.info('user %s created.', user_id) return user else: logger.info('user %s fetched.', user_id) return user
async def balance(message): if message.channel.is_private: user = db.get_user_by_id(message.author.id) if user is None: return balances = await wallet.get_balance(user) actual = balances['actual'] actualnano = actual / 1000000 available = balances['available'] availablenano = available / 1000000 send = balances['pending_send'] sendnano = send / 1000000 receive = balances['pending'] receivenano = receive / 1000000 await post_response(message, BALANCE_TEXT, "{:,}".format(actual), actualnano, "{:,}".format(available), availablenano, "{:,}".format(send), sendnano, "{:,}".format(receive), receivenano)
def get_user_by_id(uid): """This function gets user's data by it's id. It takes user's id and retrieves user's data from db. After that this function creates User object and returns it. :Parameters: - `id`: id of the user to retrieve. :Returns: User object, if the row with such id exists in database or None, if no row with such id has been found. """ user = None if uid: user = db.get_user_by_id(uid) if user: return User(uid=user[0], first_name=user[1], last_name=user[2], email=user[3], password=user[4], age=user[5], state=user[6], native_lang=user[7]) return None
def _create_from_db(self, uid, sid, addr, ctime, atime): """ Create a new session from database data. This goes through the new-style object function __new__ rather than through the __init__ function. """ session = SqlQuixoteSession.__new__(SqlQuixoteSession) session.id = sid session.user = db.get_user_by_id(uid) session._remote_address = addr if ctime is None: session._creation_time = time.time() else: session._creation_time = ctime.ticks() if atime is None: session._access_time = time.time() else: session._access_time = atime.ticks() return session
def new_comment(): if not auth.is_login(): return jsonify({'status': 'not_login'}) current_user = session.get('current_user') current_user = db.db_session.query( db.User).filter(db.User.u_name == current_user).first() u_id = current_user.u_id data = request.get_json() p_id = data['p_id'] c_content = data['c_content'] f_id = data['f_id'] db.add_comment(u_id, p_id, c_content, f_id) all_comments = db.get_all_comments(p_id) comments = [] for i in all_comments: commit_user = db.get_user_by_id(i.u_id) if i.f_id == 0: comments.append([ i.c_id, i.u_id, i.p_id, i.c_content, i.f_id, commit_user.u_head_img, commit_user.u_nickname, 0, 0 ]) else: f_user = db.get_user_by_f_id(i.f_id) comments.append([ i.c_id, i.u_id, i.p_id, i.c_content, i.f_id, commit_user.u_head_img, commit_user.u_nickname, f_user.u_id, f_user.u_nickname ]) post_obj = db.db_session.query( db.Post).filter(db.Post.p_id == p_id).first() post = [ post_obj.p_id, post_obj.p_title, post_obj.p_content, post_obj.p_create_at, post_obj.p_count_comments, post_obj.b_id, post_obj.u_id ] return jsonify({'comments': comments, 'post': post})
def specific_user_portfolios(user_id: int): retVal = {'error': 'none'} if g.user is None: retVal['error'] = "not logged in" return json.dumps(retVal) if (not g.user.is_admin) and g.user.id != user_id: retVal['error'] = "logged in user must be admin or owner of account" return json.dumps(retVal) accessed_user: db.User = db.get_user_by_id(user_id) if accessed_user is None: retVal['error'] = "user does not exist" return json.dumps(retVal) return render_template('portfolio.html', values={ "user": accessed_user, "portfolios": accessed_user.get_portfolios(), })
def users_modify(): id = request.args.get('id') user = db.get_user_by_id(id) return render_template('user_modify.html', user=user)
def notes(): if not g.user: return redirect(url_for('all_notes')) cur_username = db.get_user_by_id(session['user_id'])['username'] return render_template('notes.html',notes=reversed(db.get_notes_by_author(cur_username)))
msvcrt.setmode (0, os.O_BINARY) # stdin = 0 msvcrt.setmode (1, os.O_BINARY) # stdout = 1 except ImportError: pass path = 'images/' form = cgi.FieldStorage() data = session.get_session_data() if data is None: print ("Location: login.py") else: user = db.get_user_by_id(str(data['user_id'])) if user is None: print ("Location: login.py") base.start_html() if (os.environ["REQUEST_METHOD"].upper() == "POST"): directory = form.getvalue("directory_name") file_item = form["avatar"] path += directory+"/" if not os.path.isdir(path): os.mkdir(path) if (file_item.filename): print("<br>")
def user(user_id): u = get_user_by_id(user_id) if not u: return jsonify(id=None) return jsonify(id=u.id, username=u.username)
def before_request(): g.user = None if 'user_id' in session: g.user = db.get_user_by_id(session['user_id'])
def identity(payload): print(payload) user_id = payload['identity'] return db.get_user_by_id(user_id).name
def fetch_user_by_id(user_id): user = get_user_by_id(user_id) return User(user[1], None, user[0])