Пример #1
0
def authorized():
    if "error" in request.args:
        # User cancelled the auth flow - discard auth (most likely there won't be any)
        session.pop("twitch_token", None)
        return redirect(url_for("mainpage"))
    twitch = OAuth2Session(config.CLIENT_ID,
                           config.CLIENT_SECRET,
                           state=session["login_state"])
    resp = twitch.fetch_access_token(
        "https://id.twitch.tv/oauth2/token",
        code=request.args["code"],
        # For some bizarre reason, we need to pass this information along.
        client_id=config.CLIENT_ID,
        client_secret=config.CLIENT_SECRET,
        redirect_uri=url_for("authorized", _external=True))
    if "access_token" not in resp:
        # Something went wrong with the retrieval. No idea what or why,
        # so I'm doing a cop-out and just dumping to console.
        print("Unable to log in")
        pprint(resp)
        print("Returning generic failure.")
        raise Exception
    session["twitch_token"] = resp["access_token"]
    session["twitch_refresh_token"] = resp["refresh_token"]
    session["twitch_auth_scopes"] = " ".join(sorted(resp["scope"]))
    user = query("helix/users", token="bearer")["data"][0]
    user["_id"] = user[
        "id"]  # For now, everything looks for _id. Existing logins don't have user["id"].
    database.create_user(user["_id"])
    session["twitch_user"] = user
    return redirect(url_for("mainpage"))
Пример #2
0
def create_new_user():
    username = input("Username: "******"Password: "******"First Name:")
    surname = input("Surname: ")
    salt, bcrypt_password = create_password_salt(password)
    database.create_user(username, bcrypt_password, salt, first_name, surname)
Пример #3
0
def signup():
    if "logged_in" in session and session['logged_in']:
        return redirect(url_for("home_page"))
    else:
        if request.method == 'POST':
            username = request.form['username']
            email = request.form['email']
            password = request.form['password']
            file = request.files['file']
            failed = None
            if file and allowed_file(file.filename):
                a = database.get_last_user_id()
                b = file.filename
                if a == None:
                    f = str(1) + "." + b.rsplit('.', 1)[1].lower()
                else:
                    f = str(
                        (int(a.id) + 1)) + "." + b.rsplit('.', 1)[1].lower()
                target = os.path.join(app.config['UPLOAD_FOLDER_2'], f)
                file.save(target)
                database.create_user(username, email, password, f, 0, 0)

                # ###########################IMPORTANT Q: how to create a new name for session['pics(1/2/3/4/5/6/7/....)'] everytime it goes through the for loop
                return redirect(url_for('home_page'))
            if file and not allowed_file(file.filename):
                failed = True
                return render_template("signup.html", failed=failed)
        else:
            return render_template("signup.html")
Пример #4
0
def signup():
    if request.method == "POST":
        email = request.form["email"]
        session["email"] = email
        password = request.form["password"]
        password2 = request.form["password-two"]
        access = request.form["access"]
        name = request.form["name"]
        location = request.form["location"]
        # Change this to create a user if authentic email
        if password != password2:
            return render_template("home.html", correct={"signup":True}, bad_signup=True, error="Passwords must match.")

        if database.user_exists(email):
            return render_template("home.html", correct={"signup":True}, bad_signup=True, error="User already exists.")
            

        if security.check_email(email):
            database.create_user(email, password, name, access, location)

            token = security.generate_confirmation_token(email)
            confirm_url = url_for("confirm", token=token, _external=True)
            html = render_template("activate.html", confirm_url=confirm_url)
            subject = "Please confirm your email"
            send_email(email, subject, html)

            flash("A confirmation email has been sent via email.", "success")
            return render_template("home.html", correct={"login":True}, bad_login=True, error="An authentication link has been sent to your email.", resend_auth=True)
        else:
            return render_template("home.html", correct={"signup":True}, bad_signup=True, error="Invalid email.")
    else:
        return render_template("home.html", correct={"signup":True}, bad_signup=False)
