def create_user():
# ...
data = request.get_json()
print('\n\ncreate_user()')
print(json.dumps(data, indent=4))
first_name = data.get('first_name')
last_name = data.get('last_name')
email = data.get('email')
username = data.get('username')
password = sha256_crypt.hash((str(data.get('password'))))
# TODO move to controller ..
user = User()
user.email = email
user.first_name = first_name
user.last_name = last_name
user.password = password
user.username = username
user.authenticated = True
user.active = True
# ...
db.session.add(user)
db.session.commit()
response = dict(
result=user.to_json(),
message={
'info': 'User added',
'code': 201
},
)
return jsonify(response)
def edituser(id):
form = UserForm()
if id == 0:
user = User()
else:
user = User.query.get(id)
if form.validate_on_submit():
if not user.active and form.active.data:
send_activated_mail(user)
user.email = form.email.data
user.active = form.active.data
if form.admin.data:
user.add_role('admin')
else:
user.remove_role('admin')
if form.supplier.data:
user.add_role('supplier')
else:
user.remove_role('supplier')
if id == 0:
db.session.add(user)
db.session.commit()
flash(_('Gespeichert'))
return redirect(url_for('main.manageusers'))
form.username.data = user.username
form.email.data = user.email
form.active.data = user.active
form.admin.data = user.has_role('admin')
form.supplier.data = user.has_role('supplier')
return render_template('admin/edit_user.html', form=form)
def register():
try:
model = RegisterSchema().load(request.json)
user = User()
user.email = model['email']
user.first_name = model['first_name']
user.last_name = model['last_name']
user.password_hash = bcrypt.generate_password_hash(model['password'])
user.active = True
user.roles = ','.join([Roles.CUSTOMER.value])
db.session.add(user)
db.session.commit()
payload = {
'id_user': user.id_user,
'email': user.email,
'first_name': user.first_name,
'last_name': user.last_name,
'roles': user.roles,
}
token = jwt_manager.encode(payload)
return {'token': token.decode('utf-8'), 'expire': payload['exp']}
except IntegrityError as ex:
return {'error': 'Data integrity error'}, 400
def update_user(number, active=None, call_time=False):
"""
:param number:
:param (bool) active:
:param (datetime | bool) call_time: If True,
:return bool created: Whether a new user had to be created
"""
created = False
u = User.query.filter_by(phone=number).first()
if u is None:
# No user yet exists in the database with that phone number
u = User(id=random.randint(0, 2**31), phone=number, active=False)
created = True
if active is not None:
u.active = active
if call_time:
if call_time is True:
call_time = datetime.now()
u.last_call = call_time
print("creating user", u)
db.session.add(u)
db.session.commit()
return created
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
user = User()
form.populate_obj(user)
user.set_password(form.password.data)
user.level = 3
user.active = 1
db.session.add(user)
db.session.commit()
flash('Congratulations, you are now a registered user!', 'success')
return redirect(url_for('login'))
breadcrumbs = [{
'link': url_for('index'),
'text': 'Home',
'visible': True
}, {
'text': 'Register'
}]
return render_template('auth/register.html',
title='Register',
form=form,
breadcrumbs=breadcrumbs)
def test_inactive_user(self):
self.app.logger.debug('test_inactive_user')
user = User('*****@*****.**')
user.set_password('password')
user.active = False
db.session.add(user)
db.session.commit()
assert User.query.first() is not None
assert User.query.active().all() == []
def register():
form = RegistrationForm()
if form.validate_on_submit():
email = form.email.data
user = User(email=email)
user.set_password(form.password.data)
user.active = True
db.session.add(user)
db.session.commit()
# user_datastore.create_user(email=email, name=name, password=form.password.data)
flash('Congratulations!')
return redirect(url_for('auth.login'))
return render_template('auth/register.html', title='Register', form=form)
def generate_db():
app.logger.info("Start make db")
currentsession = get_user_session_by_userid()
serviceprovider = [
'3 River Wireless', 'ACS Wireless', 'Alltel', 'AT&T', 'Bell Canada',
'Bell Canada', 'Bell Mobility (Canada)', 'Bell Mobility',
'Blue Sky Frog', 'Bluegrass Cellular', 'Boost Mobile', 'BPL Mobile',
'Carolina West Wireless', 'Cellular One', 'Cellular South',
'Centennial Wireless', 'CenturyTel', 'Cingular (Now AT&T)', 'Clearnet',
'Comcast', 'Corr Wireless Communications', 'Dobson', 'Edge Wireless',
'Fido', 'Golden Telecom', 'Helio', 'Houston Cellular', 'Idea Cellular',
'Illinois Valley Cellular', 'Inland Cellular Telephone', 'MCI',
'Metrocall', 'Metrocall 2-way', 'Metro PCS', 'Microcell',
'Midwest Wireless', 'Mobilcomm', 'MTS', 'Nextel', 'OnlineBeep',
'PCS One', "President's Choice", 'Public Service Cellular', 'Qwest',
'Rogers AT&T Wireless', 'Rogers Canada', 'Satellink',
'Southwestern Bell', 'Sprint', 'Sumcom', 'Surewest Communicaitons',
'T-Mobile', 'Telus', 'Tracfone', 'Triton', 'Unicel', 'US Cellular',
'Solo Mobile', 'Sprint', 'Sumcom', 'Surewest Communicaitons',
'T-Mobile', 'Telus', 'Triton', 'Unicel', 'US Cellular', 'US West',
'Verizon', 'Virgin Mobile', 'Virgin Mobile Canada',
'West Central Wireless', 'Western Wireless'
]
db_session.close()
drop_db()
init_db()
user = User('admin', '1')
user.email = 'admin@localhost'
user.mobilenumber = '800 000 0000'
user.referfrom = 'admin'
user.active = 1
user.paidservice = 1
user.create_date = datetime.datetime.now()
user.modified_date = datetime.datetime.now()
db_session.add(user)
db_session.commit()
sps = {}
for row in serviceprovider:
if row not in sps:
sps[row] = 1
sp = ServiceProvider()
sp.name = row
try:
db_session.add(sp)
db_session.commit()
except:
db_session.rollback()
return output_json("status:ok", 200)
def process_signup():
current_app.logger.info(f"New Sign Up attempt: {request.form['first_name']} - {request.form['last_name']} - {request.form['email']}")
if current_app.config['DEBUG']:
form = SignupForm()
if form.validate_on_submit():
user = User()
form.populate_obj(user)
user.set_password(form.password.data)
user.active = True
db.session.add(user)
db.session.commit()
flash('Welcome to Web Serialist.com!', 'success')
return redirect(url_for('main.index'))
return redirect(url_for('auth.login'))
flash('We are not accepting new users at the moment. Thank you for your interest!', 'danger')
return redirect(url_for('main.index'))
def _users_from_json(app, content=''):
if 'users' in content:
for u in content['users']:
user = User.query.filter_by(email=u['email']).first()
if user is None:
user = User()
user.email = u['email']
user.pw_hash = u['pw_hash']
user.active = u['active']
user.superuser = u['superuser']
if 'locale' in u:
user.locale = u['locale']
app.logger.debug('adding user: %s' % user)
db.session.add(user)
db.session.commit()
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.active = False
# Set password to something random
user.set_password(randomword(16))
db.session.add(user)
db.session.commit()
servername = app.config['SERVERNAME']
send_password_reset_email(user, servername)
flash('Check your email for instructions to reset your password',
'info')
return redirect(url_for('index'))
return render_template('register.html', title='Register', form=form)
def user_form_handler(form, action):
if action == "add":
user = User(username=form.username.data,
email=form.email.data,
role_id=form.roles.data)
user.set_password(form.password.data)
user.active = form.active.data
return write_to_db(user, db.session.add)
elif action == "delete":
user = User.query.filter_by(form.id.data).first()
if user is None:
abort(404)
return write_to_db(user, db.session.delete)
elif action == "update":
user = User(email=form.email.data,
role_id=form.roles.data,
active=form.active.data)
return write_to_db(user, db.session.add)
return 500, Exception(f"Invalid action: {action}")
def get(self):
from flask import request, redirect
provider = request.args.get('provider')
from app.oauth import OAuthSignIn
from app import db
oauth = OAuthSignIn.get_provider(provider)
social_id, email, fullname = oauth.callback()
username = fullname + str(db.session.query(User).count())
email = 'google$' + email
if social_id is None:
return {
'response': False,
'message': 'Something is wrong with Facebook API.'
}, 500
user = User.query.filter_by(socialId=social_id).first()
if not user:
user = User(
socialId=social_id,
username=username,
email=email,
fullname=fullname
)
user.active = True
user.subType = 'basic'
user.save_to_db()
access_token = create_access_token(identity = {'username': user.username, 'subscription': user.subType})
refresh_token = create_refresh_token(identity = {'username': user.username, 'subscription': user.subType})
return redirect('http://localhost:4200/oauth_redirect?access_token={0}&refresh_token={1}'.format(
access_token, refresh_token
))
def register():
form = SignupForm(request.form)
if form.validate():
user = User()
form.populate_obj(user)
user_exist = User.query.filter_by(email=form.email.data).first()
if user_exist:
# form.email.error.append('Email already in use.')
return redirect(url_for('authentication.register'))
else:
user.password = flask_bcrypt.generate_password_hash(
form.password.data, 15).decode('utf-8')
user.active = True
db.session.add(user)
db.session.commit()
return redirect(url_for('views.index'))
return render_template('register.html',
form=SignupForm(),
login_form=SigninForm())
def post(self):
data = reg_parser.parse_args()
if User.find_by_username(data['username']):
return {
'response': False,
'message': 'User {} already exists'. format(data['username'])
}
new_user = User()
new_user.set_password(data['password'])
new_user.username = data['username']
new_user.email = data['email']
new_user.isCompany = bool(data['isCompany'])
new_user.fullname = data['fullname']
new_user.subType = 'basic'
try:
new_user.active = True
new_user.save_to_db()
access_token = create_access_token(identity = {'username': data['username'], 'subscription': new_user.subType})
refresh_token = create_refresh_token(identity = {'username': data['username'], 'subscription': new_user.subType})
return {
'response': True,
'message': 'User {} was created'.format(data['username']),
'id': new_user.id,
'access_token': access_token,
'refresh_token': refresh_token
}
except:
return {
'response': False,
'message': 'Something went wrong'
}, 500
def is_accessible(self):
return current_user.is_authenticated and str(
current_user.username) == 'admin'
def inaccessible_callback(self, name, **kwargs):
# redirect to login page if user doesn't have access
return render_template('admin_403.html'), 403
from app.models import User, Product, Release, Instance
user = User.query.filter_by(username='******').first()
if user is None:
print('User admin does not exist; creating user admin with password admin')
user = User(username='******', email='')
user.active = True
user.set_password('admin')
db.session.add(user)
db.session.commit()
class ExitView(BaseView):
@expose('/')
def index(self):
if current_user.is_authenticated and str(
current_user.username) == 'admin':
os._exit(errno.EINTR)
else:
return render_template('admin_403.html'), 403
def gen_data(weeks=13, num_positions=10):
# create fixtures
# Top 10, Top 25, etc
# num_positions = 10
positions = list(range(num_positions))
# Add weeks
saturdays_2015 = gen_saturdays(weeks=weeks, start="2015-8-31")
saturdays_2016 = gen_saturdays(weeks=weeks, start="2016-9-1")
# saturdays_2017 = gen_saturdays(weeks=weeks, start=start)
# Week.new()
# add roles
admin = Role(name="admin")
voter = Role(name="voter")
session.add_all([admin, voter])
# add users
kyle = User(name="Kyle")
frank = User(name="Frank")
jeff = User(name="Jeff")
matt = User(name="Matt")
brian = User(name="Brian")
kyle.active = True
frank.active = True
jeff.active = True
matt.active = True
brian.active = True
kyle.role = admin
frank.role = admin
jeff.role = voter
matt.role = voter
brian.role = voter
kyle.set_password("kyle")
frank.set_password("frank")
jeff.set_password("jeff")
matt.set_password("matt")
brian.set_password("brian")
users = [kyle, frank, jeff, matt, brian]
session.add_all(users)
add_teams()
top_teams = Team.query.filter(
Team.name.in_([
'Alabama',
'Clemson',
'Miami (FL)',
'Oklahoma',
'Wisconsin',
'Auburn',
'Georgia',
'Notre Dame',
'Ohio State',
'Penn State',
'USC',
'TCU',
'Washington State',
])).all()
add_submissions(saturdays_2015, users, top_teams, positions)
add_submissions(saturdays_2016, users, top_teams, positions)
async def twitter_login_step_2(verifier: int = Query(...),
session: Session = Depends(get_db),
user: User = Depends(get_current_user)) -> dict:
"""
Step 2 in the Twitter Login.
You must have gotten a PIN from Twitter after Authorizing this app, enter that pin as the _verifier_.
You have to be logged in to use this, click the padlock icon to login, or sign up with the **Create User** endpoint above.
Click **Try it out** and then **Execute**.
Once it's successful, you can try the other endpoints like **Make Tweet**
"""
oauth_token = user.oauth_token
if not oauth_token:
raise HTTPException(
400,
detail=
"It seems you've not completed step one. Please go back and complete it."
)
url = "https://api.twitter.com/oauth/access_token"
params = {"oauth_token": oauth_token, "oauth_verifier": verifier}
r = requests.post(url, params=params)
if not r.ok:
if str(verifier)[0] == 0:
raise HTTPException(
400,
detail=
"The verifier token seems to be bad, please repeat Step 1")
raise HTTPException(
400,
detail={
"message":
"Something went wrong with Twitter, please try again",
"error": r.text
})
old_username = user.username.casefold()
token, secret, twitter_id, username = [
x.split("=")[1] for x in r.text.split("&")
]
user.token = token
user.token_secret = secret
user.twitter_id = int(twitter_id)
user.username = username
user.oauth_token = None
user.active = True
try:
session.commit()
except Exception as e:
raise HTTPException(
400,
detail=
"Something seems to have went wrong with updating your account. Please try again"
)
if user.username.casefold() != old_username:
return {
"success":
f"Your Twitter login is complete, your username has been changed from '{old_username}' to '{user.username}'"
}
return {
"success":
f"Your Twitter login is complete, you can now use Twitter from here"
}
