Esempio n. 1
0
def register_local():
    form = Art17LocalRegisterForm(request.form)

    if form.validate_on_submit():
        register_user(**form.to_dict())
        return render_template('message.html', message="")

    return render_template('auth/register_local.html', **{
        'register_user_form': form,
    })
Esempio n. 2
0
def register():
    '''
    Vendor registration page
    if GET - render the registration page
    if POST - validate the form and redirect to the 
        customer setup pages
    '''
    form = VendorRegisterForm()

    # if POST
    if request.method == 'POST' and form.validate_on_submit():
        registration_data = form.to_dict()
        data = form.data

        # create address model out of form
        address = Address()
        form.populate_obj(address)

        # create user model out of form, and add address
        user = register_user(**registration_data)
        user.address = address
        user.update_subscribe(data.get('subscribe'))

        # create vendor model out of user
        vendor = Vendor(user=user, company_name=data.get('company_name'))
        form.populate_obj(vendor)

        # commmit!
        db.session.add(vendor)
        db.session.commit()
        return redirect('/')

    # if GET
    return render_template('account/vendor/register.html', form=form)
Esempio n. 3
0
    def register_user(self):

        schema = RELS['v1.AuthView:register'][request.method]

        try:
            data = request_register_options.parse_args()
            validate(data, schema, format_checker=FormatChecker())

            invite_token = data['token']
            if invite_token:
                expired, invalid, invitor = get_token_status(invite_token, 'invite', 'USE_INVITE')

                if invalid or not invitor:
                    return dict(status=409, message="Invite is invalid"), 409

                if expired:
                    return dict(status=409, message="Invite has expired"), 409

                inviteTokenObj = Invite.find(token=invite_token).first()

                if not inviteTokenObj:
                    return dict(status=409, message="Invite not found"), 409

                if inviteTokenObj.invitee_id:
                    return dict(status=409, message="Invite already used"), 409

            password = encrypt_password(data['password'])
            user = register_user(email=data['email'], password=password, first_name=data['firstName'],
                   last_name=data['lastName'], roles=[Role.first(name='user')])

            if invite_token:
                inviteTokenObj.invitee_id = user.id
                inviteTokenObj.save()

            token = generate_confirmation_token(user)
            confirmation_link = urljoin(current_app.config['CLIENT_DOMAIN'], '/#/confirm?token='+token)

            #TODO this mail send should be performed asynchronously using celery, see issue #88850472
            send_message(
                subject='Please Confirm Your FogMine Account',
                sender="*****@*****.**",
                recipients = [user.email],
                html_body=render_template('email/activate.html', user=user, confirmation_link=confirmation_link),
                text_body=render_template('email/activate.txt', user=user, confirmation_link=confirmation_link)
            )

            user_data = generate_response_dict(user=user)

            #SEE 90454516, Login the user
            login_user(user)
            user.save() #saving the user as a precaution, want the log data

            return dict(status=201, message='A confirmation email has been sent to '+user.email, user=user_data), 201

        except ValidationError as e:
            return dict(status=400, message=e.message), 400
        except IntegrityError:
            return {'status': 409, 'message': 'An account with that email already exists.'}, 409
        except werkzeug.exceptions.ClientDisconnected:
            return dict(status=400, message='one or more required arguments missing from this request'), 400
Esempio n. 4
0
 def run(self):
     email = prompt('Email')
     password = prompt_pass('Password')
     password_confirm = prompt_pass('Confirm Password')
     fullname = prompt('Fullname')
     tel = prompt('Tel')
     active = bool(prompt('Actvice immediately', default='True'))
     role = prompt('Role', default='admin')
     data = MultiDict(
         dict(email=email,
              password=password,
              password_confirm=password_confirm,
              fullname=fullname,
              tel=tel,
              active=active,
              role=role))
     form = RegisterForm(data, csrf_enabled=False)
     if form.validate():
         user = register_user(email=email,
                              password=password,
                              fullname=fullname,
                              tel=tel,
                              active=active,
                              role=role)
         print("\nUser created successfully")
         print("User(id=%s,email=%s,fullname=%s)" %
               (user.id, user.email, user.fullname))
         return
     print("\nError creating user:"******"\n".join(errors))
