示例#1
0
def register():
    form = RegisterForm(request.form)
    if request.method == "POST" and form.validate():
        name = form.name.data
        username = form.username.data
        email = form.email.data
        password = sha256_crypt.encrypt(form.password.data)

        cursor = mysql.connection.cursor()

        sorgu = "SELECT * FROM users where username = %s"

        result = cursor.execute(sorgu, (username, ))

        if result > 0:
            flash(message="Böyle bir kullanıcı adı bulunmaktadır...",
                  category="danger")
            return redirect(location=url_for("register"))
        else:
            sorgu = "INSERT into users(name,email,username,password) VALUES(%s,%s,%s,%s)"

            cursor.execute(sorgu, (name, email, username, password))
            mysql.connection.commit()
            cursor.close()
            flash(message="Başarıyla Kayıt Oldunuz...", category="success")
            return redirect(location=url_for("login"))
    else:
        return render_template("register.html", form=form)
示例#2
0
def showSignIn():
    error = ''
    try:
        if request.method == "POST":
            name = request.form['inputName']
            password = sha256_crypt.encrypt(str(request.form['inputPassword']))
            c, conn = connection()

            data = c.execute("SELECT * FROM doctor WHERE docname = (%s)", name)

            data = c.fetchone()[4]

            if sha256_crypt.verify(password, data):
                session['logged_in'] = True
                session['username'] = name

                flash("You are now logged in")
                return redirect(url_for("main"))

            else:
                print data
                error = "Invalid credentials, try again."

        gc.collect()

        return render_template("signin.html", error=error)

    except Exception as e:
        # flash(e)
        error = "Invalid credentials, try again."
        return render_template("signin.html", error=error)
示例#3
0
def change_password(token):
    email = confirm_token(token)

    user = UserInfo.query.filter(UserInfo.email == email).first_or_404()

    if user.password_token is not None:
        form = ChangePasswordForm(request.form)
        if form.validate_on_submit():
            user = UserInfo.query.filter_by(email=email).first()
            if user:
                user.password = sha256_crypt.encrypt(str(form.password.data))
                user.password_token = None

                subject = 'Password has been updated'
                html = render_template('pwchange_confirm.html',
                                       username=user.username)

                send_email(user.email, subject, html)
                db.session.commit()

                flash('Password successfully updated.', 'success')
                return redirect(url_for('login'))

            # else:
            #     flash('Password change was unsuccessful.', 'danger')
            #     return redirect(url_for('login'))
        else:
            flash('Please enter your new password.', 'success')
            return render_template('change_password.html', form=form)
    else:
        flash('unable to reset the password, try again.', 'danger')

    return redirect(url_for('login'))
示例#4
0
def gebruikerswachtwoordaanpassen(id):

    cur.execute(
        "SELECT idUser, forename, lastname, username, idWoning, rank FROM domotica_db.User WHERE idUser=%s", (int(id))
    )
    gebruiker = cur.fetchall()

    # Vraagt het eerder gemaakte 'wachtwoordaanpassen' form aan.
    form = wachtwoordaanpassen()

    cur.execute(
        "SELECT idUser, forename, lastname, username, idWoning, rank FROM domotica_db.User WHERE idUser=%s", (int(id))
    )
    gebruiker = cur.fetchall()

    # Zodra de post op de pagina langs de vallidators van WTForm zijn gegaan kan de rest plaatsvinden.
    if form.validate_on_submit():
        # Nodig voor de request die we hierna gaan maken.
        forminfo = wachtwoordaanpassen(request.form)

        # Alle velden worden binnengehaald en aan een variabele gekoppelt.
        wachtwoord = forminfo.password.data

        # Het wachtwoord wordt met een random salt gehashed en beide worden in één variabele gestopt.
        versleutelde_password = hash.encrypt(escape(wachtwoord))

        cur.execute("UPDATE User SET password=%s WHERE idUser=%s", (versleutelde_password, int(id)))
        g.db_conn.commit()

        return redirect(url_for("admin"))

    return render_template("gebruiker_wachtwoord_aanpassen.html", gebruiker=gebruiker, form=form)
