def create():
    """
    Creates and initializes the SQLite database from the schema file.
    """
    with current_app.app_context():
        connect()
        with current_app.open_resource(schema_name, mode="r") as f:
            g.sqlite_connection.cursor().executescript(f.read())

        add_user({
            "username": "admin",
            "password_hash": generate_password_hash("password"),
            "email": "[email protected]",
            "permissions": "administrator"
        })
        add_user({
            "username": "author",
            "password_hash": generate_password_hash("password"),
            "email": "[email protected]",
            "permissions": "author"
        })
        add_category({"name": "Uncategorized"})
        add_post({
            "author": "author",
            "creation_date": str(datetime.now()).split(".")[0],
            "category": category_id("Uncategorized"),
            "title": "Test Post",
            "body": "<p>Your bones don't break, mine do. That's clear. Your cells react to bacteria and viruses differently than mine. You don't get sick, I do. That's also clear. But for some reason, you and I react the exact same way to water. We swallow it too fast, we choke. We get some in our lungs, we drown. However unreal it may seem, we are connected, you and I. We're on the same curve, just on opposite ends.</p><p>The path of the righteous man is beset on all sides by the iniquities of the selfish and the tyranny of evil men. Blessed is he who, in the name of charity and good will, shepherds the weak through the valley of darkness, for he is truly his brother's keeper and the finder of lost children. And I will strike down upon thee with great vengeance and furious anger those who would attempt to poison and destroy My brothers. And you will know My name is the Lord when I lay My vengeance upon thee.</p><p>The path of the righteous man is beset on all sides by the iniquities of the selfish and the tyranny of evil men. Blessed is he who, in the name of charity and good will, shepherds the weak through the valley of darkness, for he is truly his brother's keeper and the finder of lost children. And I will strike down upon thee with great vengeance and furious anger those who would attempt to poison and destroy My brothers. And you will know My name is the Lord when I lay My vengeance upon thee.</p>"
        })
        create_about("New Site", "This is a blank description.")
        create_site_avatar("/static/face.png")
        g.sqlite_connection.commit()

 def setUp(self):
     ''' Test setup '''
     
     self.browser = Browser('phantomjs')
     
     # if we don't set the window size, we won't be able to interact with UI that might 
     # be hidden because of our media queries with a smaller emulated window
     self.browser.driver.set_window_size(1120, 550)
     
     # set up the tables in the database
     Base.metadata.create_all(engine)
     
     # create an example user
     self.user = User(name = 'capnmorgan', email = '[email protected]',
         password = generate_password_hash('test'))
     session.add(self.user)
     session.commit()
     
     # create a second example user
     self.user = User(name = 'Bob', email = '[email protected]',
         password = generate_password_hash('test'))
     session.add(self.user)
     session.commit()
     
     self.process = multiprocessing.Process(target = app.run, kwargs = { 'port': 7000 })
     self.process.start()
     time.sleep(1)

	def setUpClass(cls):
		conn = MongoClient()
		cls.database = conn['dev_scdb']
		# Add superuser
		cls.s = cls.database.user.insert({'email':'[email protected]',
		    'password': generate_password_hash('123'),
			'roles': ["superusers"],
			'token': generate_token('[email protected]')})
		# Add ordinary user
		cls.u = cls.database.user.insert({'email':'[email protected]',
					'password': generate_password_hash('123'),
					'roles': ["users"],
					'token': generate_token('[email protected]')})
		# simple join string to url
		host = 'http://localhost:9014/api/v2/'
		cls.concat = lambda cls, rp: "{}{}".format(host, rp) # rp = relative path
		cls.LOGIN_URL = "http://localhost:9010/login_api/"
		cls.get_token = lambda cls, token: base64.b64encode("{}:".format(token))
		# get token by POST in webapp (another host)
		def get_token_via_api(cls, identifier, password="123"):
			r = requests.post(cls.LOGIN_URL, json={"identifier": identifier,
				"password": password})
			token_64 = cls.get_token(json.loads(r.text)['message']['token'])
			return token_64
		cls.get_token_api = get_token_via_api

    def test_password_hashing(self):
        hash0 = generate_password_hash("default")
        assert check_password_hash(hash0, "default")
        assert hash0.startswith("pbkdf2:sha1:1000$")

        hash1 = generate_password_hash("default", "sha1")
        hash2 = generate_password_hash(u"default", method="sha1")
        assert hash1 != hash2
        assert check_password_hash(hash1, "default")
        assert check_password_hash(hash2, "default")
        assert hash1.startswith("sha1$")
        assert hash2.startswith("sha1$")

        fakehash = generate_password_hash("default", method="plain")
        assert fakehash == "plain$$default"
        assert check_password_hash(fakehash, "default")

        mhash = generate_password_hash(u"default", method="md5")
        assert mhash.startswith("md5$")
        assert check_password_hash(mhash, "default")

        legacy = "md5$$c21f969b5f03d33d43e04f8f136e7682"
        assert check_password_hash(legacy, "default")

        legacy = u"md5$$c21f969b5f03d33d43e04f8f136e7682"
        assert check_password_hash(legacy, "default")