Esempio n. 5
0
def login():
    current_app.logger.info(
        'Try to authenticate a user with mails: %s' % request.environ.get(
            current_app.config.get('WEBAUTHCLIENT_REMOTE_MAIL')))
    mails = request.environ.get(
        current_app.config.get('WEBAUTHCLIENT_REMOTE_MAIL')).replace(
            ';', ',').split(',')

    for mail in mails:
        user = User.query.filter_by(email=mail).one_or_none()
        if user is not None:
            break

    if user is None:
        password = ''.join(
            choice(ascii_uppercase + ascii_lowercase + digits)
            for _ in range(16))
        user = register_user(password=password,
                             email=mails[0],
                             active=True,
                             confirmed_at=datetime.now())

    login_user(user, remember=False)

    return redirect(request.args.get('next'))
Esempio n. 6
0
    def run(self):
        email = prompt('Email')
        password = prompt_pass('Password')
        password_confirm = prompt_pass('Confirm Password')

        ListRolesCommand().run()
        role_names = prompt("This user's comma-separated roles")
        role_models = []
        for name in role_names.split(','):
            r = roles.first(name=name.strip())
            if not r:
                print('Invalid role: %s' % name.strip())
            else:
                role_models.append(r)

        data = MultiDict(dict(email=email, password=password, password_confirm=password_confirm))
        form = RegisterForm(data, csrf_enabled=False)
        if form.validate():
            user = register_user(email=email, password=password)
            user.roles = role_models
            db.session.add(user)
            db.session.commit()
            print('\nUser created successfully')
            print('User(id=%s email=%s, roles=%s)' % (user.id, user.email,
                ','.join([r.name for r in user.roles])))
        else:
            print('\nError creating user:'******'\n'.join(errors))
Esempio n. 7
0
    def register_user(self):
        """Prompt for user details."""
        # Get the information.
        email = prompt('Email')
        name = prompt('Name')
        password = prompt_pass('Password')
        password_confirm = prompt_pass('Confirm Password')

        data = MultiDict({
            'email': email,
            'password': password,
            'password_confirm': password_confirm,
        })

        # Validate the form.
        form = RegisterForm(data, csrf_enabled=False)
        if form.validate():
            # Register the new user.
            user = register_user(name=name, email=email, password=password)

            print('\nUser created successfully.')
            print('User(id={} email={})'.format(user.id, user.email))

            return user

        # If something went wrong, report it and exit out.
        print('\nError creating user:'******'\n'.join(errors))
        sys.exit(1)
Esempio n. 8
0
def user2(db_session):
    user = register_user(username='******',
                         email='*****@*****.**',
                         password='******')
    db_session.add(user)
    db_session.commit()
    return user
Esempio n. 9
0
def callback():
    # Get authorization code Google sent back to you
    code = request.args.get("code")
    current_app.logger.debug('CODE IS: %s' %code)

    # Find out what URL to hit to get tokens that allow you to ask for
    # things on behalf of a user
    google_provider_cfg = get_google_provider_cfg()
    token_endpoint = google_provider_cfg["token_endpoint"]

    # Prepare and send a request to get tokens! Yay tokens!
    token_url, headers, body = client.prepare_token_request(
        token_endpoint,
        authorization_response=request.url,
        redirect_url=request.base_url,
        code=code
    )
    token_response = requests.post(
        token_url,
        headers=headers,
        data=body,
        auth=(_clientId, _clientSecret)
    )

    # Parse the tokens!
    client.parse_request_body_response(json.dumps(token_response.json()))

    # Now that you have tokens (yay) let's find and hit the URL
    # from Google that gives you the user's profile information,
    # including their Google profile image and email
    userinfo_endpoint = google_provider_cfg["userinfo_endpoint"]
    current_app.logger.debug('USR_NFO_EPT: %s' %userinfo_endpoint)
    uri, headers, body = client.add_token(userinfo_endpoint)
    userinfo_response = requests.get(uri, headers=headers, data=body)

    # You want to make sure their email is verified.
    # The user authenticated with Google, authorized your
    # app, and now you've verified their email through Google!

    if userinfo_response.json().get("email_verified"):
        unique_id = userinfo_response.json()["sub"]
        users_email = userinfo_response.json()["email"]
        picture = userinfo_response.json()["picture"]
        users_name = userinfo_response.json()["given_name"]

        if users_email is not None:
            user = User.query.filter(func.lower(User.email) == func.lower(users_email)).one_or_none()
            if user is None:
                password = ''.join(choice(ascii_uppercase + ascii_lowercase + digits) for _ in range(16))
                user = register_user(password=password, email=users_email.lower(), active=True, confirmed_at=datetime.now())

            login_user(user, remember=False)

    else:
        return "User email not available or not verified by Google.", 400

    return redirect('/')
