Exemple #1
0
def register_handler():
    form = RegisterForm(request.forms)
    dic = {"status": "error", "reason": None}
    if form.validate():
        email = form.email.data.lower()
        password = red.hget('userinfo:%s' % email, 'password')
        dic["status"], dic["reason"] = "success", u"帐号确认中..."
        if not password:
            # 若用户不存在,即邮箱未注册,则邮箱可用
            now = datetime.datetime.now()
            name = email.split('@')[0]
            red.hmset('userinfo:%s' % email,
                      {'password': encrypt(form.password.data),
                       'name': name,
                       'visited_times': 0,
                       'date_join': now})
            s = request.environ.get('beaker.session')
            s['username'] = email
            s.save()
            red.set('userinfo:%s:visited_times' % email, 0)
        else:
            dic["status"], dic["reason"] = "invalid", u"用户名已存在"
    form_errors = (form.email.errors
                   if form.email.errors else form.password.errors)
    if form_errors:
        dic['status'] = "invalid"
        dic['reason'] = form_errors
    return dic
Exemple #2
0
def register():
    """Регистрация пользователя"""

    if current_user.is_authenticated:
        return redirect('/feed')

    form_reg = RegisterForm()
    form_log = LoginForm()

    # если форма заполнена и отправлена
    if form_reg.validate_on_submit():
        # проверка совпадения паролей
        if form_reg.password.data != form_reg.password_again.data:
            return render_template('enter_page.html',
                                   title='Главная',
                                   form_reg=form_reg,
                                   form_log=form_log,
                                   message_reg="Пароли не совпадают")

        db_session.global_init("db/database.sqlite")
        session = db_session.create_session()

        # проверка наличия почты в БД (почта должна быть уникальной)
        if session.query(User).filter(
                User.email == form_reg.email.data).first():
            return render_template('enter_page.html',
                                   title='Главная',
                                   form_reg=form_reg,
                                   form_log=form_log,
                                   message_reg="Такая почта уже есть")

        # проверка наличия ника в БД (ник должн быть уникальным)
        if session.query(User).filter(
                User.nickname == form_reg.nickname.data).first():
            return render_template('enter_page.html',
                                   title='Главная',
                                   form_reg=form_reg,
                                   form_log=form_log,
                                   message_reg="Такой пользователь уже есть")

        # если всё было корректно, добавляем пользователя
        post('http://sunsite.herokuapp.com/api/users',
             json={
                 'nickname': form_reg.nickname.data,
                 'email': form_reg.email.data,
                 'password': form_reg.password.data
             })
        return redirect('/')
    return render_template('enter_page.html',
                           title='Регистрация',
                           form_reg=form_reg,
                           form_log=form_log)
Exemple #3
0
def register():
    '''This functionallows users to register. Heence will add users to the system.'''
    register_form = RegisterForm()
    username = register_form.username.data
    email = register_form.email.data
    password = register_form.password.data
    if request.method == 'POST' and register_form.validate_on_submit():
        new_user = User(username, email, password)
        db.session.add(new_user)
        db.session.commit()
        flash('Registration successful')
        return redirect(url_for('create_short'))
    else:
        flash("Make sure all fields are filled with valid data")
    return render_template('register.html', register_form=register_form)
def sign_up():
    """Renders sign up page."""
    form = RegisterForm()

    if form.validate_on_submit():

        username: str = form.username.data
        usertag: str = form.usertag.data
        password: str = form.password.data

        if validate_signup(usertag):
            user = register_user(username, usertag, password)
            login_user(user)
            return redirect(f"/user/{usertag}")

    return dict(form=form)
Exemple #5
0
def login():
    """Авторизация пользователя"""

    if current_user.is_authenticated:
        return redirect('/feed')

    form_log = LoginForm()
    form_reg = RegisterForm()

    # если форма заполнена и отправлена
    if form_log.validate_on_submit():
        db_session.global_init("db/database.sqlite")
        session = db_session.create_session()
        user = session.query(User).filter(
            User.email == form_log.email.data).first()

        # если пароль введён верный
        if user and user.check_password(form_log.password.data):
            # выполняется вход пользователя
            login_user(user, remember=True)
            return redirect("/")

        return render_template('enter_page.html',
                               message_log="Неправильный логин или пароль",
                               form_log=form_log,
                               form_reg=form_reg)
    return render_template('enter_page.html',
                           title='Авторизация',
                           form_log=form_log,
                           form_reg=form_reg)
Exemple #6
0
def reqister():
    # Получение форм
    form = RegisterForm()
    if session.get('data'):
        name = session.get('data')['name']
    else:
        name = None

    # Проверка валидации формы
    if form.validate_on_submit():
        # Проверка повторного ввода пароля
        if form.password.data != form.password_again.data:
            return render_template('register.html',
                                   title='Регистрация',
                                   form=form,
                                   message="Пароли не совпадают",
                                   name=name)

        db_sess = db_session.create_session()  # Создание ссесии с БД

        # Проверка идентичности email адресса
        if db_sess.query(User).filter(User.email == form.email.data).first():
            return render_template('register.html',
                                   title='Регистрация',
                                   form=form,
                                   message="Такой пользователь уже есть",
                                   name=name)

        # Создание и добавление пользователя
        user = User(name=form.name.data,
                    email=form.email.data,
                    about=form.about.data,
                    couriers_added=0,
                    orders_added=0)
        user.set_password(form.password.data)
        db_sess.add(user)
        db_sess.commit()

        # Редирект на страницу авторизации
        return redirect('/login')

    # Успешный рендер страницы
    return render_template('register.html',
                           title='Регистрация',
                           form=form,
                           name=name)
