def admin_users_edit(gen): user = User.query.filter_by(gen=gen).first() user.role = User.get_role(user) user.user_status = User.get_status(user) form = EditForm() form.role.default = user.user_role form.role.process(request.form) form.status.default = user.status form.status.process(request.form) if form.is_submitted(): print("submitted") if form.validate(): print("valid") print(form.errors) if form.validate_on_submit(): if form.photo.data: form.photo.data.save(dir + '/app/static/img/photo/%s.png' % user.gen) form.save_user() return redirect(url_for("admin_users_list")) return render_template('admin/users/edit.html', user=user, form=form)
def create_admin_user(): session = db.session() admin = User('0000001', 'admin', 'admin', role.admin, status.active) user = User('0000002', 'user', 'user', role.user, status.active) session.add(admin) session.add(user) session.commit()
def sync_edm(context, refresh=False): """ Sync the users from the EDM onto the local Hudson """ from app.modules.users.models import User User.edm_sync_all(refresh=refresh)
def init_users(): with db.session.begin(): root_user = User(username='******', email='root@localhost', password='******', is_active=True, is_regular_user=True, is_admin=True) db.session.add(root_user) docs_user = User(username='******', email='documentation@localhost', password='******', is_active=False) db.session.add(docs_user) regular_user = User(username='******', email='user@localhost', password='******', is_active=True, is_regular_user=True) db.session.add(regular_user) internal_user = User(username='******', email='internal@localhost', password='******', is_active=True, is_internal=True) db.session.add(internal_user) return root_user, docs_user, regular_user
def admin_users_list(): user_list = User.query.order_by(User.id) # Конвертирование ид роли и статуса в название users = [] for item in user_list: item.role = User.get_role(item) item.user_status = User.get_status(item) users.append(item) return render_template('admin/users/list.html', user_list=users)
def create_user( context, email, is_internal=False, is_admin=False, is_staff=False, is_active=True, ): """ Create a new user. """ from app.modules.users.models import User password = input('Enter password: ') new_user = User( password=password, email=email, is_internal=is_internal, is_admin=is_admin, is_staff=is_staff, is_active=is_active, ) from app.extensions import db with db.session.begin(): db.session.add(new_user)
def create_oauth2_client(context, email, guid, secret, default_scopes=None): """ Create a new OAuth2 Client associated with a given user (email). """ from app.modules.users.models import User from app.modules.auth.models import OAuth2Client user = User.find(email=email) if user is None: raise Exception("User with email '%s' does not exist." % email) if default_scopes is None: from app.extensions.api import api_v1 default_scopes = list( api_v1.authorizations['oauth2_password']['scopes'].keys()) oauth2_client = OAuth2Client( guid=guid, secret=secret, user=user, default_scopes=default_scopes, ) from app.extensions import db with db.session.begin(): db.session.add(oauth2_client)
def get(self, target, path): params = {} params.update(request.args) params.update(request.form) request_func = current_app.edm.get_passthrough passthrough_kwargs = {'params': params} response = _request_passthrough(target, path, request_func, passthrough_kwargs) # private means cannot be read other than admin ####@edm_configuration.login_required(oauth_scopes=['configuration:write']) TODO somehow need to *allow* private if has auth!!! data = response.json() if (response.ok and 'response' in data and 'private' in data['response'] and data['response']['private']): abort(code=HTTPStatus.FORBIDDEN, message='unavailable') if path == '__bundle_setup': data = response.json() data['response']['configuration'][ 'site.adminUserInitialized'] = User.admin_user_initialized() return data return response
def test_encounter_add_owner(db): from app.modules.users.models import User from app.modules.encounters.models import Encounter test_user = User( email='testuser@localhost', password='******', full_name='Gregor Samsa ', ) test_encounter = Encounter(title='New Test Encounter A', ) with db.session.begin(): db.session.add(test_encounter) db.session.add(test_user) db.session.refresh(test_encounter) db.session.refresh(test_user) assert test_encounter.get_owner() is None # need to set up association object, but this works test_user.owned_encounters.append(test_encounter) with db.session.begin(): db.session.add(test_encounter) db.session.add(test_user) db.session.refresh(test_encounter) db.session.refresh(test_user) assert test_encounter.get_owner() is not None assert test_encounter.get_owner().guid == test_user.guid
def create_user( context, username, email, is_internal=False, is_admin=False, is_regular_user=True, is_active=True ): """ Create a new user. """ from app.modules.users.models import User password = input("Enter password: ") new_user = User( username=username, password=password, email=email, is_internal=is_internal, is_admin=is_admin, is_regular_user=is_regular_user, is_active=is_active ) from app.extensions import db db.session.add(new_user) db.session.commit()
def referral_login(email=None, password=None, remember=None, refer=None, *args, **kwargs): # pylint: disable=unused-argument """ This endpoint is the landing page for the logged-in user """ if email is None: email = request.form.get('email', None) if password is None: password = request.form.get('password', None) if remember is None: remember = request.form.get('remember', None) remember = remember in ['true', 'on'] if refer is None: refer = flask.request.args.get('next', request.form.get('next', None)) if refer in ['origin']: refer = request.referrer if refer is not None: if not _is_safe_url(refer): log.error('User gave insecure next URL: %r' % (refer,)) refer = None failure_refer = 'frontend.home' user = User.find(email=email, password=password) redirect = _url_for(failure_refer) if user is not None: if True not in [user.in_alpha, user.in_beta, user.is_staff, user.is_admin]: log.warning( 'User %r had a valid login, but is not a staff or beta member.', ) redirect = _url_for(failure_refer) else: status = login_user(user, remember=remember) if status: # User logged in organically. log.info( 'Logged in User (remember = %s): %r' % ( remember, user, ) ) create_session_oauth2_token() if refer is not None: log.info('Sending user to requested next: %r' % (refer,)) redirect = refer else: log.warning('Username or password unrecognized.') redirect = _url_for(failure_refer) else: log.warning('Username or password unrecognized.') redirect = _url_for(failure_refer) return flask.redirect(redirect)
def setup(): adminUser = User(email='*****@*****.**', username='******', first_name='Omni', last_name='Potent', password='******') db.session.add(adminUser) testUser = User(email='*****@*****.**', username='******', first_name='Chaos', last_name='Monkey', password='******') db.session.add(testUser) role = Role(name='Admin', description='All powerful') db.session.add(role) db.session.commit()
def generate_user_instance( user_guid=None, email=None, password=None, full_name='First Middle Last', created=None, updated=None, is_active=True, is_staff=False, is_admin=False, is_internal=False, in_alpha=True, ): """ Returns: user_instance (User) - an not committed to DB instance of a User model. """ # pylint: disable=too-many-arguments from app.modules.users.models import User if user_guid is None: user_guid = uuid.uuid4() if email is None: email = '%s@localhost' % (email, ) if password is None: password = security.generate_random(128) user_instance = User( guid=user_guid, full_name=full_name, password=password, email=email, created=created or datetime.now(), updated=updated or datetime.now(), is_active=is_active, is_staff=is_staff, is_admin=is_admin, is_internal=is_internal, in_alpha=in_alpha, ) user_instance.password_secret = password return user_instance
def init_users(): root_user = User(username='******', email='root@localhost', password='******', is_active=True, is_admin=True) db.session.add(root_user) docs_user = User(username='******', email='documentation@localhost', password='******', is_active=False) db.session.add(docs_user) regular_user = User(username='******', email='user@localhost', password='******', is_active=True) db.session.add(regular_user) db.session.commit() return root_user, docs_user, regular_user
def init_users(): from app.modules.users.models import User with db.session.begin(): root_user = User( email='root@localhost', password='******', is_active=True, is_admin=True, ) db.session.add(root_user) docs_user = User( email='documentation@localhost', password='******', is_active=True, ) db.session.add(docs_user) staff_member = User( email='staff@localhost', password='******', is_active=True, is_staff=True, ) db.session.add(staff_member) regular_user = User( email='test@localhost', password='******', is_active=True, ) db.session.add(regular_user) internal_user = User( email='internal@localhost', password='******', is_active=True, is_internal=True, ) db.session.add(internal_user) return docs_user
def create_admin_user(email=None, password=None, repeat_password=None, *args, **kwargs): """ This endpoint creates the initial admin user if none exists """ message = None if User.admin_user_initialized(): message = 'This function is disabled. Admin user exists.' else: log.info('Attempting to create first run admin user.') if email is None: email = request.form.get('email', None) if password is None: password = request.form.get('password', None) if repeat_password is None: repeat_password = request.form.get('repeat_password', None) if password == repeat_password: if None not in [email, password, repeat_password]: admin = User.ensure_user( email, password, is_admin=True, update=True, ) if admin.is_admin: message = 'Success creating startup admin user.' # update configuration value for admin user created return flask.redirect(_url_for('backend.home')) else: message = 'We failed to create or update the user as an admin.' else: message = 'You must specify all fields.' else: message = 'The password fields do not match.' if message is not None: flash(message)
def post(): exist_user = User.query.filter_by(email=request.json['email']).first() if exist_user: return {'message': {'email': 'EMAIL_IS_ALREADY_EXIST'}}, 400 user = User(**request.json) db.session.add(user) db.session.commit() login_user(user) return {'message': 'signup ok'}
def generate_user_instance( user_id=None, username="******", password=None, email=None, first_name="First Name", middle_name="Middle Name", last_name="Last Name", created=None, updated=None, is_active=True, is_readonly=False, is_admin=False ): """ Returns: user_instance (User) - an not committed to DB instance of a User model. """ # pylint: disable=too-many-arguments from app.modules.users.models import User if password is None: password = '******' % username user_instance = User( id=user_id, username=username, first_name=first_name, middle_name=middle_name, last_name=last_name, password=password, email=email or '*****@*****.**' % username, created=created or datetime.now(), updated=updated or datetime.now(), is_active=is_active, is_readonly=is_readonly, is_admin=is_admin, ) user_instance.password_secret = password return user_instance
def profile(): try: m_users = User() m_user = current_user # html or Json response if request_wants_json(): return jsonify(data=m_user) else: return render_template("users/show.html", user=m_user, app=app) except Exception, ex: print("------------ ERROR ------------\n" + str(ex.message)) flash(str(ex.message), category="warning") abort(404)
def _process_members(self, members): from app.modules.users.models import User for member in members: log.info('Adding Member ID %s' % (member.id, )) user, is_new = User.ensure_edm_obj(member.id) if user not in self.members: enrollment = OrganizationUserMembershipEnrollment( organization=self, user=user, ) with db.session.begin(): self.user_membership_enrollments.append(enrollment)
def create_submission_from_path( context, path, email, description=None, ): """ Create a new submission via a local file or folder path. Command Line: > invoke app.submissions.create-submission-from-path --path tests/submissions/test-000/ --email [email protected] """ from app.modules.users.models import User from app.modules.submissions.models import Submission, SubmissionMajorType from app.extensions import db import socket user = User.find(email=email) if user is None: raise Exception("User with email '%s' does not exist." % email) absolute_path = os.path.abspath(os.path.expanduser(path)) print('Attempting to import path: %r' % (absolute_path, )) if not os.path.exists(path): raise IOError('The path %r does not exist.' % (absolute_path, )) with db.session.begin(): args = { 'owner_guid': user.guid, 'major_type': SubmissionMajorType.filesystem, 'description': description, } submission = Submission(**args) db.session.add(submission) db.session.refresh(submission) repo, project = submission.ensure_repository() submission.git_copy_path(absolute_path) hostname = socket.gethostname() submission.git_commit('Initial commit via CLI on host %r' % (hostname, )) submission.git_push() print('Created and pushed new submission: %r' % (submission, ))
def flask_app(): app = create_app(config_name='testing') from app import db with app.app_context(): db.create_all() user = User(email='*****@*****.**', username='******', first_name='Chaos', last_name='Monkey', password='******') db.session.add(user) role = Role(name='Admin', description='All powerful') db.session.add(role) db.session.commit() yield app db.drop_all()
def register(): form = RegisterForm(request.form) if form.validate_on_submit(): # TODO перенести в форму регистрации user = User(login=form.login.data, gen=form.gen.data, password=generate_password_hash(form.password.data)) try: db.session.add(user) db.session.commit() except IntegrityError: return render_template("users/register.html", form=form, error=True) # Автологин после регистрации login_user(user) return redirect(url_for('index')) return render_template("users/register.html", form=form)
def promote_to_admin( context, email, ): """ Promote a given user (email) to administrator permissions """ from app.modules.users.models import User user = User.find(email=email) if user is None: print("User with email '%s' does not exist." % email) print('\nNo updates applied.') return if user.is_admin: print('The given user is already an administrator:\n\t%r' % (user, )) print('\nNo updates applied.') return user.is_admin = True print('Found user:\n\t%r' % (user, )) answer = input( 'Are you sure you want to promote the above found user to a site administrator? [Y / N]: ' ) answer = answer.strip().lower() if answer not in ['y', 'yes']: print('Confirmation failed.') print('\nNo updates applied.') from app.extensions import db with db.session.begin(): db.session.merge(user) db.session.refresh(user) assert user.is_admin print('\nThe user was successfully promoted to an administrator.')
def post(self, args, team): """ Add a new member to a team. """ with api.commit_or_abort( default_error_message="Failed to update team details." ): user_id = args.pop('user_id') #user = User.query.get(user_id) user = User.objects(user_id=user_id).first() if user is None: abort( code=HTTPStatus.NOT_FOUND, message="User with id %d does not exist" % user_id ) team_member = TeamMember(team=team, user=user, **args) team_member.save() #db.session.add(team_member) return team_member
def post(self, args): """ Log-in via a new OAuth2 Session. """ email = args['email'] password = args['password'] user = User.find(email=email, password=password) failure = None if user is not None: if True not in [ user.in_alpha, user.in_beta, user.is_staff, user.is_admin ]: failure = 'Account Not Authorized' else: status = login_user(user, remember=False) if status: log.info('Logged in User via API: %r' % (user, )) create_session_oauth2_token() else: failure = 'Account Disabled' else: failure = 'Account Not Found' if failure is None: response = { 'success': True, 'message': 'Session Created', } code = HTTPStatus.OK else: response = { 'success': False, 'message': failure, } code = HTTPStatus.UNAUTHORIZED return response, code
def login(*args, **kwargs): if request.method == 'GET': # Note: it is critical to not have the action parameter on the form return ''' Please log in to access your account <form method='POST'> <input type='text' name='email' id='email' placeholder='email'></input> <input type='password' name='pw' id='pw' placeholder='password'></input> <input type='submit' name='submit'></input> </form> ''' email = request.form['email'] user = User.query.get(email) if request.form['pw']: user = User.find_with_password(request.form['email'], request.form['pw']) flask_login.login_user(user) next = request.args.get("next") if next is None: next = 'auth/protected' return redirect(next) return 'Bad login'
def clone_submission_from_gitlab( context, guid, email, ): """ Clone an existing submission from the external GitLab submission archive Command Line: > invoke app.submissions.clone-submission-from-gitlab --guid 290950fb-49a8-496a-adf4-e925010f79ce --email [email protected] """ from app.modules.users.models import User from app.modules.submissions.models import Submission user = User.find(email=email) if user is None: raise Exception("User with email '%s' does not exist." % email) from app import create_app app = create_app() submission = Submission.query.get(guid) if submission is not None: print('Submission is already cloned locally:\n\t%s' % (submission, )) app.sub.ensure_repository(submission) return submission = app.sub.ensure_submission(guid, owner=user) if submission is None: raise ValueError('Could not find submission in GitLab using GUID %r' % (guid, )) print('Cloned submission from GitLab:') print('\tSubmission: %r' % (submission, )) print('\tLocal Path: %r' % (submission.get_absolute_path(), ))
def authorize(*args, **kwargs): # pylint: disable=unused-argument """ This endpoint asks user if he grants access to his data to the requesting application. """ # TODO: improve implementation. This implementation is broken because we # don't use cookies, so there is no session which client could carry on. # OAuth2 server should probably be deployed on a separate domain, so we # can implement a login page and store cookies with a session id. # ALTERNATIVELY, authorize page can be implemented as SPA (single page # application) from flask_login import login_user user = current_user() if request.method == 'GET': try: grant = oauth2.validate_consent_request(end_user=user) except OAuth2Error as error: return error.error return render_template('authorize.html', user=user, grant=grant) if not user and 'username' in request.form: username = request.form.get('username') password = request.form.get('password') user = User.find_with_password(username, password) if user: login_user(user) if request.form['confirm']: grant_user = user else: grant_user = None with db.session.begin(): response = oauth2.create_authorization_response(grant_user=grant_user) return response or None
def _usergetter(self, username, password, client, request): # pylint: disable=method-hidden,unused-argument # Avoid circular dependencies from app.modules.users.models import User return User.find_with_password(username, password)