def login_menu_choice(): # sequence for starting menu
login_count = 3
active_user = None
print(
'Calculator.Simple.\n1. Register\n2. Log in(existing user)\n3.Fast calculations\t\t\t\t\t'
'At any time type "quit" to quit')
while True:
try:
menu = float(quit_filter(input('>>> ')))
break
except Exception as e:
print(f'{e} Please re-enter')
while True:
if active_user:
print(f'Logged in as {active_user.login}')
break
if login_count <= 3 and active_user == None:
print(f'{login_count} attempts to log in left...\n\n\n{"*" * 40}')
if login_count <= 0:
menu = 3
if menu == 1:
while True:
try:
print('Create new user')
init_db()
user = register()
if user:
active_user = User(login=user['login'],
password=user['password'],
id=user['id'],
log=user['log'])
else:
active_user = anon
break
except Exception as e:
print(f'{e}, dude come on, its not that hard! ◕_◕')
elif menu == 2:
while True:
try:
login, password = login_input()
break
except Exception as e:
print(e)
for user in Database.read_users('pipi'):
if user['login'] == login and user['password'] == password:
print(f'logging in as {user["login"]}')
active_user = User(user['login'], user['password'],
user['log'], user['id'])
break
else:
login_count -= 1
elif (menu != 1 and menu != 2):
print('Welcome my dear Anonymous')
active_user = anon
print(active_user)
return active_user
def _populate_db():
""" Populates database with three users each with one order """
with app.app_context():
for i in range(1, 4):
user = User(
username="******".format(i),
api_public="79z47uUikMoPe2eADqfJzRB{}".format(i),
api_secret="j9ey6Lk2xR6V-qJRfN-HqD2nfOGme0FnBddp1cxqK6k8Gbjd")
order = Orders(
order_id='00000000-0000-0000-0000-00000000000{}'.format(i),
order_price=3567.5,
order_size=1,
order_side='Buy',
order_symbol="XBTUSD")
user.orders.append(order)
db.session.add(user)
# adds a real user that has valid apikey for bitmex related stuff
user = User(
username="******",
api_public="79z47uUikMoPe2eADqfJzRBu",
api_secret="j9ey6Lk2xR6V-qJRfN-HqD2nfOGme0FnBddp1cxqK6k8Gbjd")
order = Orders(order_id='00000000-0000-0000-0000-000000000000',
order_price=3567.5,
order_size=1,
order_side='Buy',
order_symbol="XBTUSD")
user.orders.append(order)
db.session.add(user)
db.session.commit()
def ldap_login(username, password, remember=False):
if DEBUG and not USE_LDAP:
try:
user = User.objects.get(username=username)
user.admin = True
except:
user = User(username=username, name=username, admin=True,
active=True, email='*****@*****.**').save()
warning = 'User did not exist, admin user created.'
flash(warning)
login_user(user, remember=remember)
return True
data = ldap_authenticate(username, password)
if data:
try:
user = User.objects.get(username=username)
except:
user = User(username=username)
user.name = str(data[0]['cn'])
if data[0]['mail']:
user.email = str(data[0]['mail'])
else:
print('A user has no mail entry in LDAP!')
user.active = True
user.save()
login_user(user, remember=remember)
return True
else:
return False
def seed_db(session):
maks = User(name='Maksym Prihara',
email='*****@*****.**',
password_hash='vfhajshjbdsdfsbdsbjdsfj')
vasyl = User(name='Vasl Zibrov',
email='*****@*****.**',
password_hash='dufhvfdskajdvk')
garage = Advertisement(modifier=ModifierEnum.local,
summary='Selling garage',
description='Selling a garage on Sykhiv',
topic='transport',
user=vasyl)
course_work = Advertisement(
summary='Doing course works',
description='Doing different course works on different '
'subjects related to chemistry',
topic='study',
modifier=ModifierEnum.public,
user=maks)
poland = Advertisement(modifier=ModifierEnum.public,
summary='Travelling to Poland',
user=maks,
description='A Volkswagen Transporter '
'deriving you to a '
'beautiful country',
topic='travelling')
session.add_all([maks, vasyl])
session.add_all([garage, course_work, poland])
session.commit()
session.close()
def setUp(self): create_schema() self.sender = Mock() self.trader = Trader(self.sender) self.buyer = User(email = "*****@*****.**", display_name = "Buyer") self.seller = User(email = "*****@*****.**", display_name = "Seller") db.session.add(self.buyer) db.session.add(self.seller) db.session.commit()
def __init__(self,queue,exchange,host='localhost',port=5672):
user1 = User(1,1)
user2 = User(2,2)
user3 = User(3,3)
self.queue = queue
self.exchange =exchange
self.users = [user1]#,user2,user3]
self.pKeys = {}
self.boundQueue = 0
def test_add_user(self):
owner = User(name="joe")
room = Room(owner=owner)
user = User(name="james")
room.add_user(user)
self.assertIn(
user._id,
Room(_id=room._id)._object['users']
)
def setUp(self):
create_schema()
self.user = User(email="*****@*****.**", display_name="First Last")
self.another_user = User(email="*****@*****.**",
display_name="Yet another User")
db.session.add(self.user)
db.session.add(self.another_user)
db.session.commit()
self.sender = Sender()
self.sender._send_email = Mock()
def test_draft(self):
owner = User(name="joe")
room = Room(owner=owner)
for name in ['john','carl','james']:
user = User(name=name)
room.add_user(user)
self.assertIn(
room.draft(),
Room(_id=room._id)._object['users']
)
def test_remove_inexistent_user(self):
owner = User(name="joe")
room = Room(owner=owner)
user = User(name="james")
room.add_user(user)
room.remove_user(user)
self.assertNotIn(
user._id,
Room(_id=room._id)._object['users']
)
def test_add_user_twice(self):
owner = User(name="joe")
room = Room(owner=owner)
user = User(name="james")
room.add_user(user)
room.add_user(user)
self.assertEqual(
Room(_id=room._id)._object['users'].count(user._id),
1
)
def setUp(self):
testuser = User(username='******', email='*****@*****.**')
testuser.save()
self.testuser = testuser
User(username='******', email='*****@*****.**', admin=True).save()
testpayment = Transaction(diff=1000, user=testuser)
testpayment.save()
testexpense = Transaction(diff=-500)
testexpense.save()
testcons = Consumption(units=1, price_per_unit=50, user=testuser)
testcons.save()
self.app = coffee.app.test_client()
def user_add():
User(name="Maximiliano", lastname="Sar Fernandez", userid="maxi182", password="******",
rol="admin")
commit()
for i in range(2):
User(name=config['loader']['user']['data']['name'][i],
lastname=config['loader']['user']['data']['lastname'][i],
userid=config['loader']['user']['data']['userid'][i],
password=config['loader']['user']['data']['password'][i],
rol=config['loader']['user']['data']['rol'][i],
medicid=config['loader']['user']['data']['medicid'][i])
commit()
def setUp(self):
create_schema()
self.user = User(email="*****@*****.**", display_name="First Last")
self.another_user = User(email="*****@*****.**",
display_name="Yet another user")
self.email = Email(purpose="verify")
self.user.active_emails.append(self.email)
db.session.add(self.user)
db.session.add(self.another_user)
db.session.commit()
self.sender = Mock()
self.trader = Mock()
self.responder = Responder(self.sender, self.trader)
def signup():
form = SignupForm()
if form.validate_on_submit():
# 生成随机码
n = []
for i in range(10):
n.append(str(random.randint(0, 9)))
active_code = ''.join(n)
new_user = User(name=form.name.data,
stu_id=form.stu_id_data,
major=form.major.data,
email=form.email.data,
phone=form.phone.data,
address=form.address.data,
password=form.password.data,
role=form.role.data,
active_code=active_code)
db.session.add(new_user)
# 发送验证邮件
user = User.query.filter_by(email=form.email.data).first()
sub = "请点击链接继续完成注册："
link = '127.0.0.1/signup/' + str(user.id) + '/' + active_code
send_mail(new_user.email, sub, link, app, mail)
flash("请查收邮件以继续完成注册")
return redirect(url_for('login'))
return render_template('form.html', form=form)
def userregister():
if request.method == 'POST':
session = DBSession()
email = request.form['useremail']
username = request.form['username']
password = request.form['userpassword']
password = generate_password_hash(password)
print(email)
if session.query(User).filter(User.email == email).first():
return render_template('register.html', msg='该邮箱已被注册！')
else:
adduser = User(password=password, username=username, email=email, admin=0,activated=0)
session.add(adduser)
session.commit()
os.makedirs(os.path.join(os.getcwd(),'static','files','{0}'.format(adduser.userid)))
url='http://47.94.138.25/activate/{0}'.format(gen_token(adduser.userid))
# message=Message('Account authorize',sender='*****@*****.**',recipients=['{}'.format(username),'{}'.format(email)])
message = Message('Account authorize', sender='*****@*****.**',recipients=['*****@*****.**'])
message.body="Hello,{0}<br>This email is from admin!<br>Your account has not been activated yet!<br><a href='{1}'>click here to activate your account!</a><br>if you mistaken the email,please ignore it!".format(username,url)
mail.send(message)
session.close()
return redirect(url_for('users.userlogin'))
else:
return render_template('register.html')
def admin_add():
if not session.get('admin'):
abort(400)
form = AdminAddForm()
if form.validate_on_submit():
# 简化增加用户,自动生成随机码
n = []
for i in range(6):
n.append(str(random.randint(0, 9)))
active_code = ''.join(n)
# 自动构建通过验证的用户
user = User(stu_id=form.stu_id.data,
name=form.name.data,
major=form.major.data,
address=form.address.data,
email=form.email.data,
phone=form.phone.data,
password=form.password.data,
role=form.role.data,
active_code=active_code,
active_state=True)
db.session.add(user)
flash('增加成功')
return redirect(url_for('admin_add'))
return render_template('adminadd.html', form=form)
def _sign_in(self):
login = input('Login: '******'Password: '******'Por favor insira uma senha mais segura')
first_name = input('First Name (can be empty): ')
last_name = input('Last Name (can be empty): ')
self.user = User(
login,
password,
database=self.database,
first_name=first_name,
last_name=last_name,
)
try:
self.user.create()
except IntegrityError:
return False, f"{Bcolors.FAIL}Usuario {login} ja cadastrado{Bcolors.ENDC}"
self.user.authenticate()
return True, ""
def login():
data = dict()
if (request.form['action'] and request.form['email']
and request.form['password']):
data['email'] = request.form['email']
data['password'] = request.form['password']
if request.form['action'] == 'signup':
# New user
# Email check
my_user = User.query.filter_by(email=data['email']).first()
if not my_user:
# Create
my_user = User(data['email'], data['password'])
db.session.add(my_user)
try:
db.session.commit()
except:
db.session.rollback()
else:
data['error'] = 'register'
# Checks if the user exists
if 'error' not in data:
my_user = User.query.filter_by(email=data['email'],
password=data['password']).first()
if my_user:
# Create user session
session['user_id'] = my_user.id
session['user_email'] = my_user.email
return redirect(url_for('dashboard'))
else:
data['error'] = 'login'
return index(data)
def create_user():
new_user1 = User(username='******',
user_id="00x21",
real_name="C3PO",
email="*****@*****.**",
amount=22.5)
session.add(new_user1)
def post(self):
""" Makes new account to cryptotrading API. """
if not request.json:
return create_error_response(415, "Unsupported media type",
"Requests must be JSON")
try:
validate(request.json, MasonControls.account_schema())
except ValidationError as e:
return create_error_response(400, "Invalid JSON document", str(e))
user = User(username=request.json["accountname"],
api_public=request.json["api_public"],
api_secret=request.json["api_secret"])
try:
db.session.add(user)
db.session.commit()
except IntegrityError:
return create_error_response(
409, "Already exists",
"Account with name '{}' already exists.".format(
request.json["accountname"]))
return Response(status=201,
headers={
"Location":
api.url_for(Account,
apikey=request.json["api_public"])
})
def is_user_from_country(stream_data, code):
user = User.get_user(stream_data['user__slug'].lower())
if not user:
user_data = requests.get(stream_data['user'], cookies=cookies).json()
user = User(username=user_data['username'].lower(), country_code=user_data['country'])
return user.country_code == code
def createUser(login_session):
newUser = User(name=login_session['username'], email=login_session[
'email'], picture=login_session['picture'])
session.add(newUser)
session.commit()
user = session.query(User).filter_by(email=login_session['email']).one()
return user.id
def createUser(login_session):
#Create a New User
now = datetime.datetime.now()
#format_now = now.strftime('%Y-%m-%d %H:%M:%S')
newUser = User(name=login_session['username'],
email=login_session['email'],
picture=login_session['picture'])
session.add(newUser)
session.commit()
user = session.query(User).filter_by(email=login_session['email']).one()
#Create new asset asociated with the user
name = "Asset_" + str(user.id)
newAsset = Asset(name=name, activated="true")
session.add(newAsset)
session.commit()
asset = session.query(Asset).filter_by(name=name).first()
print asset.name
#Create asset owned by the user
newOrderBook = OrderBook(type="buy",
ammount=100000,
user_id=user.id,
asset_id=asset.id)
session.add(newOrderBook)
session.commit()
return user.id
def _get_user(number=1):
""" Creates user model """
return User(
username="******".format(number),
api_public="79z47uUikMoPe2eADqfJzRB{}".format(number),
api_secret="j9ey6Lk2xR6V-qJRfN-HqD2nfOGme0FnBddp1cxqK6k8Gbj{}".format(
number))
async def create_user(
user: UserModel,
enforcer: casbin.Enforcer = Depends(get_enforcer),
db: Session = Depends(get_db),
current_user: Auth0ClaimsPatched = Depends(get_current_user)):
user_dict = user.dict()
# Drop the roles field if it was provided.
user_dict.pop('roles', None)
new_user = User(id=current_user.username if current_user.username else 42)
new_user_version = UserVersion(data=strip_metadata(user_dict),
server_version=settings.server_version)
new_user_version.user = new_user
new_user.current = new_user_version
add_owner(new_user, current_user.username)
db.add_all([new_user, new_user_version])
db.commit()
add_policy(enforcer,
user=current_user.username,
path=f"/user/{str(new_user.id)}",
method="GET")
add_policy(enforcer,
user=current_user.username,
path=f"/user/{str(new_user.id)}",
method="PUT")
return add_role(enforcer, versioned_row_to_dict(new_user,
new_user_version))
def register():
"""POST users/register
Desc: Registers a new user
Validates email and password used to register
Ensures new accounts are not duplicates
Returns:
201: authentication token
401: validation error, unauthorized access
409: duplicate account, conflict with database
"""
req = request.get_json()
is_valid, errors = valid_registration(req)
if not is_valid:
return errors, 401
user = User.objects(email=req['email']).first()
if user:
return {
'email': 'Account could not be created. User already exists.',
'password': ''
}, 409
new_user = User(**req)
pw_hash = bcrypt.generate_password_hash(new_user.password).decode('utf-8')
new_user.password = str(pw_hash)
new_user.save()
access_token = create_access_token(identity=new_user)
return {'token': access_token}, 201
async def start_handler(event: types.Message):
if not User.get(event.from_user.id):
new_user = User(user_id=event.from_user.id, first_name=event.from_user.first_name,
last_name=event.from_user.last_name, username=event.from_user.username,
platform='telegram')
new_user.save()
await event.answer(text=f"Hello from custom_handler(). ID %s" % event.message_id)
def callback_handling():
# Handles response from token endpoint
auth0.authorize_access_token()
resp = auth0.get('userinfo')
userinfo = resp.json()
# Store the user information in flask session.
login_session['jwt_payload'] = userinfo
login_session['profile'] = {
'user_id': userinfo['sub'],
'name': userinfo['name'],
'picture': userinfo['picture'],
'email': userinfo['email']
}
storeuser = login_session['profile']
DBSession = sessionmaker(bind=engine)
session = DBSession()
check = session.query(User).filter_by(id=storeuser['user_id']).first()
if check == None:
new_user = User(id=storeuser['user_id'],
name=storeuser['name'],
email=storeuser['email'],
picture=storeuser['picture'])
session.add(new_user)
session.commit()
return redirect('http://localhost:8080/dashboard')
def insert_messages(messages):
from database import DBSession, Message, User
for index, message in enumerate(messages):
new_msg = Message(id=-index,
link='',
text='{}: {}'.format(message.sender,
message.message),
video='',
photo='',
audio='',
voice='',
type='text',
category='',
from_id=0,
date=message.date)
session = DBSession()
session.add(new_msg)
session.commit()
session.close()
deafult_user = User(id=0,
fullname='历史聊天记录',
username='******',
update_time=datetime.now())
session = DBSession()
session.add(deafult_user)
session.commit()
session.close()