Пример #5
0
def user_render(access):
    if not database.valid_access(access):
        return render_template("error.html", error="Page not found.")
    elif not database.is_admin(session["access"]):
        return redirect(url_for("unauthorized"))
    else:
        users = database.get_users()
        if request.method == "POST":
            email = request.form["email"]
            password = request.form["password"]
            password2 = request.form["password-two"]
            new_access = request.form["access"]
            name = request.form["name"]
            location = request.form["location"]
            # Change this to create a user if authentic email
            if password != password2:
                return render_template("users.html", users=users, access=access, error="Passwords for " + email + " do not match.")

            if database.user_exists(email):
                return render_template("users.html", users=users, access=access, error="User: "******" already exists.")
            
            database.create_user(email, password, name, new_access, location)

            token = security.generate_confirmation_token(email)
            confirm_url = url_for("confirm", token=token, _external=True)
            html = render_template("account.html", confirm_url=confirm_url, access = new_access, password=password)
            subject = "Please confirm your email"
            send_email(email, subject, html)
            print("CONFIRM: ", confirm_url)
            print("EMAIL: ", email)
            return render_template("users.html", users=users, access=access, error="An authentication email has been send to: " + email)
        else:
            return render_template("users.html", users=users, access=access)
Пример #6
0
 def post(self):
     try:
         info = loads(request.data.decode())
         db.create_user(**info)
     except decoder.JSONDecodeError as e:
         return f'Error decoding json ({str(e)})', 500
     else:
         return None, 204
Пример #7
0
def create_new_user(group_id=1):
    username = input("Username: "******"Password: "******"First Name:")
    surname = input("Surname: ")
    email = input("Email: ")
    salt, bcrypt_password = create_password_salt(password)
    database.create_user(username, bcrypt_password, salt, first_name, surname,
                         email, group_id)
Пример #8
0
def start(bot, update):
    m = update.message
    if not is_message_for_bot(m):
        return
    m.reply_text(messages.START_MESSAGE)
    if not is_registered(m.from_user):
        create_user({
            'telegram_id': m.from_user.id,
            'first_name': m.from_user.first_name
        })
Пример #9
0
def mainpage(channelid=None):
    # NOTE: If we've *reduced* the required scopes, this will still force a re-login.
    # However, it'll be an easy login, as Twitch will recognize the existing auth.
    if "twitch_token" not in session or session.get(
            "twitch_auth_scopes") != REQUIRED_SCOPES:
        return render_template("login.html")
    user = session["twitch_user"]
    if channelid is None: channelid = user["_id"]
    try:
        channelid = str(int(channelid))
    except ValueError:
        # If you go to /editor/somename, redirect to /editor/equivalent-id
        # Bookmarking the version with the ID will be slightly faster, but
        # streamers will usually want to share the version with the name.
        users = query("helix/users", token="app", params={"login":
                                                          channelid})["data"]
        # users is either an empty list (bad login) or a list of one.
        if not users: return redirect("/")
        return redirect("/editor/" + users[0]["id"])
    if not may_edit_channel(user["_id"], channelid):
        return redirect(url_for("mainpage"))
    database.create_user(
        channelid
    )  # Just in case, make sure the database has the basic structure
    channel = get_channel_setup(channelid)
    sched_tz, schedule, sched_tweet = database.get_schedule(channelid)
    if "twitter_oauth" in session:
        auth = session["twitter_oauth"]
        username = auth["screen_name"]
        twitter = "Twitter connected: " + username
        tweets = list_scheduled_tweets(auth["oauth_token"],
                                       auth["oauth_token_secret"], sched_tz)
    else:
        twitter = Markup(
            """<div id="login-twitter"><a href="/login-twitter"><img src="/static/Twitter_Social_Icon_Square_Color.svg" alt="Twitter logo"><div>Connect with Twitter</div></a></div>"""
        )
        tweets = []
    error = session.get("last_error_message", "")
    session["last_error_message"] = ""
    return render_template(
        "index.html",
        twitter=twitter,
        username=user["display_name"],
        channel=channel,
        channelid=channelid,
        error=error,
        setups=database.list_setups(channelid),
        sched_tz=sched_tz,
        schedule=schedule,
        sched_tweet=sched_tweet,
        checklist=database.get_checklist(channelid),
        timers=database.list_timers(channelid),
        tweets=tweets,
    )
Пример #10
0
def handle_start (message):
    if not user_exist(message.from_user.id):
        create_user(message.from_user.id, message.chat.id, message.from_user.first_name, carteira="")
    #BOTÕES DO BOT
    user_markup = telebot.types.ReplyKeyboardMarkup(True, True)
    user_markup.row(' NST  {:.8f} '.format(Salcon))
    user_markup.row('Iniciar', 'Deposito')
    user_markup.row('Wallet NST', 'Saque', 'Suporte')
    user_markup.row('Ajuda')
    bot.send_message(message.from_user.id, 'Seu cadastro foi criado com sucesso! \n'
                                           ' Seja, Bem vindo {} ! ao melhor Bot de investimento.'.format(message.from_user.first_name), reply_markup=user_markup)
