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 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 __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 run_single_session():
"""Executes a single dialog session.
"""
user = User(policy_type=UserPolicyType.handcrafted)
agent = Agent()
session = DialogSession(user, agent)
session.start()
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 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 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 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
def _value_to_user(self)->User:
"""
a
"""
return User(
"",
"",
""
)
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 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 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 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
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')
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 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")
def signup():
if current_user.is_authenticated:
return redirect(url_for('book'))
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
if (login_service.user_exists(username)):
return Response(status="401")
else:
login_service.new_user(username, password)
user = User(username)
login_service.login_session_user(user)
login_user(user)
return redirect(url_for('book'))
return render_template('signup.html')
def load_qp_mixed_user_simulation(filepath):
"""Loads the best user-simulation using QP formulation from a dump of
user-simulations leant through IRL.
Args:
filepath (string): Path of the user-simulations dump
Returns:
BestUserSimulation: The user-simulation whose feature expectation is
closest to that of the expert user.
"""
real_user = User(policy_type=UserPolicyType.handcrafted)
simulation = QpMixedUserSimulation(filepath, real_user)
simulation.solve_qp()
print simulation.mixture_weights
simulation.collect_statistics(NUM_SESSIONS_FE)
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 test_register_with_already_used_email(self, mock_user, mock_db):
# Given: a user already existing with email
mock_user.query.filter_by.first.return_value = User(
email="*****@*****.**", password="******", authenticated=True)
# When: a new user is registered with same email
response = app.test_client().post("/register",
data=dict(email="*****@*****.**",
password="******",
repeat_password="******",
register=True),
follow_redirects=True)
# Then: the registration is not successful
assert not mock_db.session.commit.called
self.assertEqual(HTTP_SUCCESS, response.status_code)
self.assertIn(b"Register", response.data)
self.assertIn(b"Email already in use. Please choose a different email",
response.data)
def get_all_users(size, page):
con = db.get_connection_func()
cur = con.cursor()
cur.execute(
"select id, nasional_number, fullname, address, register_date "
"from \"user\" "
"order by register_date desc "
"limit %s offset %s", (size, size * (page - 1)))
rows = cur.fetchall()
users = []
for row in rows:
p1 = User(row[0], row[1], row[2], row[3], row[4])
users.append(p1)
con.close()
return users
def _add_user(self):
if len(self.get_all_items()) == self.max_length:
messagebox.showerror("User Limit Reached",
"Unable to add more users")
return
form = AddUserForm(bg=self.bg,
fg=self.fg,
button_bg=self.button_bg,
activebackground=self.activebackground,
activeforeground=self.activeforeground,
entry_bg=self.entry_bg)
self.user_comp.wait_window(
form.root) # wait for the user to finish filling out the form
info = form.get_info()
if len(info.keys()) == 0:
return
new_user = User(data=info,
shoe_size=info["Shoe Size"],
shirt_size=info["Shirt Size"],
pant_size=info["Pant Size"])
self.add_elem(new_user, info["Name"])
def login(request, *args, **kwargs):
if request.method != 'POST':
return JsonResponse(ERR_BAD_REQ) # change to http error response
k_user = User()
try:
body = json.loads(request.body)
email = body['email']
pw = body['pw']
isLoggedIn = k_user.login(email, pw)
if isLoggedIn == True:
responseString = "Logged in succesfully"
else:
responseString = "Something went wrong during Login"
resp = {
"m": responseString,
"loggedIn": isLoggedIn
}
return JsonResponse(resp)
except:
return JsonResponse(ERR_BAD_REQ)
"""flask module"""
from user.user import User
from flask import Flask
from flask import render_template, session
from flask import redirect
from flask import request
from shoppinglist.Shopping import ShoppingList
from shoppingitem.shoppinglist_items import ListItems
app = Flask(__name__)
user = User()
shplist = ShoppingList()
shpitem = ListItems()
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
# index
@app.route('/')
def home():
"""Defines landing page"""
return render_template('index.html')
# about page
@app.route('/about')
def about():
"""Defines about page"""
return render_template('about.html')
# login page