def setup_server(manager, session=None):
    """ Sets up and starts/restarts the web service. """
    if not manager.is_daemon:
        return

    web_server_config = manager.config.get('web_server')

    if not web_server_config:
        return

    web_server = WebServer(
            bind=web_server_config['bind'],
            port=web_server_config['port'],
    )

    _default_app.secret_key = get_secret()

    # Create default flexget user
    if session.query(User).count() == 0:
        session.add(User(name="flexget", password=generate_password_hash("flexget")))
        session.commit()
    # Migrate existing user password to be hashed
    elif session.query(User).count() >= 1:
        users = session.query(User).filter(User.name == "flexget").all()
        for user in users:
            if not user.password.startswith('pbkdf2:sha1'):
                user.password = unicode(generate_password_hash(user.password))
        session.commit()

    if web_server.is_alive():
        web_server.stop()

    if _app_register:
        web_server.start()

 def checkpassword(id,oldpassword,newpassword):
     temp = db.reader.find({id,oldpassword})
     if temp == None:
         return False
     else:
         generate_password_hash(newpassword,str='pbkdf2:sha1',int=8)
         return True

    def on_model_change(self, form, model, is_created):
        username = model.get('username')
        password = model.get('password')

        if is_created:
            # if password is blank raise error
            if not password:
                raise ValidationError('Password is required for new users')
            # new user so hash the new password
            model['_id'] = username
            model['password'] = generate_password_hash(
                password, method='pbkdf2:sha256'
            )
        else:
            # existing user, so compare if password is provided and changed
            current = current_app.db.users.find_one({'username': username})
            if password and current.get('password') != password:
                # if a different password provided, hash it
                model['password'] = generate_password_hash(
                    password, method='pbkdf2:sha256'
                )
            else:
                # if password is blank in form, keep the current
                model['password'] = current['password']

        model.pop('csrf_token', None)
        return model

def register():
    if request.method == 'POST' and 'User-Agent' not in request.headers:
        email = request.form['email']
        password = generate_password_hash(request.form['password'])
        name = request.form['name']
        if name and email and password:
            if Users.query.filter_by(email = email).first() is None:
                new_user = Users(name, email, password)
                db.session.add(new_user)
                db.session.commit()
                user = Users.query.filter_by(email = email).first()
                token = user.generate_auth_token(600)  #---visit tutorial on generating this
                return jsonify({'error':'null', 'data':{'token': token.decode('ascii'), 'expires': 600, 'user':{'id': user.id, 'email': user.email, 'name': user.name}, 'message':'success'}})
            if Users.query.filter_by(email = email).first() is not None:
                user = Users.query.filter_by(email = email).first()
                return jsonify({'error': '1', 'data': {'email': user.email}, 'message':'user already exists'})
    form = SignUpForm()
    if request.method == 'POST' and 'User-Agent' in request.headers:
        if form.validate_on_submit():
            email = request.form['email']
            password = generate_password_hash(request.form['password'])
            name = request.form['name']
            new_user = Users(name, email, password)
            db.session.add(new_user)
            db.session.commit()
            # user = Users.query.filter_by(email = email).first()
            # token = user.generate_auth_token(600)  #---visit tutorial on generating this
            return redirect(url_for('login'))
    return render_template(
        'signup.html',
        title='User Signup',
        year=datetime.now().year,
        form=form,
        user=g.user
    )