Пример #11
0
 def sign_up(connection):
     firstname = input("Enter your first name ")
     lastname = input("Enter your last name ")
     password = input("Enter your password ")
     status = input("Enter your access code")
     date = datetime.datetime.now()
     if status == '256':
         status = 'admin'
     else:
         status = 'customer'
     database.create_user(connection, firstname, lastname, password, status, date)
Пример #12
0
def start(bot, update):
    chat_id = update.message.chat_id

    try:
        send_message(bot, chat_id, START_TEXT)

        username = get_username(update.message.chat)
        db.create_user(chat_id, username)

    except Exception as e:
        print('Error with chat_id: {}'.format(chat_id))
        print(traceback.format_exc())
        send_message(bot, chat_id, 'There was a server error')
Пример #13
0
def create_user(bot, update):
    chat_id = update.message.chat_id

    try:
        send_message(bot, chat_id,
                     'Creating your user, wait for a confirmation message')
        db.create_user(chat_id)
        send_message(bot, chat_id, 'User successfully created!')
    except Exception as e:
        print('Error with chat_id: {}'.format(chat_id))
        print(traceback.format_exc())
        send_message(bot, chat_id,
                     'There was an error while creating your user')
Пример #14
0
def signUp():
    if request.method == "GET":
        return render_template("signIn.html")
    else:
        firstname = request.form["firstname"]
        lastname = request.form["lastname"]
        password = request.form["password"]
        email = request.form["email"]
        db.create_user(email,
                       password,
                       first_name=firstname,
                       last_name=lastname)
        return redirect(url_for("home"))
Пример #15
0
def register():
    form = forms.RegisterUserForm(request.form)
    if request.method == 'POST' and form.validate():
        if form.access_code.data == access_code and not database.get_user_details_from_username(
                form.username.data):
            salt, bcrypt_password = logins.create_password_salt(
                form.password.data)
            database.create_user(form.username.data, bcrypt_password, salt,
                                 form.first_name.data, form.surname.data,
                                 form.email.data)
            return 'New user account created! <meta http-equiv="refresh" content="3;url=/login" />'
        return "Error, unable to create user account. User may already exist or access code may be incorrect"
    return (render_template("register.html", form=form))
Пример #16
0
def signup():
    if request.method == 'POST':
        first_name = request.form['first_name']
        last_name = request.form['last_name']
        session['email'] = request.form['email']
        email = request.form['email']
        phoneNumber = request.form['phoneNumber']
        password = request.form['password']
        database.create_user(first_name, last_name, email, phoneNumber,
                             password, '0')
        return render_template("survey.html")
    else:
        return render_template("signup.html")
Пример #17
0
def post_sign_up():
    next_url = request.args['next']
    email = request.form['email']
    password = request.form['password']
    confirmation = request.form['confirmation']

    # Check if the fields were filled.
    email_valid = email is not None and email != ''
    email_feedback = 'Please enter your email address'

    password_valid = password is not None and password != ''
    password_feedback = 'Please enter your password'

    confirmation_valid = confirmation is not None and confirmation != ''
    confirmation_feedback = 'Please enter your password again'

    # Check if the fields match our simple regex.
    if email_valid:
        email_valid = re.match(r'[^@]+@[^@]+\.[^@]+', email)
        email_feedback = 'The value you’ve entered is not a valid email address'

    if password_valid:
        password_valid = len(password) >= 6
        password_feedback = 'The password you’ve entered is too short to be valid'

    if confirmation_valid:
        confirmation_valid = password == confirmation
        confirmation_feedback = 'The passwords you’ve entered don’t match'

    # Check if the user does not already exist in the DB.
    if email_valid:
        email_valid = not database.user_exists(email)
        email_feedback = 'The email you’ve entered is already in use by another account'

    if email_valid and password_valid and confirmation_valid:
        # Hash the password.
        salt = os.urandom(SALT_LENGTH)
        password_hash = scrypt.hash(password, salt)

        # Create the user and their password in the database.
        user_id = database.create_user(email)
        database.create_password(user_id, salt, password_hash)

        # Set the login cookie.
        session['user_id'] = user_id
        session['email'] = email

        return redirect(next_url)
    else:
        return render_template('sign_up.html',
                               next=next_url,
                               email=email,
                               email_valid=email_valid,
                               email_feedback=email_feedback,
                               password=password,
                               password_valid=password_valid,
                               password_feedback=password_feedback,
                               confirmation=confirmation,
                               confirmation_valid=confirmation_valid,
                               confirmation_feedback=confirmation_feedback)