示例#5
0
 def setUp(self, settings_file=None, url_converters=None):
     super().setUp(settings_file, url_converters)
     # Let's add another account
     self.db.accounts.insert({
         'email':
         '[email protected]',
         'password':
         sha256_crypt.encrypt('1234'),
         'role':
         'admin',
         'token':
         'TOKENB',
         'databases':
         self.app.config['DATABASES'][1],
         'defaultDatabase':
         self.app.config['DATABASES'][1],
         '@type':
         'Account'
     })
     self.token_b = super(TestBase, self).post('/login', {
         'email': '[email protected]',
         'password': '******'
     })[0]['token']
     self.db2 = self.app.config['DATABASES'][1]  # 'dht2'
     self.db1 = self.app.config['DATABASES'][0]  # 'dht1'
def register():
    form = RegisterForm(request.form)
    if request.method == 'POST' and form.validate():
        name = form.name.data
        email = form.email.data
        username = form.username.data
        password = sha256_crypt.encrypt(str(form.password.data))

        # Create cursor
        cur = mysql.connection.cursor()

        # Execute query
        cur.execute(
            "INSERT INTO users(name, email, username, password) VALUES(%s, %s, %s, %s)",
            (name, email, username, password))

        # Commit to DB
        mysql.connection.commit()

        # Close connection
        cur.close()

        flash('You are now registered and can log in', 'success')

        return redirect(url_for('login'))
    return render_template('register.html', form=form)
示例#7
0
def register():
    form = RegisterForm(request.form)
    if request.method == 'POST' and form.validate():
        name = form.name.data
        email = form.email.data
        mobile = form.mobile.data
        speciality = form.speciality.data
        username = form.username.data
        password = sha256_crypt.encrypt(str(form.password.data))

        # create cursor
        cur = mysql.connection.cursor()

        cur.execute(
            "INSERT INTO users(name, email, speciality, username, password, phone_num) values(%s, %s, %s, %s, %s, %s)",
            (name, email, speciality, username, password, mobile))

        # commit to db
        mysql.connection.commit()

        # close connection
        cur.close()

        flash('you are now registered and can log in', 'success')

        return redirect(url_for('index'))

# continue from here
    return render_template('register.html', form=form)
示例#8
0
def register():
    form = RegisterForm(request.form)

    if request.method == "POST" and form.validate():
        name = form.name.data
        username = form.username.data
        email = form.email.data
        password = sha256_crypt.encrypt(form.password.data)

        cursor = mysql.connection.cursor()
        query1 = "select username from users where username = %s"
        result = cursor.execute(query1, (username, ))

        if result > 0:
            flash(
                """<strong>Kapılmış!</strong> Bu kullanıcı ismi zaten alınmış. Bu sensen <a href="/login"> Giriş Yap!</a>""",
                "warning")
            return redirect(url_for("register"))

        query = "Insert into users(name, email, username, password) VALUES(%s, %s, %s, %s)"

        cursor.execute(query, (name, email, username, password))
        mysql.connection.commit()
        cursor.close()

        flash("<strong>Hoşgeldin!</strong> Başarıyla kayıt oldunuz!",
              category="success")

        return redirect(url_for("login"))
    else:
        return render_template("register.html", form=form)
def gen_complete_user(name, password, mail, first_name, last_name, adress,
                      role):
    """
    Generiere einen User in der Datenbank mit allen einfügbaren Daten die es gibt
    :param name:
    :param password:
    :param mail:
    :param first_name:
    :param last_name:
    :param adress:
    :param role:
    :return: id des generierten Nutzers
    """
    chars = string.ascii_letters + string.digits
    size = 16
    salt = ''.join((random.choice(chars)) for x in range(size))
    pw_hash = sha256_crypt.encrypt(password + salt)
    pwmd5 = get_md5_bytes(password)
    cursor = get_cursor()
    cursor.execute(
        'INSERT INTO user (name, password, salt, secure_id, pw_md5, role, mail, first_name, last_name, adress) '
        'VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', [
            name.lower(), pw_hash, salt, salt, pwmd5, role, mail, first_name,
            last_name, adress
        ])
    return cursor.lastrowid
示例#10
0
    def post(self):
        sess = sessionmaker(bind=DBConnectionsFacade.get_edusson_ds())()

        json_data = tornado.escape.json_decode(self.request.body)
        username = json_data.get('username')
        password = json_data.get('password')
        boards = json_data.get('boards', [])
        access_level_id = json_data.get('access_level_id')
        is_active = json_data.get('is_active')

        if not password:
            raise MyAppException(reason='password cannot be empty',
                                 status_code=400)

        if not username:
            raise MyAppException(reason='username cannot be empty',
                                 status_code=400)

        user = DashUser(username=username,
                        password=sha256_crypt.encrypt(password),
                        is_active=is_active,
                        access_level_id=access_level_id)

        for board_id in boards:
            board_access = DashUserBoardAccess(
                user=user,
                dashboard_id=get_analytic_dashboard(),
                board_id=board_id)
            user.boards.append(board_access)

        sess.add(user)
        sess.commit()
