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())