Пример #18
0
def test_create_user(session):
    user = create_user(session, name="Bob", password="******")
    session.commit()

    assert user.name == "Bob", "Bob's name should not be changed"
    assert user.password != "1234", "User password should be protected by a hash!"
    assert user.id == 1, "Bob should have an id!"
Пример #19
0
def register_user(message):
    """ Handle creating a new user in the database. """

    LOGGER.debug(f"Attempting to create user from {message}")
    try:
        user_name = message["user_name"]
        email = message["email"]
        password = message["password"]
    except KeyError as error:
        raise UnauthorizedError(
            "A username, email, and password must be provided to register"
        ) from error

    user = create_user(database_session, user_name, email, password)
    database_session.commit()

    LOGGER.info(f"New user registered: {user.email} as {user.name}")

    emit(
        "registration_success",
        {
            "user_id": user.id,
            "user_name": user.name,
            "email": user.email
        },
    )
Пример #20
0
def create_user(data):
    try:
        firstname = data["name"]
        name = data["name"]
        username = data["username"]
        password = data["password"]
        confirm_password = data["confirm_password"]
    except KeyError:
        emit("Error", {
            "message": "Fields are missing in create_user",
            "show": "false"
        })
        return

    if (password != confirm_password):
        emit("Error", {"message": "Passwords do not match", "show": "true"})
        return

    password = hashlib.md5(bytes(password, 'utf-8'))
    password = password.hexdigest()
    new_user = db.create_user(username, firstname, name, password)

    if (new_user):
        emit('new_user', 'success')
        return
    else:
        emit('new_user', 'failure')
        emit(
            'Error', {
                "message": "Username already exists, try another username",
                "show": "true"
            })
        return

    emit("new_user", "success")
Пример #21
0
async def profile(ctx, user=None):
    dec = database.read("users.json")

    if user is None: u_disc = ctx.message.author
    else:
        if isinstance(user, str):
            if user.startswith("<@!") and user.endswith(">"): user = user[3:][:-1]
            try: user = int(user)
            except ValueError:
                for u, d in dec.items():
                    if d['name'] == user:
                        user = int(u)
                        break
                else:
                    await ctx.send(f":x: Aucun participant du nom de `{user}` n'a été trouvé !")
                    return
        if isinstance(user, int):
            u_disc = client.get_user(user)
            if u_disc is None:
                await ctx.send(f":x: Aucun participant avec l'id `{user}` n'a pas été trouvé !")
                return
            
    try: user = dec[str(u_disc.id)]
    except KeyError:
        username = client.get_guild(688355824934060032).get_member(u_disc.id).nick
        if username is None: username = client.get_user(u_disc.id).display_name
        user = database.create_user(dec, username, u_disc.id)
    await ctx.send(embed=show_user(u_disc, user))
Пример #22
0
 def setUp(self):
     prepare_db_for_tests()
     self.app = FlaskClient(app, response_wrapper=FormWrapper)
     self.app.application.config["CSRF_ENABLED"] = False
     self.depute = Depute(test_depute).save()
     self.user = create_user("test", "test")
     self.ctx = app.test_request_context()
     self.ctx.push()
Пример #23
0
 def setUp(self):
     prepare_db_for_tests()
     self.app = FlaskClient(app, response_wrapper=FormWrapper)
     self.app.application.config["CSRF_ENABLED"] = False
     self.depute = Depute(test_depute).save()
     self.user = create_user("test", "test")
     self.ctx = app.test_request_context()
     self.ctx.push()
Пример #24
0
def create_user(username, password, type_):
    db = current_app.config["db"]
    if db.create_user(username, password, type_):
        user_id = db.get_user(username, type_)
        user = User(user_id, username, password)
        return user
    else:
        return None
Пример #25
0
def create_account():
    """ Render register page and process register requests. """

    if request.method == "POST":
        form = request.form

        user_name = form["user_name"]
        password = form["password"]

        # Register and Login the user.
        create_user(g.session, user_name, password)
        g.session.commit()

        login(user_name, password)

        return redirect(url_for("main_page"))

    return render_template("register.html")
Пример #26
0
def login():
    username = request.form.get("username")

    # check that username is not empty
    if not username:
        return "Username is empty"

    # check that username is free
    if username in logged_in_users:
        return "Username is busy"

    db.create_user(username)
    db.check_online(username)

    # create session for new user
    session["username"] = username
    logged_in_users.append(username)

    return redirect(url_for("chat"))
Пример #27
0
def signup():
    form = request.form
    new_user = NewUser(form)
    uuid = create_user(new_user)

    if uuid is None:
        return redirect('/')

    session['uuid'] = uuid
    return redirect('/home')