示例#11
0
def register():
    form = RegisterForm(request.form)

    if request.method == "POST" and form.validate():
        name = form.name.data
        nickname = form.nickname.data
        email = form.email.data
        password = sha256_crypt.encrypt(form.password.data)

        cursor = mysql.connection.cursor()
        
        sorgu = "INSERT INTO users(name,email,nickname,password) VALUES(%s,%s,%s,%s)"

        cursor.execute(sorgu,(name,email,nickname,password))
        mysql.connection.commit()

        cursor.close()

        flash("Başarıyla kayıt oldunuz...","success")


        return redirect(url_for("login"))

    else:
        return render_template("register.html",form = form)
示例#12
0
def sample_register():
    form = Sample_register(request.form)
    if request.method == 'POST' and form.validate() == True:
        username = form.username.data

        password = sha256_crypt.encrypt(str(form.password.data))

        position = form.position.data

        cur = mysql.connection.cursor()
        # get ssnid by customer in db
        result = cur.execute("select * from users where position= %s", [position])
        cur.close()
        # if the result is fetched then redirect with message as ssnid already used
        if result > 0:
            flash("Account with this position already exists,If more than 1 account is required then contact Manager",'danger')
            return render_template("sample_registration.html", form=form)
        else:
            cur = mysql.connection.cursor()
            cur.execute("insert into users(username,password,position) VALUES(%s,%s,%s)",(username,password,position))
            mysql.connection.commit()
            cur.close()
            flash("Successfully User Registered",'success')
            return redirect('/')
    return render_template("sample_registration.html", form=form)
示例#13
0
def registro():
    error = ''
    conn = psycopg2.connect(conn_string)
    salida = ''
    try:
        if request.method == "POST":
            username = request.form['username']
            email = request.form['email']
            password = request.form['password']
            passwordEncrypt = sha256_crypt.encrypt(password)
            confirm = request.form['confirm']
            cursor = conn.cursor()
            if password == confirm:
                cursor.execute("INSERT into usuario (nombre, email, password) values (%s, %s, %s)",
                               [str(username), str(email), str(passwordEncrypt)])
                conn.commit()
                cursor.execute("SELECT nombre FROM usuario where nombre = (%s)", [request.form['username']])
                for row in cursor:
                    salida += str(row[0])
                valores.usuarioActual = salida
                return redirect((url_for('dashboard')))
            else:
                error = "Password does not match each other, please try again"
        return render_template("registro.html", error=error)

    except Exception as e:
        return render_template("registro.html", error=error)
示例#14
0
def admin():
    # Vraagt het eerder gemaakte 'NieuweGebruikerForm' form aan.
    form = NieuweGebruikerForm()

    # Zodra de post op de pagina langs de vallidators van WTForm zijn gegaan kan de rest plaatsvinden.
    if form.validate_on_submit():
        # Nodig voor de request die we hierna gaan maken.
        admin = NieuweGebruikerForm(request.form)

        # Alle velden worden binnengehaald en aan een variabele gekoppelt.
        username = admin.gebruikersnaam.data
        password = admin.password.data
        voornaam = admin.voornaam.data
        achternaam = admin.achternaam.data
        rang = admin.rang.data

        # Een laatste check of de username wel beschikbaar is (Deze moet uniek zijn):
        cur.execute("SELECT username FROM User WHERE username =%s", (escape(username)))
        beschikbaar = cur.fetchall()

        if beschikbaar == ():
            # Het wachtwoord wordt met een random salt gehashed en beide worden in één variabele gestopt.
            versleutelde_password = hash.encrypt(escape(password))

            # De gegevens worden naar de database verstuurd:
            cur.execute(
                "INSERT INTO User (username, forename, lastname, password, rank) VALUES (%s, %s, %s, %s, %s)",
                (escape(username), escape(voornaam), escape(achternaam), versleutelde_password, int(rang)),
            )
            g.db_conn.commit()

            # Redirect naar dezelfde pagina voor een refresh, later misschien naar de net aangemaakte user?
            return redirect(url_for("admin"))

    return render_template("admin.html", NieuweGebruikerForm=form)
