def __init__(self, redis_client):
self.redis = redis_client
self.games = []
self.user = User()
self.player = Player()
GameManagerParsing(self.redis).start()
GameManagerInitGame(self.redis, self.user).start()
def addUser(self, data):
"""
Allows to add a user on the system. This is the first required step.
Without a user the app can't create/remove buckets.
@type data: dict
@param data: dict with data about the user
@rtype: basestring
@returns: the id generated by adding the user on the system. If the user
can't added, an empty value is returned.
"""
# sanity check
assert isinstance(data, dict)
# create a user and a controller to handle it
try:
# call user constructor
self.__user = User(data)
return self.__user.getUserId()
# system can't create the user: return False
except (AssertionError, RuntimeError), err:
sys.stderr.write('Error: %s\n' % str(err))
def get_all_users(self):
query = select([self.users])
result_proxy = self.con.execute(query)
result_set = result_proxy.fetchall()
users = {}
for i, result in enumerate(result_set):
user = User(result[0], result[1], result[2], result[3], result[4])
users[i] = (user.get_user())
return users
class Login:
def __init__(self, root, window):
self.root = root
self.window = window
self.user = User()
self.build()
def login(self):
self.user.login(self.username.get(), self.password.get())
login_status = self.user.login_status
if login_status == 1:
self.window.destroy()
dashboard.main(self.user.user_id, login_status)
elif login_status == 2:
self.window.destroy()
dashboard.main(self.user.user_id, login_status)
else:
Message("Incorrect Credentials")
def build(self):
row = 0
user = User()
ui.margin_y(self.root, px=20, row=row)
row += 1
ui.title(self.root, text='Login', row=row)
row += 1
ui.margin_y(self.root, px=10, row=row)
row += 1
tk.Label(self.root, text='Username').grid(row=row)
row += 1
self.username = tk.Entry(self.root)
self.username.grid(row=row)
row += 1
tk.Label(self.root, text='Password').grid(row=row)
row += 1
self.password = tk.Entry(self.root, show="*")
self.password.grid(row=row)
row += 1
ui.margin_y(self.root, px=20, row=row)
command = lambda : self.login()
tk.Button(self.root, text='Login', command=command).grid(row=row)
row += 1
ui.margin_y(self.root, px=20, row=row)
row += 1
def userLogin(self, ):
"""This function handles user login
Args:
Raises:
Returns:
- userInfo -- dictionary
success - boolean
userObj - object of User Class
"""
loginFlag = False
retryCount = 0
while not loginFlag and retryCount < 3:
userInfo = dict()
userInfo['email'] = input('Enter Email Id: ')
userInfo['password'] = self.getPass()
userObj = (User(userInfo))
retryCount = retryCount + 1
loginFlag = userObj.success
if not loginFlag and retryCount < 3:
print('{}'.format('Mail id, password combination invalid'))
success = False
elif not loginFlag and retryCount == 3:
print('{}'.format('Mail id, password combination invalid'))
print('{}'.format(
'Maximum tries exceeded, redirecting to login page'))
time.sleep(2)
success = False
else:
success = True
return {'success': success, 'userObj': userObj}
def test_app():
# Create the new board & update the board id environment variable
# Setup the test items
item_store = ItemStore()
item_store.setup_test_store()
# Setup the test users
user_store = UserStore()
user_store.setup_test_store()
user_store.add_user_if_missing(User("Peter", 1, "peter1", "*****@*****.**", UserRole.ADMIN))
# construct the new application
application = app.create_app(item_store, user_store)
application.config['LOGIN_DISABLED'] = True
# start the app in its own thread.
thread = Thread(target=lambda: application.run(use_reloader=False))
thread.daemon = True
thread.start()
yield app
# Tear Down
thread.join(1)
# Reset the item store internal stat
item_store.reset_store()
user_store.reset_store()
def run_single_session():
"""Executes a single dialog session.
"""
user = User(policy_type=UserPolicyType.handcrafted)
agent = Agent()
session = DialogSession(user, agent)
session.start()
def addUser(self, data):
"""
Allows to add a user on the system. This is the first required step.
Without a user the app can't create/remove buckets.
@type data: dict
@param data: dict with data about the user
@rtype: basestring
@returns: the id generated by adding the user on the system. If the user
can't added, an empty value is returned.
"""
# sanity check
assert isinstance(data, dict)
# create a user and a controller to handle it
try:
# call user constructor
self.__user = User(data)
return self.__user.getUserId()
# system can't create the user: return False
except (AssertionError, RuntimeError), err:
sys.stderr.write('Error: %s\n' % str(err))
def submit_rating():
usr = request.args.get('username')
res = User.find_by_username(usr)
status = 400 # username not found
if res is not None:
tconst = request.args.get('FilmID')
rating = int(request.args.get('Rating'))
if 0 <= rating <= 10:
status = 350
cur = g.db.cursor()
cur.execute(
f"SELECT average_ratings FROM ratings WHERE tconst = '{tconst}';"
)
old_rating = float(cur.fetchone()[0])
cur.execute(
f"SELECT num_votes FROM ratings WHERE tconst = '{tconst}';")
num_votes = int(cur.fetchone()[0])
new_rating = ((
(old_rating * num_votes) + rating)) / (num_votes + 1)
num_votes += 1
cur.execute(
f"UPDATE ratings SET average_ratings = '{new_rating}', num_votes = '{num_votes}' WHERE tconst = '{tconst}';"
)
return jsonify({'exit_code': status})
else:
status = 300 # rating not between 0 and 10
return jsonify({'exit_code': status})
def find_matches():
usr = request.args.get('username')
res = User.find_by_username(usr)
status = 500
if res is not None:
cur = g.db.cursor()
cur.execute(f"""
CREATE OR REPLACE VIEW view1 AS
SELECT user_id, tconst from favouriteFilms
WHERE tconst IN (SELECT tconst FROM favouriteFilms WHERE user_id = '{usr}')
AND user_id <> '{usr}'
ORDER BY user_id
LIMIT 1000;
SELECT user_id, list FROM (
SELECT user_id, array_to_string(ARRAY_AGG(primary_title), ',') as list, COUNT(primary_title)
FROM (SELECT user_id, primary_title from view1 INNER JOIN films ON view1.tconst = films.tconst) as x
GROUP BY user_id
ORDER BY COUNT(primary_title) DESC
LIMIT 10) as y;
""")
res = [{
"user": i[0],
"movies": i[1].split(",")
} for i in cur.fetchall()]
return json.dumps(res)
return jsonify({'exit_code': status})
def write():
st.markdown(f'# {PAGE_TITLE}')
# initialize models
user = User()
user_id = user.db_user['id']
tracker = Tracker()
# TBU - make hours_back based on goal type (calories 24, workout 7*24)
st.markdown('## 1. Choose Goal & Submit Entry')
choose = submit_entry(tracker, user_id)
st.markdown('## 2. Review Entries')
df = tracker.existing_entries
df = df[df['entry_type'] == choose]
sum = df.sum()
sum['entry_type'] = 'Total'
sum['description'] = '24hr Total'
df = df.append(sum, ignore_index=True)
df.drop(columns=['user_id', 'created_at'], inplace=True)
st.write(df)
st.markdown('## 3. Create New Entry Type')
create_type(tracker, user_id)
footer()
def get_user_by_token(self, token):
query = select(self.users).where(self.users.c.token == token)
user = None
for row in self.con.execute(query):
user = User(row[0], row[1], row[2], row[3], row[4], row[5])
return user
def signup():
# Get user input
usr = request.args.get('username')
pswrd = request.args.get('password')
# Check for blanks
if usr == "" or pswrd == "":
status = -2 # Empty input
else:
res = User.find_by_username(usr)
status = 2 # Username is already exist
if res is None:
newUser = User(usr, pswrd)
newUser.save_to_db()
status = 11 # Username does not exist thus can be used
return jsonify({'status': status})
def test_login_with_valid_credentials(self, mock_user, mock_db):
# Given: a registered user
registered_user = User(email="*****@*****.**", authenticated=True)
registered_user.set_password("test")
mock_user.query.get.return_value = registered_user
# When: valid login credentials are provided
response = app.test_client().post("/login",
data=dict(email="*****@*****.**",
password="******",
remember_me=False,
login=True),
follow_redirects=True)
# Then: the user is successfully logged in
assert mock_db.session.commit.called
self.assertEqual(HTTP_SUCCESS, response.status_code)
self.assertIn(b"FeedMe - Home", response.data)
def login_with_credentials(body):
k_user = User()
#if k_user.isLoggedIn == True:
# return True
try:
json_body = json.loads(body)
login_body = json_body['LOGIN']
email = login_body['email']
pw = login_body['pw']
isLoggedIn = k_user.login(email, pw)
if isLoggedIn == False:
print("Login failed")
return (isLoggedIn, k_user)
except:
return (False, k_user)
def register_user():
if not request.json \
or not 'name' in request.json \
or not 'password' in request.json \
or not 'email' in request.json:
return Result.gen_fail(None,
'Request not Json or miss name/email/password')
elif User.objects(name=request.json['name']).first():
return Result.gen_fail(None, 'Name is already existed.')
else:
user = User(
uid=User.objects().count() + 1,
name=request.json['name'],
email=request.json['email'] if 'email' in request.json else "",
password=request.json['password'],
createtime=datetime.now())
try:
user.save()
except Exception as ex:
traceback.print_exc()
return Result.gen_fail(None, 'Register error.')
return Result.gen_success({'uid': user.get_id()}, 'Register success.')
def _value_to_user(self)->User:
"""
a
"""
return User(
"",
"",
""
)
def register():
form = RegistrationForm(request.form)
if request.method == "POST" and form.validate():
user = User()
user.create_user(
name=form.name,
plaintext_password=form.password,
email=form.email,
title=form.title,
secret_question=form.secret_question,
plaintext_secret_answer=form.secret_answer,
phone_number=form.phone_number,
company=session["company"],
authentication_level=form.authentication_level,
)
flash("Thanks for registering")
return redirect(url_for("login"))
return render_template("user/register.html")
def test_role_reader():
#given
role = UserRole.READER
#when
user = User("fred", 1234, "login", "*****@*****.**", role)
#then
assert user.is_readonly == True
assert user.is_admin == False
def main():
user = User()
st.sidebar.title("Navigation")
selection = st.sidebar.radio("Go to", list(PAGES.keys()))
st.sidebar.markdown(f'Logged in as **{user.current_username}**.')
page = PAGES[selection]
with st.spinner(f"Loading {selection} ..."):
ast.shared.components.write_page(page)
def __call__(self, args):
self._args = args
result, error_message = config.set_configs(self._args.config_file)
if result is False:
error_message = "Failed to load config file: {}".format(error_message)
logger.error(self, error_message)
self._parser.error(error_message)
user_api.set_user(User(config.TOKEN, config.ORG_URL))
group_api.set_group(Groups(config.TOKEN, config.ORG_URL))
ip_address, port = config.USER_APP_ADDRESS.split(":")
app.run(port=int(port), debug=False, host=ip_address)
def get_users(self):
"""
Fetches all saved users from the Mongo DB.
Returns:
list: The list of saved users.
"""
users = [User.from_json(json) for json in self.get_collection().find()]
users = sorted(users, key=lambda kv: kv.id)
return users
class Controller(object):
"""
Implements all necessary methods to control all operations related to users
on the system. Each controller instance is associated with one single user,
that can create or remove one or more buckets.
"""
def __init__(self):
"""
Constructor.
@rtype: None
@returns: Nothing
"""
# controller ID
# TODO: find a better way to calculate this
self.__controllerID = 0
# user associated with this controller
self.__user = None
# dict of available gold pots
self.__buckets = {}
# dict with deleted buckets: allow to recovery them if necessary
self.__deletedBuckets = {}
# __init__()
def addUser(self, data):
"""
Allows to add a user on the system. This is the first required step.
Without a user the app can't create/remove buckets.
@type data: dict
@param data: dict with data about the user
@rtype: basestring
@returns: the id generated by adding the user on the system. If the user
can't added, an empty value is returned.
"""
# sanity check
assert isinstance(data, dict)
# create a user and a controller to handle it
try:
# call user constructor
self.__user = User(data)
return self.__user.getUserId()
# system can't create the user: return False
except (AssertionError, RuntimeError), err:
sys.stderr.write('Error: %s\n' % str(err))
def login():
if not request.json or not 'name' in request.json or not 'password' in request.json:
return Result.gen_fail(None, 'Request not Json or miss name/password')
else:
user = User.objects(name=request.json['name'],
password=request.json['password']).first()
if user:
login_user(user)
return Result.gen_success({'uid': user.get_id()}, 'Login success.')
else:
return Result.gen_fail(None, 'Login fail.')
class Controller(object):
"""
Implements all necessary methods to control all operations related to users
on the system. Each controller instance is associated with one single user,
that can create or remove one or more buckets.
"""
def __init__(self):
"""
Constructor.
@rtype: None
@returns: Nothing
"""
# controller ID
# TODO: find a better way to calculate this
self.__controllerID = 0
# user associated with this controller
self.__user = None
# dict of available gold pots
self.__buckets = {}
# dict with deleted buckets: allow to recovery them if necessary
self.__deletedBuckets = {}
# __init__()
def addUser(self, data):
"""
Allows to add a user on the system. This is the first required step.
Without a user the app can't create/remove buckets.
@type data: dict
@param data: dict with data about the user
@rtype: basestring
@returns: the id generated by adding the user on the system. If the user
can't added, an empty value is returned.
"""
# sanity check
assert isinstance(data, dict)
# create a user and a controller to handle it
try:
# call user constructor
self.__user = User(data)
return self.__user.getUserId()
# system can't create the user: return False
except (AssertionError, RuntimeError), err:
sys.stderr.write('Error: %s\n' % str(err))
def createUser(userData):
"""Returns (user, isNew) where user is a user instance and isNew is a boolean, True if a new user was created and False if not."""
os.system("clear")
while True:
print("Welcome! Type the number of the option you want: ")
print("1. Log in with an existing account")
print("2. Create a new account")
print("3. Exit")
answer = validate_int_input([1, 2, 3], "Please enter 1, 2, or 3", "")
if (answer == 1):
username = input("Enter your username: "******"Enter your password: "******"password"] == password):
print("Successfully logged in!")
time.sleep(1)
newUser = User(user["username"], user["password"],
user["data"])
return (newUser, False)
else:
print("Invalid username or password.")
time.sleep(1)
os.system('clear')
elif answer == 2:
username = input("Enter your username: "******"Username already exists.")
time.sleep(1)
os.system('clear')
else:
password = hash_password(input("Enter your password: "))
#Other information here will probably include location, inventory, etc.
user = User(username, password, userData)
user.createUser()
return (user, True)
elif answer == 3:
sys.exit(0)
def login(self, username, password):
query = select(self.users).where(self.users.c.username == username)
user = None
for row in self.con.execute(query):
user = User(row[0], row[1], row[2], row[3], row[4], row[5])
if user and pbkdf2_sha256.verify(password, user.password):
auth_token = encode_auth_token(user.username)
update_query = update(self.users).where(self.users.c.username == username).values(token=auth_token.decode('utf-8'))
self.con.execute(update_query)
return auth_token
else:
return None
def add_favourite():
usr = request.args.get('username')
res = User.find_by_username(usr)
status = 500
if res is not None:
status = 200
tconst = request.args.get('FilmID')
cur = g.db.cursor()
cur.execute(
f"INSERT INTO favouriteFilms(user_id, tconst) VALUES ('{usr}','{tconst}');"
)
return jsonify({'exit_code': status})
return jsonify({'exit_code': status})
def remove_favourite():
usr = request.args.get('username')
res = User.find_by_username(usr)
status = 500
if res is not None:
status = 200
tconst = request.args.get('FilmID')
cur = g.db.cursor()
cur.execute(
f"DELETE FROM favouriteFilms WHERE tconst='{tconst}' AND user_id='{usr}';"
)
return jsonify({'exit_code': status})
return jsonify({'exit_code': status})
def generate_dialog_corpus(num_sessions):
"""Generates a dialog corpus by executing multiple sessions successively.
Args:
num_sessions (int, optional): Number of dialog sessions to be executed.
"""
user = User(policy_type=UserPolicyType.handcrafted)
agent = Agent()
for _ in xrange(num_sessions):
session = DialogSession(user, agent)
session.start()
print("----")
session.clear_user_log()
def main():
with app.app_context():
db.metadata.create_all(db.engine)
if User.query.all():
print("An admin user already exists!"),
return
email = "*****@*****.**"
password = "******"
user = User(email=email,
password=bcrypt.generate_password_hash(password))
db.session.add(user)
db.session.commit()
print("Admin user added")
async def add_user(self, user_info: dict, custom_task_control: dict,
custom_task_arrangement: dict):
task_control = {**self._global_task_control, **custom_task_control}
task_arrangement = {
**self._global_task_arrangement,
**custom_task_arrangement
}
user = User(dict_user=user_info,
task_ctrl=task_control,
task_arrangement=task_arrangement,
dict_bili=self._dict_bili,
force_sleep=self._force_sleep)
self._users.append(user)
def login():
if current_user.is_authenticated:
return redirect(url_for('book'))
if request.method == 'POST':
username = request.form['username']
passwd = request.form['password']
if login_service.check(username, passwd):
user = User(username)
login_service.login_session_user(user)
login_user(user)
return redirect(url_for('exchange'))
else:
return Response(status="401")
return render_template('login.html')
class AddUser:
def __init__(self, root, window):
self.root = root
self.window = window
self.User = User()
self.build()
def add(self):
userAdded = self.User.add_user(self.userID.get(), self.password.get())
if (userAdded == True):
self.window.destroy()
print("Added user")
else:
#display message
print("failed to add user")
def build(self):
row = 0
user = User()
ui.margin_y(self.root, px=20, row=row)
row += 1
ui.title(self.root, text='Add User', row=row)
row += 1
ui.margin_y(self.root, px=10, row=row)
row += 1
tk.Label(self.root, text='Username').grid(row=row)
row += 1
self.userID = tk.Entry(self.root)
self.userID.grid(row=row)
row += 1
tk.Label(self.root, text='Password').grid(row=row)
row += 1
self.password = tk.Entry(self.root)
self.password.grid(row=row)
row += 1
ui.margin_y(self.root, px=20, row=row)
command = lambda : self.add()
tk.Button(self.root, text='Add', command=command).grid(row=row)
row += 1
ui.margin_y(self.root, px=20, row=row)
row += 1
def expert(num_sessions):
freq = {}
for action in UserActionType:
freq[action] = 0
user = User(policy_type=UserPolicyType.handcrafted)
for _ in xrange(num_sessions):
user_log = run_single_session(user)
for _, action in user_log:
freq[action] += 1
for action in freq.keys():
freq[action] /= (1. * num_sessions)
print freq
def __init__(self, root, window):
self.root = root
self.window = window
self.user = User()
self.build()
