def get_file(self, ref=False): list_git_files = self.get_posts_json(ref) if not list_git_files: list_git_files = False if ref: get_file('static/%s_%s_branch.txt' % (self.git_name.lower(), self.git_repository_blog.lower()), list_git_files) elif not ref: get_file('static/%s_%s.txt' % (self.git_name.lower(), self.git_repository_blog.lower()), list_git_files) return False if ref: get_file('static/%s_%s_branch.txt' % (self.git_name.lower(), self.git_repository_blog.lower()), list_git_files) elif not ref: get_file('static/%s_%s.txt' % (self.git_name.lower(), self.git_repository_blog.lower()), list_git_files) user_s = Users(self.git_name, self.git_repository_blog) session_git = user_s.open_base() users = session_git.query(Users) new_user = True for user in users: if user.user_name == self.git_name.lower() and user.user_repo_name == self.git_repository_blog.lower(): session_git.close() new_user = False if new_user: new_user = Users(user_name=self.git_name.lower(), user_repo_name=self.git_repository_blog.lower()) session_git.add(new_user) session_git.commit() session_git.close() posts = sorted(list_git_files, key=lambda d: d['date'], reverse=True) if not posts[0]['date']: return [{'date': False}] return posts
def help_take_data_git(git_access, git_name, git_repository_blog): create_repo = git_access.create_repo(git_repository_blog) if create_repo.status_code == 201: git_access.get_file() users_list = Users(git_name, git_repository_blog) users_list.new_user() return jsonify({'message': 'new repo created'}) elif create_repo.status_code == 422: users_list = Users(git_name, git_repository_blog) users_list.new_user() return jsonify({'message': 'repo is empty'}) else: return abort(404)
def newTeam(): if request.method == 'POST': teamName = request.form['teamName'] password = request.form['password'] teamDescription = request.form['description'] if 'file' not in request.files: #ADD CHANGES TO DATABASES user = Users(username=teamName, password=password, userType='team') team = Teams(teamName=teamName, teamDescription=teamDescription, totalPoints=0) db.session.add(user) db.session.add(team) db.session.commit() else: image_file = request.files['file'] # if image filename is empty string if image_file.filename == '': #ADD CHANGES TO DATABASES user = Users(username=teamName, password=password, userType='team') team = Teams(teamName=teamName, teamDescription=teamDescription, totalPoints=0) db.session.add(user) db.session.add(team) db.session.commit() # if image is allowed elif image_file and allowed_file(image_file.filename, ALLOWED_EXTENSIONS): filename = secure_filename(image_file.filename) image_file.save( os.path.join(app.config['UPLOAD_FOLDER'], filename)) user = Users(username=teamName, password=password, userType='team') team = Teams(teamName=teamName, teamDescription=teamDescription, teamPhoto=str(filename), totalPoints=0) db.session.add(user) db.session.add(team) db.session.commit() return render_template('teamForm.html')
def create(cls, session: Session, user: UserBaseCreate) -> Users: db_user = Users(**user.dict()) db_user.password = Security.get_pwd_hash(user.password) session.add(db_user) session.commit() session.refresh(db_user) return db_user
def get_all_users(): # Open a connection to the database with sqlite3.connect("rare.db") as conn: # Just use these. It's a Black Box. conn.row_factory = sqlite3.Row db_cursor = conn.cursor() # Write the SQL query to get the information you want db_cursor.execute(""" SELECT u.id, u.email, u.name, u.password FROM users u """) # Initialize an empty list to hold all user representations users = [] # Convert rows of data into a Python list dataset = db_cursor.fetchall() # Iterate list of data returned from database for row in dataset: user = Users(row['id'], row['email'], row['name'], row['password']) users.append(user.__dict__) # Use `json` package to properly serialize list as JSON return json.dumps(users)
def check_if_valid(post_body): # {'password': '******', 'email': '*****@*****.**'} password = post_body['password'] email = post_body['email'] with sqlite3.connect("rare.db") as conn: # Just use these. It's a Black Box. conn.row_factory = sqlite3.Row db_cursor = conn.cursor() # Write the SQL query to get the information you want db_cursor.execute(""" SELECT u.id, u.email, u.name, u.password FROM users u WHERE u.email = ? AND u.password = ? """, (email, password, )) # Initialize an empty list to hold all user representations # Convert rows of data into a Python list data = db_cursor.fetchone() user = Users(data['id'], data['email'], data['name'], data['password']) # Iterate list of data returned from database response_object = {'valid': True, 'id': user.id} return json.dumps(response_object)
def user_login(): try: user_data = request.get_json() username = user_data['username'] password = user_data['password'] except Exception as error: return jsonify({ "Error": "Invalid User Input", "message": "missing either username or password", "status": 400 }), 400 user = Users(['', username, password, '']) found_user = user.query_login() if found_user is not None: print(password) print(found_user.password) if found_user.password == password: token = found_user.generate_auth_token() return jsonify({ 'user': username, 'token': token['sub'], 'message': 'login was successful' }), 200 else: return jsonify({'Error': 'Incorrect Password'}), 403 return jsonify({'Error': 'Username not found'}), 403
def user_register(): try: user_data = request.get_json() name = user_data['name'] username = user_data['username'] password = hash_password(user_data['password']) email = user_data['email'] except Exception as error: return make_response( jsonify({ "error": "invalid user data input", "message": "missing either name, username, email or password", "status": 400 }), 400) new_user = Users([name, username, password, email]) if not new_user.is_existing_user(): new_user.create_new_user() return make_response( jsonify({ "status": 201, "message": "user created successfully" }), 201) return make_response( jsonify({ "status": 403, "message": "username already exists" }), 403)
def register(): """ User register view. :return: HTTP Response """ if request.method == 'GET': return render_template('register-page.html') else: required_inputs = [ 'username', 'email', 'password1', 'password2', 'terms_and_conditions' ] form_inputs = ['bio', 'country', 'city', 'school'] for inp in required_inputs: if inp not in request.form: return redirect(url_for('core.home')) if is_mail(request.form['email']) is None or \ request.form['password1'] != request.form['password2'] or \ not password_validation(request.form['password1']): return redirect(url_for('core.home')) user = Users(username=request.form['username'], email=request.form['email']) for inp in form_inputs: if inp in request.form: user.__setattr__(inp, request.form[inp]) user.save() user.set_password(request.form['password1']) login_user(user) return redirect(url_for('core.home'))
def connect_with_user(): '''Make a connection with a 'normal' user''' error = None current_user_id = session.get('logged_in_user') if request.method == 'POST': # fetch values and check they are actually provided if 'key' in request.form: key_value = request.form['key'] useri = Users(current_user_id) key_user_id = useri.validate_key(key_value) # valid key if key_user_id: # cannot connect to ourselves and make a connection that has already been made ;) if not key_user_id == current_user_id and not useri.is_connection(user_id=key_user_id): # create connections from us to them and back useri.add_connection(key_user_id) flash('Connection made') else: error = 'I can haz myself impossible' else: error = 'Invalid key' else: error = 'You need to provide a key' return render_template('admin_connect_with_user.html', **locals())
def schedule(): data = request.get_json() token = data.get("token") user_info = Users.authenticate(token) user = Users(user_info[0][1], user_info[0][2], user_info[0][4], twitch_id=user_info[0][3]) # get schedule info from react the "data" coming in will need to have a lot of info # i.e. date, a time slots array, a performers array, user_id will come from the auth here in the route, # and the unique sked_id generated here: sk_id = sked_id_gen() # print(sk_id) time_slots = data.get("timeSlots") # print(time_slots) performers = data.get("performers") # print(performers) print(user_info[0][3], data.get("date"), time_slots[0], performers[0]) for i in range(len(time_slots)): sked = Schedule(user_info[0][3], data.get("date"), time_slots[i], performers[i], sked_id=sk_id) sked._insert() return jsonify({"create": "successful", "sk_id": sk_id})
def logout(): data = request.get_json() token = data.get("token") user_info = Users.authenticate(token) user = Users(user_info[0][1], user_info[0][2], user_info[0][4]) user.logout() return jsonify({"logout": "successful"})
def create_user(self): username = input("Please enter a username: "******"Enter your password: ") password_hash = hashlib.sha256(str_password.encode()).hexdigest() user = Users(username) user.save_user_to_mongo(password_hash) self.user = username
def post(self) -> Response: body = request.get_json() try: key = uuid.uuid4().int data = { 'staffID': str(key)[0:6], 'username': body['username'], 'password': body['password'], 'name': body['name'], 'role': body['role'], 'department': body['department'], 'create_at': str(datetime.utcnow()), 'update_at': str(datetime.utcnow()), } user = Users(**data) user.save() response = jsonify({ "data": data, "message": "success", "status": 200 }) response.status_code = 201 return response except Exception as e: response = jsonify({ "data": None, "message": "error", "status": 204 }) response.status_code = 204 return response
def update_user(): response.content_type = 'application/json' user = request.json new_user = Users(**user) session.add(new_user) session.commit() return json.dumps(new_user.to_dict())
def register() -> Response: form = RegistrationForm() if form.validate_on_submit(): username = form.data['username'] password = form.data['password'] mail = form.data['mail'] hashed_pswd = pbkdf2_sha256.hash(password) user = Users(username=username, mail=mail, password=hashed_pswd, confirmed=False) db.session.add(user) db.session.commit() token = SendingMails(app, mail).generate_confirmation_token(user.mail) confirm_url = url_for('confirm_email', token=token, _external=True) html = render_template('users/activate.html', confirm_url=confirm_url) subject = "Please confirm your email" SendingMails(app, mail).send_email(user.mail, subject, html) flash('A confirmation email has been sent via email. :)', 'success') return redirect(url_for('unconfirmed')) return render_template('users/register.html', form=form)
def register(): userId = "522422199412263654" cardId = "522422199412263654" username = "******" password = "******" group = "技术部" phone = "18212707348" type = '1' regTime = datetime.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S') pd = generate_password_hash(password) try: data = Users(userId=userId, cardId=cardId, username=username, passWord=pd, group=group, phone=phone, type=type, regTime=regTime) db.session.add(data) db.session.commit() except Exception as e: print(e) print('添加用户错误') return jsonify({"message": "ok"})
def post() -> Response: """ POST response method for creating user. :return: JSON object """ data = request.get_json() usercart = Cart().save() output = {'id': str(usercart.id)} y = {"cartId": str(usercart.id)} print('usercart') print(usercart.id) print(usercart.products) print('data') print(data) data.update(y) print('data') print(data) post_user = Users(**data) try: post_user.save() except NotUniqueError as exc: return {'message': "Email Id already exits!!"}, 400 output = {'id': str(post_user.id)} return jsonify({'result': output})
def create_user(self): """ 회원가입한 유저 정보 DB에 저장 :return: Boolean """ name = self._body.get('name') nickname = self._body.get('nick_name') password = self._body.get('password') phone = self._body.get('phone') email = self._body.get('email') gender = self._body.get('gender') password = self.encrypt_password(password=password) session = db.session() try: user = Users(name=name, nickname=nickname, password=password, phone=phone, email=email, gender=gender) session.add(user) except Exception as e: print(f'err : {e}') session.rollback() return False else: session.commit() session.close() return True
def export(direction=None, user=None, date=None): '''Export loan entries''' current_user_id = session.get('logged_in_user') our_loans = Loans(current_user_id) our_users = Users(current_user_id) # fetch loans loans = our_loans.get_loans() # fetch users from connections from us users = our_users.get_connections() # provided user? if user: # valid slug? user_id = our_users.is_connection(slug=user) if user_id: loans = our_loans.get_loans(user_id=user_id) # provided a date range? date_range = translate_date_range(date) if date_range: loans = our_loans.get_loans(date_from=date_range['low'], date_to=date_range['high']) # date ranges for the template date_ranges = get_date_ranges() # provided a direction? if direction: loans = our_loans.get_loans(direction=direction) response = make_response(render_template('admin_export_loans.html', **locals())) response.headers['Content-type'] = 'text/csv' response.headers['Content-disposition'] = 'attachment;filename=' + 'loans-' + str(today_date()) + '.csv' return response
def generate_test_users(filepath: str = 'resources/user_data.csv', delimiter: str = '\t'): """ Converts data in csv file to documents in user collection. Uses @mongo wrapper to connect via mongoengine during execution. Randomly generates fav_meals list and access__admin parameters. :param filepath: :param delimiter: :return: """ with open(filepath, 'r') as file: data = csv.DictReader(file, delimiter=delimiter) for datum in data: try: user = Users(**datum, __auto_convert=True) # generate random admin access, password, and favorite meals user.access.admin = (randint(0, 1) == 1) user.fav_meals = get_random(Meals, randint(1, 5)) user.password = user.name + str(randint(0, 9)) user.save() print( f"Added: {user.name} | {user.email} | {user.password} | Admin-{user.access.admin is True} => {user.id}" ) except NotUniqueError: print(f'Invalid Entry: {user.email} is already taken.') except ValidationError: print(f'Validation Error: {user}')
def index(direction=None, user=None, date=None, page=1, items_per_page=10): '''List loans user has with other users''' current_user_id = session.get('logged_in_user') our_loans = Loans(current_user_id) our_users = Users(current_user_id) # fetch loans loans = our_loans.get_loans() # fetch users from connections from us users = our_users.get_connections() # provided user? if user: # valid slug? user_id = our_users.is_connection(slug=user) if user_id: loans = our_loans.get_loans(user_id=user_id) # provided a date range? date_range = translate_date_range(date) if date_range: loans = our_loans.get_loans(date_from=date_range['low'], date_to=date_range['high']) # date ranges for the template date_ranges = get_date_ranges() # provided a direction? if direction: loans = our_loans.get_loans(direction=direction) # build a paginator paginator = Pagination(loans, page, items_per_page, loans.count(), loans.offset((page - 1) * items_per_page).limit(items_per_page)) return render_template('admin_show_loans.html', **locals())
def post(): data = request.get_json() post_user = Users(**data) post_user.save() output = {'id': str(post_user.id)} return jsonify({'result': output})
def give(): '''Give a loan or pay someone back''' current_user_id = session.get('logged_in_user') our_accounts = Accounts(current_user_id) if request.method == 'POST': dict = __validate_give_loan_form() for key in dict.keys(): exec(key + " = dict['" + key + "']") # 'heavier' checks if not error: # valid amount? if is_float(amount): # valid date? if is_date(date): # valid account? if our_accounts.is_account(account_id=deduct_from_account): # add our loans entry our_loans = Loans(current_user_id) our_loan_id = our_loans.add_loan(other_user_id=to_user, date=date, account_id=deduct_from_account, description=description, amount=-float(amount)) # add their loans entry their_loans = Loans(to_user) their_loan_id = their_loans.add_loan(other_user_id=current_user_id, date=date, account_id=deduct_from_account, description=description, amount=amount) # generate slugs for the new loans our_slugs = Slugs(current_user_id) slug = our_slugs.add_slug(type='loan', object_id=our_loan_id, description=description) their_slugs = Slugs(to_user) their_slugs.add_slug(type='loan', object_id=their_loan_id, slug=slug) their_accounts = Accounts(to_user) # transfer money from/to respective accounts our_accounts.modify_user_balance(account_id=deduct_from_account, amount=-float(amount)) their_accounts.modify_user_balance(amount=amount) # fudge loan 'account' monies our_accounts.modify_loan_balance(amount=amount, with_user_id=to_user) their_accounts.modify_loan_balance(amount=-float(amount), with_user_id=current_user_id) flash('Loan given') else: error = 'Not a valid source account' else: error = 'Not a valid date' else: error = 'Not a valid amount' # fetch users from connections from us our_users = Users(current_user_id) users = our_users.get_connections() accounts = our_accounts.get_accounts() return render_template('admin_give_loan.html', **locals())
def post(self): args = parser.parse_args() user = Users(username=args.username, email=args.email) db.session.add(user) db.session.commit() db.session.remove() return handle_success(message='add success', code='10201')
def del_repo(git_name, git_repository_blog): args = request.args.get('access_token') if not args: return jsonify({'access_token': args}) git_access = GitAccess(git_name, git_repository_blog, args) data = git_access.get_all_posts() users_list = Users(git_name, git_repository_blog) session_git = users_list.open_base() users = session_git.query(Users) query_fav = session_git.query(Favorites).filter( Favorites.user_name == git_name.lower()) for one_fav in query_fav: session_git.delete(one_fav) if data.status_code == 200: for dir_ in data.json(): git_access.del_one_post(dir_['sha'], dir_['path']) for user in users: if user.user_name == git_name.lower( ) and user.user_repo_name == git_repository_blog.lower(): session_git.delete(user) session_git.commit() session_git.close() git_access.del_branch() remove_files(git_name, git_repository_blog) return '', 200 else: for user in users: if user.user_name == git_name.lower( ) and user.user_repo_name == git_repository_blog.lower(): session_git.delete(user) session_git.commit() session_git.close() git_access.del_branch() remove_files(git_name, git_repository_blog) return '', 200
def dummy_user(): """ A fixture that creates and saves a user to the database that is to be used for testing purposes """ user = Users("User", "*****@*****.**", Users.generate_hash("wfnbqk".encode("utf8")).decode("utf8"), True, True) user.save() user.commit() return user
def create_user(user): sql = "Insert into banking.users Values(default,%s,%s,%s) RETURNING *" cursor = connection.cursor() cursor.execute(sql, (user.username, user.first_name, user.last_name)) connection.commit() record = cursor.fetchone() new_user = Users(record[0], record[1], record[2], record[3]) return new_user
def __init__(self, *args, **kwargs): super(LoginWidget, self).__init__(*args, **kwargs) uic.loadUi(self._path, self) self.show() self.users = Users() self.sign_in.clicked.connect(self.handle_sign_in) self.sign_up.clicked.connect(self.handle_sign_up)
def signup(): data = request.get_json() hashed_password = generate_password_hash(data["password"]) new_user = Users(name=data["name"], password=hashed_password) new_user.save() return jsonify({"message": "registered successfully"})