def main(): app = Application() app.master.title('Portal') app.database.add_role('admin', ['add_remove_user', 'add_remove_role']) ryan = db.User('ryan', '1234', ['admin']) kunle = db.User('kunle', '12345', ['admin']) app.database.add_user(kunle) app.database.add_user(ryan) app.mainloop()
def setUp(self): self.s=db.create_sessionmaker('sqlite://')() u=db.User(name='test',password='******') # password is 'pass' self.s.add(u) u=db.User(name='test_1',password='******') # password is 'pass' self.s.add(u) u=db.User(name='test_2',password='******') # password is 'pass' self.s.add(u) u=db.User(name='admin',password='******') # password is 'pass' self.s.add(u) self.s.commit()
def post(self): # Get information from the signup forms. first_name = self.request.get('firstname') last_name = self.request.get('lastname') email = self.request.get('email') password = self.request.get('password') address = self.request.get('address') gender = self.request.get('gender') birthday = self.request.get('birthday') interests = self.request.get('interests') # Use mail API to check if the email is valid. if not mail.is_email_valid(email): error = "The provided email is not valid." self.render("signup.html", error=error) # Check if the email is in user database. user = database.User.all().filter('email =', email).get() if user: error = "You have already signed up. Please go to login page." self.render("signup.html", error=error) # Store new user in the database and send email to the user. else: self.send_signup(email, first_name) database.User(first_name=first_name, last_name=last_name, email=email, password=hash_str(password.strip()), address=address, gender=gender, birthday=birthday, interests=interests, offensive_score=0, no_of_quotes=0).put() self.redirect('/login')
def register(): register_form = forms.RegisterForm(request.form) title = 'REGISTER' if request.method == 'POST' and register_form.validate(): email = register_form.email.data passw = register_form.password.data #comprobar que no este en la base de datos user = database.User.query.filter_by(email=email).first() if user is None: user = database.User(email = email, password = passw) database.db.session.add(user) database.db.session.commit() msg = Message('Gracias por tu registro!', sender = app.config['MAIL_USERNAME'], recipients=[user.email]) msg.html = render_template('email.html') #mail.send(msg) success_message = 'Usuario registrado' category = "alert alert-success alert-dismissible" flash(success_message, category) return redirect( url_for('index') ) else: error_message = 'Ya existe este usuario' category = "alert alert-danger alert-dismissible" flash(error_message, category) return render_template('register.html', title=title, form=register_form)
def register_user_enters(bot, update): """ One or more users enter the group, the bot should register the change. """ success, (chat, user, chat_member) = register_update(bot, update) if not success: return me = bot.get_me() for new_user in update.effective_message.new_chat_members: if new_user == me: # TODO Set chat active continue chat_member = db.ChatMember(new_user, update.effective_chat) new_user = db.User(new_user) if not new_user.exists(): new_user.commit() if not chat_member.exists(): chat_member.commit() else: # TODO Set chat member active pass
def api_v1_user_register(): f_data = f.request.form username = f_data.get("username") password = f_data.get("password") if username is None or password is None: return f.jsonify({ "result": "error", "reason": "Missing username or password." }) user = d.session.query( database.User).filter_by(username=username).one_or_none() if user is not None: return f.jsonify({ "result": "error", "reason": "Username already in use." }) salt = bcrypt.gensalt() bcrypted_password = bcrypt.hashpw(bytes(password, encoding="utf8"), salt) new_user = database.User(username=username, password=bcrypted_password, admin=False) d.session.add(new_user) d.session.commit() return f.jsonify({ "result": "success", "description": "New user created.", "user": new_user.json() })
def register_user_leaves(bot, update): """ A user left the chat, the bot should register the change. """ success, (chat, user, chat_member) = register_update(bot, update) if not success: return left_user = update.effective_message.left_chat_member if left_user == bot.get_me(): # TODO Set chat inactive return chat_member = db.ChatMember(left_user, update.effective_chat, is_active=False) left_user = db.User(left_user) if not left_user.exists(): left_user.commit() if not chat_member.exists(): chat_member.commit() else: # TODO Set chat member inactive pass
def register(): form = forms.RegistrationForm() if request.method == 'POST' and form.validate(): existing_user = db.User.objects(username=form.username.data).first() if existing_user is None: # Create the new user, stored with hashed passwords hashpass = generate_password_hash(form.password.data, method='sha256') newUser = db.User(addedby='self', username=form.username.data, firstname=form.firstname.data, lastname=form.lastname.data, email=form.email.data, passwordhash=hashpass, roleassignments=[]) newUser.save() newUser.update(addedby=newUser) # If it's the first user, assign them to the admin role if (len(db.User.objects()) == 1): newRole = db.RoleAssignment(role='admin', user=newUser, addedby=newUser, addeddate=datetime.utcnow(), iscurrent=True) newRole.save() newUser.update(push__roleassignments=newRole) return redirect('/login') else: form.username.errors.append('User already exists') return render_template('register.html', form=form)
def register(): register_form = forms.RegisterForm(request.form) title = 'REGISTER' tituloPag = 'Registro' if request.method == 'POST' and register_form.validate(): email = register_form.email.data passw = register_form.password.data #comprobar que no este en la base de datos user = database.User.query.filter_by(email=email).first() if user is None: user = database.User(email=email, password=passw) database.db.session.add(user) database.db.session.commit() success_message = 'Usuario {} registrado'.format(email) category = "alert alert-success alert-dismissible" flash(success_message, category) session['email'] = email return redirect(url_for('index')) else: error_message = 'Ya existe este usuario' category = "alert alert-danger alert-dismissible" flash(error_message, category) return render_template('register.html', title=title, form=register_form, tituloPag=tituloPag)
def user_to_db(user_id, chat_id, username=None, first_name=None, last_name=None): session = db.Session() entry = db.User(user_id=user_id, username=username, first_name=first_name, last_name=last_name) entry.chats.append(db.Chat(chat_id=chat_id)) session.merge(entry) session.commit()
def approve_request(bot, update): query = update.callback_query telegram_id = query.message.chat_id session = database.RegistrySession[telegram_id] request = list(database.Request.select(lambda c: c.status == 0))[session.request_c] database.Actions(implementer=str(telegram_id), action="approved registry request for", implementee=str(request.telegramID)) enrolled_user = database.User(telegramID=request.telegramID, phone=request.phone, address=request.address, priority=request.faculty, alias=request.alias, name=request.name) database.Request[request.id].status = 1 session.request_c = 0 # Editing message bot.edit_message_text(text="Request has been successfully approved (Telegram ID: " + str(request.telegramID) + ")", chat_id=query.message.chat_id, message_id=query.message.message_id) bot.send_message(text="Your request has been approved!", chat_id=int(enrolled_user.telegramID)) request.delete() database.RegistrySession[telegram_id].request_c = 0 commit()
def login(): if request.method == 'POST': username = request.form.get('username', None) password = request.form.get('password', None) redirect_url = request.form.get('redirect_url', '') if redirect_url is '': redirect_url = url_for('index') user = database.User(username=username) try: dbuser = database.User.query.filter_by(username=user.username).one() except: dbuser = None if dbuser is not None: # check password user.set_password(password, dbuser.salt) if dbuser is None or user.password != dbuser.password: flash(u'Niepoprawna nazwa użytkownika lub hasło', 'error') else: session['user_id'] = dbuser.id flash(u'Zalogowano użytkownika', 'success') return redirect(redirect_url) redirect_url = request.args.get('redirect_url', '') return render_template('login.html', redirect_url=redirect_url)
def decorator(update: Update, context: CallbackContext): session = db.Session() tg_user: User = update.effective_user if not session.query(db.User).filter(db.User.id == tg_user.id).first(): session.add(db.User(id=tg_user.id, is_admin=False)) session.commit() session.close() func(update, context)
def create_database_user(discord_user: discord.User) -> database.User: if (database.session.query( database.User).filter_by(discord_id=discord_user.id).first() is not None): raise RuntimeError(f"User #{discord_user.id} already exists") user = database.User(discord_id=discord_user.id, username=get_full_username(discord_user)) database.add_to_database(user) return user
def register2(): email = request.form.get('email') username = request.form.get('username') password = request.form.get('password') re_password = request.form.get('password2') if password == re_password: user = database.User(email=email, username=username, password=password) database.add_info(user) return 'content' else: pass return 'fail'
async def generate_user(self, session=None): name = self.name local_session = False if session is None: local_session = True session = database.Session() user = session.query(database.User).filter_by(name=name).first() if not user: user = database.User(name=name) session.add(user) session.commit() if local_session: session.close() return user
def reg(): if flask.request.method == "GET": return flask.render_template("reg.html") elif flask.request.method == "POST": data = flask.request.form print(data) new_user = database.User(data['login'] , data['pass']) result = db.registration(new_user) print("123") if result[0]: return 'все ок' else: return result[1]
def signup(username=Form(...), email=Form(...), password=Form(...), db: database.Session = Depends(database.get_db)): if db.query(database.User).filter_by(username=username).first(): raise HTTPException(status_code=status.HTTP_302_FOUND, detail='Username taken') elif db.query(database.User).filter_by(email=email).first(): raise HTTPException(status_code=status.HTTP_302_FOUND, detail='Email address already in use') elif len(username) <= 3: raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail='Username must be longer than 3 characters') elif len(username) >= 25: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail='Username is too long. Maximum length: 25 characters') elif len(password) < 7: raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail='Password must be 8 characters or more') elif len(password) >= 40: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail='Password is too long. Maximum length: 40 characters') elif PasswordStats(password).strength() <= float(0.350): raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail= 'Password is not strong enough. Try adding some symbols or numbers your password' ) elif len(email) >= 75: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail='Email is too long. Must be less than 75 characters') try: valid = validate_email(email) email = valid.email except EmailNotValidError as e: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail='Email address not supported. Please use another email.') else: pwd_hash = Hash.get_password_hash(str(password)) db_user = database.User(username=username, email=email, password=pwd_hash) db.add(db_user) db.commit() db.refresh(db_user) return models.User(username=username, email=email, password=password)
def register(user_name: str, user_fullname: str, user_password: str): hash_pass = hash_password(user_password, user_name) new_user = database.User(name=user_name, fullname=user_fullname, password=hash_pass) session = database.Session() try: session.add(new_user) session.commit() logger.info(f"User registered : {new_user}") except: logger.info(f"User not registered because of an error: {new_user}") return False return True
def cmd_adduser(self, nick, args, admin): """Felhasználó hozzáadása. Használat: !adduser user""" if admin: if args: database.session.add(database.User(name=args.split()[0])) try: database.session.commit() except sqlalchemy.exc.IntegrityError: return 'Már létezik felhasználó ilyen névvel.' else: return args.split()[0] + ' hozzáadva!' else: return cmd_help(nick, 'adduser', admin) else: return autherror
def update_db_entry(self, auth, name, pub, bio, check, privacy, pin=None, password=None): dbc = self.settings["local_store"] with dbc.lock: session, owner_of_cid = dbc.get_by_id_ig(pub) if owner_of_cid and owner_of_cid.name != name: session.close() self.set_status(400) self.json_payload(error_codes.ERROR_DUPE_ID) return 0 session, mus = dbc.get_ig(name, session) if not mus: mus = database.User() elif mus.public_key != auth: session.close() self.set_status(400) self.json_payload(error_codes.ERROR_NAME_TAKEN) return 0 mus.name = name mus.public_key = pub mus.checksum = check mus.privacy = privacy mus.timestamp = datetime.datetime.now() mus.sig = self.settings["crypto_core"].sign(mus) mus.bio = bio mus.pin = pin if password: mus.password = password ok = dbc.update_atomic(mus, session) if not ok: session.close() self.set_status(400) self.json_payload(error_codes.ERROR_DUPE_ID) return 0 if hooks: hooks.did_update_record(self.settings["hooks_state"], database.StaleUser(mus)) session.close() return 1
def saveToDatabase(rawData): userid = rawData.get('player')['userid'] logg(f' [{userid}] saving data to database...') # save to table users user = database.User.query.get(userid) if user == None: database.db.session.add( database.User(userid=userid, username=rawData.get('player')['username'], cost=rawData.get('cost'), old_cost=rawData.get('old_cost'), player=rawData.get('player'), pp=rawData.get('pp'), time=rawData.get('time'))) else: user.name = rawData.get('player')['username'], user.cost = rawData.get('cost'), user.player = rawData.get('player'), user.pp = rawData.get('pp'), user.time = rawData.get('time') # save to table tables table = database.Table.query.get(userid) if table == None: database.db.session.add( database.Table(userid=userid, table=rawData.get('table'), time=rawData.get('time'))) else: table.userid = userid table.table = rawData.get('table'), table.time = rawData.get('time') # add the record database.db.session.add( database.Record(userid=userid, username=rawData.get('player')['username'], cost=rawData.get('cost'), old_cost=rawData.get('old_cost'), player=rawData.get('player'), pp=rawData.get('pp'), time=rawData.get('time'))) database.db.session.commit() logg(f' [{userid}] complete!')
def signup(): if get_current_user() is not None: return redirect(url_for('home_page')) if request.method == 'GET': return render_template('signup.html') elif request.method == 'POST': name = request.form['name'] username = request.form['username'] email = request.form['email'] password = request.form['password'] # Create new user new_user = database.User(name=name, username=username, email=email, password=password) new_user = database.save_object(new_user) # Return to homepage return make_login_response(redirect(url_for('home_page')), new_user.id)
def create_user(): c = request.get_json(silent=True) newuser = json.loads(request.form["values"]) if newuser["id"] not in database.cacheusers: user = database.User(id=newuser['id'], username=newuser['username'], password=newuser['password'], fullname=newuser['fullname']) database.session.add(user) database.session.commit() for i in newuser: database.cachemessages[newuser["id"]] = [ newuser['username'], newuser['password'], newuser['fullname'] ] return 'User created' return "The id is already in use"
def login(): if flask.request.method == "GET": # считываем куки q = flask.request.cookies.get('sid') res = flask.make_response(flask.render_template("login.html")) return res elif flask.request.method == "POST": data = flask.request.form auth_user = database.User(data['login'], data['pass']) result = db.auth(auth_user) if result[0]: response = flask.make_response(flask.redirect(f"/profile/{data['login']}")) response.set_cookie('sid', result[1]) return response else: return result[1]
def login(): username = flask.request.args.get('username', None) if username == 'garfield': user = flask.g.session.query( database.User).filter(database.User.name == username).first() if not user: user = database.User(name=username) flask.g.session.add(user) flask.g.session.commit() flask.ext.login.login_user(user) flask.flash('Logged in successfully.') return flask.redirect('/gallery') return flask.render_template('login.html')
def get_user(session, username): """Get a user from the database.""" user = session.query(database.User) \ .filter_by(username=username) \ .first() if user is None: user = database.User( username=username, lastactivity=datetime.datetime.now(), trust=False, ) session.add(user) else: user.lastactivity = datetime.datetime.now() session.flush() session.commit() return user
def create_user(): """ Handles creating a user with an rfid and a name associated with it. The rfid is the id of the chip of the user and the name of the user is included. Creation of a user is done via a get request that contains the unique rfid, first, and last names of the user. The rfid needs to match the rfid of the chip that would represent the user. rfid (str): A string representation of the rfid name (str): The name of the user """ # Get the data for the user rfid = request.args.get('rfid') first_name = request.args.get('first_name') last_name = request.args.get('last_name') # Create a new user and save the user to the database user = database.User(rfid=rfid, first_name=first_name, last_name=last_name) user.save() return Response(status=200)
async def register(self): try: db.User( **{ 'user_id': self._id, 'chat_id': self._chat_id, 'name': self._name, 'verified': False }).save() await bot.send_message( self._chat_id, f'{self._name}, Добро пожаловать!🤘\n' f'Напиши @DOMINOkaty чтобы продолжить работу с ботом') await self._state.set_state('wait_for_verified') except NotUniqueError: user_messages_to_delete[self._id] = [ (await bot.send_message(self._chat_id, 'Это имя уже занято😥\n Попробуй другое')) ]
def register(self, user_id, chat_id, name): database.User(**{ 'user_id': user_id, 'chat_id': chat_id, 'name': name }).save() try: if database.User.objects(user_id=user_id).first(): # Добавить логи в таком формате [Line | Status | Time | ALL DATA] pass elif not database.User.objects(user_id=user_id).first(): # Добавить логи в таком формате [Status | Time | ALL DATA] pass else: # Добавить логи в таком формате [Line | Status | Time | ALL DATA] pass except Exception: # Добавить логи в таком формате [Line | Exception | Time | ALL DATA] pass