Esempio n. 10
0
 def create_view(self):
     template = self.create_template
     form = OyRegisterForm()
     if form.validate():
         if not current_app.debug:
             register_user(**form.to_dict())
         else:
             user_data = form.to_dict()
             user_datastore.create_user(
                 user_name=user_data["user_name"],
                 email=user_data["email"],
                 password=hash_password(user_data["password"]),
                 roles=user_data["roles"],
             )
             db.session.commit()
         flash(gettext("User created successfully."))
         return redirect(url_for(".index_view"))
     return self.render(template, form=form)
Esempio n. 11
0
def oauth_register(form):
    """Register user if possible."""
    if form.validate():
        data = form.to_dict()
        if not data.get('password'):
            data['password'] = ''
        user = register_user(**data)
        if not data['password']:
            user.password = None
        _datastore.commit()
        return user
Esempio n. 12
0
def oauth_register(account_info, form_data=None):
    """Register user if possible."""
    email = account_info.get("email")
    if form_data and form_data.get("email"):
        email = form_data.get("email")

    if email:
        form_data['password'] = None
        user = register_user(**form_data)
        return user

    return None
Esempio n. 13
0
def create_superuser(email, password):
    admin = user_datastore.find_or_create_role('admin')

    user = User.query.filter_by(email=email).first()
    if not user:
        user = register_user(email=email, password=password)
        user.confirmed_at = datetime.now()
        db.session.add(user)
        db.session.commit()

    user_datastore.add_role_to_user(user, admin)
    db.session.commit()
Esempio n. 14
0
def oauth_register(account_info, form_data=None):
    """Register user if possible."""
    email = account_info.get("email")
    if form_data and form_data.get("email"):
        email = form_data.get("email")

    if email:
        form_data['password'] = None
        user = register_user(**form_data)
        return user

    return None
Esempio n. 15
0
def createuser(email=None):
    "Add a new user to the database"

    if not email:
        email = prompt("Please enter the email of the new user")

    while (not is_email_valid(email)):
        email = prompt("Please enter the email of the new user")

    password = prompt_pass("Please enter the password")
    password2 = prompt_pass("Please enter the password again")

    while (password != password2):
        print("Passwords are different, please enter the 2 passwords again.",
              file=sys.stderr)
        password = prompt_pass("Please enter the password")
        password2 = prompt_pass("Please enter the password again")

    #credit = prompt("Please enter the credit (number of hours), -1 for no limit")
    credit = -1

    french_model = AsrModel.query.filter_by(name='french.studio.fr_FR').first()
    english_model = AsrModel.query.filter_by(name='english.studio').first()

    models = []

    if french_model:
        models.append(french_model)

    if english_model:
        models.append(english_model)

    registerable.register_user(email=email,
                               password=password,
                               credit=credit,
                               asr_models=models)

    db.session.commit()

    print("User '{user}' created successfully!".format(user=email))
 def create_user(self, **kwargs):
     """
     Create a new user. (Registration)
     :param kwargs:
     :return:
     """
     kwargs = DictEncoder.encode(kwargs)
     kwargs['email'] = kwargs.pop('registrationEmail')
     kwargs['password'] = kwargs.pop('registrationPassword')
     # for k in kwargs:
     #     print(k)
     user = register_user(**kwargs)
     db.session.commit()
     return user