示例#15
0
 def create(user: User) -> ObjectId:
     try:
         user.password = sha256_crypt.encrypt(user.password)
         user_id = Base.users.insert_one(user.get_dict()).inserted_id
         return user_id
     except Exception as e:
         print(e)
         return None
def get_encrypted_password():
    """
    returns the user password entered in the
    registration form. Encrypts it using sha256
    """

    password = request.form["password"]
    encrypted_password = sha256_crypt.encrypt(password)
    return encrypted_password
示例#17
0
 def add_accounts_dht3and4(self):
     self.db.accounts.insert({
         'email':
         '[email protected]',
         'password':
         sha256_crypt.encrypt('1234'),
         'role':
         'admin',
         'token':
         'TOKENC',
         'databases':
         self.app.config['DATABASES'][2],
         'defaultDatabase':
         self.app.config['DATABASES'][2],
         '@type':
         'Account'
     })
     self.token_c = super(TestBase, self).post('/login', {
         'email': '[email protected]',
         'password': '******'
     })[0]['token']
     self.db.accounts.insert({
         'email':
         '[email protected]',
         'password':
         sha256_crypt.encrypt('1234'),
         'role':
         'admin',
         'token':
         'TOKEND',
         'databases':
         self.app.config['DATABASES'][3],
         'defaultDatabase':
         self.app.config['DATABASES'][3],
         '@type':
         'Account'
     })
     self.token_d = super(TestBase, self).post('/login', {
         'email': '[email protected]',
         'password': '******'
     })[0]['token']
     self.db3 = self.app.config['DATABASES'][2]  # 'dht3'
     self.db4 = self.app.config['DATABASES'][3]  # 'dht4'
示例#18
0
def update_password(username):
    form = ChangePasswordForm(request.form)
    if request.method == 'POST' and form.validate():
        new = form.new_password.data
        entered = form.old_password.data
        if session['prof'] == 1:
            cur = mysql.connection.cursor()
            cur.execute("SELECT password FROM admin WHERE username = %s",
                        [username])
            old = (cur.fetchone())['password']
            if sha256_crypt.verify(entered, old):
                cur.execute(
                    "UPDATE admin SET password = %s WHERE username = %s",
                    (sha256_crypt.encrypt(new), username))
                mysql.connection.commit()
                cur.close()
                flash('New password will be in effect from next login!!',
                      'info')
                return redirect(
                    url_for('adminDash', username=session['username']))
            cur.close()
            flash('Old password you entered is wrong!!, try again', 'warning')
        if session['prof'] == 2:
            cur = mysql.connection.cursor()
            cur.execute("SELECT password FROM member WHERE username = %s",
                        [username])
            old = (cur.fetchone())['password']
            if sha256_crypt.verify(entered, old):
                cur.execute(
                    "UPDATE member SET password = %s WHERE username = %s",
                    (sha256_crypt.encrypt(new), username))
                mysql.connection.commit()
                cur.close()
                flash('New password will be in effect from next login!!',
                      'info')
                return redirect(
                    url_for('memberDash', username=session['username']))
            cur.close()
            flash('Old password you entered is wrong!!, try again', 'warning')
        return render_template('updatePassword.html', form=form)
    return render_template('updatePassword.html', form=form)
示例#19
0
def create_admin(mysql):
    cur = mysql.connection.cursor()
    res = cur.execute("SELECT * FROM users WHERE username=%s", ["admin"])
    if res < 1:
        print("Creating admin account...")
        password = sha256_crypt.encrypt("password1")
        cur.execute(
            "INSERT INTO users(name, username, password, positionTitle, email, startDate) VALUES(%s, %s, %s, %s, %s, %s)",
            ("admin", "admin", password, "Admin", "*****@*****.**",
             "1/1/1970"))
        mysql.connection.commit()
    cur.close()
def register_user(db, form):
    from flask_app import Users
    name = form.name.data
    email = form.email.data
    username = form.username.data
    password = str(sha256_crypt.encrypt(form.password.data))

    new_user = Users(name, email, username, password)
    try:
        db.session.add(new_user)
        db.session.commit()
        return new_user
    except IntegrityError:
        return False
