def update_favorite_lots(lot_id):
if request.method == "PUT":
user.add_lot_to_favorites(lot_id)
return RestAPI.message("A lot is added to favorites"), 201
if request.method == "DELETE":
user.remove_lot_from_favorites(lot_id)
return RestAPI.message("A lot is removed from favorites"), 201
def unsubscribe_from_lot(lot_id):
try:
user.unsubscribe_from_lot(lot_id)
return RestAPI.message(
f"You are no longer subscribed to lot {lot_id}"), 201
except:
return RestAPI.message("You are not subscribed"), 200
def index(self, param):
"""
ページの処理
"""
username = self.form_data.getvalue('username', '')
password = self.form_data.getvalue('password', None)
mode = self.form_data.getvalue('mode')
login = False;
redirect = False
login_failed = False
if not username.isalnum():
username = ''
if self.session.getvalue('login', False):
login = True
elif mode == 'login':
login_failed = True
user = User()
if user.login(username, password, self.setting['password']['salt']):
# ログイン成功
self.session.setvalue('login', True)
self.session.setvalue('user_id', user.getvalue('id'))
redirect = True
# テンプレ―ト用データ
template_data = {}
template_data['mode'] = mode
template_data['redirect'] = redirect
template_data['login'] = login
template_data['login_failed'] = login_failed
template_data['username'] = username
return self.template(template_data)
def index(self, param):
"""
ページの処理
"""
username = self.form_data.getvalue('username', '')
password = self.form_data.getvalue('password', None)
mode = self.form_data.getvalue('mode')
login = False
redirect = False
login_failed = False
if not username.isalnum():
username = ''
if self.session.getvalue('login', False):
login = True
elif mode == 'login':
login_failed = True
user = User()
if user.login(username, password,
self.setting['password']['salt']):
# ログイン成功
self.session.setvalue('login', True)
self.session.setvalue('user_id', user.getvalue('id'))
redirect = True
# テンプレ―ト用データ
template_data = {}
template_data['mode'] = mode
template_data['redirect'] = redirect
template_data['login'] = login
template_data['login_failed'] = login_failed
template_data['username'] = username
return self.template(template_data)
def put_user(user_id):
db_user = db.session.query(Users).get(user_id)
if db_user is None:
return render_template(
'user/list.html',
users=db.session.query(Users).order_by(Users.id).all(),
errors=u'Пользователя с id=%s не существует' % user_id)
db_roles = db.session.query(Roles).all()
radio_roles = [(role.id, role.name) for role in db_roles]
form = EditUserForm(login=db_user.login)
form.role.choices = radio_roles
if form.validate_on_submit():
password = form.password.data.strip()
if password:
user = User(form.login.data.strip(), form.password.data.strip())
db_user.password = user.pw_hash
else:
user = User(form.login.data.strip())
if db_user.login != user.login and db.session.query(Users).filter(
Users.login == user.login).count() > 0:
return render_template(
'user/edit.html',
errors=[
u'Пользователь с логином <b>%s</b> уже существует' %
user.login
],
form=form)
db_user.login = user.login
db_role = db.session.query(Roles).get(form.role.data)
db_user.roles[0] = db_role
db.session.commit()
flash(u'Пользователь изменен')
return redirect(url_for('users'))
return render_template('user/edit.html', form=form, user=db_user)
def login():
# login form that uses Flask-WTF
form = LoginForm()
errors = list()
# Validate form input
if form.validate_on_submit():
# Retrieve the user from the hypothetical datastore
user = db.session.query(Users).filter(
Users.login == form.login.data.strip()).first()
if user:
check_user = User(user.login)
# Compare passwords (use password hashing production)
if check_user.check_password(form.password.data.strip(),
user.password):
# Keep the user info in the session using Flask-Login
login_user(user)
# Tell Flask-Principal the identity changed
identity_changed.send(current_app._get_current_object(),
identity=Identity(user.id))
return redirect(request.args.get('next') or url_for('index'))
else:
errors.append(u'Неверная пара логин/пароль')
else:
errors.append(u'Нет пользователя с логином <b>%s</b>' %
form.login.data.strip())
return render_template('user/login.html', form=form, errors=errors)
def update_favorite_lots(lot_id):
if request.method == 'PUT':
user.add_lot_to_favorites(lot_id)
return RestAPI.message('A lot is added to favorites'), 201
if request.method == 'DELETE':
user.remove_lot_from_favorites(lot_id)
return RestAPI.message('A lot is removed from favorites'), 201
def new_user():
data = request.get_json()
data = data['user']
email = data['email']
password_hash = bcrypt.generate_password_hash(data['password'])
# save user in database
save_user = User()
user_id = save_user.save(email, password_hash)
trxn = TransactionUtil(user_id)
trxn_success = trxn.create_basic_profile()
trxn_accounts = trxn.get_account_information()
# login user
if user_id is None:
auth_token = None
user = None
success = False
# return token
else:
auth_token = save_user.generate_auth_token(user_id)
user = save_user.get_user_from_id(user_id)
success = True
ret_val = {
"success": success,
"trxn_succes": trxn_success,
"token": auth_token,
"user": user,
"accounts": trxn_accounts
}
return jsonify(ret_val)
def load_data(cls):
try:
with open('users.dat', 'rb') as file:
user_db = pickle.load(file)
User.set_id(user_db.max_id())
except IOError:
user_db = UserManager()
return user_db
def test_user_attributes(self):
user = User()
self.assertRaises(AttributeError, getattr, user, 'ip')
user.ip = 1
try:
user.ip
except AttributeError:
self.fail("Unexpected AttributeError!")
def verify_token(token):
user = User()
user_info = user.verify_token(token)
if user_info:
setattr(g, 'user', user_info)
return True
else:
return False
def inner(*a, **kw):
username = request.params.get('username') or kw.get('username')
password = request.params.get('password')
if username is None or password is None:
raise AuthenticationError
user = User(username)
if not user.password_auth(password):
raise AuthenticationError
return func(user=user, *a, **kw)
def inner(*a, **kw):
id_ = request.params.get('id') or kw.get('id_')
password = request.params.get('password')
if id_ is None or password is None:
raise AuthenticationError
user = User(id_)
if not user.password_auth(password):
raise AuthenticationError
return func(user=user, *a, **kw)
def main():
db = lib.db.db
db.create_tables ([
lib.db.User,
lib.db.Bet,
lib.db.Wager,
lib.db.Outcome,
])
lib.db.User.create (
nick = 'neil',
pwhash = 'd68e939882371200637d5024b360fc20', # neil
hats = 101,
)
lib.db.User.create (
nick = 'mike',
pwhash = '18126e7bd3f84b3f3e4df094def5b7de', # mike
hats = 101,
)
lib.db.User.create (
nick = 'buzz',
pwhash = 'b9056d71aca02a3a7fb860f66864fef0', # buzz
hats = 101,
)
laika = User (
nick = 'laika',
pw = 'laika',
hats = 101,
)
laika.save()
user_id = laika.id
derby = Bet (
owner = laika,
text = 'Who will win the next Derby ?',
outcomes = [
dict (text = 'Rapid', odds = 2.00),
dict (text = 'Austria', odds = 2.00),
]
)
derby.save()
bet_id = derby.id
derby = Bet (
owner = laika,
text = 'Who will win the Fruit Cup ?',
outcomes = [
dict (text = 'Gramatneusiedel', odds = 1.20),
dict (text = 'Oed im Winkel', odds = 1.80),
]
)
derby.save()
bet_id = derby.id
def test_set_prefs():
matt = User({'type': 'github', 'id': 'hhsetprefshh' })
matt.set_prefs({
'one': 'a',
'two': 'b',
})
print(str(matt.dict))
assert matt.dict['prefs']['one'] == 'a'
assert matt.dict['prefs']['two'] == 'b'
def test_learn_node():
mo = User({'type': 'google', 'id': 'xPr' })
mo.learn_node('nonemptygraph')
assert 'nonemptygraph' in mo.dict['learned_node_ids']
mo_fresh = User({'type': 'google', 'id': 'xPr' })
assert 'nonemptygraph' in mo_fresh.dict['learned_node_ids']
matt_thick = User({'type': 'github', 'id': 'ggg' })
assert 'nonemptygraph' not in matt_thick.dict['learned_node_ids']
def get_page_thumb(request, username, docname, pagename):
user = User(username)
doc = user.getdocument(docname)
pagename_without_ext = os.path.splitext(pagename)[0]
pagepath = doc.pages[pagename_without_ext].thumbpath
if os.path.exists(pagepath):
return send_file(request, pagepath)
else:
return HttpResponseNotFound()
def auth_user():
user_id = g.user['id']
user = User()
user_info = user.get_user_from_id(user_id)
trxn = TransactionUtil(user_id)
trxn_accounts = trxn.get_account_information()
ret_val = {"user": user_info, "accounts": trxn_accounts}
return jsonify(ret_val)
def login_user():
data = request.get_json()
data = data['user']
user = User()
pw_hash = user.get_password_hash(data['email'])
validate = bcrypt.check_password_hash(pw_hash, data['password'])
user_info = user.get_user_from_email(data['email'])
token = user.generate_auth_token(user_info['id'])
ret_val = {"success": validate, "token": token, "user": user_info}
return jsonify(ret_val)
def register_users(self):
for _ in range(int(self.number_of_users)):
user = User(name=fake.user_name(),
password=fake.password(length=16,
special_chars=True,
digits=True,
upper_case=True,
lower_case=True),
email=fake.email())
code, data = user.sing_up(self.url + 'api/users/')
if code == 201:
self.users.append(user)
return self.users
def test_extend():
matt = User({'type': 'facebook', 'id': 'hhextendhh' })
matt.learn_node('node-one')
john = User({'type': 'linkedin', 'id': 'hhextendhh' })
john.learn_node('node-two')
matt.extend(john)
assert matt.dict['learned_node_ids'] == ['node-one', 'node-two']
def make_top(self):
"""
トップ部分作成
"""
top = DivTag('top', H1Tag(u'テストページ'))
if self.session.getvalue('login', False):
user_id = self.session.getvalue('user_id')
user = User(user_id)
top.add_value(PTag(u'ログイン中です:[%s] %s さん' % (escape(user.getvalue('username','')), escape(user.getvalue('nickname', '')))))
top_links = [('top', u'トップ'), ('edit', u'問題作成'), ('bbs', u'掲示板'), ('about', u'取扱説明書'), ('profile', u'プロフィール'), ('regist', u'登録'), ('logout', u'ログアウト'), ('login', u'ログイン'), ('admin', u'管理画面')]
for p in top_links:
top.add_value(u'[%s]' % ATag('/%s'%p[0], p[1]))
return top
def edit_profile():
data = request.get_json()
data = data['profile']
profile = ProfilePipeline()
save = profile.run([data])
user = User()
user_info = user.get_user_from_id(g.user['id'])
g.user = user_info
ret_val = {"success": save, "user": user_info}
return jsonify(ret_val)
def scan_page(request, scanner_id, docname, pagename):
image = IMAGE_SCANNER.scan(scanner_id)
user = User()
doc = user.getdocument(docname)
if doc is None:
user.createdocument(docname)
doc.addpage(pagename, image)
host = 'http://' + request.get_host()
args = (user.username, docname, pagename)
host_image = reverse('get-page', args=args) + ".png"
return host + host_image
def edit_user_data():
try:
request_json = json.loads(request.data)
except json.decoder.JSONDecodeError:
raise NoJsonError()
data_required = {
"phone": "phone_number",
"name": "name",
}
for data in data_required:
if data in request_json:
user.edit_data(data_required[data], request_json[data])
return RestAPI.message("Data is edited successful"), 201
def edit_user_data():
try:
request_json = json.loads(request.data)
except:
raise NoJsonError()
data_required = {
'phone': 'phone_number',
'name': 'name',
}
for data in data_required:
if data in request_json:
user.edit_data(data_required[data], request_json[data])
return RestAPI.message('Data is edited successful'), 201
def post_user():
# create a new user
db_roles = db.session.query(Roles).all()
radio_roles = [(role.id, role.name) for role in db_roles]
form = EditUserForm()
form.role.choices = radio_roles
if form.validate_on_submit():
user = User(form.login.data.strip(), form.password.data.strip())
if db.session.query(Users).filter(
Users.login == user.login).count() > 0:
return render_template(
'user/edit.html',
errors=[
u'Пользователь с логином <b>%s</b> уже существует' %
user.login
],
form=form)
db_user = Users(user.login, user.pw_hash)
db_role = db.session.query(Roles).get(form.role.data)
db_user.roles.append(db_role)
db.session.add(db_user)
db.session.commit()
flash(u'Пользователь добавлен')
return redirect(url_for('users'))
return render_template('user/edit.html', form=form)
def edit(request, uid=None):
if uid == None:
iapp_user = User()
else:
iapp_user = User.get_by_uid(uid)
context = {'iapp_user': iapp_user}
return render(request, 'iapp_user/edit.html', context)
def get_updated_settings(args):
settings = Settings.load()
u = User(user=args.user, password=args.password)
s = XcodeServer(host=args.host, port=args.port)
settings.update(s, u)
settings.validate()
return settings
def regist_user(self, username, password):
"""
登録
"""
user = User(username=username)
if user.exist():
return USER_EXIST
user.setvalue('username', username)
user.setvalue('nickname', u'名無し')
user.reset_hash()
if not user.reset_password(new_password=password, salt=self.setting['password']['salt'], force=True):
return PASSWORD_ERROR
if user.insert():
self.user = user;
return REGIST_CORRECT
return OTHER_ERROR
def create_lot():
request_json = RestAPI.request_data_to_json(request.data)
data_required = [
"name",
"amount",
"currency",
"term",
"return_way",
"security",
"percentage",
"form",
"commentary",
]
RestAPI.check_required_fields(request_json, data_required)
return (
jsonify({
"lot_id":
user.create_lot(
*[request_json[data] for data in data_required])
}),
201,
)
def get_pdf_document(request, username, docname):
user = User(username)
docname_without_ext = os.path.splitext(docname)[0]
doc = user.getdocument(docname_without_ext)
if doc is not None:
pages = simplejson.loads(request.GET.get('pages'))
doctitle = request.GET.get('doctitle')
lang = request.GET.get('lang')
docpath = doc.topdf(doctitle, pages, lang)
if os.path.exists(docpath):
return docpath
return HttpResponseNotFound()
def __call__(self, args):
self._args = args
try:
with open(self._args.config_file) as f:
self._settings = yaml.load(f, yaml.SafeLoader)
except Exception as e:
self._parser.error(
"Failed in loading the settings.yml file:{}".format(e))
self._logger = Logger(self._settings["logs_locations"])
self._database = Database(self._settings, self._parser, self._logger)
self._user = User(self._settings["okta_token"],
self._settings["okta_organization_url"])
self._group = Group(self._settings["okta_token"],
self._settings["okta_organization_url"])
self._change_policy = ChangePolicy(self._settings, self._user,
self._group)
self._run_risk_score_monitor()
def getUsers(self):
users = []
with open(userDir, "r") as json_file:
data = json.load(json_file)
for u in data['user']:
object = User(u['username'], u['email'], u['password'], u['name'],
u['role'])
users.append(object)
return users
def register():
if not request.json:
raise NoJsonError()
data_required = [
'email',
'password',
]
for data in data_required:
if data not in request.json:
raise NotEnoughDataError(data_required, request.json.keys())
user.begin_email_verification(
request.json['email'],
request.json['password'],
)
return RestAPI.message(f"Verification is sent to {request.json['email']}"), 201
def create_bets (self):
laika = User (
nick = 'laika',
pw = 'laika',
hats = 101,
)
laika.save()
self.user_id = laika.id
derby = Bet (
owner = laika,
text = 'Who will win the next Derby ?',
outcomes = [
dict (text = 'Rapid', odds = 2.00),
dict (text = 'Austria', odds = 2.00),
]
)
derby.save()
self.bet_id = derby.id
def post(self):
userid = self.get_argument('userid')
data = json.loads(self.request.body.decode())
publickey_pem = data.get('publickey', None)
privatekey_pem = data.get('privatekey', None)
meta = data.get('meta', None)
user = User(userid, publickey_pem, privatekey_pem=privatekey_pem,
services=data['services'], meta=meta)
ioloop.IOLoop.current().add_callback(partial(userprocess, user))
self.api_response("OK")
def collect_users(self):
"""Return a list of wifi user statistics scraped from CloudTrax"""
for network in self.network['networks']:
parameters = {'id': network}
logging.info('Requesting user statistics')
request = self.session.get(self.url['user'], params=parameters)
logging.info('Received user statistics ok')
if request.status_code == 200:
for raw_values in distill_html(request.content, 'table',
{'class': 'inline sortable'}):
user = User(raw_values)
usage_dl = user.get_dl()
usage_ul = user.get_ul()
user_mac = user.get_mac()
node_mac = user.get_node_mac()
if user_mac in self.users.keys():
self.users[user_mac].add_usage(usage_dl, usage_ul)
else:
self.users[user_mac] = user
gateway = self.nodes[node_mac].add_usage(usage_dl,
usage_ul)
if gateway != 'self' and gateway != 'not reported':
self.nodes[node_mac].add_gw_usage(usage_dl, usage_ul)
self.usage[0] += usage_dl
self.usage[1] += usage_ul
else:
logging.error('Request failed')
exit(request.status_code)
return self.users
def test_set_pref():
matt = User({'type': 'github', 'id': 'ggg' })
matt.set_pref({ 'anything': 'now' })
assert matt.dict['prefs']['anything'] == 'now'
matt.set_pref({ 'anything': 'notnow' })
assert matt.dict['prefs']['anything'] == 'notnow'
with pytest.raises(ValueError):
matt.set_pref({ 'one': 'more', 'thing': 'here' })
def add_lot_photo(lot_id):
if not Lot.can_user_edit(user.email(), lot_id):
raise NoPermissionError()
a = request.files
resp = {
filename: Lot.add_photo(request.files[filename], lot_id)
for filename in request.files
}
return jsonify(resp), 201
def edit_avatar():
if request.method == 'GET':
user.get_avatar_link()
return jsonify({'link': user.get_avatar_link()}), 200
if request.method == 'POST':
user.add_avatar(request.files['file'])
return RestAPI.message('New avatar is saved'), 201
if request.method == 'DELETE':
user.delete_avatar()
return RestAPI.message('Your avatar is now deleted'), 201
def edit_avatar():
if request.method == "GET":
user.get_avatar_link()
return jsonify({"link": user.get_avatar_link()}), 200
if request.method == "POST":
user.add_avatar(request.files["file"])
return RestAPI.message("New avatar is saved"), 201
if request.method == "DELETE":
user.delete_avatar()
return RestAPI.message("Your avatar is now deleted"), 201
def login():
error = None
if request.method == "POST":
username = request.form["username"]
user = User.find(username)
if user is None:
error = "User not found. Please try again."
elif request.form["password"] == user.password: # Valid login
return redirect(url_for("profile", username=username))
else:
error = "Invalid password. Please try again."
return render_template("login.html", error=error)
def show_number(self, ggnumber):
if FileManager.has_history(ggnumber):
sql = SQL()
query = 'select * from users where ggnumber=:ggnumber;'
ret = sql.execute(query, {'ggnumber': ggnumber})
row = ret.fetchone()
user = User(row, ggnumber)
view = UserView(user)
self.clear()
view()
else:
self.refresh()
ROText(1, 0, u'Nie znaleziono histori dla podanego numeru.',
u'Błąd').run()
def __init__(self, addr, port):
RPCServer.__init__(self, addr, port, user=User())
self._sandbox = Sandbox()
locks = []
for _ in range(LOCK_MAX):
locks.append(Lock())
self._locks = HashRing(locks)
self._cache = {}
if DEBUG:
self._register_cnt = 0
self._login_cnt = 0
self._upload_cnt = 0
self._install_cnt = 0
self._uninstall_cnt = 0
def index(self, param):
"""
ページの処理
"""
mode = self.form_data.getvalue('mode')
username = self.form_data.getvalue('username')
password = self.form_data.getvalue('password')
login = self.session.getvalue('admin', False)
enable = self.setting['admin']['enable'] == 'On'
users = []
login_faled = False
if enable:
if mode == 'login':
if username == self.setting['admin']['user'] and password == self.setting['admin']['pass']:
self.session.setvalue('admin', True)
login = True
else:
login_faled = True
elif mode == 'logout':
self.session.delvalue('admin')
login = False
elif mode == 'reset_password':
user = User(username)
user.reset_password(new_password=password, salt=self.setting['password']['salt'], force=True)
user.update()
if login:
users = self.dba.select('user_tbl', '*')
# テンプレ―ト用データ
template_data = {}
template_data['enable'] = enable
template_data['login'] = login
template_data['login_failed'] = login_faled
template_data['users'] = users
return self.template(template_data)
def login():
form = LoginForm(csrf_enabled=False)
# Work in progress
# user_id = request.cookies.get('SessionProdTools')
# if user_id:
# user =
if request.method == 'POST' and form.validate_on_submit():
user = app.config['USERS_COLLECTION'].find_one({"_id": form.username.data})
#user = MongoClient()['blog'].users.find_one({"_id": form.username.data})
if user and User.validate_login(user['password'], form.password.data):
user_obj = User(user['_id'])
login_user(user_obj, remember=True)
flash("Logged in successfully!", category='success')
return redirect(request.args.get("next") or url_for("add_item"))
flash("Wrong username or password!", category='error')
return render_template('login.html', title='login', form=form)
def group(request, cn, sort_by='sn'):
group = Group.get_by_cn(cn, ['cn', 'description', 'gidNumber', 'memberUid', 'owner'])
members = []
owner = group.owner.split(',')[0][4:]
description = group.description
for memberUid in group.memberUid:
user = User.get_by_uid(memberUid, ['uid', 'givenName', 'sn'])
if not user:
kwargs = {}
kwargs['uid'] = memberUid
kwargs['givenName'] = ''
kwargs['sn'] = ''
kwargs['former_member'] = True
user = User(**kwargs)
members.append(user)
sorted_members = sorted(members, key=attrgetter(sort_by))
context = {
'description' : description,
'group': group,
'members': sorted_members,
'owner' : owner,
}
return render(request, 'iapp_group/details.html', context)
# coding: utf-8
from lib.user import User
user_list = []
## admin
admin = User()
admin.name = u"Admin User"
admin.email = "*****@*****.**"
admin.set_password("admin1234")
admin.role = "admin"
user_list.append(admin)
def test_nodes_to_send():
# Need to complete! Each option works independently but I did not try combining them!
MG = fill_sample_custom_nodes()
pre_set = {"type":"axiom","description":"__This is the node for set__","name":"set","importance":4}
sset = create_appropriate_node(pre_set)
pre_vertex = {"type":"axiom","description":"__This is the node for vertex__","name":"vertex","importance":4}
vertex = create_appropriate_node(pre_vertex)
pre_multiset = {"type":"axiom","description":"__This is the node for multiset__","name":"multiset","importance":4}
multiset = create_appropriate_node(pre_multiset)
MG.add_n(sset)
MG.add_n(vertex)
MG.add_n(multiset)
MG.add_path(['a', 'b', 'c', 'e'])
MG.add_path(['b', 'd', 'e'])
MG.add_edges_from([
('set', 'a'), ('vertex', 'a'), ('multiset', 'a')
])
greg = User({'type': 'local', 'id': None})
#helpers
def reset_prefs(user): # sets preferences for minimal client nodes; should send learned nodes and starting nodes only
user.set_prefs({
'subject': 'graph theory',
'goal_id': None,
'always_send_learnable_successors': False,
'always_send_learnable_pregoals': False,
'send_learnable_pregoal_number': 1,
'always_send_goal': False,
'always_send_unlearned_dependency_tree_of_goal': False,
})
def reset_learned(user):
for node_id in user.dict['learned_node_ids']:
user.unlearn_node(node_id)
# check starting nodes
reset_learned(greg)
reset_prefs(greg)
nodes = MG.nodes_to_send(greg).difference({'set', 'multiset', 'vertex'})
assert nodes == set()
greg.set_pref({'subject': None})
with pytest.raises(ValueError):
MG.nodes_to_send(greg)
greg.set_pref({'subject': 'not a real subject'})
with pytest.raises(ValueError):
MG.nodes_to_send(greg)
# check learned nodes
reset_learned(greg)
reset_prefs(greg)
greg.learn_node('a')
greg.learn_node('b')
nodes = MG.nodes_to_send(greg).difference({'set', 'multiset', 'vertex'})
assert nodes == {'a', 'b'}
# check absolute dominion
reset_learned(greg)
reset_prefs(greg)
greg.learn_node('a')
greg.set_pref({'always_send_learnable_successors': True})
# should now send learnable successors of learned nodes
nodes = MG.nodes_to_send(greg).difference({'set', 'multiset', 'vertex'})
assert nodes == {'a', 'b'}
# check learnable pregoals
reset_learned(greg)
reset_prefs(greg)
greg.learn_node('a')
greg.learn_node('b')
greg.set_pref({'always_send_learnable_pregoals': True})
greg.set_pref({'goal_id': 'e'}) # using a manually set goal
nodes = MG.nodes_to_send(greg).difference({'set', 'multiset', 'vertex'})
assert nodes == {'a', 'b', 'd'} # d is chosen over c because it is more important
greg.set_pref({'send_learnable_pregoal_number': 2}) # ask for more than one pregoal
nodes = MG.nodes_to_send(greg).difference({'set', 'multiset', 'vertex'})
assert nodes == {'a', 'b', 'c', 'd'} # c and d both chosen as pregoals
greg.set_pref({'goal_id': None}) # choses a goal without setting it
# in this case d should be chosen as the goal (because d and c are the only successors of learned_nodes and d is more important)
greg.set_pref({'send_learnable_pregoal_number': 1})
nodes = MG.nodes_to_send(greg).difference({'set', 'multiset', 'vertex'})
assert nodes == {'a', 'b', 'd'} # d is chosen as the goal, then also set as the pregoal
# check always send goal
reset_learned(greg)
reset_prefs(greg)
greg.learn_node('a')
greg.learn_node('b')
greg.set_pref({'always_send_goal': True})
greg.set_pref({'goal_id': 'e'})
nodes = MG.nodes_to_send(greg).difference({'set', 'multiset', 'vertex'})
assert nodes == {'a', 'b', 'e'}
# check always send dependency tree of goal
reset_learned(greg)
reset_prefs(greg)
greg.learn_node('a')
greg.learn_node('b')
greg.set_pref({'always_send_unlearned_dependency_tree_of_goal': True})
greg.set_pref({'goal_id': 'e'})
nodes = MG.nodes_to_send(greg).difference({'set', 'multiset', 'vertex'})
assert nodes == {'a', 'b', 'c', 'd', 'e'}
def details(request, uid):
iapp_user = User.get_by_uid(uid)
context = {'iapp_user': iapp_user,
}
return render(request, 'iapp_user/details.html', context)
def index(request):
users = User.all(['cn','uid', 'uidNumber'])
context = {'users': users}
return render(request, 'iapp_user/index.html', context)
def rest_scan(sync_gateway, db, online, num_docs, user_name, channels):
# Missing ADMIN
# TODO: GET /{db}/_session/{session-id}
# TODO: POST /{db}/_session
# TODO: DELETE /{db}/_session/{session-id}
# TODO: DELETE /{db}/_user/{name}/_session/{session-id}
# TODO: DELETE /{db}/_user/{name}/_session
# TODO: DELETE /{db}/_user/{name}
# TODO: POST /{db}/_role/
# TODO: DELETE /{db}/_role/{name}
# Missing REST
# TODO: POST /{db}/_all_docs
# TODO: DELETE /{db}/{doc}
# TODO: PUT /{db}/{doc}/{attachment}
# TODO: GET /{db}/{doc}/{attachment}
# Missing Local Document
# TODO: DELETE /{db}/{local-doc-id}
# Missing Authentication
# TODO: POST /{db}/_facebook_token
# TODO: POST /{db}/_persona_assertion
admin = Admin(sync_gateway=sync_gateway)
error_responses = list()
# PUT /{db}/_role/{name}
try:
admin.create_role(db=db, name="radio_stations", channels=["HWOD", "KDWB"])
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/_role
try:
roles = admin.get_roles(db=db)
log.info(roles)
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/_role/{name}
try:
role = admin.get_role(db=db, name="radio_stations")
log.info(role)
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# PUT /{db}/_user/{name}
try:
user = admin.register_user(target=sync_gateway, db=db, name=user_name, password="******", channels=channels)
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/_user
try:
users_info = admin.get_users_info(db=db)
log.info(users_info)
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/_user/{name}
try:
user_info = admin.get_user_info(db=db, name=user_name)
log.info(user_info)
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}
try:
db_info = admin.get_db_info(db=db)
if not online:
assert (db_info["state"] == "Offline")
else:
assert (db_info["state"] == "Online")
log.info(db_info)
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# Create dummy user to hit endpoint if offline, user creation above will fail
if not online:
user = User(target=sync_gateway, db=db, name=user_name, password="******", channels=channels)
# PUT /{db}/{name}
add_docs_errors = user.add_docs(num_docs=num_docs)
error_responses.extend(add_docs_errors)
# POST /{db}/_bulk_docs
bulk_doc_errors = user.add_docs(num_docs=num_docs, bulk=True)
error_responses.extend(bulk_doc_errors)
# POST /{db}/
for i in range(num_docs):
try:
user.add_doc()
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/{name}
# PUT /{db}/{name}
if online:
update_docs_errors = user.update_docs(num_revs_per_doc=1)
error_responses.extend(update_docs_errors)
else:
try:
# Try to hit the GET enpoint for "test-id"
user.update_doc("test-id")
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# PUT /{db}/{local-doc-id}
local_doc_id = uuid.uuid4()
try:
doc = user.add_doc("_local/{}".format(local_doc_id), content={"message": "I should not be replicated"})
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/{local-doc-id}
try:
doc = user.get_doc("_local/{}".format(local_doc_id))
assert(doc["content"]["message"] == "I should not be replicated")
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# GET /{db}/_all_docs
try:
all_docs_result = user.get_all_docs()
# num_docs /{db}/{doc} PUT + num_docs /{db}/_bulk_docs + num_docs POST /{db}/
assert(len(all_docs_result["rows"]) == num_docs * 3)
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# POST /{db}/_bulk_get
try:
doc_ids = list(user.cache.keys())
first_ten_ids = doc_ids[:10]
first_ten = user.get_docs(first_ten_ids)
assert(len(first_ten) == 10)
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
# wait for changes
time.sleep(2)
# GET /{db}/_changes
try:
changes = user.get_changes()
# If successful, verify the _changes feed
verify_changes(user, expected_num_docs=num_docs * 3, expected_num_revisions=1, expected_docs=user.cache)
except HTTPError as e:
log.error((e.response.url, e.response.status_code))
error_responses.append((e.response.url, e.response.status_code))
return error_responses
def test_unlearn_node():
mo = User({'type': 'google', 'id': 'xPr' })
mo.learn_node('vertex')
assert 'vertex' in mo.dict['learned_node_ids']
mo.unlearn_node('vertex')
assert 'vertex' not in mo.dict['learned_node_ids']
def index(self, param):
"""
ページの処理
"""
login = self.session.getvalue('login', False)
user_id = self.session.getvalue('user_id', '-1')
mode = self.form_data.getvalue('mode')
reset_hash = self.form_data.getvalue('reset_hash', '') == 'reset'
nickname = unicode(self.form_data.getvalue('nickname', ''), 'utf-8')
edit_status = EDIT_NONE
userid = ''
userhash = ''
user = User(user_id)
if login:
if mode == 'pass_update':
old_password = self.form_data.getvalue('old_password', '')
new_password = self.form_data.getvalue('new_password', '')
retype_password = self.form_data.getvalue('retype_password', '')
if new_password == retype_password:
if user.reset_password(old_password, new_password, self.setting['password']['salt']):
edit_status = EDIT_CORRECT
else:
edit_status = EDIT_FAILED
elif mode == 'update':
if reset_hash:
user.reset_hash()
if nickname != '':
user.setvalue('nickname', nickname)
edit_status = EDIT_CORRECT
user.update()
# テンプレ―ト用データ
template_data = {}
template_data['login'] = login
template_data['userid'] = str(user.getvalue('id', -1))
template_data['username'] = user.getvalue('username', '')
template_data['nickname'] = user.getvalue('nickname', '')
template_data['userhash'] = user.getvalue('hash', '')
template_data['mode'] = mode
template_data['edit_status'] = edit_status
return self.template(template_data)
def list_doc_pages(request, username, docname):
user = User(username)
doc = user.getdocument(docname)
pages = doc.pages
return [ pages[key].info() for key in pages ]
from flask import render_template, request, redirect, url_for
from app import app
#imports the user class from the libraries folder to be
#able to use the user methods
from lib.user import User
#Creates a new user and checks if the user exists
user = User('*****@*****.**', 'awesomesauce')
user.exist()
#gets username
username = user.getName()
#The following code uses flask methods to communicate between
#the database via the user class and the html pages using Jinja2
#variables
@app.route('/', methods=['GET', 'POST'])
@app.route('/index.html', methods=['GET', 'POST'])
def index():
#gets the grocery lists associated
#with the user
glists = user.getGListsItemList()
#gets a lists of names for all the user's grocery lists
gListNames = user.getGListsNames()
#Post requests in flask mean that the user has clicked on a button or link
# coding: utf-8 from lib.user import User user_list = [] ## admin admin = User() admin.username = u"Admin User" admin.email = "*****@*****.**" admin.password = "******" user_list.append(admin)
def test_user_connection(self):
user, ip = User(), '127.0.0.1'
user.connectFrom(ip)
self.assertEqual(user.ip, ip)
self.assertEqual(user.is_authorized, True)
self.assertLess(user.login_time, datetime.datetime.now())