def data_input():
    form = RegisterForm()
    if form.validate_on_submit():
        form.street.data = form.street.data if form.street.data != '' else choice(
            STREET_LIST) + '$' + str(randint(0, 100))
        form.fill.data = form.fill.data if form.fill.data != '' else randint(
            0, 100)
        form.days.data = form.days.data if form.days.data != '' else randint(
            0, 1000)

        loc = str(form.street.data)
        fill = str(form.fill.data)
        days = str(form.days.data)

        print('loc:', loc)
        print('fill:', fill)
        print('days:', days)
        return redirect('/add/' + loc + '&' + fill + '&' + days)
    return render_template('data_handle.html', form=form)
Exemple #8
0
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
        # TODO
        password = sha256_crypt.encrypt(str(form.password.data))

        user = User(name, email, username, password)

        if db.register_user(user):
            flash('You are now registered and can log in', 'success')
            return redirect(url_for('index_page.index'))
        else:
            flash('User already exist!', 'danger')
            return render_template('register.html', form=form)

    return render_template('register.html', form=form)
Exemple #9
0
def register():
	form = RegisterForm()
	if request.method == 'GET':
		return render_template('register.html', form=form)
	if form.validate_on_submit():
		# check user not already registered
		user = User.query.filter_by(email=form.email.data)
		if user.count() > 0:
			error_message = 'This email address has already been registered.'
			back_url = url_for('web.register')
			return render_template('generic-error.html', error_message=error_message, back_url=back_url), 400
		# add the new user
		user = User(form.nickname.data, form.email.data, form.password.data)
		db.session.add(user)
		db.session.commit()
		# log them in
		login_user(user)
		# redirect to home
		return redirect(url_for('web.index'))
	# return just the basic view
	return render_template('register.html', form=form)
Exemple #10
0
def create_short(page=1):
    '''creating a short url from a given long url'''
    login_form = LoginForm()
    update_form = UpdateUrlForm()
    register_form = RegisterForm()
    form = UrlForm()
    url = form.url.data
    custom_url = form.vanity_string.data
    current_id = current_user.get_id()

    #The Url variable holds the original url data which is passed to generate a short Url
    data = UrlSchema.query.filter_by(author_id=current_id).order_by(
        desc(UrlSchema.id)).paginate(page, POSTS_PER_PAGE, False)
    url_short = None

    if request.method == 'POST' and form.validate_on_submit():
        if len(url) > 100:
            flash("Invalid entry Url too long!!!.", 'error')
        else:
            new_long_url = UrlSchema(url)
            db.session.add(new_long_url)
            db.session.commit()
            new_long_url.author_id = current_id
            #adding url title by spliting the original long url
            url_title = url.split("/")[2:3]
            """removing curly brackets from the url title """
            new_long_url.title = (', '.join(url_title))
            # if there is no custom url the short url will be genrated randomly
            new_long_url.short_url = custom_url if custom_url else sh_url.encode_url(
                new_long_url.id)
            url_short = new_long_url.short_url
            db.session.commit()
            form = UrlForm(formdata=None)

    # get frequent users
    frequent_users = get_frequent_users()
    #popular links i.e links with most clicks (above and equal to 3)
    pop_link = get_popular_links()
    #latest links added
    recent_links = get_recent_links()
    return render_template('index.html',
                           form=form,
                           update_form=update_form,
                           data=data,
                           frequent_users=frequent_users,
                           pop_link=pop_link,
                           url_short=url_short,
                           recent_links=recent_links,
                           login_form=login_form,
                           register_form=register_form)
Exemple #11
0
 def post(self):
     form = RegisterForm(self.request.arguments)
     dic = {"status": "error", "reason": None}
     if form.validate():
         password = yield tornado.gen.Task(client.hget, 'userinfo:%s' % form.email.data, 'password')
         dic["status"], dic["reason"] = "success", u"帐号确认中..."
         if not password:
             # database handle
             with client.pipeline(transactional=True) as pipe:
                 pipe.hset('subchannels:%s' % form.email.data, u'Nemesis', 0)
                 # add accounts to channel
                 pipe.sadd('subunames:%s' % u'Nemesis', form.email.data)
                 pipe.hset('userinfo:%s' % form.email.data, 'password', form.password.data)
                 yield tornado.gen.Task(pipe.execute)
                 # print res, len(res)
             self.set_secure_cookie('username', form.email.data)
         else:
             dic["status"], dic["reason"] = "invalid", u"用户名已存在"
     form_errors = form.email.errors if form.email.errors else form.password.errors
     if form_errors:
         dic['status'] = "invalid"
         dic['reason'] = form_errors
     self.write(dic)
Exemple #12
0
 def test_email_already_registered(self):
      form = RegisterForm(email='*****@*****.**', password='******', password2='password')
      self.assertFalse(form.validate())
Exemple #13
0
 def test_invalid_password_format(self):
      form = RegisterForm(username='******', 
                         email='*****@*****.**', password='******', password2='different')
      self.assertFalse(form.validate())
Exemple #14
0
 def test_validate_success_register_form(self):
     form = RegisterForm(username='******', 
                         email='*****@*****.**', password='******', password2='password')
     self.assertTrue(form.validate())