Esempio n. 17
0
 def create_user(self, **kwargs):
     """
     Create a new user. (Registration)
     :param kwargs:
     :return:
     """
     kwargs = DictEncoder.encode(kwargs)
     kwargs['email'] = kwargs.pop('registrationEmail')
     kwargs['password'] = kwargs.pop('registrationPassword')
     # for k in kwargs:
     #     print(k)
     user = register_user(**kwargs)
     db.session.commit()
     return user
Esempio n. 18
0
 def run(self):
     email = prompt('Email')
     password = prompt_pass('Password')
     password_confirm = prompt_pass('Confirm Password')
     data = MultiDict(dict(email=email, password=password, password_confirm=password_confirm))
     form = RegisterForm(data, csrf_enabled=False)
     if form.validate():
         user = register_user(email=email, password=password)
         print('\nUser created successfully')
         print('User(id=%s email=%s)' % (user.id, user.email))
         return
     print('\nError creating user:'******'\n'.join(errors))
Esempio n. 19
0
 def run(self):
     email = prompt('Email')
     password = prompt_pass('Password')
     password_confirm = prompt_pass('Confirm Password')
     data = MultiDict(dict(email=email, password=password, password_confirm=password_confirm))
     form = RegisterForm(data, csrf_enabled=False)
     if form.validate():
         user = register_user(email=email, password=password)
         print '\nUser created successfully'
         print 'User(id=%s email=%s)' % (user.id, user.email)
         return
     print '\nError creating user:'******'\n'.join(errors)
Esempio n. 20
0
def oauth_register(form):
    """Register user if possible.

    :param form: A form instance.
    :returns: A :class:`invenio_accounts.models.User` instance.
    """
    if form.validate():
        data = form.to_dict()
        if not data.get('password'):
            data['password'] = ''
        user = register_user(**data)
        if not data['password']:
            user.password = None
        _datastore.commit()
        return user
Esempio n. 21
0
def register():
    form = RegisterForm(MultiDict(request.json))
    if request.method == 'POST':
        if form.validate_on_submit():
            user = register_user(**form.to_dict())
            form.user = user
            login_user(user)
            return jsonify({
                'success': {
                    'user': form.user.get_security_payload(),
                    'token': form.user.get_auth_token()
                }
            }), 200
        return jsonify({'errors': form.errors}), 400
    return render_template("register.html", register_user_form=form)
Esempio n. 22
0
 def run(self):
     email = prompt("Email")
     password = prompt_pass("Password")
     password_confirm = prompt_pass("Confirm password")
     data = MultiDict(dict(email=email, password=password,
                           password_confirm=password_confirm))
     form = RegisterForm(data, csrf_enabled=False)
     if form.validate():
         user = register_user(email=email, password=password)
         print "\nUser created."
         print "<User id=%s email=%s>" % (user.id, user.email)
     else:
         print "Error:"
         for errors in form.errors.values():
             print "\n".join(errors)
Esempio n. 23
0
def oauth_register(form):
    """Register user if possible.

    :param form: A form instance.
    :returns: A :class:`invenio_accounts.models.User` instance.
    """
    if form.validate():
        data = form.to_dict()
        if not data.get('password'):
            data['password'] = ''
        user = register_user(**data)
        if not data['password']:
            user.password = None
        _datastore.commit()
        return user
Esempio n. 24
0
def oauth_register(account_info):
    """Register new OAuth users.

    This is needed as we don't use Flask Forms (for now), thus the default
    function would fail.
    """
    from flask_security.registerable import register_user
    user_data = account_info.get("user")
    user_data['password'] = ''
    user = register_user(**user_data)
    # Create user <-> external id link.
    oauth_link_external_id(
        user,
        dict(id=str(account_info.get('external_id')),
             method=account_info.get('external_method')))
    return user