Пример #28
0
def fitbit_user():
    """
        POST /user?access_token=<aaa>&user_id=<fitbit_user_id>

    """
    access_token = request.args.get('access_token', '')
    logger.debug('Creating user with token %s', access_token)
    #get lifetimfe stats https://api.fitbit.com/1/user/4KRQ6L/activities.json
    # Get users fitbit email and points balance.

    # eg: https://api.fitbit.com/1/user/4KRQ6L/activities.json


    fitbit_id = request.args.get('user_id', '')
    user = database.get_user_by_fitbit(fitbit_id)

    if user is None:
        if len(access_token) > 0:
            fitbit_api = fitbit.Fitbit('227QRF', 'aacdb90aaaa175c50e0556e1a50f35ab',access_token=access_token)
            name = fitbit_api.user_profile_get(fitbit_id)['user']['fullName']
            database.create_user(name=name, email='*****@*****.**', loyalty_program_user_id='GlobalRewards123',
                                        access_token=access_token, refresh_token='some refresh token',
                                        token_expiry='2016-10-01 12:12:12.777', fitbit_id=fitbit_id, points=20146)
        else:
            raise StandardError("no user found, or access token sent")
        user = database.get_user_by_fitbit(fitbit_id)


    if len(access_token) > 0:
        database.update_user_token(user.get('userIdentifier'), access_token)


    #points_balance = lcp_query.get_balance(user_id)
    #points_balance = 549
    userJSON = {
        'access_token': access_token,
        'userId': user.get('userIdentifier'),
        'points_balance': user.get('points'),
        'name': user.get('name'),
        'fitbitId':user.get('fitbit_id')
    }
    return Response(json.dumps(userJSON), status=httplib.CREATED, mimetype='application/json')
Пример #29
0
def register():
    username = bleach.clean(request.form['username'])
    key = uuid.uuid4().hex

    if not db.user_exists(username, key) and studip.is_valid(username):
        points = studip.get_points(username)
        rank = studip.get_rank(username)

        try:
            db.create_user(username, key, points, rank)
        except db.IntegrityError:
            return get_error('Could not create user.')

        # return jsonify({'username': username, 'key': key, 'points': points, 'rank': rank})
        return redirect(
            url_for('show_user', username=username) + '?uuid=' + str(key))
    else:
        return get_error(
            'Username not available in Stud.IP or already registered in this service.'
        )
Пример #30
0
def register(conn):
    conn.send(b'Enter username: '******'Enter password: '******'You have been successfully registered\n')
    else:
        conn.send(b'Opps error... Try again\n')
Пример #31
0
    def register(self):
        if not self.type_selected:
            tkMessageBox.showwarning("Registration Failure", "Must select if creating a " "student or teacher account.")
            return

        if (self.tpw_entry != None) and (self.tpw_entry.get() != "engineering"):
            tkMessageBox.showwarning(
                "Registration Failure", "Must enter correct password " "to create teacher account."
            )
            return
        name = self.name_entry.get()
        username = self.username_entry.get()
        password = self.password_entry.get()
        password_conf = self.confpw_entry.get()
        for x in [name, username, password, password_conf]:
            if x == "":
                tkMessageBox.showwarning("Registration Failure", "Please complete all fields.")
                return
        if password != password_conf:
            # Pop up window saying that passwords do not match
            tkMessageBox.showwarning(
                "Registration Failure",
                "The passwords you have entered do not match. "
                "Ensure that your passwords are matching and try again.",
            )
            return
        if self.type_selected == "student":
            account_type = "student"
        else:
            account_type = "teacher"
        if database.username_exists(username):
            tkMessageBox.showwarning(
                "Registration Failure",
                "The username that you have selected already exists. " "Please choose a different username.",
            )
            return
        else:
            database.create_user(name, username, account_type, hasher.create_hash(password))
            self.destroy()
            login = LoginScreen(master=self.master)
            login.pack()
Пример #32
0
def addrec():
	'''runs the SQL to make a new user, then renders a page
	   based upon whether it was successful or not'''

	if request.method == 'POST':
		try:
			conn = mysql.connect()
			nm = request.form['nm']
			unm = request.form['unm']
			pswd = request.form['pswd']
			dob = request.form['dob']
			email = request.form['email']
			salt = generate_salt()
			password = bcrypt.generate_password_hash(pswd + salt).decode('utf-8')
			database.create_user(conn, unm, nm, dob, password, email, salt)
			msg = "	success!"
		except pymysql.err.IntegrityError:
			msg = "Sorry that username is already taken! Please try again."
		finally:
			conn.close()
			return render_template("result.html",msg=msg, links=check_for_cookie()[0])
