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
def get_current_user():
user = users.get_current_user()
return Account.get(key_name=user.email())
# 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_post(self):
Account.create(json.loads(self.request.body))
return 200
def api_list(self):
self.context['data'] = Account.list_all()