Esempio n. 25
0
 def run(self):
     email = prompt("Email")
     password = prompt_pass("Password")
     password_confirm = prompt_pass("Confirm password")
     data = MultiDict(
         dict(email=email,
              password=password,
              password_confirm=password_confirm))
     form = RegisterForm(data, csrf_enabled=False)
     if form.validate():
         user = register_user(email=email, password=password)
         print "\nUser created."
         print "<User id=%s email=%s>" % (user.id, user.email)
     else:
         print "Error:"
         for errors in form.errors.values():
             print "\n".join(errors)
Esempio n. 26
0
def register():
    if _security.confirmable or request.is_json:
        form_class = _security.confirm_register_form
    else:
        form_class = _security.register_form

    if request.is_json:
        form_data = MultiDict(request.get_json())
    else:
        form_data = request.form

    form = form_class(form_data)

    if form.validate_on_submit():
        user_data = {'email': form.email.data, 'password': form.password.data}
        user = register_user(**user_data)
        contact = Contact(first_name=form.contact.first_name.data,
                          last_name=form.contact.last_name.data,
                          email=form.email.data,
                          phone=form.contact.phone.data)
        company = Company(name=form.company.company_name.data)
        role = Role.query.filter_by(name="Company Admin").first_or_404()
        user.add_role(role)
        user.company = company
        user.contact = contact
        form.user = user

        if not _security.confirmable or _security.login_without_confirmation:
            after_this_request(_commit)
            login_user(user)

        if not request.is_json:
            if 'next' in form:
                redirect_url = get_post_register_redirect(form.next.data)
            else:
                redirect_url = get_post_register_redirect()

            return redirect(redirect_url)
        return _render_json(form, include_auth_token=True)

    if request.is_json:
        return _render_json(form)

    return _security.render_template('/security/register_user.html',
                                     register_user_form=form,
                                     **_ctx('register'))
Esempio n. 27
0
    def register(self):
        title = REGISTER_TITLE
        return_url = get_redirect_target or self.get_url('admin.index')

        form = self.register_form()
        self._remove_fields_from_form_instance(['submit'], form)

        if self.validate_form(form):
            user = register_user(**form.to_dict())
            form.user = user

        template = self.register_template

        return self.render(template,
                           form=form,
                           title=title,
                           return_url=return_url)
Esempio n. 28
0
def create(first_name=None, last_name=None, email=None, password=None):
    first_name = first_name or prompt('First Name'),
    last_name = last_name or prompt('Last Name'),
    email = email or prompt('Email'),
    password = password or prompt_pass('Password')
    form = RegisterForm(MultiDict(dict(first_name=first_name,
                                       last_name=last_name,
                                       email=email,
                                       password=password,
                                       password_confirm=prompt_pass('Confirm Password'),
                                       accept_tos=True)), csrf_enabled=False)
    if form.validate():
        user = register_user(first_name=first_name, last_name=last_name, email=email, password=password)
        print('%s created successfully' % repr(user))
        return
    print('Error creating user:'******'\n'.join(errors))
Esempio n. 29
0
def oauth_register(account_info):
    """Register new OAuth users.

    This is needed as we don't use Flask Forms (for now), thus the default
    function would fail.
    """
    from flask_security.registerable import register_user
    user_data = account_info.get("user")
    user_data['password'] = ''
    user = register_user(**user_data)
    # Create user <-> external id link.
    oauth_link_external_id(
        user, dict(
            id=str(account_info.get('external_id')),
            method=account_info.get('external_method')
        )
    )
    return user
Esempio n. 30
0
def register():
    error = _validate_register_request_json(request.get_json())
    if error != None:
        return error

    email = request.get_json()['email']
    password = request.get_json()['password']
    username = request.get_json()['username']
    roles = [Role.query.filter_by(name='contestant').first()]
    solves = [
        Solve(solved=False, challenge=challenge)
        for challenge in Challenge.query.all()
    ]

    new_user = register_user(email=email,
                             password=password,
                             username=username,
                             roles=roles,
                             solves=solves)

    login_user(new_user)
    return (jsonify({'authentication_token': new_user.get_auth_token()}), 200)