示例#21
0
def register():
    form = RegistrationForm(request.form)
    if request.method == 'GET':
        return render_template('register.html', form=form)

    if request.method == 'POST':
        #if form.validate_on_submit():
        fname = form.fname.data
        lname = form.lname.data
        username = form.username.data
        email = form.email.data
        password = sha256_crypt.encrypt((str(form.password.data)))
        createUser(fname, lname, username, email, password)
        return "success"
示例#22
0
def register():
    next_url = request.args.get('next')
    if not current_user.is_authenticated:
        try:
            if request.method == "POST":
                con, conn = connection()
                form = request.form
                email = form['email']
                password = sha256_crypt.encrypt((str(form['password'])))
                used_username = con.execute(
                    "SELECT * FROM user WHERE login = (%s)",
                    escape_string(request.form['login']))
                if "@" not in email:
                    wrong_email = True
                else:
                    wrong_email = False
                if used_username or wrong_email:
                    return render_template('register.html',
                                           form=form,
                                           used_username=used_username,
                                           wrong_email=wrong_email)
                con.execute(
                    "INSERT INTO scout (first_name, last_name) VALUES (%s, %s)",
                    (escape_string(
                        form['first-name']), escape_string(form['last-name'])))
                conn.commit()
                scout_id = con.lastrowid
                sql = "INSERT INTO user (login, password, email, scout_id) VALUES (%s, %s, %s, " + str(
                    scout_id) + ")"
                con.execute(
                    sql,
                    (escape_string(form['login']), escape_string(password),
                     escape_string(form['email'])))
                conn.commit()
                flash("Zarejestrowano pomyślnie!", 'success')
                send_confirmation_email(form['email'])
                con.close()
                conn.close()
                gc.collect()
                return redirect(url_for('login', next=next_url,
                                        username=email))
            else:
                return render_template('register.html')
        except Exception as error:
            flash('Błąd: ' + str(error), 'danger')
            return redirect('/')
    else:
        flash("Jesteś już zalogowany!", 'warning')
        return redirect(next_url)
示例#23
0
def register():
    form = RegisterForm(request.form)
    if request.method == "POST" and form.validate():
        name = form.name.data
        username = form.username.data
        email = form.email.data
        password = sha256_crypt.encrypt(form.password.data)
        cursor = mysql.connection.cursor()
        user_query = "Insert into users(name,username,email,password) VALUES(%s, %s, %s, %s)"
        cursor.execute(user_query, (name, username, email, password))
        mysql.connection.commit()
        cursor.close()
        flash(message="You have successfully registered.", category="success")
        return redirect(url_for("login"))
    else:
        return render_template("register.html", form=form)
示例#24
0
def index():
    form = RegistrationForm(request.form)
    if request.method == "POST" and form.validate():
        password = sha256_crypt.encrypt(form.password.data)
        user = User(username=form.username.data, email=form.email.data, password=password)
        try:
            db.session.add(user)
            db.session.commit()
            flash("Kaydolmayı başardın, tebrikler!","success")
        except:
            flash("Başaramadın, girdiğin bilgiler ile kayıtlı bir kullanıcı var!","info")
            
        
        return render_template('index.html',form = form)
    else:
        return render_template('index.html',form = form)
def save_pw(pw, id):
    """
    Speichere übergebenes Passwort in allen benötigten Formaten in Datenbank ab
    :param pw:
    :param id:
    :return: None
    """
    chars = string.ascii_letters + string.digits
    size = 16
    salt = ''.join((random.choice(chars)) for x in range(size))
    pw_hash = sha256_crypt.encrypt(pw + salt)
    pwmd5 = get_md5_bytes(pw)
    cursor = get_cursor()
    cursor.execute(
        'UPDATE user SET password = ?, salt = ?, pw_md5 = ? WHERE secure_id = ?',
        [pw_hash, salt, pwmd5, id])
def gen_user(name, passwd):
    """
    Generiere einen User in der Datenbank nur mit Name und Passwort
    :param name:
    :param passwd:
    :return: id des generierten nutzers
    """
    chars = string.ascii_letters + string.digits
    size = 16
    salt = ''.join((random.choice(chars)) for x in range(size))
    pw_hash = sha256_crypt.encrypt(passwd + salt)
    pwmd5 = get_md5_bytes(passwd)
    cursor = get_cursor()
    cursor.execute(
        'INSERT INTO user (name, password, salt, secure_id, pw_md5, role) VALUES (?, ?, ?, ?, ?, ?)',
        [name.lower(), pw_hash, salt, salt, pwmd5, 'user'])
    return cursor.lastrowid
