def testGraphs():
#tests the graphs using fake users
users = [0, 0, 0, 0]
users[0] = User('Josh', (255, 0, 0))
users[0].add_edit(Edit(dt.datetime(2018, 9, 6, 11, 59, 0), '1', False))
users[0].add_edit(Edit(dt.datetime(2018, 9, 6, 11, 54, 0), '123456', True))
users[1] = User('Keith', (0, 255, 0))
users[1].add_edit(Edit(dt.datetime(2018, 9, 7, 11, 59, 0), '123', False))
users[1].add_edit(Edit(dt.datetime(2018, 9, 5, 11, 54, 0), '12345', True))
users[2] = User('Glyn', (0, 0, 255))
users[2].add_edit(Edit(dt.datetime(2018, 10, 7, 11, 59, 0), '1234', False))
users[2].add_edit(Edit(dt.datetime(2018, 10, 5, 11, 54, 0), '1234', True))
users[3] = User('Michael', (100, 100, 100))
users[3].add_edit(Edit(dt.datetime(2018, 10, 13, 11, 59, 0), '45', False))
plt1 = main_file.plot_pie_chart(users, True)
plt2 = main_file.plot_pie_chart(users, False)
plt3 = main_file.plot_lines(users, dt.datetime(2018, 9, 4, 11, 54, 0),
dt.datetime(2018, 10, 14, 11, 59, 0), True)
plt4 = main_file.plot_lines(users, dt.datetime(2018, 9, 4, 11, 54, 0),
dt.datetime(2018, 10, 14, 11, 59, 0), False)
save_all_plots([plt1, plt2, plt3, plt4], 'testGraphs.pdf')
def balance_overview(user_ids=-1):
to_print = ''
if user_ids == -1:
user_ids = []
elif isinstance(user_ids, list):
pass
elif isinstance(user_ids, int):
user_ids = [user_ids]
else:
to_print += '\nWrong input'
return
users = server_conn('list_users')
counterpart_ids = users.to_list()
if not user_ids:
user_ids = counterpart_ids
for user_id in user_ids:
to_print += '\n'
to_print += ('=' * 50)
user1 = User(user_id=user_id)
user1.load()
to_print += '\n'
to_print += user1.f_name
user1_balance = user1.balance()
to_print += '\n'
to_print += ('Accumulated debt: {0} RUB'.format(user1_balance[0]))
to_print += '\n'
to_print += ('Accumulated receivables: {0} RUB'.format(
user1_balance[1]))
remaining_users = [i for i in counterpart_ids if i != user1.user_id]
for counterpart_id in remaining_users:
user2 = User(user_id=counterpart_id)
counterpart_balance = user1.balance(counterpart_id=user2.user_id)
debt_to_counterpart = counterpart_balance[0]
receivables_from_counterpart = counterpart_balance[1]
if debt_to_counterpart != 0 or receivables_from_counterpart != 0:
user2.load()
to_print += '\n'
to_print += ('-' * 20)
to_print += '\n'
to_print += ('Debt to {0}: {1} RUB:'.format(
user2.f_name, debt_to_counterpart))
to_print += '\n'
to_print += ('Receivables from {0}: {1} RUB'.format(
user2.f_name, receivables_from_counterpart))
print(to_print)
return to_print
def savehw():
if request.method == "POST":
uid = User(current_user.name,"zzz", "zzz").get_id()[0]
c = request.form['cpu']
g = request.form['gpu']
r = request.form['ram']
o = request.form['os']
with dbapi2._connect(current_app.config['dsn']) as connection:
cursor = connection.cursor()
query = """ SELECT ID FROM CPU WHERE (NAME = %s) """
cursor.execute(query,(c,))
cid = cursor.fetchone()[0]
query = """ SELECT ID FROM GPU WHERE (NAME = %s) """
cursor.execute(query,(g,))
gid = cursor.fetchone()[0]
query = """ SELECT ID FROM RAM WHERE (SIZE = %s) """
cursor.execute(query,(r,))
rid = cursor.fetchone()[0]
query = """ SELECT COUNT(*) FROM SYSDB WHERE USERID = %s """
cursor.execute(query,(uid,))
count = cursor.fetchone()[0]
if count == 0:
query = """ INSERT INTO SYSDB(USERID,GPUID,CPUID,RAMID,OSNAME) VALUES (%s, %s, %s, %s, %s) """
cursor.execute(query,(uid,gid,cid,rid,o,))
else:
query = """UPDATE SYSDB SET GPUID=%s,CPUID=%s,RAMID=%s,OSNAME=%s WHERE(USERID=%s)"""
cursor.execute(query,(gid,cid,rid,o,uid,))
return redirect(url_for('link3.userProfile'))
def set_up_time_step(message):
try:
var = int(message.text)
if isinstance(var, int):
user = User(user_id=message.from_user.id,
chat_id=message.chat.id,
name=message.from_user.first_name)
user.check_if_user_exists()
old_time = user.current_time
user.change_current_time(time=message.text)
if int(old_time) > int(user.current_time):
pussy = True
else:
pussy = False
bot.send_message(
message.chat.id,
min_planked_time_answer2(old_time=old_time,
new_time=user.current_time,
pussy=pussy,
politeness=user.politeness))
except ValueError:
bot.send_message(message.chat.id,
'You idiot, it is not an integer! Try again, moron')
def register():
"""
Description: Capture user details and try to create a user
Returns:
Returns a new user
"""
# Enter User Details
name = input("Please enter your name: ")
# Loop rounf until user inputs valid registration data
while True:
age = input("Please enter you age: ")
if age.isdigit():
age = int(age)
break
else:
print("Age must be a number. Try again.")
while True:
year_group = input("Please enter your year group: ")
if year_group.isdigit():
year_group = int(year_group)
break
else:
print("Year group must be a number. Try again.")
# Create User object
user = User(name, age, year_group)
print("Your user name is {} \n".format(user))
# Attempt to create and save the user
new_user(user)
return user
async def sigma_start(self, message: discord.Message):
# h = self.get_channel(496450097928732672)
users[str(message.author.id)] = User.User(message.author.id, client)
# await message.channel.send(str(await h.create_invite()))
await self.send(message.channel,
f"ユーザーデータのロード完了。\nこんにちは、{message.author.name}さん。")
def test_findUser(self):
'''Test case method to test for functionality find user'''
self.new_user.saveUser()
confirm_user = User('Ali@234', 'Ali12345')
confirm_user.saveUser()
found_user = User.findUser("Ali@234")
self.assertEqual(found_user.userName, confirm_user.userName)
def read_data(file_name):
# The users dictionary: key = username,
# value = user object
users = {}
tasks = []
with open(file_name, 'r') as f:
num_users = int(f.readline())
i = 0
while i < num_users:
line = f.readline().strip()
parts = line.split(';')
user = User(parts[0], parts[1], parts[2])
users[user.login] = user
i += 1
num_tasks = int(f.readline())
i = 0
while i < num_tasks:
line = f.readline().strip()
parts = line.split(';')
task = Task(parts[0], parts[1], parts[2], parts[3])
if parts[3] == TASK_ALL_USERS:
add_task_to_users(users, task)
else:
user = users.get(parts[3], None)
if user:
user.add_task(task)
tasks.append(task)
i += 1
return (users, tasks)
def loadUser(id=5):
# find the user based on the given id
infile = open("../data/test_users/user_profiles.csv", "r")
for line in infile:
items = line.split(",")
print(items)
cur_id = int(items[0])
name = items[1].lstrip()
gender = items[2].lstrip()
desired_gender = items[3].lstrip()
user_pic = Picture(name=items[4].lstrip())
# NOTE: only works for lists of length 1
yup = []
yup.append(items[5].strip()[1:-1])
nup = []
nup.append(items[6].strip()[1:-1])
if cur_id == id:
infile.close()
ret = User(userID=cur_id,
name=name,
gender=gender,
desiredGender=desired_gender,
picture=user_pic,
yup=yup,
nup=nup)
print(ret)
return ret
infile.close()
def finished_round():
user = User(session['email'])
user_model = UserModel()
word_list_view = user_model.get_word_list_view(user)
seen_list = word_list_view.seen_word_list
learnt_list = word_list_view.learnt_word_list
forgotten_list = word_list_view.forgotten_word_list
# graph_pygal = pygal.Line()
# graph_pygal.title = '% Change Coolness of programming languages over time.'
# graph_pygal.x_labels = ['2011', '2012', '2013', '2014', '2015', '2016']
# graph_pygal.add('Python', [15, 31, 89, 200, 356, 900])
# graph_pygal.add('Java', [15, 45, 76, 80, 91, 95])
# graph_pygal.add('C++', [5, 51, 54, 102, 150, 201])
# graph_pygal.add('All others combined!', [5, 15, 21, 55, 92, 105])
pie_chart = pygal.Pie()
pie_chart.title = 'TITLE'
pie_chart.add('Seen Words', WordModel.get_number_labels(seen_list))
pie_chart.add('Forgotten Words', WordModel.get_number_labels(forgotten_list))
pie_chart.add('Learnt Words', WordModel.get_number_labels(learnt_list))
pie_chart.render()
graph_data = pie_chart.render_data_uri()
return render_template('list.html',
seen_list=seen_list,
learnt_list=learnt_list,
forgotten_list=forgotten_list,
graph_data=graph_data
)
def signup():
if request.method == "POST":
username = request.form['username']
email = request.form['email']
password0 = request.form['password']
with dbapi2._connect(current_app.config['dsn']) as connection:
cursor = connection.cursor()
query = "SELECT ID FROM USERS WHERE (USERNAME = %s)"
cursor.execute(query, (username, ))
user1 = cursor.fetchone()
query = "SELECT ID FROM USERS WHERE (EMAIL =%s)"
cursor.execute(query, (email, ))
user2 = cursor.fetchone()
if user1 is not None or user2 is not None:
if user1 is not None:
flash('Please choose a unique Username')
if user2 is not None:
flash('Please choose a unique E-mail.')
return redirect(url_for('page.signup'))
else:
password = pwd_context.encrypt(password0)
newuser = User(username, email, password)
app.userlist.add_user(newuser)
if login_user(newuser):
flash("Welcome, " + current_user.username)
else:
flash("A problem occured.")
return render_template('home.html')
else:
return render_template('signup.html')
def load_user_button_click(self):
global f_name_out_label, l_name_out_label, debt_out_label, receivables_out_label
user = User(username=self.username_entry.get())
user.load(offer_to_create=False)
if user.user_id == -1:
messagebox.showwarning('Error', 'User not found')
f_name_out_label.destroy()
l_name_out_label.destroy()
debt_out_label.destroy()
receivables_out_label.destroy()
else:
f_name_out_label = tk.Label(self.user_overview, text=user.f_name)
f_name_out_label.grid(row=2, column=1)
l_name_out_label = tk.Label(self.user_overview, text=user.l_name)
l_name_out_label.grid(row=3, column=1)
balance = user.balance()
debt_out_label = tk.Label(self.user_overview, text=balance[0])
debt_out_label.grid(row=4, column=1)
receivables_out_label = tk.Label(self.user_overview,
text=balance[1])
receivables_out_label.grid(row=5, column=1)
def login_page():
if request.method == "POST":
if current_user.get_id() is not None:
flash('You are already logged in MovieShake as ' +
current_user.username)
return redirect(url_for('page.home_page'))
else:
username = request.form['uname']
passwordNotEncrypted = request.form['pass']
if app.userlist.verify(username, passwordNotEncrypted) is not 0:
flash('Please check your user name and password')
return redirect(url_for('page.login_page'))
else:
with dbapi2._connect(app.config['dsn']) as connection:
cursor = connection.cursor()
query = "SELECT EMAIL FROM USERS WHERE (USERNAME = %s)"
cursor.execute(query, (username, ))
email = cursor.fetchone()
userToLogin = User(username, email, passwordNotEncrypted)
if login_user(userToLogin):
flash("Welcome, " + current_user.username)
else:
flash("A problem occured, please try again.")
return redirect(url_for('page.home_page'))
else:
return render_template('login.html')
def load_user(user_id):
if user_id is not None:
get_user = "******"%(user_id)
user = views.getOneRowQuery(db_uri, get_user)
user = User(user[0], user[1], user[2], user[4], user[3])
return user
return None
def _s():
self.id = SLOTS.addUser(User(packet['name'], self))
self.user = SLOTS[self.id]
self.send({'tag':'WELCOME', 'hash':00000, 'motd':MOTD, 'id':self.id})
self.state = 'CONN'
self.task = task.LoopingCall(self.action_PING)
self.task.start(300) #Ping request every 5 mins
def registerHandler():
error = None
if request.method == 'POST':
email = request.json.get('email')
username = request.json.get('username')
password = request.json.get('password')
authenticated = False
## Check Email Validity and Username Availability
email_valid = re.match('^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,4})$', email)
if email_valid == None:
error = "Please enter a valid email address!"
else:
checkUser = User.query.filter_by(username=username).first()
if checkUser != None:
error = "Username is taken! Please try again!"
else:
## Add user to database
user = User(email=email, username=username, password=password, authenticated=authenticated)
db.session.add(user)
db.session.commit()
##Login user
user.authenticated = True
db.session.add(user)
db.session.commit()
login_user(user, remember=True)
return jsonify({'message': ' user created'}), 200
def balance_overview(message): # todo update with a keyboard & usernames
if message.text == '':
users = -1
else:
users = [message.text]
print('users', users)
to_print = ''
counterparts = server_conn('list_users')
counterpart_usernames = counterparts
if users == -1:
users = counterpart_usernames
for username in users:
print('user', username)
to_print += '\n'
to_print += ('=' * 50)
user1 = User(username=username)
user1.load()
to_print += '\n'
to_print += user1.f_name
user1_balance = user1.balance()
to_print += '\n'
to_print += ('Accumulated debt: {0} RUB'.format(user1_balance[0]))
to_print += '\n'
to_print += ('Accumulated receivables: {0} RUB'.format(user1_balance[1]))
remaining_users = [i for i in counterpart_usernames if i != user1.user_id]
for counterpart_id in remaining_users:
user2 = User(username=counterpart_id)
counterpart_balance = user1.balance(counterpart_id=user2.user_id)
debt_to_counterpart = counterpart_balance[0]
receivables_from_counterpart = counterpart_balance[1]
if debt_to_counterpart != 0 or receivables_from_counterpart != 0:
user2.load()
user2.describe()
to_print += '\n'
to_print += ('-' * 20)
to_print += '\n'
to_print += ('Debt to {0}: {1} RUB:'.format(user2.f_name, debt_to_counterpart))
to_print += '\n'
to_print += ('Receivables from {0}: {1} RUB'.format(user2.f_name, receivables_from_counterpart))
bot.send_message(message.chat.id, to_print, reply_markup=types.ReplyKeyboardRemove())
def load_all_users():
url = LB_SERVER + "get_all_users"
resp = requests.get(url)
responses = loads(resp.text)
users = []
for response in responses:
users.append(User(response[0], UUID(response[1]), "none"))
return users
def user(self):
try:
with open(".\\user\\data.txt", "r") as f:
username = f.read()
except FileNotFoundError:
username = "******"
return User(username, USERCOLOR)
def test_saveCredentials(self):
'''Method to test if the user credentials are being saved'''
self.new_user.saveUser()
test_user = User('Abdihakim99', 'ABDULHAKIM')
test_user.saveUser()
credential1 = Credential('Facebook', 'Abdihakim9_', 'ABDULHAKIM')
test_user.saveCredentials(credential1)
self.assertEqual(len(test_user.credentials), 1)
def _return_user(self) -> User:
''' Takes input from self._get_result() and tries to return a User.
If result is empty, raises, UserNotFoundException'''
result = self._get_result()
if result == None:
raise UserNotFoundException
else:
return User(*result)
def insert_empty_ride(token, ride_code):
user = select_user_by_token(token)
user_obj = User(*user)
cur = _connection.cursor()
cur.execute("""INSERT INTO rides(user_id, ride_code) VALUES (\'{user_id}\', {ride_code})""".format(
user_id=user_obj.id, ride_code=ride_code
))
_connection.commit()
def createMockData():
connection = sqlite3.connect(DATABASE_URI)
c = connection.cursor()
c.execute("DELETE FROM users")
c.execute("DELETE FROM messages")
connection.commit()
connection.close()
user = User("*****@*****.**", hash("abcde"),"John","Smith","Decidedly male","Kansas City","Murica")
user2 = User("*****@*****.**", hash("abcdef"),"John","Wick","Surely male","Missouri","Murica")
message = Message(user.email, user.email, "Hello World!")
message2 = Message(user.email, user2.email, "Hej World!")
addUser(user)
addUser(user2)
addMessage(message)
addMessage(message2)
def start_message(message):
user = User(user_id=message.from_user.id,
chat_id=message.chat.id,
name=message.from_user.first_name)
user.check_if_user_exists()
msg = bot.reply_to(
message,
min_planked_time_answer(user=user.name, politeness=user.politeness))
bot.register_next_step_handler(msg, set_up_time_step)
def get_users(self, logins):
"""
Fetches user details for multiple users
Accepts a array of login emails
"""
out = self._proxy.User.get({
'names': logins
})
return [User(user) for user in out['users']]
def register_users():
## SQLite3 user database initialization
create_user_table()
# Open users worksheet
sheet = access_spreadsheet()
users_sheet = sheet.get_worksheet(0)
# Get number of rows (new user registrations)
number_of_users = (users_sheet.row_count - 1)
print('Number of new registrations: ' + str(number_of_users))
# Loop through new user registrations
for x in range(number_of_users):
new_user = users_sheet.row_values(2 + x)
# Formatting user data
reg_date = time_now('date.month.year')
email = new_user[1]
firstname = new_user[2]
lastname = new_user[3]
age = new_user[4]
postal_number = new_user[5]
street_name = new_user[6]
street_number = new_user[7]
phone = new_user[8]
bsu = new_user[9]
bsu_bank = new_user[10]
savings = new_user[11]
savings_bank = new_user[12]
savings_limit = new_user[13]
savings_limit_bank = new_user[14]
retirement = new_user[15]
retirement_bank = new_user[16]
usagesalary = new_user[17]
usagesalary_bank = new_user[18]
# Formatting current user to class
current_user = User(reg_date, email, firstname, lastname, age,
postal_number, street_name, street_number, phone,
bsu, bsu_bank, savings, savings_bank,
savings_limit, savings_limit_bank, retirement,
retirement_bank, usagesalary, usagesalary_bank)
# Insert new user into the user database
response = insert_user(current_user)
# Send confirmation email for new registrations and updates
if response == 'new_user':
registration_email(current_user)
elif response == 'update_user':
update_email(current_user)
# Loop through and delete user entries in sheet
print('Deleting new user entries from sheet...')
for x in range(number_of_users):
users_sheet.delete_row((number_of_users + 1) - x)
def user_acc_generator():
count = read_single_name()
for i in range(0, ACCNUM):
# Make account and save to list for future code upgrade
user_accounts.append(
User(single_name_get(count), single_name_get(count)))
write_user_accounts()
def test_state():
chan = "#chan"
# join
state = State()
user = User("oreqizer", None)
state.join(user, chan)
assert len(state.channels) == 1, f"state.join: state.channels: {len(state.channels)} == 1"
ch = state.channels[chan]
assert len(user.channels) == 1, f"state.join: user.channels: {len(user.channels)} == 1"
assert len(ch.users) == 1, f"state.join: ch.users: {len(ch.users)} == 1"
# part
state = State()
user = User("oreqizer", None)
state.join(user, chan)
ch = state.channels[chan]
state.part(user, chan)
assert len(user.channels) == 0, f"state.part: user.channels: {len(user.channels)} == 0"
assert len(ch.users) == 0, f"state.part: ch.users: {len(ch.users)} == 0"
# get_channel
state = State()
user = User("oreqizer", None)
assert_throw(lambda: state.get_channel(chan))
state.join(user, chan)
ch = state.channels[chan]
assert state.get_channel(
chan) == ch, f"state.get_channel: {state.get_channel(chan).name} == {ch.name}"
# get_user_channel
state = State()
user = User("oreqizer", None)
assert_throw(lambda: state.get_user_channel(user, chan))
state.users[user.nickname] = user
assert_throw(lambda: state.get_user_channel(user, chan))
ch = Channel(chan)
state.channels[chan] = ch
assert_throw(lambda: state.get_user_channel(user, chan))
state.join(user, chan)
assert state.get_user_channel(
user, chan) == ch, f"state.get_user_channel: {state.get_user_channel(user, chan).name} == {ch.name}"
print("test_state OK")
def get(self, user):
try:
person = self._db.labels.get(self._label).get(email=user.email)
if person and person[0]:
return User(person[0].properties['email'],
person[0].properties['password'])
except Exception as e:
print(e)
else:
return None
def home():
if request.method == 'POST':
username = request.form['username']
user = User(username=username)
user.load()
balance = user.balance()
return render_template('load_user.html', f_name=user.f_name, l_name=user.l_name, debt=balance[0], receivables=balance[1])
return render_template('load_user.html', f_name='', l_name='', debt='', receivables='')