Esempio n. 31
0
def create(first_name=None, last_name=None, email=None, password=None):
    first_name = first_name or prompt('First Name'),
    last_name = last_name or prompt('Last Name'),
    email = email or prompt('Email'),
    password = password or prompt_pass('Password')
    form = RegisterForm(MultiDict(
        dict(first_name=first_name,
             last_name=last_name,
             email=email,
             password=password,
             password_confirm=prompt_pass('Confirm Password'),
             accept_tos=True)),
                        csrf_enabled=False)
    if form.validate():
        user = register_user(first_name=first_name,
                             last_name=last_name,
                             email=email,
                             password=password)
        print('%s created successfully' % repr(user))
        return
    print('Error creating user:'******'\n'.join(errors))
Esempio n. 32
0
def register():
    '''
    Customer registration page
    if GET - render the registration page
    if POST - validate the form and redirect to the 
        customer setup pages
    '''
    form = GradientConfirmRegisterForm()

    # if POST
    if form.validate_on_submit():
        data = form.to_dict()
        user = register_user(**data)
        customer = Customer(user=user)
        form.populate_obj(customer)
        db.session.add(customer)
        db.session.commit()
        login_user(user)
        return redirect(url_for('customer.onboarding'))

    # if GET
    return render_template('account/customer/register.html',
                           register_user_form=form)
Esempio n. 33
0
 def setUp(self):
     # Register a user and login.
     # NOTE: merely "creating" a user (i.e. not "registering") does NOT hash the password which is problemating when comparing submitted (and hashed) passwords.
     register_user(**self.userdata)
     self.client.post("/test_login", data={"id": 1})
