def change_password(*, account: Account, current_password: str, new_password: str) -> Account: if account.password != hashed_password(current_password): raise InvalidInputFormat("Wrong current password.") password_format_check(new_password) account.password = hashed_password(new_password) account.save()
def signup_post(self): if Account.query.filter_by(audit_is_deleted=False, name=request.form['account_name']).first(): flash('Account name already in use', 'error') return self._render('auth/signup.html', 'Register') if User.query.filter_by(audit_is_deleted=False, username=request.form['username']).first(): flash('Username already in use', 'error') return self._render('auth/signup.html', 'Register') if User.query.filter_by(audit_is_deleted=False, email_address=request.form['email_address']).first(): flash('Email address already in use', 'error') return self._render('auth/signup.html', 'Register') if request.form['password'] != request.form['password_confirm']: flash('Password and confirmation do not match', 'error') return self._render('auth/signup.html', 'Register') account = Account(name=request.form['account_name']) account.create() user = User(username=request.form['username'], email_address=request.form['email_address'], account_id=account.id) user.create() user.update_password(request.form['password']) flash('User created successfully, Please login', 'success') return self._render('auth/login.html', 'Login')
def add_account(user_id): """Add a new Account""" user_name = request.args.get('user_name') user_image_url = request.args.get('user_image_url') account = Account.get(user_id) if account: # Setup results code = 1 desc = 'Account Already Exists' account = account.to_dict_stores() else: new_account_model = Account(user_id=user_id, user_name=user_name, user_image_url=user_image_url, store_deps=[]) new_account_model.put() account = new_account_model.to_dict_stores() # Setup results code = 0 desc = 'Account Added Successfully' return jsonify(code=code, desc=desc, account=account)
def get(self, client_id: str, id: str) -> Account: client_ref = self.get_client_ref(client_id) accounts = client_ref.get().to_dict()['accounts'] # search in array of accounts for account in accounts: if account['id'] == id: return Account(**account)
def add_store_to_account(user_id): """Create a new store and add to an account.""" store_name = request.form.get('store_name') dep_name = request.form.get('dep_name') account = Account.get(user_id) if not account: # Setup results code = Errors.account_not_found desc = 'Add Store to Account Failed. Account does not exist.' return jsonify(code=code, desc=desc) store = StoreDepartment.get(user_id, store_name, dep_name) if not store: store = StoreDepartment(user_id=user_id, store_name=store_name, dep_name=dep_name, schedules=[]) store.put() exists = account.is_store_in_account(store) if not exists: account.store_deps.append(store.key) account.put() # Setup results code = 0 desc = 'Store Added to Account Successfully.' else: # Setup results code = Errors.store_in_account desc = 'Store Already Exists in Account.' return jsonify(code=code, desc=desc)
def admin(self): self.meta.view.template_name = 'angular/admin-index.html' active_user = UserSvc.get_current_user() user = Account.transform_message(active_user) self.context['active_user'] = protojson.encode_message(user) self.context['logout_url'] = users.create_logout_url('/') self.context['commission'] = settings.get('paypal').get('commission')
def add_account(): username = request.form.get('username') email = request.form.get('email') password = request.form.get('password') repassword = request.form.get('repassword') group_ids = request.form.get('group_ids') if username is None or username == '' or group_ids is None or group_ids == '[]' or email is None or email == '' or not password or not repassword: return u'输入有误,请检查', 502 username = username.replace(' ', '') if username.find('@') != -1: return u'用户名不能出现"@",请更换用户名', 502 if password != repassword: return u'密码不匹配,请检查', 502 if Account.query.filter(Account.username == username).count(): return u'该用户名已被占用,请更换用户名', 502 if Account.query.filter(Account.email == email).count(): return u'该邮箱已被占用,请更换邮箱', 502 account_item = Account(username=username, email=email, password=password, groups=group_ids.replace('"', '')) db.session.add(account_item) db.session.commit() return 'success'
def create_account(): body = flask_rebar.get_validated_body() account = Account(**body) db.session.add(account) db.session.commit() return account, 201
def import_row(self, row, which): if which == self.ACCOUNTS: account = Account( account_id=row[1], # Acct Id company_name=row[2], # Account Name person_name=None, # only from Divisions phone_number=row[3], address=("%s, %s, %s, %s, %s, %s" % (row[8], row[9], row[10], row[11], row[12], row[13])), driver_voucher=self.safe_cast(None, bool), special_requirements=row[0] # Account Notes ) account.put() elif which == self.VEHICLE: vehicle = Vehicle(vehicle_id=row[0]) vehicle.put()
def test_account(test_user): account = Account(name='test account', balance=123.33, description='random desc', currency=currencies[1], account_type=account_types[0], user=test_user) return account
def create_account(*, username: str, password: str, email: str, account_type: str) -> Account: """ Create user account if not exist. Return Account object on success, None on failure. """ username_format_check(username) password_format_check(password) account_type_check(account_type) account = Account.objects.filter(username=username).first() if account: return None account = Account(username=username, password=hashed_password(password), account_type=account_type) account.save() create_email(email=email, account=account) return account
def create(self, account_create: AccountCreate) -> Account: data = account_create.dict() # create document inside client document client_ref = self.get_client_ref(data['client_id']) client_ref.update({self.array_name: firestore.ArrayUnion([data])}) # the object will be the last one created account = client_ref.get().to_dict()['accounts'][-1] if account['id'] == data['id']: return Account(**account)
def get_schedules(user_id): """Return all of the users schedules sorted in reverse if specified.""" reverse = request.args.get('reverse') account = Account.get(user_id) schedules = [] if account: schedules = account.get_schedule_dicts() return jsonify(schedules=sort_schedules(schedules, reverse))
def get_accounts_stores(user_id): """Return all of the stores for the given account""" account = Account.get(user_id) if account: account_dict = account.to_dict_stores() return jsonify(stores=account_dict['store_deps']) else: return jsonify(stores=[])
def create_account(db: Session, account: AccountCreate): db_account_type = Account(name=account.name, balance=account.balance, account_type_id=account.account_type_id, bank_id=account.bank_id, user_id=account.user_id) db.add(db_account_type) db.commit() db.refresh(db_account_type) return db_account_type
def create(self, db: Session, *, obj_in: AccountCreate) -> Account: db_obj = Account( email=obj_in.email, hashed_password=get_password_hash(obj_in.password), full_name=obj_in.full_name, is_superuser=obj_in.is_superuser, ) db.add(db_obj) db.commit() db.refresh(db_obj) return db_obj
def get_account(user_id): """Return the Account Info""" account = Account.get(user_id) if account: account_dict = account.to_dict_stores() else: account_dict = None return jsonify(account=account_dict)
def stores_list(self): key = request.args.get("key") q = request.args.get("q") page = request.args.get("page", 1) kind = None if q: kind = "name" key = q else: kind="near" results, page = Account.search_store(key=key, kind=kind, page=page) return dict(msg="ok", code=200, stores=[result.to_json() for result in results], page=page)
def login_loop(): views.login_welcome() while True: views.display_login_menu() choice = views.get_login_choice() if int(choice) > 3: print("That is not an option!") #CREATE AN ACCOUNT elif int(choice) == 1: print("-----Create an Account-----") full_name = input("What is your full name?: ") values = {"full_name":full_name, "pin": views.input_new_pin(), "balance": 0.00} new_account = Account(**values) new_account.save() print("Account Created! Your account number is:", new_account.account_number) continue #LOGIN TO EXISTING ACCOUNT elif int(choice) == 2: account_num = views.get_login_num() pin = views.input_pin() if Account.validate(account_num, pin) == True: loaded_account = Account.load_account(account_num, pin) print("This is your loaded account: ", loaded_account.account_number) return loaded_account #EXIT PROGRAM elif int(choice) == 3: break
def get_schedules_by_year_week(user_id, year, week): """Return the users schedules for a given year and week.""" reverse = request.args.get('reverse') account = Account.get(user_id) week_schedules = [] if account: schedules = account.get_schedules() for schedule in schedules: if schedule.year == int(year) and schedule.week == int(week): week_schedules.append(schedule.to_dict_images()) return jsonify(schedules=sort_schedules(week_schedules, reverse))
def create_account(*, username: str, password: str, email: str, account_type: str) -> Account: """ Create user account if not exist. Return Account object on success, None on failure. """ username_format_check(username) password_format_check(password) account_type_check(account_type) account = Account.objects.filter(username=username).first() if account: user_existed = True return user_existed, { 'access_token': '', 'account': { 'id': 0, 'username': '', 'account_type': '', } } else: user_existed = False account = Account(username=username, password=hashed_password(password), account_type=account_type) account.save() create_email(email=email, account=account) account = Account.objects.filter( username=username, password=hashed_password(password)).first() access_token = generate_access_token(account) return user_existed, { 'access_token': access_token, 'account': { 'id': account.id, 'username': account.username, 'account_type': account.account_type, } }
def post(self): account = Account(account_id=request.json['account_id'], status=request.json['status'], balance=request.json['balance']) db.session.add(account) db.session.commit() output = { 'message': 'Account Created', 'resource_id': account.account_id, 'status': 200 } return output
def post(self): user = users.get_current_user() username = self.request.get("username") # Get the language header langheader = self.request.headers['Accept-Language'] # Check for language if langheader.startswith('fr'): langfile = file(os.path.join(os.path.dirname(__file__), '../i18n/fr/home.yaml')) else: langfile = file(os.path.join(os.path.dirname(__file__), '../i18n/en/home.yaml')) if user and username and username != "": account = Account.gql("WHERE username = :1", username).get() if account: vars = { "lang": yaml.load(langfile), "logouturl": users.create_logout_url(self.request.uri), "useremail": user.nickname(), "error": True, "username": username } path = os.path.join(os.path.dirname(__file__), '../views/userform.html') else: account = Account(username=username) account.put() vars = { "lang": yaml.load(langfile), "logouturl": users.create_logout_url(self.request.uri), "username": username } path = os.path.join(os.path.dirname(__file__), '../views/userhome.html') # Load the template self.response.out.write(template.render(path, vars))
def create_account( db_session: Session, first_name: str, last_name: str, email: str, password: str, is_system_admin: bool = False, is_active: bool = False, send_registration_email: bool = True, is_verified: bool = False, ): """Create an user account.""" account_obj = Account( first_name=first_name, last_name=last_name, is_system_admin=is_system_admin, is_active=is_active, ) db_session.add(account_obj) db_session.flush() email_obj = EmailAddress(account_id=account_obj.id, email=email, primary=True, verified=is_verified) password_obj = Password(account_id=account_obj.id, password=password) db_session.add(email_obj) db_session.add(password_obj) db_session.commit() # Send registration email. if send_registration_email: token = create_token_from_id(email_obj.id) registration_link = "{}/{}/verify?token={}".format( FRONTEND_BASE_URL, email_obj.id, token) send_email( to_email=email, subject="Welcome!", body="""Weclome to the website. <p />Please use the following link to continue your registration. <p /><a href="{}">{}</a> """.format(registration_link, registration_link), ) db_session.refresh(account_obj) return account_obj
def get_schedules_by_year_store_dep(user_id, store_name, dep_name, year, week): """Return the users schedules for a given year and week and store""" store_user_id = request.args.get('store_user_id') reverse = request.args.get('reverse') store = StoreDepartment.get(store_user_id, store_name, dep_name) account = Account.get(user_id) year_schedules = [] if account and store: if account.is_store_in_account(store): schedules = store.get_schedules() for schedule in schedules: if schedule.year == int(year) and schedule.week == week: year_schedules.append(schedule.to_dict_images()) return jsonify(schedules=sort_schedules(year_schedules, reverse))
def get_schedules_by_store(user_id, store_name, dep_name, store_user_id=None): """Return the users schedules for a store""" if not store_user_id: store_user_id = request.args.get('store_user_id') reverse = request.args.get('reverse') store = StoreDepartment.get(store_user_id, store_name, dep_name) account = Account.get(user_id) if account and store: if account.is_store_in_account(store): schedules = store.get_schedule_dicts() return jsonify(schedules=sort_schedules(schedules, reverse)) return None
def accounts(): accounts = Account.query.filter_by(user=current_user) if request.method == 'POST': account = Account.query.filter_by(user=current_user, name=request.form.get('name')).first() if account is not None: return render_template('accounts.html', error_message=ErrorMessage.ACCOUNT_ALREADY_EXISTS.value, account_types=account_types, accounts=enumerate( accounts, start=1), currencies=currencies, currency_rate_date=get_currency_rate_date()) account = Account(name=request.form.get('name'), balance=request.form.get('balance'), description=request.form.get('description'), currency=request.form.get('currency'), account_type=request.form.get('account_type'), user=current_user) db.session.add(account) db.session.commit() return redirect(url_for('accounts')) return render_template('accounts.html', account_types=account_types, accounts=enumerate(accounts, start=1), currencies=currencies, currency_rate_date=get_currency_rate_date())
def seed_db(): acct = Account.query.filter_by(name='Internal').first() if acct: print('DB contents already exist, Cannot seed again') quit(1) accounts = [ {'name': 'Internal', 'is_suspended': False}, ] # Internal Users internal_users = [ {'username': '******', 'email_address': '*****@*****.**', 'is_admin': True}, {'username': '******', 'email_address': '*****@*****.**', 'is_admin': True}, {'username': '******', 'email_address': '*****@*****.**', 'is_admin': True} ] # Reserved Users for i in range(1, 10): internal_users.append({ 'username': '******'.format(i), 'email_address': 'Reserved {0}'.format(i), 'is_admin': False }) # Add the accounts for item in accounts: account = Account() for key, value in item.items(): setattr(account, key, value) db.session.add(account) db.session.commit() internal_account = Account.query.filter_by(name='Internal').first() for item in internal_users: item['account_id'] = internal_account.id user = User() for key, value in item.items(): setattr(user, key, value) db.session.add(user) db.session.commit() print('DB seeded successfully') return
def join_store(user_id): """Join Store by adding store to users account found in SharedStoreDepartment by provided key. """ key = request.args.get('key') account = Account.get(user_id) if not account: # Setup account not found error code = Errors.account_not_found desc = 'Join Failed: Account Not Found.' return jsonify(code=code, desc=desc) shared_store = SharedStoreDepartment.get(key) # Check if a store was returned if not shared_store: # Setup store key not found error code = Errors.key_not_found desc = 'Join Failed: Key Not Found.' return jsonify(code=code, desc=desc) date = shared_store.shared_dateTime if date < (datetime.datetime.now() - datetime.timedelta(days=7)): # Expired code = Errors.key_too_old desc = 'Join Failed: Key Too Old (Over 7 Days).' return jsonify(code=code, desc=desc) store = shared_store.get(key) if not store: # Expired code = Errors.store_not_found desc = 'Join Failed: Store Not Found.' return jsonify(code=code, desc=desc) account.store_deps.append(store.store_dep_key) account.put() # Setup results code = 0 desc = 'Join Successful' return jsonify(code=code, desc=desc)
def get(self): # Get the language header langheader = self.request.headers['Accept-Language'] # Check for language if langheader.startswith('fr'): langfile = file(os.path.join(os.path.dirname(__file__), '../i18n/fr/home.yaml')) else: langfile = file(os.path.join(os.path.dirname(__file__), '../i18n/en/home.yaml')) user = users.get_current_user() if user: account = Account.gql("WHERE userid = :1", user).get() if account: vars = { "lang": yaml.load(langfile), "logouturl": users.create_logout_url(self.request.uri), "username": account.username } path = os.path.join(os.path.dirname(__file__), '../views/userhome.html') else: vars = { "lang": yaml.load(langfile), "logouturl": users.create_logout_url(self.request.uri), "useremail": user.nickname() } path = os.path.join(os.path.dirname(__file__), '../views/userform.html') else: vars = { "lang": yaml.load(langfile), "loginurl": users.create_login_url(self.request.uri) } path = os.path.join(os.path.dirname(__file__), '../views/home.html') # Close the file, not sure this works langfile.close() # Load the template self.response.out.write(template.render(path, vars))
def share_store(user_id): """Share Store by adding store to SharedStoreDepartment with key. """ store_user_id = request.args.get('store_user_id') store_name = request.args.get('store_name') dep_name = request.args.get('dep_name') # make a random UUID u = uuid.uuid4() key = u.hex account = Account.get(user_id) if account: store = account.get_store_from_account(store_user_id, store_name, dep_name) if store: store_dep_key = store.key shared_store = SharedStoreDepartment(share_key=key, store_dep_key=store_dep_key) shared_store.put() # Setup results code = 0 desc = 'Share Successful. Key valid for 7 days.' else: # Setup results code = 1 desc = 'Share Unsuccessful. Store Not Found.' key = None else: # Setup results code = 2 desc = 'Share Unsuccessful. Account Not Found.' key = None return jsonify(code=code, desc=desc, key=key)
def remove_store_from_account(user_id): """Remove a store from an account.""" store_user_id = request.args.get('store_user_id') store_name = request.args.get('store_name') dep_name = request.args.get('dep_name') account = Account.get(user_id) if not account: # Setup results code = Errors.account_not_found desc = 'Remove Store From Account Failed. Account does not exist.' return jsonify(code=code, desc=desc) store = StoreDepartment.get(store_user_id, store_name, dep_name) if not store: # Setup store not found error code = Errors.store_not_found desc = 'Remove Store Failed: Store Not Found.' return jsonify(code=code, desc=desc) exists = account.is_store_in_account(store) if exists: account.store_deps.remove(store.key) account.put() # Setup results code = 0 desc = 'Store Removed from Account Successfully.' else: # Setup results code = Errors.store_in_account desc = 'Store Already Exists in Account.' return jsonify(code=code, desc=desc)
guest = 'guest' if __name__ == "__main__": ctime = arrow.utcnow().timestamp # openid = '%s_%s' % (guest, 0) # openkey = openid # user_mapping = UserMapping.get(openid) # if not isinstance(user_mapping, UserMapping): # user_mapping = UserMapping._install(openid, openkey, 4) pwd = '123456' account_number = 'test10' openid = get_uuid() openkey = _generate_token(SECRET_KEY) pwd_md = hashlib.md5() pwd_md.update(pwd) Account._install(account_number, pwd_md.hexdigest(), openid) AccountMapping._install(openid, account_number, openkey) user_mapping = UserMapping.get(openid) if not isinstance(user_mapping, UserMapping): user_mapping = UserMapping._install(openid, openkey, 4) uid = user_mapping.uid rk_user = User.get(uid) if not isinstance(rk_user, User): rk_user = User._install_new_user(uid, openid) rk_user.stage._install(uid) charpter = map(int, game_config.chapter[10]['pve'].split(","))[-1] # 关卡编号 skip(rk_user, 10, charpter) # 关卡 # need_lv = game_config.exp.keys()[rk_user.user_lv_manage.ulv - 1: 10] # total_exp = [] # for i in need_lv: # total_exp.append(game_config.exp[i]['exp'])
def new(): account = Account(request.get_json(force=True)) db.session.add(account) db.session.commit() return jsonify(success=True, account_id=account.id)
def get_current_user(): user = users.get_current_user() return Account.get(key_name=user.email())
def accounts_list(self, page=1): """列出我加入的公司""" a = self.accounts.paginate(int(page), per_page=25, error_out=False) page = Account.res_page(a) return a.items, page
# coding=utf-8 from cookielib import LWPCookieJar import requests.utils import requests from app.models.account import Account from app.settings import COOKIE_FILENAME user = Account('*****@*****.**', 'wrx0831') def auth(): tmp = requests.utils.dict_from_cookiejar(user.cookies) session = requests.Session() cookie = LWPCookieJar() cookie.load(filename=COOKIE_FILENAME) print type(cookie), cookie session.cookies = cookie s = session.post('https://www.leetcode.com/dream_going') print s.status_code if __name__ == '__main__': user.login() print user.is_login print user.username tmp = requests.utils.dict_from_cookiejar(user.cookies) print tmp auth()
def api_list(self): self.context["data"] = Account.list_all()
def api_post(self): Account.create(json.loads(self.request.body)) return 200
def upload_image(user_id): """ Accept an schedule with info and image""" image = request.files['file'] header = image.headers['Content-Type'] parsed_header = parse_options_header(header) blob_key_str = parsed_header[1]['blob-key'] store_user_id = request.form.get('store_user_id') store_name = request.form.get('store_name') dep_name = request.form.get('dep_name') upload_user_id = request.form.get('upload_user_id') year = request.form.get('year', type=int) week = request.form.get('week', type=int) week_offset = request.form.get('week_offset', type=int) store = StoreDepartment.get(store_user_id, store_name, dep_name) if not store: # Setup store not found error code = Errors.store_not_found desc = 'Upload Failed: Store Not Found.' return jsonify(code=code, desc=desc) account = Account.get(user_id) if not account: # Setup store not found error code = Errors.account_not_found desc = 'Upload Failed: Account Not Found.' return jsonify(code=code, desc=desc) schedule = store.has_schedule(upload_user_id, year, week, week_offset) if schedule: # Update schedule schedule.image_blob = blobstore.BlobKey(blob_key_str) schedule.upload_user_id = user_id schedule.user_name = account.user_name schedule.put() # Setup results code = 0 desc = 'Upload Successful. Store Updated' else: # No schedule found so make new one and add to store schedule = Schedule(parent=store.key, upload_user_id=user_id, user_name=account.user_name, year=year, week=week, week_offset=week_offset, image_blob=blobstore.BlobKey(blob_key_str)) schedule.put() store.schedules.append(schedule.key) store.put() # Setup results code = 0 desc = 'Upload Successful' return jsonify(code=code, desc=desc)
def list(self, client_id: str) -> List[Account]: client_ref = self.get_client_ref(client_id) accounts = client_ref.get().to_dict()['accounts'] return [Account(**account) for account in accounts]
def api_list(self): self.context['data'] = Account.list_all()