示例#27
0
 def register(self, data):
     customer = session.query(UsersDbTable).filter_by(email=data['email']).first()
     if customer is None:
         bits = random.getrandbits(126)
         token = hex(bits)
         customer = UsersDbTable(name=data['name'],
                                 surname=data['surname'],
                                 email=data['email'],
                                 password=sha256_crypt.encrypt(data['password']),
                                 pseudo=data['pseudo'],
                                 type=data['type'],
                                 token=token)
         session.add(customer)
         session.commit()
         return customer.token
     else:
         abort(409)
示例#28
0
    def create(self,
               username,
               password,
               is_active,
               access_level_id,
               boards=None):
        user = DashUser(username=username,
                        password=sha256_crypt.encrypt(password),
                        is_active=is_active,
                        access_level_id=access_level_id)

        if boards:
            self.attach_boards(user, boards)
            # attach board, not boards

        self.session.add(user)
        self.session.commit()
示例#29
0
 def setUp(self, settings_file=None, url_converters=None):
     super().setUp(settings_file, url_converters)
     # Let's add another account
     self.db.accounts.insert(
         {
             'email': '[email protected]',
             'password': sha256_crypt.encrypt('1234'),
             'role': 'admin',
             'token': 'FDAEWHPIOZMGU',
             'databases': self.app.config['DATABASES'][1],
             'defaultDatabase': self.app.config['DATABASES'][1],
             '@type': 'Account'
         }
     )
     self.token_b = super(TestBase, self).post('/login', {'email': '[email protected]', 'password': '******'})[0]['token']
     self.db2 = self.app.config['DATABASES'][1]  # 'dht2'
     self.db1 = self.app.config['DATABASES'][0]  # 'dht1'
示例#30
0
    def put(self, id):
        json_data = tornado.escape.json_decode(self.request.body)
        username = json_data.get('username')
        password = json_data.get('password', None)
        boards = json_data.get('boards', [])
        access_level_id = json_data.get('access_level_id', None)
        is_active = json_data.get('is_active', True)

        sess = sessionmaker(bind=DBConnectionsFacade.get_edusson_ds())()

        user = sess.query(DashUser).filter_by(user_id=id).first()

        user_board_accesses = sess.query(DashUserBoardAccess).filter_by(
            user_id=id, dashboard_id=get_analytic_dashboard()).all()

        exists_ids = []
        for board_access in user_board_accesses:
            exists_ids.append(board_access.board_id)

            if board_access.board_id not in boards:
                sess.query(DashUserBoardAccess).filter_by(
                    user_id=id,
                    dashboard_id=get_analytic_dashboard(),
                    board_id=board_access.board_id).delete()

        for board_id in boards:
            if board_id not in exists_ids:
                board_access = DashUserBoardAccess(
                    user=user,
                    dashboard_id=get_analytic_dashboard(),
                    board_id=board_id)
                user.boards.append(board_access)

        user.username = username
        user.is_active = is_active

        if password:
            user.password = sha256_crypt.encrypt(password)

        if access_level_id:
            user.access_level_id = access_level_id

        sess.commit()
示例#31
0
def register():
    try:
        form = RegistrationForm(request.form)
        if request.method == 'POST' and form.validate():
            title = form.title.data
            username = form.username.data
            email = form.email.data
            password = sha256_crypt.encrypt(str(form.password.data))
            real_name = form.name.data

            db, cur = get_db()

            x = cur.execute('SELECT * FROM user WHERE username = ?',
                            [username])
            print(x)

            if x is not None and x.fetchall():
                flash("That username is already taken, please choose another")
                return render_template('register.html', form=form)

            else:
                cur.execute(
                    "INSERT INTO user (title, username, email, password, real_name) VALUES(?,?,?,?,?)",
                    [title, username, email, password, real_name])
                db.commit()

                flash("Thanks for registering!")

                cur.close()
                db.close()
                gc.collect()  # collect garbage

                session['logged_in'] = True
                session['username'] = username

                return redirect(url_for('home'))

        return render_template('register.html', form=form)

    except Exception as e:
        return str(e)
    def add_user(user):

        # adding address in address table
        result = AddressService.add_address(user['address'])
        if result['status'] is False:
            return {
                'status': constants.STATUS_FAIL,
                'message': 'Failed to create address'
            }

        address_id = result['address_id']
        '''encrypt password'''
        password = sha256_crypt.encrypt(user['password'])

        try:
            log.info("adding in user table")
            users = RbaUser(name=user['name'],
                            mobile=user['mobile'],
                            email=user['email'],
                            password=password,
                            gender=user['gender'],
                            aadhaar_no=user['aadhaar_no'],
                            dob=user['dob'],
                            profile_image=user['profile_image'],
                            address_id=address_id)
            db.session.add(users)
            db.session.flush()
            op_object = {
                'status': constants.STATUS_PASS,
                'user_id': users.id,
                'address_id': address_id
            }
        except SQLAlchemyError as e:
            template = "An exception of type {0} occurred. Arguments:\n{1!r}"
            error = template.format(type(e).__name__, e.args)
            log.error("problem in user table")
            log.error(error)
            op_object = {'status': constants.STATUS_FAIL, 'msg': error}

        return op_object