Esempio n. 34
0
def seed(debug=False):
    # Patch out saving images to S3.
    patcher = patch('argos.util.storage.save_from_url', autospec=True, return_value='https://i.imgur.com/Zf9mXlj.jpg')
    patcher.start()

    seeds = open('manage/core/data/seed.json', 'r')

    sample_images = [
        'https://upload.wikimedia.org/wikipedia/commons/d/d5/Michael_Rogers_-_Herbiers_2004.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/6/6e/Brandenburger_Tor_2004.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/a/ad/ChicagoAntiGaddafiHopeless.jpg/576px-ChicagoAntiGaddafiHopeless.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/Evo_morales_2_year_bolivia_Joel_Alvarez.jpg/640px-Evo_morales_2_year_bolivia_Joel_Alvarez.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/9/9f/2010_wet_season_cloud_over_colombia.jpg/640px-2010_wet_season_cloud_over_colombia.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/2/27/Barack_Obama_at_Las_Vegas_Presidential_Forum.jpg/640px-Barack_Obama_at_Las_Vegas_Presidential_Forum.jpg'
        'https://upload.wikimedia.org/wikipedia/commons/thumb/a/a9/2010-10-23-Demo-Stuttgart21-Befuerworter.png/640px-2010-10-23-Demo-Stuttgart21-Befuerworter.png',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/f/fc/51%C2%BA_Congresso_da_UNE_%28Conune%29.jpg/640px-51%C2%BA_Congresso_da_UNE_%28Conune%29.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/f/f7/Tough_return%2C_365.35.jpg/640px-Tough_return%2C_365.35.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/8/83/Saint_Isaac%27s_Cathedral_in_SPB.jpeg/800px-Saint_Isaac%27s_Cathedral_in_SPB.jpeg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/a/a5/Ponta_de_S%C3%A3o_Louren%C3%A7o_north_north_east.jpg/800px-Ponta_de_S%C3%A3o_Louren%C3%A7o_north_north_east.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/e/e9/TU_Bibl_01_DSC1099w.jpg/644px-TU_Bibl_01_DSC1099w.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/f/fe/%D0%9C%D0%B0%D0%BA%D0%B5%D0%B4%D0%BE%D0%BD%D0%B8%D1%83%D0%BC_-_%D0%9A%D1%80%D1%83%D1%88%D0%B5%D0%B2%D0%BE.jpg/800px-%D0%9C%D0%B0%D0%BA%D0%B5%D0%B4%D0%BE%D0%BD%D0%B8%D1%83%D0%BC_-_%D0%9A%D1%80%D1%83%D1%88%D0%B5%D0%B2%D0%BE.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/6/64/Puente_Mong%2C_Ciudad_Ho_Chi_Minh%2C_Vietnam%2C_2013-08-14%2C_DD_01.JPG/800px-Puente_Mong%2C_Ciudad_Ho_Chi_Minh%2C_Vietnam%2C_2013-08-14%2C_DD_01.JPG',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/c/c3/Autignac%2C_H%C3%A9rault_01.jpg/800px-Autignac%2C_H%C3%A9rault_01.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/6/6a/Caesio_teres_in_Fiji_by_Nick_Hobgood.jpg/800px-Caesio_teres_in_Fiji_by_Nick_Hobgood.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/9/9a/Ash_in_Yogyakarta_during_the_2014_eruption_of_Kelud_01.jpg/800px-Ash_in_Yogyakarta_during_the_2014_eruption_of_Kelud_01.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/b/bd/12-07-12-wikimania-wdc-by-RalfR-010.jpg/800px-12-07-12-wikimania-wdc-by-RalfR-010.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/7/71/Mortagne-sur-Gironde_Civellier_Mayflowers_2013.jpg/800px-Mortagne-sur-Gironde_Civellier_Mayflowers_2013.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/5/5a/British_Museum_Great_Court%2C_London%2C_UK_-_Diliff.jpg/611px-British_Museum_Great_Court%2C_London%2C_UK_-_Diliff.jpg',
        'https://upload.wikimedia.org/wikipedia/commons/thumb/2/26/Mercedes-Benz_Museum_201312_08_blue_hour.jpg/800px-Mercedes-Benz_Museum_201312_08_blue_hour.jpg'
    ]

    print('Resetting the database...')
    db.reflect()
    db.drop_all()
    db.create_all()

    # Create sources
    print('Creating sources...')
    create_sources()
    num_sources = Source.query.count()
    print('Created {0} sources.'.format(num_sources))

    # Create articles
    entries = json.load(seeds)
    print('Seeding {0} articles...'.format(len(entries)))
    articles = []
    for entry in entries:
        if debug:
            print(json.dumps(entry, sort_keys=True, indent=4))

        feed = Feed.query.filter_by(ext_url=entry['source']).first()

        a = Article(
                ext_url=entry['url'],
                feed=feed,
                source=feed.source,
                html=entry['html'],
                text=entry['text'],
                tags=entry['tags'],
                title=entry['title'],
                created_at = parse(entry['published']),
                updated_at = parse(entry['updated']),
                image=random.choice(sample_images), # fake image
                score=random.random() * 100         # fake score
        )
        articles.append(a)
        db.session.add(a)

        progress_bar(len(articles) / len(entries) * 100)

    print('Creating additional articles...')

    # Collect all appropriate files.
    all_files = []
    for dir, subdir, files in os.walk('manage/core/data/organized_articles'):
        for file in files:
            filepath = os.path.join(dir, file)
            name, ext = os.path.splitext(filepath)
            if ext == '.txt':
                all_files.append((dir, name, filepath))

    # Create articles for appropriate files.
    for dir, name, filepath in all_files:
        category = dir.split('/')[-1]
        f = open(filepath, 'r')
        article = Article(
                text=f.read(),
                title=name.split('/')[-1],
                ext_url='http://fauxurl/',
                source = Source.query.get(1),       # fake source
                image=random.choice(sample_images), # fake image
                score=random.random() * 100         # fake score
        )
        db.session.add(article)
        articles.append(article)
        progress_bar(len(articles)/len(all_files) * 100)

    db.session.commit()

    num_articles = Article.query.count()
    num_concepts = Concept.query.count()
    print('Seeded {0} articles.'.format(num_articles))
    print('Found {0} concepts.'.format(num_concepts))

    print('Clustering articles into events...')
    cluster.cluster(articles)
    num_events = Event.query.count()
    print('Created {0} event clusters.'.format(num_events))

    print('Clustering events into stories...')
    # TO DO
    num_stories = Story.query.count()
    print('Created {0} story clusters.'.format(num_stories))

    patcher.stop()

    print('\n\n==============================================')
    print('From {0} sources, seeded {1} articles, found {2} concepts, created {3} events and {4} stories.'.format(num_sources, num_articles, num_concepts, num_events, num_stories))
    print('==============================================\n\n')

    client = current_app.test_client()
    ctx = current_app.test_request_context()
    ctx.push()
    register_user(email='[email protected]', password='******')
    ctx.pop()
    print('\n\n==============================================')
    print('Created a test user, email is [email protected], password is password')
    print('==============================================\n\n')

    client = Client(
        #client_id=gen_salt(40),
        #client_secret=gen_salt(50),
        client_id='test',
        client_secret='test',
        _redirect_uris='http://localhost:5000/authorized',
        _default_scopes='userinfo',
        _allowed_grant_types='authorization_code refresh_token password',
        user_id=None,
        is_confidential=True # make a confidential client.
    )
    db.session.add(client)
    db.session.commit()
    print('\n\n==============================================')
    print('Created a test client:\nclient id: {0}\nclient secret: {1}'.format(client.client_id, client.client_secret))
    print('==============================================\n\n')