Пример #33
0
def access_db():
    """Renders 'user.html' page and checks for passed username inside the database.
    Gets user's data tuple only when flash messages are not displayed."""
    form = LoginForm()
    global session_user
    if form.validate_on_submit():
        if not signing_up:  # As signing in...
            if database.check_user(form.username.data) is not None:
                flash('Username taken!')
                return redirect(url_for('access_db'))
            else:
                database.create_user(form.username.data, form.userkey.data)
                session_user = database.check_user(form.username.data)
                return redirect(url_for('user_choice'))
        else:
            if database.check_user(form.username.data) is None:
                flash('Cannot find username in database!')
            else:
                session_user = database.check_user(form.username.data)
                return redirect(url_for('user_choice'))
    return render_template('user.html', form=form)
Пример #34
0
def create_user(conn):
    conn.send(b'Enter username: '******'Enter password: '******'0. newbie\n1. soldier\n2. sergeant\n3. ensign\n4. lieutenant\n5. captain\n6. major\n7. colonel\n8. brigadier\n9. general\n10. marshal\nChoose rank: ')
    rank = int(get_input(conn))

    success = database.create_user(username, password, rank)
    if success == True:
        conn.send(b'User successfully created\n')
    else:
        conn.send(b'Opps error... Try again\n')
Пример #35
0
def user_sign_up():
  if request.method=="GET":
    return render_template('signup.html', incorrect=False, user=True, action_name="usersignup")
  elif request.method=="POST":
    username = request.form["username"]
    password = request.form["password"]
    confirm_pass = request.form["confirm"]
    first_name = request.form["first_name"]
    last_name = request.form["last_name"]
    if password != confirm_pass or not database.create_user(first_name, last_name, username, password):
      return render_template('signup.html', incorrect=True, user=True, action_name="usersignup")
    else:
      session["user"] = username
      return redirect(url_for("user_dashboard"))
Пример #36
0
def create_user():
    """Creates a new user."""
    if 'username' in session:
        return jsonify(ok=0, msg='First logout before creating a new user')
    user = request.form['user']
    passw = request.form['pass']
    if database.user_exists(user):
        return jsonify(ok=0, msg='User already exists')

    if database.create_user(user, passw):
        session['username'] = user
        session['userid'] = database.get_userid(user)
        session['password'] = passw
        return jsonify(ok=1, msg='User created!')
    return jsonify(ok=0, msg='User could not be created')
Пример #37
0
def register():
    form = RegisterForm()
    if form.validate_on_submit():
        if User.collection.find_one({"username": form.username.data}):
            form.username.errors.append(u"Ce pseudonyme est déjà pris.")
            return render_template("register.haml", form=form)

        if form.password.data != form.confirm_password.data:
            form.confirm_password.errors.append(u"Les mots de passe ne correspondent pas.")
            return render_template("register.haml", form=form)

        user = create_user(form.username.data, form.password.data)
        login_user(user)
        flash(u"Votre compte a correctement été créé.", "success")
        return redirect(url_for("home"))
    return render_template("register.haml", form=form)
Пример #38
0
 def authenticate_client(self):
    request = conn.recv(1024)
    request = json.loads(request.decode("utf-8"))
    if request["action"] == "CREATE":
       print("Creating User")
       if request["username"] in database.users:
          response = {"action":"RESP", "good":"False", "reqnum":request["reqnum"], "message":"User already exists"}
          conn.send(json.dumps(response).encode("utf-8"))
          return False
       if len(request["username"]) == 0:
          response = {"action":"RESP", "good":"False", "reqnum":request["reqnum"], "message":"username cannot be empty"}
          conn.send(json.dumps(response).encode("utf-8"))
          return False
       if len(request["password"]) == 0:
          response = {"action":"RESP", "good":"False", "reqnum":request["reqnum"], "message":"password cannot be empty"}
          conn.send(json.dumps(response).encode("utf-8"))
          return False
       if len(request["email"]) == 0:
          response = {"action":"RESP", "good":"False", "reqnum":request["reqnum"], "message":"email cannot be empty"}
          conn.send(json.dumps(response).encode("utf-8"))
          return False
       if database.create_user(request):
          self.username=request["username"]
          response = {"action":"RESP", "good":"True", "reqnum":request["reqnum"]}
          conn.send(json.dumps(response).encode("utf-8"))
          return True
    if not request["action"] == "AUTH":
       response = {"action":"RESP", "good":"False", "reqnum":request["reqnum"]}
       conn.send(json.dumps(response).encode("utf-8"))
       return False
    if not database.authenticate(request["username"], request["password"]):
       response = {"action":"RESP", "good":"False", "reqnum":request["reqnum"]}
       conn.send(json.dumps(response).encode("utf-8"))
       return False
    self.username = request["username"]
    response = {"action":"RESP", "good":"True", "reqnum":request["reqnum"]}
    conn.send(json.dumps(response).encode("utf-8"))
    return True
