def github_auth(): """ Github OAuth, redirects to github OAuth and obtains token using client id and secret :return: """ if 'code' in request.args: github_url = 'https://github.com/login/oauth/access_token' data = {'client_id': client_id, 'client_secret': client_secret, 'code': request.args.get('code'), } headers = {'Accept': 'application/json'} r = requests.post(github_url, data=data, headers=headers) results = r.json() print(results) # Note: Once values are added to session, Flask will turn these into # a cookie that will be stored on the client side # (using set-cookie on header since cookies is not a valid header on # a response?) # Because of the secret key, values are stored with cryptography session['username'] = get_username(results.get('access_token')) session['code'] = request.args.get('code') # Import the user model and create a new instance of the object users = database.all('User') for user in users.values(): if user.user_name == session['username']: session['id'] = user.id return redirect(url_for('user.homepage')) new_user = User(**({'user_name': session.get('username'), 'level_id': '100'})) new_user.save() session['id'] = new_user.id return redirect(url_for('user.homepage'))
def post_users(): request_params = request.get_json() email = request_params.get('email') password = request_params.get('password') name = request_params.get('name') gender = request_params.get('gender') profile_image = request_params.get('profileImage') profile_image_id = request_params.get('profileImageId') q = db.session.query(User).filter(User.email == email) if q.count() > 0 : return jsonify( userMessage = "enrolled email" ), 400 created_user = User(email=email, password=password, name=name, gender=gender, profile_image=profile_image, profile_image_id=profile_image_id) db.session.add(created_user) db.session.commit() return jsonify( data=model_to_dict(created_user), token=created_user.get_token_string() )
def general_user(session): try: general_user = User.query.filter_by( google_id="*****@*****.**").first() assert not general_user general_user = User(google_id="*****@*****.**", en_name="Hammington", ko_name="Hee San", entry_date=datetime.datetime(2017, 1, 1), admin=False) session.add(general_user) except BaseException: general_user = User(google_id="*****@*****.**", en_name="Hammington", ko_name="Hee San", entry_date=datetime.datetime(2017, 1, 1), admin=False) general_user.google_id = str(random.randint( 1, 1000)) + "_" + general_user.google_id session.add(general_user) session.commit() return general_user
def post(self): data = request.get_json() user = User(username=data['username']) user.set_password(data['password']) db.session.add(user) db.session.commit() return "User " + user.username + " has been saved", 201
def sign_up(): request_params = request.get_json() email = request_params.get('email') q = db.session.query(User) \ .filter(User.email == email) if q.count() > 0: return jsonify( userMeesage="이미 가입되어있는 이메일 주소입니다." ), 409 try: user = User() user = user.update_data(**request_params) db.session.add(user) db.session.commit() token = user.get_token() user_data = user.serialize() return jsonify( data=user_data, token=token ), 201 except AttributeError: return jsonify( userMessage="요청 데이터의 키밸류가 바람직 하지 않습니다." ), 400
def set_default(): record = User().query_record(id=1) if record: return {'code': 400, 'message': 'db has initialized'}, 400 default_role = { 'name': 'admin', 'alias': '管理员', 'status': 1, } role = Role.create_record(**default_role) default_user = { 'name': 'David', 'pwd': '123456', 'status': 1, 'role_id': 1 } user = User.create_record(**default_user) return { 'user': user.to_dict(rules=('-pwd', '-role')), 'role': role.to_dict(rules=('-users', )), }, 201
def recommendation() -> Response: """Get insurance recommendation. :return: JSON response """ # Get data from the request data = request.get_json() try: # Check if email is registered user: Optional[User] = User.find_by_email(data['email']) token: Optional[str] = request.headers.get('Authorization', None) # Update user data only if auth user has the same email as the one in the questionnaire if user and user.id == User.decode_auth_token(token): # type: ignore user.first_name = data['first_name'] user.address = data['address'] user.children = data['children'] user.occupation = data['occupation'] user.update() # Get insurance recommendation insurance_list = Insurance.get_recommendation(data['occupation'], data['children']) except Exception: return make_response( jsonify({'message': 'Failed to get recommendation.'}), 500) response_object = { 'recommendations': insurance_schema.dump(insurance_list, many=True) } return make_response(jsonify(response_object), 200)
def register(): form = RegistrationForm(request.form, meta={'locales': ['fa']}) if request.method == 'POST' and form.validate(): plain_email = re.match(re.compile("(.*)(@.*)"), form.email.data) user_email = plain_email.group(1).replace('.', '') + plain_email.group(2) new_user = User(email=user_email, password=form.password.data) db.session.add(new_user) token = new_user.generate_confirmation_token() url = url_for('user.confirm', token=token, _external=True) try: email.send( new_user.email, 'Confirm Your Account', render_template('user/email/confirm.html', user=new_user, url=url)) db.session.commit() new_user.add_ability(Abilities.TYPICAL) except ConnectionError: flash( u'.ارسال ایمیل تایید حساب کاربری با مشکل روبه رو شد.مجددا تلاش کنید' ) db.session.rollback() return render_template('user/register.html', form=form) flash(u'.یک ایمیل تایید حساب کاربری برای شما ارسال شده است') return redirect(url_for('main.index')) return render_template('user/register.html', form=form)
def yelp_business_match(): if 'Authorization' not in request.headers: abort(401) if not User().verify_key(request.headers.get('Authorization')): abort(401) if not request.is_json: abort(400) request_data = request.get_json(silent=True) if request_data is None: abort(400) if 'name' not in request_data or 'street_address' not in request_data or 'city' not in request_data \ or 'state' not in request_data or 'country' not in request_data: return make_response(jsonify({'error': 'Missing required attributes'}), 400) user_id = User().get_user_id(request.headers.get('Authorization')) YelpData().yelp_request(yelp_request=request_data, user_id=user_id) data = YelpData().get_business_match_data( user_id=user_id, name=request_data['name'], address1=request_data['street_address'], city=request_data['city'], state=request_data['state'], country=request_data['country']) return jsonify(data)
def post(self): current_user = get_jwt_identity() if current_user['role'] != 'system_admin': return { 'status': STATUS_CODE['AUTH'], 'message': 'Permission denied' } args = user.parse_args() isExists = User.objects(email=args['email']).first() if isExists: return { 'status': STATUS_CODE['ERROR'], 'message': 'Email already exists' } isExistsAccountNumber = User.objects( account_number=args['account_number']).first() if isExistsAccountNumber: return { 'status': STATUS_CODE['ERROR'], 'message': 'Account number already exists' } User(account_number=args['account_number'], balance=args['balance'], firstname=args['firstname'], lastname=args['lastname'], age=args['age'], gender=args['gender'], address=args['address'], employer=args['employer'], email=args['email'], city=args['city'], state=args['state']).save() return {'status': STATUS_CODE['SUCCESS'], 'message': 'Successfully'}
def sign_up(): data = request.args email = data['email'] password = data['password'] user = User.find_user_by_email(email) if not user: try: user = User(email=email, password=password, username=email) db.session.add(user) db.session.commit() identity = {'email': user.email, 'name': user.username} access_token = create_access_token(identity=identity) response_object = { 'status': 'success', 'message': 'Successfully signed up', 'auth_token': access_token } return make_response(jsonify(response_object)), 201 except Exception as e: response_object = { 'status': 'fail', 'message': 'Could not create account', 'error': ','.join(e.args) } return make_response(jsonify(response_object)), 500 else: response_object = {'status': 'fail', 'message': 'User already exists'} return make_response(jsonify(response_object)), 400
def test_encode_auth_token_exception(test_client, throw_exception_encode_fix): """ GIVEN an user id WHEN the encode_auth_token method is called and there's an exception THEN raise Exception """ with pytest.raises(Exception): User.encode_auth_token(0)
def create(): # TODO Change to request.is_json attribute (v0.11) if not request.json: abort(400) user = User(request.json['username'], request.json['password']) db.session.add(user) db.session.commit() return jsonify(user.to_dict())
def test_password_recovery(self): u1 = User(username='******', email='*****@*****.**') db.session.add(u1) db.session.commit() token = u1.get_reset_password_token() verified_user = User.verify_reset_password_token(token) self.assertEqual(u1, verified_user)
def create_user(data): user_data = data['user'] user = User(username=user_data['username']) db.session.add(user) for p in data['store_user_role_scopes']: user.update_permission(p) db.session.commit()
def test_decode_auth_token_expired_exception(test_client, throw_exception_expired_fix): """ GIVEN an authentication token WHEN the decode_auth_token method is called and there's an ExpiredSignatureError exception THEN raise Exception """ with pytest.raises(jwt.ExpiredSignatureError): User.decode_auth_token('string')
def test_add_note(self): u1 = User(username='******', email='*****@*****.**') db.session.add(u1) db.session.commit() self.assertEqual(u1.notes.count(), 0) u1.add_note('test title', 'test description') self.assertEqual(u1.notes.count(), 1) self.assertEqual(u1.notes.filter_by(id=1).first().title, 'test title')
def sign_up(): user = User(**sign_up_user_params()) print(user.name) if user.save(): access_token = create_access_token(identity=user.id) refresh_token = create_refresh_token(identity=user.id) return jsonify(access_token=access_token, refresh_token=refresh_token) else: return jsonify({"status": "usuário inválido"}), 404
def test_decode_auth_token_invalid_exception( test_client, throw_exception_invalid_token_fix): """ GIVEN an authentication token WHEN the decode_auth_token method is called and there's an InvalidTokenError exception THEN raise Exception """ with pytest.raises(jwt.InvalidTokenError): User.decode_auth_token('string')
def query_user (uid): try: record = User().query_record(uid) return jsonify(record.to_dict()) except: return 'query failed', 404
def test_encode_auth_token_success(test_client_with_db): """ GIVEN an user id in the database WHEN the encode_auth_token method is called THEN return JWT token """ user = User.find_by_email('*****@*****.**') token = User.encode_auth_token(user.id) assert token is not None
def get_user(self, code): token = self.get_token(code) path = "{}?access_token={}&scope={}".format(self.user_message_path, token, 'user') result = json.loads(requests.get(path).content.decode("utf-8")) if result is not None and len(result) > Constant.TWO.value: user = User(result['id'], result['login'], result['url'], result['avatar_url']) User.save(user) return jsonify(result)
def user_create(): form = OpsUser(is_update=False) if form.validate_on_submit(): user = User() user.password = "******" for field in form: if field.name not in ("csrf_token", "submit"): user.__setattr__(field.name, field.data) return redirect(url_for(".user_index")) return render_template("user_control/user_create.html", form=form)
def load_user(id): user = User() user.set_anonymous(False) user.set_active(True) user.set_authenticated(True) db = get_db() doc = db.fetch(id) user.fromJSON(doc.value) return user
def setUp(self): self.app = create_app('testing') self.test_app = self.app.test_client() with self.app.app_context(): db.create_all() user = User(first_name="Jimmy", last_name="Cocopuff", email="*****@*****.**", password="******") with self.app.app_context(): db.session.add(user) db.session.commit() user = User(first_name="Jimmy", last_name="Cocobeans", email="*****@*****.**", password="******") with self.app.app_context(): db.session.add(user) db.session.commit() item = Item( user_id=1, title="Tea Set", description="Antique Tea set", price=140.00, category="furniture", charity="Big Cat Rescue", charity_url="http://www.thisisatotallyligiturl.com", charity_score=4, charity_score_image= "https://d20umu42aunjpx.cloudfront.net/_gfx_/icons/stars/4stars.png", image="img.ul", auction_length=5) with self.app.app_context(): db.session.add(item) db.session.commit() item = Item( user_id=1, title="Rocking Chair", description="Vintage wood rocking chair", price=40.00, category='furniture', charity='Big Cat Rescue', charity_url="http://www.thisisatotallyligiturl.com", charity_score=4, charity_score_image= "https://d20umu42aunjpx.cloudfront.net/_gfx_/icons/stars/4stars.png", image='img.ul', auction_length=5) with self.app.app_context(): db.session.add(item) db.session.commit()
def users(): try: if request.method == 'GET': users = User.objects() return Response(users.to_json(), mimetype='application/json', status=200) elif request.method == 'POST': data = request.json user = User.create(data) login_user(user) return Response(user.to_json(), mimetype='application/json', status=200) except Error as e: return error(str(e))
def post(self): data = self.reqparse.parse_args() try: user = User(email=data['email'], is_manager=data['is_manager']) user.set_password(data['password']) db.session.add(user) db.session.commit() except IntegrityError as e: db.session.rollback() return "Integrity error: " + str(e), 400 return "User " + user.email + " has been saved", 201
def create_user (uname): try: user = User() user.name = uname record = user.create_record(uname) return jsonify(record.to_dict()), 201 except: return 'create failed', 400
def test_decode_auth_token_success(test_client_with_db): """ GIVEN a valid authentication token WHEN the decode_auth_token method is called THEN return the user id """ # Prepare test user = User.find_by_email('*****@*****.**') token = User.encode_auth_token(user.id) payload_sub = User.decode_auth_token(token) assert payload_sub == user.id
def login(request): """ 处理登录请求 """ form = request.form() u = User(form) if u.validate_login(): session_id = Session.new(u) headers = { 'Set-Cookie': 'session_id={}; Path=/'.format(session_id) } return redirect('/twitter/twitter/index', headers) else: return redirect('/twitter/user/welcome')
def setUp(self): self.app = create_app('testing') self.test_app = self.app.test_client() with self.app.app_context(): db.create_all() user = User(first_name="Johnny", last_name="McSellingstuff", email="*****@*****.**", password="******") with self.app.app_context(): user.hash_password(user.password) db.session.add(user) db.session.commit()
def post(self): email = request.json.get('email') password = request.json.get('password') if User.query.filter_by(email=email).first() is not None: abort(400, description='Email already in use') args = user_post_parser.parse_args() user = User(**args) user.hash_password(password) dt = trunc(datetime.now().timestamp()) user.created_at = dt db.session.add(user) db.session.commit() return user
def check_and_create_user(data): response = dict() if data.validate_on_submit(): existing_user = User.query.filter_by(email=data.email.data).first() if existing_user is None: user = User(name=data.name.data, email=data.email.data) user.set_password(data.password.data) db.session.add(user) db.session.commit() session["user_id"] = user.id response["message"] = "Successfully registered" response["redirect_to"] = "book.book_listing" return response
def count_users_recursively(dep): dep_childs = cls.query.filter_by(parent_id=dep.id).all() count_users = 0 for dep_child in dep_childs: count_users += User.count_users_in_department(dep_child.id) count_users += count_users_recursively(dep_child) return count_users
def head_user_recursively(dep): if dep.user_id: return User.get_by_id(dep.user_id) if dep.parent_id: dep_parent = cls.query.filter_by(id=dep.parent_id).first() return head_user_recursively(dep_parent) return None
def add_user(): _data = dict(request.form) _data['file'] = request.files['file'] v = Validator(_data) v.field('name').required() v.field('surname').required() v.field('file').image() v.field('email').required().email() v.field('login').required() v.field('department').required() v.field('groups').required() v.field('mobile_phone').required().phone_number() v.field('birth_date').datetime(format='%d.%m.%Y') if v.is_valid(): data = { 'name': v.valid_data.name, 'surname': v.valid_data.surname, 'email': v.valid_data.email, 'login': v.valid_data.login, 'department': v.valid_data.department, 'groups': v.valid_data.list('groups'), 'mobile_phone': v.valid_data.mobile_phone, 'skype': v.valid_data.skype, 'birth_date': v.valid_data.birth_date, 'photo': v.valid_data.file } already_used_login = User.get_by_login(data['login']) already_used_email = User.get_by_email(data['email']) if already_used_login: v.add_error('login', 'Такой логин уже занят') if already_used_email: v.add_error('email', 'Такой email уже занят') if already_used_login or already_used_email: return {"status": "fail", "errors": v.errors} try: create_user(**data) return {"status": "ok"} except DataProcessingError as e: return {'status': 'failOnProcess', 'error': e.value} return {"status": "fail", "errors": v.errors}
def edit_user(id): _data = dict(request.form) _data['file'] = request.files['file'] v = Validator(_data) v.field('name').required() v.field('surname').required() v.field('file').image() v.field('email').required().email() v.field('department').required() v.field('inner_phone').integer(nullable=True) v.field('mobile_phone').required().phone_number() v.field('birth_date').datetime(format='%d.%m.%Y') if v.is_valid(): edited_user = User.get_by_id(id) duplicate_error = False data = { 'id': id, 'full_name': "{0} {1}".format(v.valid_data.name, v.valid_data.surname), 'email': v.valid_data.email, 'department': v.valid_data.department, 'mobile_phone': v.valid_data.mobile_phone, 'inner_phone': v.valid_data.inner_phone, 'position': v.valid_data.position, 'skype': v.valid_data.skype, 'birth_date': v.valid_data.birth_date, 'photo': v.valid_data.file } user_with_same_email = User.get_by_email(data['email']) if user_with_same_email and user_with_same_email != edited_user: duplicate_error = True v.add_error('email', 'Такой email уже занят') if duplicate_error: return {"status": "fail", "errors": v.errors} try: update_user(**data) return {"status": "ok"} except DataProcessingError as e: return {'status': 'failOnProcess', 'error': e.value} return {"status": "fail", "errors": v.errors}
def post_users(): email = request.files['email'] password = request.files['password'] backnumber = request.files['backnumber'] name = request.files['name'] info = request.files['info'] q = db.session.query(User).filter(User.email == email) if q.count() > 0: return jsonify( userMessage="your email is already enrolled" ) user = User(email=email, password=password, name=name,info=info, backnumber=backnumber) db.session.add(user) db.session.commit() return jsonify( data=model_to_dict(user), token=user.get_token_string() )
def post(self): username = self.get_argument("username",None) password = self.get_argument("password",None) if not username or not password: # do something self.flash.error = "You must enter a username and password to proceed. Please try again." self.redirect("/login") return pw = hashlib.sha1(password).hexdigest() username = User.normalize(username) user = User.lookup(username) #check the password. if not user or user['password'] != pw: # do something self.flash.error = "Login not valid" self.redirect("/login") return # check if user is suspended. if user.is_suspended() : self.flash.error = "Sorry the account you specified has been suspended." self.redirect("/") return user.history.last_login = datetime.datetime.utcnow() Mongo.db.ui.users.update({'_id': username}, { '$set' : {'history.last_login': user.history.last_login}, '$inc' : {'history.num_logins' : 1} }) #add to the session. self.session['username'] = user._id #check keep_logged_in if self.get_argument("keep_logged_in", False) == "on" : self.session['keep_logged_in'] = True self.set_current_user(user) self.flash.notice = "Welcome, %s" % user._id forwardUrl = self.get_argument('next','/') self.redirect(forwardUrl)
def sign_up(): request_params = request.get_json() email = request_params.get('email') password = request_params.get('password') name = request_params.get('name') group_id = request_params.pop('groupId') # TODO regex, password validation need if email is None: return jsonify( userMessage="이메일 입력을 확인해주세요." ), 400 if password is None: return jsonify( userMessage="비밀번호 입력을 확인해주세요." ), 400 if name is None: return jsonify( userMessage="이름 입력을 확인해주세요." ), 400 q = db.session.query(User) \ .filter(User.email == email) if q.count() > 0: return jsonify( userMeesage="이미 등록된 이메일입니다." ), 409 user = User.add(request_params) if user is None: return jsonify( userMessage="server error, try again" ), 400 # user_group_relation 추가 if group_id != 0: user_group_relation = UserGroupRelation(user_id=int(user.id), group_id=int(group_id)) else: user_group_relation = UserGroupRelation(user_id=int(user.id)) db.session.add(user_group_relation) db.session.commit() token = user.get_token() user_data = user.serialize() user_data['user_group_relation'] = user_group_relation.serialize() return jsonify( data=user_data, token=token ), 201
def get_user(): if not g.get('user'): sid = request.cookies.get('sid', None) session = redis.get(sid) uid = None if session is not None: session = pickle.loads(session) uid = session.get('user', {}).get('id', None) touch(sid, session) g.user = User.get_by_id(uid) or AuthUser() return g.user
def _edit_user_at_local_db(id, full_name, position, department, photo, email, mobile_phone, inner_phone, birth_date, skype): try: User.edit_user( uid=id, full_name=full_name, position=position, email=email, inner_phone=inner_phone, mobile_phone=mobile_phone, birth_date=birth_date, skype=skype, photo=photo ) User.add_user2dep( dep_id=Department.get_by_name(department).id, user_id=id ) return True except: return False
def count_users_in_dep_tree(cls, dep_id): dep = cls.query.filter_by(id=dep_id).first() c_u = User.count_users_in_department(dep_id) def count_users_recursively(dep): dep_childs = cls.query.filter_by(parent_id=dep.id).all() count_users = 0 for dep_child in dep_childs: count_users += User.count_users_in_department(dep_child.id) count_users += count_users_recursively(dep_child) return count_users c_u += count_users_recursively(dep) return c_u - 1
def get_list_users(dep_id, user_name): department = Department.get_by_id(dep_id) users = User.find_user(dep_id, user_name) users_list = [] a = {"users":[]} for u in users: src_foto, dep_name = '', '' user = User.get_by_id(u.id) if user.photo: src_foto = user.photo.get_url('thumbnail') else: src_foto = '/static/img/no_photo.jpg' if u.department_id: dep_name = u.department.name or '' else: dep_name = '' a["users"].append({"u_id":u.id, "full_name":u.full_name, "dep_name":dep_name, "src_foto":src_foto}) return jsonify(**a)
def restore_post(): v = Validator(request.form) v.field('email').required().email() if v.is_valid(): email = request.form.get("email") user = User.get_by_email(email) if user: token = PasswordRestore.add_token(user) print(token) send_password_restore_ref.delay(user.email, user.full_name, token) return jsonify({"status": "ok"}) return jsonify({"status": "fail", "errors": v.errors})
def login(login, password): if ldap.bind_user(login, password): sid = request.cookies.get('sid', None) user = User.get_by_login(login) uid = user and user.id or None if sid and uid: session = { 'create_datetime': datetime.datetime.now().isoformat(), 'user': {'id': uid} } redis.set(sid, pickle.dumps(session)) return True return False
def authenticate(): """ @apiVersion 1.0.0 @apiGroup User @apiName Authenticate @apiDescription Authenticate an existing user or register a user using phone number. An activation code will be send to phone. @api {post} /v1/user/authenticate Authenticate an existing user or register a phone number @apiHeader {String} Content-Type =application/json JSON (application/json) @apiParam {String} phone Phone of the existing user. @apiSuccessExample Success-Response: HTTP/1.1 200 OK @apiSuccessExample Success-Response: HTTP/1.1 201 Created @apiUse BadRequest @apiSampleRequest http://example.com/api/v1/user/authenticate """ phone = request.json['phone'] try: user_obj = User.query.filter_by(phone=phone).one() user_obj.send_activation_code() return jsonify(), 200 except NoResultFound: user_obj = User(phone=phone) db.session.add(user_obj) db.session.commit() user_obj.send_activation_code() return jsonify(), 201
def get_departments(parent_id=None): dep_list = [] departments = db.session.query(Department).filter_by(parent_id=parent_id).all() for dep in departments: dep_dict = row2dict(dep) if dep_dict["user_id"] != 'None': user = User.get_by_id(dep_dict["user_id"]) dep_dict["user"] = row2dict(user) print(dep_dict) dep_dict['dep_list'] = get_departments(dep.id) dep_list.append(dep_dict) if len(departments): return dep_list else: return None
def profile(user_id=None): user = auth.service.get_user() if user_id is None else User.get_by_id(user_id) if user is None: abort(404) user_department = Department.get_dep_if_user_head(user.id) count_users = '' if user_department: count_users = Department.count_users_in_dep_tree(user_department.id) if user.department_id: head_user = Department.get_head_user_in_dep_tree(user.department_id, user.id) else: dep = db.session.query(Department).filter_by(parent_id=None).first() head_user = Department.get_head_user_in_dep_tree(dep.id, user.id) return render_template('profile/profile.html', user=user, user_department=user_department, count_users=count_users, head_user=head_user)
def update_user(id, full_name, position, department, photo, email, mobile_phone, inner_phone, birth_date, skype): old_login = User.get_by_id(id).login ldap_user_attr = { 'mobile': mobile_phone, 'telephoneNumber': inner_phone, 'displayName': full_name, 'mail': email } if not _edit_user_at_local_db(id, full_name, position, department, photo, email, mobile_phone, inner_phone, birth_date, skype): raise DataProcessingError('Произошла ошибка при обновлении пользователя в локальной базе данных') if not _edit_user_at_ldap(old_login, ldap_user_attr): db.session.rollback() raise DataProcessingError('Произошла ошибка при обновлении пользователя в каталоге LDAP') else: db.session.commit()
def _add_user_to_local_db(login, name, surname, email, department, photo, mobile_phone, inner_phone, birth_date, skype): try: user = User() user.login = login user.full_name = "{0} {1}".format(name, surname) user.mobile_phone = mobile_phone user.inner_phone = inner_phone user.email = email user.department = Department.get_by_name(department) user.birth_date = birth_date user.skype = skype db.session.add(user) db.session.flush() p = user.photo = File.create(name='photo.png', module='users', entity=user) p.makedir() p.update_hash() image.thumbnail(photo, width=100, height=100, fill=image.COVER).save(p.get_path(sufix="thumbnail")) image.resize(photo).save(p.get_path()) return True except: return False
def dep_users_json(dep_id): columns = [] columns.append(ColumnDT('id', filter=_default_value)) columns.append(ColumnDT('full_name', filter=_default_value)) columns.append(ColumnDT('email', filter=_default_value)) columns.append(ColumnDT('login', filter=_default_value)) columns.append(ColumnDT('mobile_phone', filter=_default_value)) columns.append(ColumnDT('inner_phone', filter=_default_value)) query = db.session.query(User).filter_by(department_id=dep_id) rowTable = DataTables(request, User, query, columns) json_result = rowTable.output_result() departments = Department.get_all() for row in json_result['aaData']: row_id = row['0'] last_columns = str(len(columns)) dep_html = '' for dep in departments: sel = 'selected' if dep.id == dep_id else '' dep_html += "<option value='"+str(dep.id)+"/"+row_id+"' "+sel+">"+dep.name+"</option>" manage_html = """ <select onchange="change_user_dep(this.value)" id="first-disabled" class="selectpicker" data-hide-disabled="true" data-live-search="true" data-width="200px"> <optgroup label="Доп возможности"> <option value="0/"""+row_id+"""">Удалить из отдела</option> </optgroup> <optgroup label="Отделы">"""+dep_html+"""</optgroup> </select> <script type="text/javascript">$('.selectpicker').selectpicker({style: 'btn-default',size: 5});</script> """ row[last_columns] = manage_html src_foto = '' user = User.get_by_id(row_id) if user.photo: src_foto = user.photo.get_url('thumbnail') else: src_foto = '/static/img/no_photo.jpg' row['1'] = """<img src="{src}" class="foto-small-struct">""".format(src = src_foto) + "<a href='"+url_for('user.profile')+"/"+row_id+"'>"+row['1']+"</a>" head_dep = str(len(columns)+1) if Department.is_user_head(dep_id, int(row_id)): checked = "checked" else: checked = '' row[head_dep] = "<input onclick='change_head_dep(this, "+str(dep_id)+", "+row_id+")' type='checkbox' id='head_check' "+checked+">" return jsonify(**json_result)
def post(self): username = self.get_argument("username",None) password = self.get_argument("password",None) if not username or not password: # do something self.flash.error = "You must enter a username and password to proceed. Please try again." self.redirect("/signup") return if password != self.get_argument("password2", None) : self.flash.error = "Passwords do not match. Please try again." self.redirect("/signup") return user = User.instance(username, password) Mongo.db.ui.users.insert(user) self.flash.info = "Successfully created your account, please log in." self.redirect("/login")
def reject_member(community_id, member_id): user = utils.auth.service.get_user() if not user.is_authorized: abort(403) community = Community.get(community_id) member = User.get(member_id) # cm = CommunityMember.query.filter( # CommunityMember.user_id == member_id, # CommunityMember.community_id == community_id).first() if not member or not community or community.owner != user: abort(404) # cm.status = cm.STATUS.REJECTED community.members.remove(member) db.session.commit() res = {'status': 'ok', 'user': {'status': CommunityMember.STATUS.TITLE[CommunityMember.STATUS.REJECTED]}} return jsonify(res)
def site_register(): form = LoginForm() if form.validate_on_submit(): try: user = User.objects.get(email=request.form['email']) if user: flash('This email address is already in use.', 'error') return render_template('site/login.html', form=form) except User.DoesNotExist: user = User() user.email = request.form['email'] user.username = request.form['email'] user.set_password(request.form['password']) user.save() flash('Successfully registered', 'success') return redirect(url_for('site_index')) return render_template('site/login.html', form=form)
def sign_up(): request_params = request.get_json() email = request_params.get('email') password = request_params.get('password') # TODO regex, password validation need if email is None: return jsonify( userMessage="이메일 입력을 확인해주세요." ), 400 if password is None: return jsonify( userMessage="비밀번호 입력을 확인해주세요." ), 400 q = db.session.query(User) \ .filter(User.email == email) if q.count() > 0: return jsonify( userMeesage="already enrolled email" ), 409 user = User.add(request_params) if user is None: return jsonify( userMessage="server error, try again" ), 400 token = user.get_token() user_data = user.serialize() return jsonify( data=user_data, token=token ), 201
def register(): form = RegisterForm() context = { 'form': form } if request.method == 'POST' and form.validate_on_submit(): user = User() user.email = form.email.data.strip().lower() user.password = form.password.data.strip() user.username = user.email db_session.add(user) db_session.commit() login_user(user) user.send_register_mail(request.host_url) return redirect(url_for("index.index")) return render_template("auth/register.html", **context)
def new_members(): users = User.get_new() return render_template('user/new_members.html', **{'users': users})
def set_rol_test(role_id, user_id): if role_id: User.set_user_role(user_id, role_id) else: User.set_user_is_admin(user_id) return jsonify({'status': 'ok'})
def set_user_to_dep(dep_id, user_id): User.add_user2dep(dep_id, user_id) return jsonify({'status': 'ok'})