Esempio n. 35
0
def load_all_fixtures(db, app):

    user_datastore = SQLAlchemyUserDatastore(db, User, Role)

    # Load default fixtures
    role = user_datastore.create_role(name=app.config['VOXO_ROLE_USER'],
                                      description='User role')
    admin_role = user_datastore.create_role(name=app.config['VOXO_ROLE_ADMIN'],
                                            description='Admin role')
    server_role = user_datastore.create_role(
        name=app.config['VOXO_ROLE_SERVER'], description='Server role')

    user_vjousse = registerable.register_user(email='*****@*****.**',
                                              password='******')
    user_datastore.add_role_to_user(user_vjousse, role)

    print("{user} with token {token} created.".format(
        user=user_vjousse.email, token=user_vjousse.get_auth_token()))

    user = registerable.register_user(email='*****@*****.**',
                                      password='******')
    user_datastore.add_role_to_user(user, admin_role)
    user_datastore.add_role_to_user(user, role)

    print("{user} with token {token} created.".format(
        user=user.email, token=user.get_auth_token()))

    server = registerable.register_user(email='*****@*****.**',
                                        password='******')
    user_datastore.add_role_to_user(server, server_role)

    print("{user} with token {token} created.".format(
        user=server.email, token=server.get_auth_token()))

    asr_model_french = AsrModel(name="french.studio.fr_FR",
                                description="General purpose french model")

    asr_model_french.users.append(user_vjousse)

    db.session.add(asr_model_french)
    db.session.flush()

    asr_model_english = AsrModel(name="english.studio",
                                 description="General purpose english model")

    asr_model_english.users.append(user_vjousse)

    db.session.add(asr_model_english)
    db.session.flush()

    media_file = MediaFile(filename='fixture_file.wav',
                           status=FileStatus.Success,
                           user_id=user_vjousse.id,
                           size=2500,
                           generated_filename='fixture_file_UUID.wav',
                           duration=70)

    db.session.add(media_file)
    db.session.flush()

    process = Process(
        file_id=media_file.id,
        status=DecodeStatus.Queued,
    )

    db.session.add(process)
    db.session.flush()

    transcription = Transcription(
        auto_filename='transcription.xml',
        ref_filename='transcription.txt',
        user_id=user_vjousse.id,
    )

    db.session.add(transcription)
    db.session.flush()

    process = Process(file_id=media_file.id,
                      status=DecodeStatus.Queued,
                      type=ProcessType.TranscriptionAlignment,
                      transcription_id=transcription.id)

    db.session.add(process)
    db.session.flush()

    db.session.commit()
Esempio n. 36
0
 def setUp(self):
     # Register a user and login.
     # NOTE: merely "creating" a user (i.e. not "registering") does NOT hash the password which is problemating when comparing submitted (and hashed) passwords.
     register_user(**self.userdata)
     self.client.post('/test_login', data={'id': 1})