def loan_book(bst: BSTree, user: User):
loan_book_menu(bst, user)
book_title = input(
"Please enter a book title to LOAN('end' to view main menu): ")
while book_title != "end":
lib_entry = bst.search_by_title(book_title)
if lib_entry is not None:
if int(lib_entry.book.price) > user.money:
print("Insufficient funds to loan " + book_title)
else:
date_entry = input(
"Please enter the due date (YYYY, MM, DD): ")
year, month, day = map(int, date_entry.split(','))
due_date = datetime(year, month, day)
due_date_str = due_date.strftime("%d-%b-%Y (%H:%M:%S.%f)")
user.take_loan(lib_entry.book, due_date_str)
user.withdraw(int(lib_entry.book.price))
lib_entry.number_in_stock -= 1
else:
print(" ** " + book_title + " not found!! **")
loan_book_menu(bst, user)
book_title = input(
"Please enter a book title to LOAN('end' to view main menu): ")
def authorized(resp):
access_token = resp['access_token']
for key in resp:
print(key)
session['access_token'] = access_token, ''
r = requests.get(
'https://www.googleapis.com/oauth2/v1/userinfo?alt=json&access_token='
+ resp['access_token'])
print(r.text)
rjson = r.json()
try:
user = app.dbbackend.get(User, {"google_id": rjson["id"]})
except User.DoesNotExist:
user = User({
"name": rjson['name'],
"email": rjson['email'],
"google_picture": rjson['picture'],
"google_id": rjson['id'],
"google_token": resp['access_token'],
"voted_waifus": [],
"banned": False
})
user.google_token = resp['access_token']
app.dbbackend.save(user)
app.dbbackend.commit()
login_user(user)
print(current_user.name)
return redirect("/")
def authorized(resp):
access_token = resp['access_token']
for key in resp:
print(key)
session['access_token'] = access_token, ''
r = requests.get('https://www.googleapis.com/oauth2/v1/userinfo?alt=json&access_token=' + resp['access_token'])
print(r.text)
rjson = r.json()
try:
user = app.dbbackend.get(User, {"google_id": rjson["id"]})
except User.DoesNotExist:
user = User({
"name": rjson['name'],
"email": rjson['email'],
"google_picture": rjson['picture'],
"google_id": rjson['id'],
"google_token": resp['access_token'],
"voted_waifus": [],
"banned": False
})
user.google_token = resp['access_token']
app.dbbackend.save(user)
app.dbbackend.commit()
login_user(user)
print(current_user.name)
return redirect("/")
def user():
response = None
if request.method == 'POST':
response = handle_response(User(**request.json).put())
elif request.method == 'GET':
try:
response = User.get(request.json.get('uuid')).to_dict()
except (AttributeError, KeyError):
response = make_response(
f"Unable to find item with uuid {request.json.get('uuid')}")
elif request.method == 'DELETE':
response = handle_response(User.delete(request.json.get('uuid')))
return response
def find_user(self, userid, username, password):
mc = mysql.connector.connect(host="eu-cdbr-west-03.cleardb.net",
user="******",
password="******",
database="heroku_263577567345e1f")
mycursor = mc.cursor()
mycursor.execute(
"SELECT * FROM heroku_263577567345e1f.user_ Where userid=%d and username='******' and password_='%s'"
% (int(userid), username, password))
data = mycursor.fetchall()
mycursor.close()
mc.close()
userid = 0
username = ""
password = ""
name_surname = ""
age = -1
status = ""
for row in data:
userid = row[0]
username = row[1]
password = row[2]
name_surname = row[3]
age = row[4]
status = row[5]
user = User(username, password, name_surname, age, status)
if (user.age != -1):
return user
else:
return None
def test_delete_user_and_links(self):
cursor = self.conn.cursor()
dorm = Dorm(DB_NAME)
user_id = 'evuong'
name = 'Erin Vuong'
refresh_key = 'awoeisld3$#9o'
optimal_hour = datetime.time(hour=10, minute=30)
optimal_day = 1
email = '*****@*****.**'
default_scaling_factor = 1.2
user = User(user_id, name, refresh_key, optimal_hour, optimal_day,
email)
# create user
dorm.create_user(user)
# create a few link
dorm.add_scheduling_link(user_id)
dorm.add_scheduling_link(user_id)
# delete user
dorm.delete_user(user_id)
# verify users table empty
cursor.execute('SELECT * FROM users')
self.assertEqual(len(cursor.fetchall()), 0)
def update_user():
db = current_app.config["db"]
if request.method == "GET":
user = db.get_user(int(session["userid"]))
return render_template("user.html",
user=user,
userid=int(session["userid"]),
update="active")
else:
userid = request.form.get("userid")
username = request.form.get("username", "").strip()
password = request.form.get("password", "").strip()
name_surname = request.form.get("name_surname")
age = request.form.get("age")
status = request.form.get("status", "").strip()
user = User(username, password, name_surname, int(age), status)
if (db.update_user(user, userid, int(session["userid"]))):
session["userid"] = userid
return user_page()
else:
return render_template(
"user.html",
user=user,
userid=int(session["userid"]),
update="active",
message=
"This userid is used by another account, please select another one."
)
def register():
# If the user fills the form and submits it.
if request.method == "POST":
# Checking whether all the fields are filled.
if not request.form.get("name"):
return render_template("error.html", message="""Please provide
User name.""", prev_page="register")
if not request.form.get("password"):
return render_template("error.html", message="""Please provide
Password.""", prev_page="register")
# Trying to see whether the user is already present or not. If present
# will ask the user to login.
try:
User.query.filter_by(name=request.form.get("name")).one()
return render_template("register.html", flag=True,
name=request.form.get("name"),
message="""It seems like you are already a
registered user with us. Please use login
button next time.""")
# If the user is not added to our we will add that person to the
# database.
except:
try:
# print(request.form.get("name"))
# print(request.form.get("password"))
db.session.add(User(request.form.get("name"),
request.form.get("password")))
def edit(game_id: int):
with dbutils.dbopen() as db:
game = games.get_by_id(game_id, dbconnection=db)
if len(game) == 0:
raise bottle.HTTPError(404)
if pages.auth.current().user_id() != game.created_by() and \
pages.auth.current().user_id() != game.responsible_user_id() and \
not pages.auth.current().userlevel.admin():
return pages.templates.permission_denied()
_sport_types = sport_types.get(0, dbconnection=db)
_game_types = game_types.get(0, dbconnection=db)
_cities = cities.get(0, dbconnection=db)
_courts = courts.get(0, dbconnection=db)
responsibles = users.get(0, 2, dbconnection=db)
unsubscribed = games.get_unsubscribed_users(game_id, dbconnection=db)
unsubscribed_list = list()
db.execute(
"SELECT * FROM users WHERE user_id IN (SELECT DISTINCT user_id FROM reports WHERE user_id!=0 AND status=2 AND game_id IN (SELECT game_id FROM games WHERE deleted=0 AND datetime+INTERVAL duration MINUTE < NOW() AND court_id='{}' AND sport_type='{}' AND game_type='{}'))"
.format( # as long as my dick
game.court_id(), game.sport_type(), game.game_type()),
dbutils.dbfields['users'])
last_users = list(map(lambda x: User(x, db), db.last()))
for i in unsubscribed:
user = users.get(i[0], dbconnection=db)
dt = i[1]
unsubscribed_list.append((user, dt))
return pages.PageBuilder('editgame',
game=game,
sports=_sport_types,
game_types=_game_types,
cities=_cities,
courts=_courts,
responsibles=responsibles,
unsubscribed=unsubscribed_list,
last_users=last_users)
def initProgram():
user = User("park", "1234")
root = Folder("root", user, 755)
root.path = ""
user_folder = Folder(user.name, user, 755, root.path)
root.addFolder(user_folder)
handler = ObjectHandler(root, user)
return handler
def read_users(sheets):
RANGE_NAME = '{}!A2:F'.format(USERS_SHEET)
values = sheets.read(RANGE_NAME)
users = Users()
if not values:
print('No data found.')
else:
for row in values:
user = User(row)
users.insert(user)
return users
def main():
user_name = input("Please enter the user NAME: ")
user = User(user_name, 50)
print("\n<-- Welcome to the Library, " + user_name + " -->")
bst = BSTree()
while True:
main_menu()
user_choice = input(
"\nPlease select an operation from the menu( 1 - 9 ): ")
if user_choice == "1":
add_books(bst)
if user_choice == "2":
search_by_title(bst)
if user_choice == "3":
search_by_category()
if user_choice == "4":
update_book(bst)
if user_choice == "5":
loan_book(bst, user)
if user_choice == "6":
bst.in_order_traversal()
if user_choice == "7":
user.print_receipt()
if user_choice == "8":
user.print_user()
if user_choice == "9":
print("\nExiting Library...")
break
def add_user(email, password, first_name, last_name, address, city, state,
zipcode):
db.connect()
user = User(email=email,
password=password,
first_name=first_name,
last_name=last_name,
address=address,
city=city,
state=state,
zipcode=zipcode)
db.register(user)
print("You were successfully registered!")
def __show_user(self, user, path, errors = []):
assert user is not None
assert not user.is_group()
assert path is not None
# Make sure that current_user has "view" permissions on it.
current_user = self.api.get_current_user()
if user.get_id() is not None:
view = self.guard.get_action(handle = 'view', type = UserAction)
assert view is not None
if not self.guard.has_permission(current_user, view, user):
user = User(user.get_name())
errors = [_("You do not have permission to view " +
"this user.")]
# Collect information for the browser.
if user.get_id() is None:
parent_id = path.crop().get_current_id()
parent = self.guard.get_resource(id = parent_id)
parent.set_attribute('path_str', path.crop().get())
parents = [parent]
acls = []
else:
acls = self.userdb.get_permission_list(user)
parents = self.guard.get_resource_parents(user)
# Abuse attributes to pass the path to the HTML template.
for parent in parents:
ppath = self.guard.get_resource_path_from_id(parent.get_id())
parent.set_attribute('path_str', ppath.get())
# Render the template.
self.api.render('user_editor.tmpl',
path = path,
user = user,
groups = parents,
acls = acls,
get_resource = self.guard.get_resource,
errors = errors)
def get(user_id,
userlevel: int = -1,
count: slice = slice(0, 20),
dbconnection: dbutils.DBConnection = None) -> User:
if isinstance(user_id, str) and len(user_id.split(',')) > 0:
user_id = splitstrlist(user_id)
if len(user_id) == 1:
user_id = user_id[0]
if isinstance(user_id, list) and len(user_id) == 0: return list()
sql = "SELECT * FROM users WHERE user_id='{}'".format(user_id)
if isinstance(user_id, int) and user_id != 0:
sql = "SELECT * FROM users WHERE user_id='{}'".format(user_id)
elif isinstance(user_id, list):
sql = "SELECT * FROM users WHERE user_id IN (" + ','.join(
map(str, user_id)) + ")"
elif user_id == 0:
sql = "SELECT * FROM users"
if userlevel >= 0 or isinstance(userlevel, set):
if user_id == 0:
sql += ' WHERE '
else:
sql += ' AND '
if isinstance(userlevel, int):
sql += " LOCATE('|{}|', userlevel) ".format(userlevel)
else:
' AND '.join(
map(lambda x: "LOCATE('|{}|', userlevel)".format(x),
userlevel))
sql += " ORDER BY played_games DESC"
if user_id == 0:
sql += " LIMIT {}, {}".format(count.start if count.start else 0,
count.stop)
dbconnection.execute(sql, dbutils.dbfields['users'])
if len(dbconnection.last()) == 0: return list()
users = dbconnection.last()
users = list(map(lambda x: User(x, dbconnection=dbconnection), users))
if isinstance(user_id, int) and user_id != 0:
return users[0]
elif isinstance(user_id, list) or user_id == 0:
return users
def validate_user():
stuid, name = auth()
try:
user = get_user(stuid)
except:
type = "admin" if stuid in options.admins else "student"
user = User(stuid=stuid, name=name, type=type)
session.add(user)
session.commit()
if user.type == "admin" and user.proxy:
user = session.query(User).get(user.proxy)
return user
def callback_handling():
# Handles response from token endpoint
auth0.authorize_access_token()
resp = auth0.get('userinfo')
userinfo = resp.json()
# Store the user information in flask session (used for checking login)
session['jwt_payload'] = userinfo
session['profile'] = {
'user_id': userinfo['sub'],
'name': userinfo['name'],
'picture': userinfo['picture']
}
# check if user in db
db = Dorm()
user = db.get_user(userinfo['sub'])
refresh_key = ''
if not user:
# get refresh key
refresh_key = get_refresh_token(userinfo['sub'])
user = User(userinfo['sub'],
userinfo['name'],
refresh_key,
email=userinfo['email'])
db.create_user(user)
else:
refresh_key = get_refresh_token(userinfo['sub'], True)
# update refresh key
if refresh_key:
db.update_refresh_key(userinfo['sub'], refresh_key)
# check refresh key validity and force refresh if not valid
else:
success = True
try:
refresh_key = db.get_user(userinfo['sub']).get_refresh_key()
success = get_avail(refresh_key)
except:
success = False
if not success:
session['error'] = 'refresh_key_error'
return redirect(url_for('home'))
def user_add_page():
if request.method == "GET":
values = {
"username": "",
"password": "",
"name_surname": "",
"age": "",
"status": ""
}
return render_template("register.html", min_age=0, values=values)
else:
db = current_app.config["db"]
username = request.form.get("username", "").strip()
userid = request.form.get("userid")
password = request.form.get("password", "").strip()
name_surname = request.form.get("name_surname")
age = request.form.get("age")
status = request.form.get("status", "").strip()
user = User(username, password, name_surname, age, status)
new_user = db.add_user(user, userid)
today = datetime.today()
day_name = today.strftime("%A")
values = {
"username": username,
"password": password,
"name_surname": name_surname,
"age": age,
"status": status
}
if (new_user):
if "userid" in session:
session.pop("userid", None)
return render_template("home.html",
day=day_name,
name=name_surname,
userid=userid)
else:
return render_template(
"register.html",
warning=
"This userid is used by another user, please try another one.",
values=values)
def change_password():
data = request.data
data = json.loads(data)
user = User(session['username'], session['role'])
old_password = data['oldPassword']
new_password = data['newPassword']
with psycopg2.connect(CONNECTION_DATA) as conn:
with closing(conn.cursor()) as cur:
cur.execute("SELECT login, password FROM site_user WHERE login = '******'"
.format(user.username))
result = cur.fetchall()
if not result:
return json.dumps({'result': 'failed'})
username = result[0][0]
password = result[0][1]
input_pass = hashlib.md5(old_password).hexdigest()
if input_pass != password:
return json.dumps({"result": "failed"})
return json.dumps({"result": "success"})
class TestBase(TestCase):
user_id = 'test_user'
name = 'Test User'
refresh = 'test_refresh'
user = User(user_id, name, refresh)
def setUp(self):
# set up test user in db
db = Dorm()
db.delete_user(self.user_id)
db.create_user(User(self.user_id, self.name, self.refresh))
def tearDown(self):
# delete test user
db = Dorm()
db.delete_user(self.user_id)
def create_app(self):
return app
def assertRedirectsRegex(self, response, location, message=None):
parts = urlparse(location)
if parts.netloc:
expected_location = location
else:
server_name = self.app.config.get('SERVER_NAME') or 'localhost'
expected_location = urljoin('http://%s' % server_name, location)
valid_status_codes = (301, 302, 303, 305, 307)
valid_status_code_str = ', '.join(
str(code) for code in valid_status_codes)
not_redirect = 'HTTP Status %s expected but got %d' % (
valid_status_code_str, response.status_code)
self.assertTrue(response.status_code in valid_status_codes, message
or not_redirect)
self.assertRegex(response.location, expected_location)
def load_objects(object_name, number=-1):
object_path = data_path + object_name + ".json"
f = open(object_path)
all_objects = []
i = 0
for line in f.readlines():
object_json = json.loads(line)
if object_name == "user":
this_object = User()
elif object_name == "business":
this_object = Business()
elif object_name == "checkin":
this_object = Checkin()
elif object_name == "review" or object_name == "review_short":
this_object = Review()
for param in object_json:
setattr(this_object, param, object_json[param])
all_objects += [this_object]
if i == number:
break
i += 1
return all_objects
def register(self):
handle = self.__api.post_data().get_str("handle", "")
firstname = self.__api.post_data().get_str("firstname", "")
lastname = self.__api.post_data().get_str("lastname", "")
email = self.__api.post_data().get_str("email", "")
password1 = self.__api.post_data().get_str("password1", "")
password2 = self.__api.post_data().get_str("password2", "")
# Perform some checks on the input values.
error = None
if handle == "":
error = _("Invalid login name!")
elif firstname == "":
error = _("Invalid first name!")
elif lastname == "":
error = _("Invalid last name!")
elif not re.match(r"\w+\@\w+\.\w+", email):
error = _("Invalid email address!")
elif password1 == "":
error = _("Please enter a password!")
elif password1 != password2:
error = _("Passwords do not match!")
else:
# Check whether the username is already taken.
res = self.__guard.get_resource(handle=handle, type=User)
if res is not None and res.is_group():
error = _("A group with the given name already exists.")
elif res is not None:
error = _("A user with the given name already exists.")
# Bail out if an error was found.
if error is not None:
self.__api.render(
"register.tmpl",
handle=handle,
firstname=firstname,
lastname=lastname,
email=email,
password1=password1,
password2=password2,
error=error,
)
return False
# Create the user with status "inactive".
rand = random.randint(0, 123456789) # no need to be strong
string = handle + password1 + firstname + lastname + str(rand)
key = sha.new(string).hexdigest()
name = firstname + " " + lastname
users = self.__guard.get_resource(handle="users", type=Group)
user = User(name, handle)
user.set_password(password1)
user.set_inactive()
user.set_activation_key(key)
self.__guard.add_resource(users, user)
# Format activation email.
# FIXME: Make configurable.
domain = "http://" + os.environ["HTTP_HOST"]
vars = self.__api.get_requested_uri(confirm=[1], key=[key])
url = domain + vars
filename = os.path.join(os.path.dirname(__file__), "confirmation.txt")
file = open(filename)
mail_text = file.read().replace("$url", url).replace("$email", email)
file.close()
# Send email.
server = smtplib.SMTP(self.server)
# server.set_debuglevel(1)
server.sendmail(self.mail_from, email, mail_text)
server.quit()
self.__api.render("mail_sent.tmpl", email=email)
return True
def create_user_if_not_exist(session, user):
ex = session.query(exists().where(User.name == user)).scalar()
if not ex:
new_user = User(name=user, password='')
session.add(new_user)
session.commit()
def user_visits(user:User, db:dbutils.DBConnection) -> int:
return db.execute("SELECT COUNT(*) FROM reports WHERE status=2 AND user_id='{}' AND game_id IN (SELECT game_id FROM games WHERE datetime BETWEEN NOW() AND NOW()-INTERVAL 30 DAY)".format(user.user_id()))[0][0]
def get_user_data():
username = session['username']
role = session['role']
user = User(username, role)
return json.dumps({'userdata': urllib.quote(pickle.dumps(user))})
def receive_message():
if request.method == 'GET':
"""Before allowing people to message your bot, Facebook has implemented a verify token
that confirms all requests that your bot receives came from Facebook."""
for attr in dir(request):
if not attr.startswith('__'):
try:
print(attr, getattr(request, attr))
except Exception:
print(attr, file=stderr)
token_sent = request.args.get("hub.verify_token")
return verify_fb_token(request, token_sent)
else:
output = request.get_json()
#body_str = request.body.decode()
#body_str = sub('true', 'True', body_str)
#body_str = sub('false', 'False', body_str)
#body_str = sub('null', 'None', body_str)
#output = eval(body_str)
print(output)
for event in output['entry']:
if 'messaging' in event:
messaging = event['messaging']
for json in messaging:
if 'message' not in json:
if 'postback' in json and 'payload' in json['postback']:
payload = json['postback']['payload']
sender_id = json['sender']['id']
if payload == 'Get started' or payload == 'first_state':
if sender_id not in users:
user = User(sender_id)
users[sender_id] = user
users[sender_id].dialog_update()
else:
print('Attempt to begin interaction twice', file=stderr)
elif payload == 'update_selfie':
pass
else:
if json.get('message'):
sender_id = json['sender']['id']
if json['message'].get('is_echo'):
print('Got echo', file=stderr)
return 'Message Processed'
if sender_id not in users:
print('Invalid user id: user was not registred', file=stderr)
return 'Message Processed'
if json['message'].get('attachments'):
if json['message']['attachments'][0]['type'] == 'image':
url = json['message']['attachments'][0]['payload']['url']
users[sender_id].dialog_update(url, tag='image')
else:
users[sender_id].dialog_update()
return 'Message Processed'
if json['message'].get('text'):
text = json['message']['text']
users[sender_id].dialog_update(text)
elif 'standby' in event:
for standby in event['standby']:
sender_id = standby['sender']['id']
if 'postback' in standby and 'title' in standby['postback'] \
and standby['postback']['title'] != 'Начать':
users[sender_id].dialog_update(standby['postback']['title'])
return 'Message Processed'
def create_users_table():
return handle_response(User.create_table())
def list_users():
return jsonify_objects(User.list())
def setUp(self):
# set up test user in db
db = Dorm()
db.delete_user(self.user_id)
db.create_user(User(self.user_id, self.name, self.refresh))
def create_schedule(active_user, make_or_write):
sessions = []
users_object_path = root / "user_objects" / active_user
logger.debug(
"\nPlease input your class info in EXACTLY the same format that will be described below: \n "
"[class (W55) length(in hours) day (as a num)]. \n"
"Days taught are entered as a number between 1-5 [1 = Monday 5 = Friday] \n"
"Use the following example to format your input: \"W60 1 3\".\n"
"The above means class W60, taught for one hour, on Wednesday \n"
"Do not include "
" or a space before W in your input. \n")
if make_or_write.lower() == "set":
while True:
session_info = input(
"Please input class information or type \"done\" if you are finished: \n"
)
if session_info.lower() == "done":
break
else:
try:
session_list = session_info.split()
if len(session_list) == 3:
sessions.append(
Session(session_list[0], session_list[1],
session_list[2]))
logger.debug("You have entered the following classes:",
end=" ")
for session in sessions:
logger.debug(session.code,
"day = ",
session.day_taught,
end=" ")
logger.debug("\n")
logger.info(active_user + " added the class",
session_info, "to there schedule.")
else:
logger.debug(
"Sorry it seems the data you entered doesnt the required format. Please try again"
)
logger.info(active_user +
"attempted to add the incorrect format: " +
session_info + " to their schedule.")
except:
logger.debug(
"Sorry it seems the data you entered doesnt the required format. Please try again"
)
logger.info(active_user +
"attempted to add the incorrect format:" +
session_info + ""
" to their schedule.")
monday_sessions = []
tuesday_sessions = []
wednesday_sessions = []
thursday_sessions = []
friday_sessions = []
for session in sessions:
if session.day_taught == "1":
monday_sessions.append(session)
elif session.day_taught == "2":
tuesday_sessions.append(session)
elif session.day_taught == "3":
wednesday_sessions.append(session)
elif session.day_taught == "4":
thursday_sessions.append(session)
elif session.day_taught == "5":
friday_sessions.append(session)
week = []
monday = Day("Monday", monday_sessions)
week.append(monday)
tuesday = Day("Tuesday", tuesday_sessions)
week.append(tuesday)
wednesday = Day("Wednesday", wednesday_sessions)
week.append(wednesday)
thursday = Day("Thursday", thursday_sessions)
week.append(thursday)
friday = Day("Friday", friday_sessions)
week.append(friday)
users_schedule = User(active_user, week)
schedule = open(users_object_path, "wb")
pickle.dump(users_schedule, schedule)
schedule.close()
logger.debug(
"\nYour schedule has been successfully created, the program will now return you "
"to the previous menu.. \n \n")
logger.info(active_user + "has successfully set up their schedule.")
def user_visits(user: User, db: dbutils.DBConnection) -> int:
return db.execute(
"SELECT COUNT(*) FROM reports WHERE status=2 AND user_id='{}' AND game_id IN (SELECT game_id FROM games WHERE datetime BETWEEN NOW() AND NOW()-INTERVAL 30 DAY)"
.format(user.user_id()))[0][0]
# Created by Ziv Kaspersky at 11/23/2019
import logging
import sys
from argparse import Namespace
from exceptions import CreateEntityException
from objects import Target, User, Group, Alias
from smar_connection import SAMRConnection
logger = logging.getLogger(__name__)
LOG_FORMAT = "[%(levelname)s]: %(message)s"
logging.basicConfig(level=logging.DEBUG, format=LOG_FORMAT, stream=sys.stdout)
# Can be changed or loaded from file according to env
EXPECTED_USERS = [
User(name='Administrator', uniq_id=500),
User(name='Guest', uniq_id=501),
User(name='krbtgt', uniq_id=502),
User(name='zivk', uniq_id=1105)
]
class TestSAMRConnection:
test_user = None
test_group = None
samr_connection = None
target = None
options = None
@classmethod
def setup_class(cls):
def test_user_simple(self):
cursor = self.conn.cursor()
dorm = Dorm(DB_NAME)
# verify users table empty
cursor.execute('SELECT * FROM users')
self.assertEqual(len(cursor.fetchall()), 0)
user_id = 'evuong'
name = 'Erin Vuong'
refresh_key = 'awoeisld3$#9o'
optimal_hour = datetime.time(hour=10, minute=30)
optimal_day = 1
email = '*****@*****.**'
default_scaling_factor = 1.2
user = User(user_id, name, refresh_key, optimal_hour, optimal_day,
email)
# create user
dorm.create_user(user)
cursor.execute('SELECT * FROM users')
users = cursor.fetchall()
self.assertEqual(len(users), 1)
user_found = users[0]
self.assertEqual(len(user_found), 7)
self.assertEqual(user_found[0], user_id)
self.assertEqual(user_found[1], name)
self.assertEqual(user_found[2], refresh_key)
self.assertEqual(user_found[3], optimal_hour)
self.assertEqual(user_found[4], optimal_day)
self.assertEqual(user_found[5], email)
self.assertEqual(user_found[6], default_scaling_factor)
# get user
get_user = dorm.get_user(user_id)
self.assert_users_equal(get_user, user)
# update refresh key
refresh_key = 'sd9w3lsdkfsodi'
dorm.update_refresh_key(user_id, refresh_key)
# update optimal hour
optimal_hour = datetime.time(hour=11, minute=30)
dorm.update_optimal_hour(user_id, optimal_hour)
# update optimal day
optimal_day = 2
dorm.update_optimal_day(user_id, optimal_day)
# check info updated
cursor.execute('SELECT * FROM users')
users = cursor.fetchall()
self.assertEqual(len(users), 1)
user_found = users[0]
self.assertEqual(len(user_found), 7)
self.assertEqual(user_found[0], user_id)
self.assertEqual(user_found[1], name)
self.assertEqual(user_found[2], refresh_key)
self.assertEqual(user_found[3], optimal_hour)
self.assertEqual(user_found[4], optimal_day)
self.assertEqual(user_found[5], email)
self.assertEqual(user_found[6], default_scaling_factor)
# get user
user = User(user_id, name, refresh_key, optimal_hour, optimal_day,
email)
get_user = dorm.get_user(user_id)
self.assert_users_equal(get_user, user)
# delete user
dorm.delete_user(user_id)
# verify users table empty
cursor.execute('SELECT * FROM users')
self.assertEqual(len(cursor.fetchall()), 0)
# try getting a nonexistent user
no_user = dorm.get_user(user_id)
self.assertEqual(no_user, None)
# try deleting a nonexistent user
dorm.delete_user(user_id)
def current(self) -> User:
if not self.loggedin(): return _MockUser()
return User(pickle.loads(get_cookie('user')))
def query_info_to_user(self, query_info, user = None):
if (user == None):
user = User(self.get_lsa_string(query_info.account_name),
self.get_lsa_string(query_info.full_name),
self.get_lsa_string(query_info.description),
query_info.rid)
else:
user.username = self.get_lsa_string(query_info.account_name)
user.full_name = self.get_lsa_string(query_info.full_name)
user.description = self.get_lsa_string(query_info.description)
user.rid = query_info.rid
user.must_change_password = (query_info.acct_flags & 0x00020000) != 0
user.password_never_expires = (query_info.acct_flags & 0x00000200) != 0
user.account_disabled = (query_info.acct_flags & 0x00000001) != 0
# TODO: account locked out does get updated!!!
user.account_locked_out = (query_info.acct_flags & 0x00000400) != 0
user.profile_path = self.get_lsa_string(query_info.profile_path)
user.logon_script = self.get_lsa_string(query_info.logon_script)
user.homedir_path = self.get_lsa_string(query_info.home_directory)
drive = self.get_lsa_string(query_info.home_drive)
if (len(drive) == 2):
user.map_homedir_drive = ord(drive[0]) - ord('A')
else:
user.map_homedir_drive = -1
return user