Пример #39
0
 def test_create_user(self):
     self.assertTrue(isinstance(create_user("foo", "bar"), User))
Пример #40
0
 def test_create_user_save(self):
     create_user("foo", "bar")
     self.assertEqual(User.collection.find().count(), 1)
Пример #41
0
 def test_user_as_login(self):
     user = create_user(username="******", password="******")
     self.assertEqual(user.username, "foo")
Пример #42
0
 def test_dont_store_password_in_clear(self):
     user = create_user(username="******", password="******")
     self.assertNotEqual(user.password, "bar")
Пример #43
0
 def test_password_is_correct(self):
     user = create_user(username="******", password="******")
     self.assertTrue(user.test_password("bar"))
Пример #44
0
 def test_password_is_not_correct(self):
     user = create_user(username="******", password="******")
     self.assertFalse(user.test_password("bad password"))
Пример #45
0
 def test_duplicated_users(self):
     create_user(username="******", password="******")
     self.assertRaises(DuplicatedUser, create_user, username="******", password="******")
Пример #46
0
 def setUp(self):
     prepare_db_for_tests()
     self.user = create_user("pouet", "pouet")
     self.depute = Depute(test_depute).save()
Пример #47
0
def weixin():
    # parse xml to dict obj
    xml = eT.fromstring(request.data)
    msg = dict()
    for ele in list(xml):
        msg[ele.tag] = ele.text

    # subscribe or unsubscribe
    if 'Event' in msg.keys():
        return weixin_response(
            from_user_name=msg['ToUserName'],
            to_user_name=msg['FromUserName'],
            content=WELCOME_TEXT
        )

    # normal command
    ask = msg['Content']
    if ask == 'user':
        # prompt user to set their sno and password
        return weixin_response(
            from_user_name=msg['ToUserName'],
            to_user_name=msg['FromUserName'],
            content=LOGIN_TEXT
        )
    elif ask == 'login':
        # prompt user to login
        check = check_user_status(msg)
        if check['status'] != 'success':
            return check['response']
        else:
            jwxt = check['instance']
            db.set_session_id(msg['FromUserName'], jwxt.cookies['JSESSIONID'])
            return weixin_response(
                from_user_name=msg['ToUserName'],
                to_user_name=msg['FromUserName'],
                content=u'已尝试登陆'
            )
    elif re.match(r'^\d+#.+$', ask):
        # set sno and password
        sno, password = ask[:ask.find('#')], ask[ask.find('#') + 1:]
        user_info = db.get_user_info(msg['FromUserName'])

        if user_info:
            db.update_user(msg['FromUserName'], sno, password)
        else:
            db.create_user(msg['FromUserName'], sno, password)

        return weixin_response(
            from_user_name=msg['ToUserName'],
            to_user_name=msg['FromUserName'],
            content=u'创建成功' if not user_info else u'修改成功'
        )
    elif ask in [str(i) for i in range(10)]:
        # query course from day 0-7, 0 stand for all, 1-7 stand for Monday to Sunday
        check = check_user_session(msg)
        if check['status'] != 'success':
            return check['response']
        else:
            jwxt = check['instance']

        try:
            # get today or tomorrow course (ask = 8, ask = 9)
            if ask == '8':
                ask = str(date.today().weekday() + 1)
            elif ask == '9':
                ask = str(date.today().weekday() + 2)

            course_list = jwxt.get_course_list(CURRENT_XND, CURRENT_XQ)
            course_list.sort(key=lambda x: int(x['day']) * 100 + int(x['start_time']))
            output_list = []
            for course in [course for course in course_list if ask == '0' or course['day'] == int(ask)]:
                course['start_time'] = COURSE_START_TIME[int(course['start_time']) - 1]
                course['end_time'] = COURSE_END_TIME[int(course['end_time']) - 1]
                course['date'] = WEEK_TIME[int(course['day']) - 1]

                output = u'{course_name}\n{date} {start_time}-{end_time}\n{location}{duration}'.format(**course)
                output_list.append(output)

            if not output_list:
                output_list.append(u'此期间没有课程')

            return weixin_response(
                from_user_name=msg['ToUserName'],
                to_user_name=msg['FromUserName'],
                content=('\n' + '-' * 20 + '\n').join(output_list)
            )
        except:
            return weixin_response(
                from_user_name=msg['ToUserName'],
                to_user_name=msg['FromUserName'],
                content=u'会话过期, 请重新输入 login 命令登陆'
            )

    elif re.match(r'^(cj#)(\d+#\d+)$', ask):
        # query score by xnd(year-year+1) and xq[0(all), 1, 2, 3]
        check = check_user_session(msg)
        if check['status'] != 'success':
            return check['response']
        else:
            jwxt = check['instance']

        try:
            tmp = ask.split('#')
            xnd, xq = u'{}-{}'.format(int(tmp[1]), int(tmp[1]) + 1), tmp[2]
            if xq in ['0', '1', '2', '3']:
                if xq == '0':
                    score_list = reduce(lambda x, y: x + y, [jwxt.get_score_list(xnd, str(i)) for i in range(1, 4)])
                else:
                    score_list = jwxt.get_score_list(xnd, xq)

                output_list = []
                for score in score_list:
                    if len(score.get('jxbpm', '')) > 1:
                        output = u'{kcmc}\n成绩: {zpcj}\n排名: {jxbpm}'.format(**score)
                    else:
                        output = u'{kcmc}\n成绩: {zpcj}'.format(**score)
                    output_list.append(output)

                if not output_list:
                    output_list.append(u'此期间没有成绩')

                return weixin_response(
                    from_user_name=msg['ToUserName'],
                    to_user_name=msg['FromUserName'],
                    content=('\n' + '-' * 20 + '\n').join(output_list)
                )
            else:
                return weixin_response(
                    from_user_name=msg['ToUserName'],
                    to_user_name=msg['FromUserName'],
                    content=u'请输入正确的查询格式'
                )
        except:
            return weixin_response(
                from_user_name=msg['ToUserName'],
                to_user_name=msg['FromUserName'],
                content=u'会话过期, 请重新输入 login 命令登陆'
            )
    elif re.match(r'^gpa(#\d+#\d+)?$', ask):
        # query gpa by xnd(year-year+1) and xq[0(all), 1, 2, 3] or all gpa
        check = check_user_session(msg)
        if check['status'] != 'success':
            return check['response']
        else:
            jwxt = check['instance']

        try:
            output_list = []
            tmp = ask.split('#')
            if len(tmp) == 1:
                gpa_list = jwxt.get_all_gpa()
            else:
                xnd, xq = '{}-{}'.format(int(tmp[1]), int(tmp[1]) + 1), tmp[2]
                if xq not in ['1', '2', '3']:
                    return weixin_response(
                        from_user_name=msg['ToUserName'],
                        to_user_name=msg['FromUserName'],
                        content=u'请输入正确的查询格式'
                    )
                gpa_list = jwxt.get_gpa(xnd, xq)

            for gpa in gpa_list:
                output = u'{oneColumn}: {twoColumn}'.format(**gpa)
                output_list.append(output)

            if not output_list:
                output_list.append(u'此期间没有绩点')

            return weixin_response(
                from_user_name=msg['ToUserName'],
                to_user_name=msg['FromUserName'],
                content='\n'.join(output_list)
            )
        except:
            return weixin_response(
                from_user_name=msg['ToUserName'],
                to_user_name=msg['FromUserName'],
                content=u'会话过期, 请重新输入 login 命令登陆'
            )
    elif ask == 'credit':
        check = check_user_session(msg)
        if check['status'] != 'success':
            return check['response']
        else:
            jwxt = check['instance']
            count = 3
            while not jwxt.tno and count >= 0:
                count -= 1
                jwxt.get_info()

        try:
            output_list = [u'已获得的学分:']
            for credit in jwxt.get_credit():
                output = u'{oneColumn}: {twoColumn}'.format(**credit)
                output_list.append(output)

            output_list.append(u'-' * 20)
            output_list.append(u'毕业所需学分:')
            for credit in jwxt.get_total_credit():
                output = u'{oneColumn}: {twoColumn}'.format(**credit)
                output_list.append(output)

            return weixin_response(
                from_user_name=msg['ToUserName'],
                to_user_name=msg['FromUserName'],
                content='\n'.join(output_list)
            )
        except:
            return weixin_response(
                from_user_name=msg['ToUserName'],
                to_user_name=msg['FromUserName'],
                content=u'会话过期, 请重新输入 login 命令登陆'
            )
    else:
        # prompt user help information
        return weixin_response(
            from_user_name=msg['ToUserName'],
            to_user_name=msg['FromUserName'],
            content=HELP_TEXT
        )