def bootstrap_auth(app):
    '''Bootstrap all the necessary authentication support if it is enabled.'''
    # Check that the admin credentials are valid.
    if not app.config.get('ADMINISTRATOR'):
        sys.exit('You did not provide an administrator username.')

    if not app.config.get('ADMIN_PASSWORD'):
        sys.exit('You did not provide an administrator password.')

    # Store the credentials of the admin account.
    admin = app.user_storage.find_by_name(app.config['ADMINISTRATOR'])
    if admin is None:
        pwhash = security.generate_password_hash(app.config['ADMIN_PASSWORD'])
        # No admin for this account name so create one.
        admin = User(app.config['ADMINISTRATOR'],
                     '',  # The admin does not use email.
                     'password',
                     pwhash)
        app.user_storage.create(admin)
    else:
        # The configuration file may have changed the password so always update
        # the administrator's password.
        pwhash = security.generate_password_hash(app.config['ADMIN_PASSWORD'])
        admin.password_digest = pwhash
        app.user_storage.update(admin)

 def setUp(self):
   """ Test setup """
   self.browser = Browser("phantomjs")
   
   # Set up the tables in the database
   Base.metadata.create_all(engine)
   
   # Create an example user
   self.user = models.User(name="Alice", email="[email protected]", password=generate_password_hash("test"))
   session.add(self.user)
   session.commit()
   
   # Create a second example user
   self.user2 = models.User(name="Carlos", email="[email protected]", password=generate_password_hash("test"))
   session.add(self.user2)
   session.commit()
   
   # Create some sample posts
   content = "A post for acceptance testing"
   for i in range (5):
     post = models.Post(title="Acceptance test post #{}".format(i+1), content=content, author=self.user)
     session.add(post)
   session.commit()
       
   self.process = multiprocessing.Process(target=app.run, kwargs={"host": "0.0.0.0", "port": 8080})
   self.process.start()
   time.sleep(1)

 def setUp(self):
   """ Test Setup """
   self.browser = Browser("phantomjs")
   self.browser.driver.set_window_size(1440, 900) # set browser size.
   
   # set up the tables in the database
   Base.metadata.create_all(engine)
   
   # create 2 example users
   self.user = models.User(name="Alice", email="[email protected]", password=generate_password_hash("test"))
   session.add(self.user)
   session.commit()
   
   self.user2 = models.User(name="Ryan", email="[email protected]", password=generate_password_hash("test"))
   session.add(self.user2)
   session.commit()
   
   # Create some sample posts
   content = "Acceptance testing content"
   for i in range (5):
     post = models.Post(title="Acceptance test post #{}".format(i+1), content=content, author=self.user)
     session.add(post)
   session.commit()    
   
   """ gives the ability to start and run other code simultaneously with your own scripts """
   self.process = multiprocessing.Process(target=app.run)
   self.process.start()
   # pause for 1 second
   time.sleep(1)

    def test_identify(self):
        password = self.generate_password()

        # Identify hashes generated by werkzeug
        passlib_hash = generate_password_hash(password, method=self.werkzeug_method)
        self.assertEqual(self.passlib.identify(passlib_hash), self.passlib_method)

        # Identify hashes generated by other werkzeug methods
        diff_werkzeug_method = random.choice([method for method in WERKZEUG_METHODS if method not in [self.werkzeug_method]])
        passlib_hash = generate_password_hash(password, method=diff_werkzeug_method)
        self.assertNotEqual(self.passlib.identify(passlib_hash), self.passlib_method)

        # Identify hashes generated by werkzeug with varying salt length
        passlib_hash = generate_password_hash(password, method=self.werkzeug_method, salt_length=self.salt_length + 1)
        self.assertEqual(self.passlib.identify(passlib_hash), self.passlib_method)

        # Identify hashes generated by itself
        passlib_hash = self.passlib.encrypt(password, method=self.passlib_method)
        self.assertEqual(self.passlib.identify(passlib_hash), self.passlib_method)

        # Identify hashes generated by other methods
        diff_passlib_method = random.choice([method for method in PASSLIB_METHODS if method not in [self.passlib_method]])
        passlib_hash = self.passlib.encrypt(password, method=diff_passlib_method)
        self.assertNotEqual(self.passlib.identify(passlib_hash), self.passlib_method)

        # Identify hashes generated by itself with varying salt length
        passlib_hash = self.passlib.encrypt(password, method=self.passlib_method, salt_length=self.salt_length + 1)
        self.assertEqual(self.passlib.identify(passlib_hash), self.passlib_method)

 def general_password(self, password):
     """
     检查密码是否正确
     :param password:
     :return:
     """
     self.password = generate_password_hash(password)
     return generate_password_hash(password)

