def user_info(): if request.method == 'GET': return jsonify(current_user.to_json()) if not request.is_json: return _error('Request must be JSON type', 400) form = request.get_json() hashed = bcrypt.hashpw(form['password'].encode('utf-8'), bcrypt.gensalt()) user = User.query.filter(User.email == form['email'] or User.id == form['_id']).first() print(user) if request.method == 'PUT': if user is not None: return _error('An account with that email already exists', 400) new_user = User(first_name=form.get('first_name'), last_name=form.get('last_name'), email=form['email'], password=hashed) db_session.add(new_user) db_session.commit() return jsonify(new_user.to_json()) elif request.method == 'POST': if user is None: return _error('Specified user not found', 400) user.first_name = form.get('first_name') user.last_name = form.get('last_name') user.email = form.get('email') if form.get('password') is not None: user.password = hashed db_session.add(user) db_session.commit() return jsonify(user.to_json()) return _error('Invalid request type.', 400)
def login(): """ POST only operation. check login form. Log user in """ if current_user.is_authenticated: return response.make_success_resp(msg="You are already logged in") form = LoginForm() if form.validate_on_submit(): user, authenticated = User.authenticate(form.login.data, form.password.data) if user: if authenticated: login_user(user, remember=form.remember_me.data) return response.make_data_resp( data=current_user.to_json(), msg="You have successfully logged in") else: return response.make_error_resp( msg="Invalid username or password", type="Wrong Authentication", code=422) else: return response.make_error_resp(msg="Username does not exist", type="Wrong Authentication", code=422) return response.make_form_error_resp(form=form)
def get(self, oauth_id=None): """ Gets current user information. :param oauth_id: :return: models/user/User plus owned_systems, secondary_systems """ if oauth_id is None: oauth_id = current_user.oauth_id if current_user.oauth_id != oauth_id: # TODO: Check for admin status here. abort(403) data = current_user.to_json() owned = OwnerModel.from_user(current_user) try: owned_data = owned.system_key.get().to_json() except AttributeError: data['owned_systems'] = [] else: data['owned_systems'] = [owned_data, ] secondary = Secondary.from_user(current_user) secondary_data = [s.system_key.get().to_json() for s in secondary] data['secondary_systems'] = secondary_data return jsonify(data)
def update_state(): json_object = {"auth": False, "user": "******", "detectImg": []} if current_user.is_authenticated: # [print(img.image_filename) for img in current_user.det_img] # [print(img.to_json()) for img in current_user.det_img] json_object["auth"] = True json_object["user"] = current_user.to_json() detect_img_json = [] try: json_files_path = [ path_to_json(img.image_filename) for img in current_user.det_img ] for json_path in json_files_path: if isfile(json_path): with open(json_path, ) as json_string: detect_img_json.append(json.loads(json_string.read())) else: print(json_path, isfile(json_path)) except Exception as e: print("ERR: ", e.__class__, "occurred.") json_object["detectImg"] = json.loads(json.dumps(detect_img_json)) # print( 'updateState: ',str(json.dumps(json_object))[:500]) return jsonify(json_object)
def generate_resource_id(): auth_user = current_user.to_json() userId = auth_user['id'] channelName = request.json['channelName'] # Get the base64 credential for making requests credential = generate_base64_credential() # Create connection object with basic URL conn = http.client.HTTPSConnection("api.agora.io") params = json.dumps({ "cname": channelName, "uid": str(userId), "clientRequest": { "resourceExpiredHour": 24, "scene": 0 } }) # Create Header object headers = { "Content-type": "application/json;charset=utf-8", "Authorization": "Basic " + credential } app_id = os.environ.get('AGORA_APP_ID') resource_url_path = '/v1/apps/' + app_id + '/cloud_recording/acquire' # Send request conn.request("POST", resource_url_path, params, headers) res = conn.getresponse() data = res.read() return data.decode("utf-8")
def show_movie_comments(id: str): """ Movie comments page. :param id: str :return: """ if request.method == 'POST': comment = request.form['comment'] requests.post( f'{MOVIE_SERVICE}/movies/{id}/comments', json={ 'movie_id': id, 'user': current_user.to_json(), 'text': comment, 'date': datetime.now().isoformat() } ) return redirect(url_for('show_movie', id=id)) r = requests.get(f'{MOVIE_SERVICE}/movie/{id}/comments') if r.status_code == 200: comments = r.json()['data'] else: comments = [] context = { 'movie': _get_movie(id), 'comments': comments } return render_template('movie_comments.html', **context)
def login(): try: idinfo = id_token.verify_oauth2_token(request.json["idToken"], requests.Request(), os.environ["GOOGLE_CLIENT_ID"]) if idinfo["iss"] not in [ "accounts.google.com", "https://accounts.google.com" ]: raise ValueError("Incorrect issuer") # google account id from decoded token userid = idinfo["sub"] # check if this user is already present in the database user = User.query.filter_by(google_id=userid).first() # if user doesn't exist, make a new user if user is None or userid != request.json["id"]: new_user = User( email=request.json["email"], username=request.json["name"], google_id=request.json["id"], google_image=request.json["photo"], ) db.session.add(new_user) db.session.commit() user = new_user login_user(user) except ValueError: return make_response(jsonify({"session": "Token not authorized"}), 400) return make_response(jsonify(current_user.to_json()), 200)
def login(self): """ user login /passport/ :return: """ form = LoginForm(request.form, csrf=False) if form.validate_on_submit(): user = UserModel.query.filter_by(email=form.email.data).first() if user is not None and user.verify_password(form.password.data): try: remember = False if current_app.config.get("COOKIE_ENABLE"): remember = True current_app.logger.info( "remember me(记住我)功能是否开启,{}".format(remember)) login_user(user, remember=remember) user.fresh_session() except WalleError as e: return self.render_json(code=e.code, data=Code.code_msg[e.code]) return self.render_json(data=current_user.to_json()) return self.render_json(code=Code.error_pwd, data=form.errors)
def get_members(): group_id = current_user.group_id groups = User.query.filter(User.group_id == group_id).filter(User.id != current_user.id).all() results = [i.to_json() for i in groups] me = current_user.to_json() me['real_name'] = '我' results.insert(0, me) return jsonify(results)
def sign(): access_id = request.args.get('access_id') tonce = request.args.get('tonce') now = time.time() * 1000 if access_id and tonce and now - 10000 < int(tonce) < now + 10000: cu = current_user.to_json() cu['token'] = serialize_data(cu) return jsonify({'code': 200, 'message': 'OK', 'data': cu}) return jsonify({'code': 401, 'message': 'invalid request'})
def am_i_logged_in(): if request.method == 'GET' and getattr(current_user, 'id', None) is not None: return jsonify(dict( code=1, user=current_user.to_json(), temples=[t.light_json() for t in Temple.query.filter_by(active=True).all()] )) else: return jsonify(dict(code=0))
def get(self): """ Get information of current user """ if Config.LOGIN_DISABLED: return current_user.to_json() user_json = fix_ids(current_user) del user_json['password'] return {'user': user_json}
def call_user(): auth_user = current_user.to_json() pusher_client.trigger( 'presence-online-channel', 'make-agora-call', { 'userToCall': request.json['user_to_call'], 'channelName': request.json['channel_name'], 'from': auth_user['id'] }) return jsonify({'message': 'call has been placed'})
def putUserEmail(): if not request.json or not 'email' in request.json: return jsonify({'err': 'Request not Json or miss email'}) else: current_user.email = request.json['email'] try: current_user.save() except Exception: return jsonify({'err': 'Modify email error.'}) return jsonify({'status': 0, 'msg': 'Email has been modified.', 'user': current_user.to_json()})
def get(self): if current_user.is_authenticated: response = make_response( jsonify(code=0, message='get current_user success', data={'user': current_user.to_json()})) return response else: response = make_response( jsonify(code=35, message='get current_user fail')) return response
def decorated_function(*args, **kwargs): if not current_user.registration_completed(): response = { "status": "error", "message": "You did not finish your registration process. Please update your profile to continue!", "data": current_user.to_json() } return response, 403 return f(*args, **kwargs)
def login(): id = request.form['id'] password = request.form['password'] user = User.query.filter_by(id=id).first() if user and user.verify_password(password): login_user(user) LoginUser.append(user.id) return jsonify({'code': 0, 'message': current_user.to_json()}) elif user: return jsonify({'code': 2, 'message': '密码错误'}) else: return jsonify({'code': 2, 'message': '账号不存在'})
def pusher_auth(): auth_user = current_user.to_json() payload = pusher_client.authenticate(channel=request.form['channel_name'], socket_id=request.form['socket_id'], custom_data={ 'user_id': auth_user['id'], 'user_info': { 'id': auth_user['id'], 'name': auth_user['username'] } }) return jsonify(payload)
def logout(): """ 注销登录,解除会话 logout_user() :return: """ current_app.logger.error("目前登录用户[%s]", current_user.to_json()) user = current_user user.authenticated = False auth_service.save_user(user) logout_user() session.pop('username', None) return redirect(url_for("auth.login"))
def update_password(): if not request.is_json: return _error('Request must be JSON type', 400) form = request.get_json() if not bcrypt.checkpw(form['old_password'].encode('utf-8'), current_user.password): return _error('Invalid credentials', 400) p = bcrypt.hashpw(form['new_password'].encode('utf-8'), bcrypt.gensalt()) current_user.password = p db_session.add(current_user) db_session.commit() return jsonify(current_user.to_json())
def put(self): """ Keys sent must be a subset or equal to the keys in model/user/User :return: model/user/User """ data = request.get_json() if data is None or not UserModel.valid_update_keys(data.keys()): abort(400) try: current_user.update_from(data) except ValueError as e: abort(400, e.message) return jsonify(current_user.to_json())
def login_user(self, login_info): # Verify user is not already logged in if current_user.is_authenticated: print("User {} was already logged in".format(current_user.id)) self.response['data'] = current_user.to_json() else: user = User.query.filter_by( email=login_info['email']).one_or_none() if not user or not check_password_hash(user.password, login_info['password']): abort(400, "Please check login details and try again.") login_user(user) self.response['data'] = user.to_json()
def update_user_info(): """更新当前用户信息 """ q = parse_params( request.json, Rule('avatar'), Rule('nickname'), Rule('gender', allow = [UserGender.female, UserGender.male]), Rule('bio') ) User.query.filter_by(id = current_user.id).update(q) db.session.commit() return success({ 'user': current_user.to_json() })
def user_list(): if current_user.role == 'admin': size = request.args.get("size", type=int, default=5) page = request.args.get("page", type=int, default=1) pagination = User.query.paginate(page=page, per_page=size, error_out=False) return jsonify(sum=pagination.total, total_page=pagination.pages, current_page=pagination.page, data=[w.to_json() for w in pagination.items]) else: return jsonify(sum=1, total_page=1, current_page=1, data=[current_user.to_json()])
def generate_agora_token(): auth_user = current_user.to_json() appID = os.environ.get('AGORA_APP_ID') appCertificate = os.environ.get('AGORA_APP_CERTIFICATE') channelName = request.json['channelName'] userAccount = auth_user['username'] expireTimeInSeconds = 3600 currentTimestamp = int(time.time()) privilegeExpiredTs = currentTimestamp + expireTimeInSeconds token = RtcTokenBuilder.buildTokenWithAccount(appID, appCertificate, channelName, userAccount, Role_Attendee, privilegeExpiredTs) return jsonify({'token': token, 'appID': appID})
def login(self): """ user login /passport/ :return: """ form = LoginForm(request.form, csrf_enabled=False) if form.validate_on_submit(): user = UserModel.query.filter_by(email=form.email.data).first() if user is not None and user.verify_password(form.password.data): login_user(user) user.fresh_session() return self.render_json(data=current_user.to_json()) return self.render_json(code=-1, data=form.errors)
def login(self): """ user login /passport/ :return: """ form = LoginForm(request.form, csrf_enabled=False) if form.validate_on_submit(): user = UserModel.query.filter_by(email=form.email.data).first() if user is not None and user.verify_password(form.password.data): login_user(user) user.fresh_session() return self.render_json(data=current_user.to_json()) return self.render_json(code=Code.error_pwd, data=form.errors)
def guest_login(): guest = User.query.filter_by(username="******").first() if guest is None: new_guest = User( email="*****@*****.**", username="******", google_id="Not a Google account", google_image="Not applicable", ) db.session.add(new_guest) db.session.commit() guest = new_guest login_user(guest) return make_response(jsonify(current_user.to_json()), 200)
def login(): """ POST only operation. check login form. Log user in """ if current_user.is_authenticated: return Response.make_success_resp(msg="You are already logged in") form = LoginForm() if form.validate_on_submit(): user, authenticated = User.authenticate(form.login.data, form.password.data) if user : if authenticated: login_user(user, remember=form.remember_me.data) return Response.make_data_resp(data=current_user.to_json(), msg="You have successfully logged in") else: return Response.make_error_resp(msg="Invalid username or password", type="Wrong Authentication", code=422) else: return Response.make_error_resp(msg="Username does not exist", type="Wrong Authentication", code=422) return Response.make_form_error_resp(form=form)
def update_user(): ''' Update user's information at user's discretion\n ''' # u_id = request.json.get('id', None) f_name = request.json.get('fname', '') # user = User.get_user_by_id(u_id) if not current_user or not validate_request(request.json, current_user.token): return jsonify({'reason': 'invalid user or CSRF violation'}), 400 current_user.update_user(f_name) ret = { 'reason': 'User successfully updated', 'result': current_user.to_json() } return jsonify(ret), 200
def login(self): """ user login /passport/ :return: """ form = LoginForm(request.form, csrf=False) if form.validate_on_submit(): user = UserModel.query.filter_by(email=form.email.data).first() if user is not None and user.verify_password(form.password.data): try: login_user(user) user.fresh_session() except WalleError as e: return self.render_json(code=e.code, data=Code.code_msg[e.code]) return self.render_json(data=current_user.to_json()) return self.render_json(code=Code.error_pwd, data=form.errors)
def myaccount(): user = current_user.to_json() user['image_file'] = url_for('static', filename='profile_pics/' + user['image_file']) del user['password'] follow_list = [] for uid in user['follow']: u = User.query.get_or_404(uid) follow_list.append({uid: u.username}) user['follow'] = follow_list black_list = [] for uid in user['black']: u = User.query.get_or_404(uid) black_list.append({uid: u.username}) user['black'] = black_list data = {} data['code'] = 1 data['user'] = user return jsonify(data)
def login(): msg = '' user_json = 'global' if request.method == 'POST': email = request.form.get('email') password = request.form.get('password') print(request.form) user = User.query.filter_by(email=email).first() if user: if check_password_hash(user.password, password): msg = 'Logged in successfully!' login_user(user, remember=True) user_json = current_user.to_json() else: msg = 'Incorrect password, try again.' else: msg = 'Email does not exist.' print(msg) response = jsonify({"success" : current_user.is_authenticated, "user" : user_json, "msg" : msg}) return response
def stop_recording(): auth_user = current_user.to_json() userId = auth_user['id'] channelName = request.json['channelName'] token = request.json['token'] # Get the base64 credential for making requests credential = generate_base64_credential() conn = http.client.HTTPSConnection("api.agora.io") params = json.dumps({ "cname": channelName, "uid": str(userId), "clientRequest": { "token": token } }) # Create Header object headers = { "Content-type": "application/json;charset=utf-8", "Authorization": "Basic " + credential } app_id = os.environ.get('AGORA_APP_ID') resource_id = request.json['resourceId'] sid = request.json['sid'] resource_url_path = '/v1/apps/'+app_id + \ '/cloud_recording/resourceid/'+resource_id+'/sid/'+sid+'/mode/web/stop' # Send request conn.request("POST", resource_url_path, params, headers) res = conn.getresponse() data = res.read() return data.decode("utf-8")
def verify_auth(): return Response.make_data_resp(data=current_user.to_json())
def get_my_info(): """查询当前用户信息 """ return success({ 'user': current_user.to_json() })
def get(self): return current_user.to_json()
def update_user(): if request.is_json: current_user.default_notebook = request.json.get('default_notebook') db.session.commit() return jsonify(current_user.to_json())