示例#33
0
文件: src.py 项目: markomih/vocabulme
def registration_page():
    try:
        if request.method == "POST":
            email = request.form['email']
            password = sha256_crypt.encrypt(request.form['password'])

            userModel = UserModel()

            if userModel.get(User(email=email)):
                flash("User already exist", 'warning')
            else:
                userModel.create(User(email, password))

                session['logged_in'] = True
                session['email'] = email

                flash("Thanks for registration :)", 'success')
    except Exception as e:
        print(e)
        flash("Database error", 'warning')
    else:
        return redirect(url_for('home'))
示例#34
0
def addMember():
    choices.clear()
    cur = mysql.connection.cursor()
    form = AddMemberForm(request.form)
    if request.method == 'POST' and form.validate():
        username = form.username.data
        password = sha256_crypt.encrypt(str(form.password.data))
        membership_no = form.membership_no.data
        q = cur.execute("SELECT username FROM member where membership_no = %s",
                        [membership_no])
        if q > 0:
            flash('Duplicate Membership No,rectify!!', 'danger')
            return redirect(url_for('addMember'))
        cur.execute(
            "INSERT INTO member(username, password, membership_no) VALUES(%s, %s, %s)",
            (username, password, membership_no))
        mysql.connection.commit()
        cur.close()
        choices.clear()
        flash('You added a new member!!', 'success')
        if (session['prof'] == 1):
            return redirect(url_for('adminDash'))
    return render_template('addMember.html', form=form)
示例#35
0
 def set_password(self, password):
     self.password = sha256_crypt.encrypt(password)
示例#36
0
    def update(self, data):
        customer = session.query(UsersDbTable).filter_by(email=data['email']).first()
        if customer is None:
            abort(400)
        else:
            customer.name = customer.name if (data['name'] == '' or data['name'] == None) else data['name']
            customer.surname = customer.surname if (data['surname'] == '' or data['surname'] == None) else data['surname']
            customer.email = customer.email if (data['email'] == '' or data['email'] == None) else data['email']
            customer.password = customer.password if (data['password'] == '' or data['password'] == None) else sha256_crypt.encrypt(data['password'])
            customer.pseudo = customer.pseudo if (data['pseudo'] == '' or data['pseudo'] == None) else data['pseudo']
            customer.type = customer.type if (data['type'] == '' or data['type'] == None) else data['type']

            session.add(customer)
            session.commit()
            return (
            {'name': customer.name, 'surname': customer.surname, 'email': customer.email, 'pseudo': customer.pseudo,
             'type': customer.type, 'token': customer.token, 'id': customer.id})
示例#37
0
 def hash_password(self,password):
     self.password_hash=sha256_crypt.encrypt(password)
     return self.password_hash
示例#38
0
 def set_password(self, password):
     hashed_password = sha256_crypt.encrypt(password)
     self.password = hashed_password
示例#39
0
 def encrypt_password(password: str) -> str:
     return sha256_crypt.encrypt(password)
示例#40
0
 def __init__(self, password, username, profile_picture, email=''):
     self.username = username
     self.password = sha256_crypt.encrypt(password)
     self.profile_picture = profile_picture
     self.email = email
示例#41
0
文件: hooks.py 项目: eReuse/DeviceHub
def hash_password(accounts: list):
    for account in accounts:
        if "password" in account:
            account["password"] = sha256_crypt.encrypt(account["password"])