def fix_pws():
    for client in Client.query.all():
        client.password_ = generate_password_hash('test')
        db.session.commit()
    for trainer in Trainer.query.all():
        trainer.password_ = generate_password_hash('test')
        db.session.commit()

    return 'changed!'

 def setUp(self):
     self.fixtures = {
         'alice': User(name='Alice', email='[email protected]',
                     password=generate_password_hash('alice')),
         'bob': User(name='Bob', email='[email protected]',
                     password=generate_password_hash('bob'))}
     self.fixtures.update({
         'entry': Entry(title='Test Entry', content='Test Content',
                        author=self.fixtures['alice'])})
     super(TestEditEntry, self).setUp()

 def __init__(self, name, desc="Test", ttl=-1, sub_passwd="",
              pub_passwd=None, exam_passwd=None):
     self.name = name
     self.desc = desc
     self._ttl = ttl
     self.sub_passwd = generate_password_hash(sub_passwd)
     self.pub_passwd = generate_password_hash(pub_passwd) \
         if pub_passwd else None
     self.exam_passwd = generate_password_hash(exam_passwd) \
         if exam_passwd else None

def create_users():
	try:
		user1 = Users(username='user1', email='[email protected]',
						password=generate_password_hash('user1234'))
		user2 = Users(username='user2', email='[email protected]',
						password=generate_password_hash('user221234'))
		db.session.add(user1)
		db.session.add(user2)
		db.session.commit()
	except Exception as err:
		print("-- user creation failed..")
		print(err)

def registro():

    datos=request.form
    nombre=datos["nombre"]
    apellidos=datos["apellidos"]
    telefono=datos["telefono"]
    pueblo=datos["pueblo"]
    correo=datos["correo"]
    passwd= generate_password_hash(datos["password"])# check_password_hash(pw_hash, password)
    #verificar datos aqui:
    #el pueblo existe
    errores=list()
    if(len(datos["password"])<6):
        errores.append("Contraseña demasiado corta")
    if(getIdPueblo(pueblo)=="ERROR"):
        errores.append("error: pueblo no existente: "+pueblo)
    #el correo es valido
    if not validate_email(correo):#paranoya: verify=True revisar que el correo existe
        errores.append("error: correo no valido: "+correo)
    #el telefono es valido
    regexpTelefono = re.compile("^[9|6|7][0-9]{8}$")
    if not regexpTelefono.match(telefono):
        errores.append("error: telefono no valido: "+telefono)
    #verificar que el usuario no está registrado:
    consultaCorreoUnico='SELECT correo FROM `usuarios` WHERE `correo` LIKE \''+correo+'\''
    conexionRegistro=conexion.conectar()
    cursorRegistro=conexionRegistro.cursor()
    cursorRegistro.execute(consultaCorreoUnico)
    for mail in cursorRegistro:
         errores.append("Ya existe un usuario con este correo")


    #En caso de error devolver una lista con los errores
    if(len(errores)>0):
        return errores

    #No hace falta else: hacemos un return

    #Generar token para el usuario en caso de exito

    token=generate_password_hash("TOKEN++"+passwd+datos["password"]+correo)

    #insertar datos en la base de datos
    insertarUsuario="INSERT INTO `usuarios` (`id_usuario`, `nombre`, `apellidos`, `telefono`, `pueblo_origen`, `pass`, `correo`, `token`) VALUES (NULL, \'" +\
    nombre+"\',\'"+apellidos+"\',\'"+telefono+"\',"+getIdPueblo(pueblo)+",\'"+passwd+"\',\'"+correo+"\',\'"+token+"\');"
    #print(insertarUsuario)
    cursorRegistro.execute(insertarUsuario)
    conexionRegistro.commit()
    conexionRegistro.close()

    #devolver {"token":token}
    return {"exito":True,"token":token}

def sign_up():
    if request.method == 'GET':
        return render_template('sign_up.html', signup_form=RegistrationForm(), hide=True)
    else:
        rf = RegistrationForm(request.form)
        if rf.validate_on_submit():
            users = db.userprofiles
            users.insert({'username': rf.username.data, 'password':generate_password_hash(rf.password.data), 'email':rf.email.data,
                'first_name':rf.first_name.data, 'last_name':rf.last_name.data, 'competencies':[], 'compfwks':[], 'lrsprofiles':[]})
            
            user = User(rf.username.data, generate_password_hash(rf.password.data))
            login_user(user)
            return redirect(url_for('index'))
        return render_template('sign_up.html', signup_form=rf, hide=True)

    def __init__(self, name, desc="Test", timeout=5, ttl=-1,
                 sub_passwd="", pub_passwd=None):
        self.name = name
        self.desc = desc
        self.timeout = timeout
        self.gc_time = datetime.now() + timedelta(hours=ttl) \
            if ttl > 0 else None

        self.sub_passwd = generate_password_hash(sub_passwd)
        self.pub_passwd = generate_password_hash(pub_passwd) \
            if pub_passwd else None

        self.subscribers = {"ALL": Subscriber("ALL")}
        self.lock = gevent.lock.RLock()