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 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)))
def users_modify():
id = request.args.get('id')
user = db.get_user_by_id(id)
return render_template('user_modify.html', user=user)
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 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)))
def before_request(): g.user = None if 'user_id' in session: g.user = db.get_user_by_id(session['user_id'])
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 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])
