def create():
form = UserCreateForm.from_json(request.get_json())
if not form.validate():
return jsonify(form.errors), 400
user = User()
user.email = form.data.get('email')
user.first_name = form.data.get('first_name')
user.last_name = form.data.get('last_name')
user.avatar = form.data.get('avatar', None)
user.password = User.make_password(form.data.get('password'))
user.save()
access_token = jwt.jwt_encode_callback(user)
return jsonify({'user': user.serialize(), 'access_token': access_token.decode('utf-8')}), 200
python类user()的实例源码
def login():
data = request.get_json()
username = data.get(current_app.config.get('JWT_AUTH_USERNAME_KEY'), None)
password = data.get(current_app.config.get('JWT_AUTH_PASSWORD_KEY'), None)
criterion = [username, password, len(data) == 2]
if not all(criterion):
return jsonify({'message': 'Invalid credentials'}), 401
user = jwt.authentication_callback(username, password)
if user:
if not user.is_active:
return jsonify({'message': 'InActive User'}), 401
access_token = jwt.jwt_encode_callback(user)
return jsonify({'user': user.serialize(), 'access_token': access_token.decode('utf-8')}), 200
else:
return jsonify({'message': 'Invalid credentials'}), 401
def signup():
from forms import SignupForm
form = SignupForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data.lower()).first()
if user is not None:
form.email.errors.append("The Email address is already taken.")
return render_template('signup.html', form=form)
newuser = User(form.firstname.data,form.lastname.data,form.email.data,form.password.data)
db.session.add(newuser)
db.session.commit()
session['email'] = newuser.email
return redirect(url_for('login'))
return render_template('signup.html', form=form)
def login():
if g.user is not None and g.user.is_authenticated:
return redirect(url_for('index'))
from app.forms import LoginForm
form = LoginForm()
if form.validate_on_submit():
session['remember_me'] = form.remember_me.data
user = User.query.filter_by(email=form.email.data.lower()).first()
if user and user.check_password(form.password.data):
session['email'] = form.email.data
login_user(user,remember=session['remember_me'])
return redirect(url_for('index'))
else:
return render_template('login.html',form=form,failed_auth=True)
return render_template('login.html',form=form)
def create_app():
app.config.from_object(development)
db.init_app(app)
bcrypt.init_app(app)
from views.auth import auth_view
from views.users import user_view
from views.chat import chat_view
from models.user import authenticate, identity
jwt.identity_handler(identity)
jwt.authentication_handler(authenticate)
jwt.init_app(app)
# Register Routes
app.register_blueprint(auth_view, url_prefix='/api')
app.register_blueprint(user_view, url_prefix='/api')
app.register_blueprint(chat_view, url_prefix='/api')
return app
def messages(room_id):
room_member = RoomMember.where('room_id', room_id).where('user_id', g.user['id']).first()
if not room_member:
return jsonify({'message': "Unknown Room"}), 400
room = Room.where('id', room_id).with_('members.user').first().serialize()
for item in room['members']:
item['user']['username'] = '%s %s' % (item['user']['first_name'],item['user']['last_name'])
messages = Message.select('messages.*', 'u.first_name', 'u.last_name', 'u.avatar') \
.where('room_id', room_id) \
.join('users as u', 'u.id', '=', 'messages.sender_id') \
.order_by('created_at', 'desc') \
.limit(100) \
.get()
return jsonify({'room': room, 'messages': messages.serialize()}), 200
def index():
"""
Index. Distinction between logged-in users and guests is performed
in the template.
"""
machex_import_form = ImportForm()
upload_sample_form = UploadSampleForm()
families_choices = [(0, "None")]
families_choices += [(f.id, f.name) for f in Family.query.order_by('name')]
upload_sample_form.family.choices = families_choices
uncategorized = []
if g.user.is_authenticated:
uncategorized = api.samplecontrol.get_user_uncategorized_samples(
g.user)
return render_template('index.html',
families=api.familycontrol.get_all(),
impform=machex_import_form,
uncategorized=uncategorized,
form=upload_sample_form)
def login():
"""
Flask-Login.
"""
if g.user.is_authenticated:
return redirect(url_for('index'))
login_form = LoginForm()
if login_form.validate_on_submit():
username = login_form.username.data
user = api.usercontrol.get_by_name(username)
if user is None:
return redirect(url_for('login'))
if api.usercontrol.check_user_pass(user, login_form.password.data):
login_user(user, remember=True)
security.datastore.commit()
flash("Logged in!", "success")
return redirect(url_for("index"))
else:
flash("Cannot login...", "error")
return render_template('login.html', title='Sign In', form=login_form)
def register_user():
"""
User registration, if enabled in configuration file.
"""
if g.user.is_authenticated or app.config['USERS_CAN_REGISTER'] is not True:
return redirect(url_for('index'))
registration_form = UserRegistrationForm()
if registration_form.validate_on_submit():
ret = api.usercontrol.create(registration_form.username.data,
registration_form.password.data,
registration_form.completename.data)
if ret:
return redirect(url_for('login'))
else:
app.logger.error("Error during user registration")
flash("Error registering user")
return render_template('register.html',
form=registration_form)
def userlist():
u=User()
form=AddUserForm()
flag=current_user.is_administrator(g.user)
if flag is True:
userlist=u.GetUserList()
jsondata=request.get_json()
if request.method == 'POST' and jsondata:
if jsondata['action'] == u'edit':
username=jsondata['username']
location=url_for('.admin_edit_profile',username=username)
return jsonify({"status":302,"location":location})
else:
username=jsondata['username']
u.RemUser(username)
return redirect('userlist')
elif request.method == 'POST' and form.validate():
pwd=u.GetPassword(g.user)
if u.verify_password(form.oripassword.data):
u.AddUser(form.username.data,form.password.data,form.role.data,form.email.data)
return redirect('userlist')
else:
return render_template('userlist.html',userlist=userlist,form=form)
else:
abort(403)
def admin_edit_profile(username):
u=User()
form=AdminEditProfileForm()
flag=current_user.is_administrator(g.user)
if request.method == 'POST' and form.validate():
if flag is True:
pwd=u.GetPassword(g.user)
if u.verify_password(form.oripassword.data):
email=form.email.data
aboutme=form.about_me.data
role=form.role.data
if form.password.data is not u'':
u.ChangePassword(username,form.password.data)
u.AdminChangeProfile(username,email,role,aboutme)
flash('??????')
return redirect(url_for('.user',username=username))
else:
flash('??????????')
else:
abort(403)
u.GetUserInfo(username)
form.email.data=u.email
form.about_me.data=u.aboutme
form.role.data=u.role
return render_template('admin_edit_profile.html',form=form,u=u)
def log():
flag=current_user.is_administrator(g.user)
if flag is True:
p=Page()
record=p.GetRecord()
records={}
records=OrderedDict()
total=len(record)
page = request.args.get('page',1,type=int)
per_page=10
keys=record.keys()
offset=(page - 1) * per_page
for i in range(len(keys)):
if i < per_page and (offset+i) < len(keys):
records[keys[offset+i]]=record[keys[offset+i]]
else:
break
pagination=Pagination(css_framework='bootstrap3',link_size='sm',show_single_page=False,page=page,per_page=per_page,total=total,format_total=True,format_number=True)
return render_template('log.html',records=records,page=page,per_page=per_page,pagination=pagination)
else:
abort(403)
def Add(self,title):
flag=GetImage(title.encode('utf8'))
if flag==True:
timenow=time.time()
r.zadd('expire',MU_MainConfig.EDITEDPREFIX+title,timenow)
r.hset('queue',MU_MainConfig.EDITEDPREFIX+title,title)
r.zadd('queuenumber',title,0)
scorequeue=r.zrange('queuenumber',0,-1)
pushtime=r.hget('pushtime',g.user)
r.hset('pushtime',g.user,int(pushtime)-1)
for i in range(len(scorequeue)):
score=r.zscore('queuenumber',scorequeue[i])
r.zadd('queuenumber',scorequeue[i],score+1)
img=r.hget('img',MU_MainConfig.EDITEDPREFIX+title)
r.hset('imgkey',title,img)
return True
else:
return False
def post(self):
args = login_parser.parse_args()
_user = User.get_object(username=args.username)
if not _user.verify_password(args.password):
return http_responses.HTTP_400_BAD_REQUEST(msg={"error": u"????"})
token = _user.generate_auth_token()
g.user = _user
# ?????????
# if not hasattr(g, "identity"):
_permissions = cache_user_privileges(token)
permissions = set()
for per in _permissions:
permissions.add(".".join([per.name, per.needs.name]))
return http_responses.HTTP_200_OK(msg={"message": "Login success",
"username": _user.username,
"nickname": _user.nickname,
"id": _user.id,
"is_superuser": _user.is_superuser,
"permissions": list(permissions),
"token": token})
def create_blog_post():
"""
Creates a new blog post
"""
if not request.json:
abort(400)
title = request.json.get('title')
content = request.json.get('content')
tags = request.json.get('tags')
author = g.user
if not title or not content:
abort(400)
post = BlogPost()
post.title = title
post.content = content
if tags:
post.tags = tags
post.author = author.id
db.session.add(post)
db.session.commit()
return jsonify({
"status": "Created",
"code": 201,
"message": "Blog post created!"
}), 201
def jsonhistory():
history = db.session.query(models.Processed)
table = DataTable(request.args, models.Processed, history, [
("date", "time", lambda i: "{}".format(i.time.strftime('%Y/%m/%d')) if i.stopped else '<span class="orange">{}</span>'.format(_("Currently watching..."))),
("ipaddress", lambda i: "{}".format(i.get_xml().find('Player').get("address"))),
("user", lambda i: '<a href="{0}" class="invert-link">{1}</a>'.format(url_for('user', name=i.user), i.user)),
("platform"),
("title", lambda i: u'<a class="invert-link" href="{0}">{1}</a>'.format(url_for('info', id=i.get_xml_value('ratingKey')), i.title)),
("type", lambda i: "{}".format(i.get_xml_value("type"))),
("streaminfo", lambda i: '<a href="#" data-link="{0}" class="orange" data-target="#streamModal" data-toggle="modal"><i class="glyphicon glyphicon glyphicon-info-sign"></i></a>'.format(url_for('streaminfo',id=i.id)) if i.platform != "Imported" else ''),
("time",lambda i: "{}".format(i.time.strftime('%H:%M'))),
("paused_counter", lambda i: "{} min".format(int(i.paused_counter)/60) if i.paused_counter else "0 min" ),
("stopped", lambda i: "{}".format(i.stopped.strftime('%H:%M')) if i.stopped else "n/a"),
("duration", lambda i: "{} min".format(int((((i.stopped - i.time).total_seconds() - (int(i.paused_counter or 0))) /60))) if i.stopped else "n/a"),
("completed", lambda i: '<span class="badge badge-warning">{}%</span>'.format(helper.getPercentage(i.get_xml_value("duration") if i.platform == "Imported" else i.get_xml_value("viewOffset"), i.get_xml_value("duration")))),
])
table.searchable(lambda queryset, user_input: perform_some_search(queryset, user_input))
return json.dumps(table.json())
def templates():
if request.method == "GET":
templates = Template.domain_query(g.domain).fetch()
return render_template("templates.html", templates=templates)
form = TemplateForm(request.form, domain=g.domain)
if form.validate_on_submit():
template = Template(
name=form.name.data,
text=form.text.data,
subject=form.subject.data,
sender=g.user.email(),
owner_domain=g.domain,
created_by=g.user.email())
template.put()
return jsonify(template.to_dict())
return json_error(400, list_errors(form), {})
def edit_template(template_id):
'''
Edits an existing template.
Args:
template_id - int - The ID of the template to edit
'''
template = Template.get_by_id(template_id)
if not template or template.owner_domain != g.domain:
abort(404)
form = TemplateForm(request.form, domain=g.domain, template_id=template_id)
if form.validate_on_submit():
template.name = form.name.data
template.text = form.text.data
template.subject = form.subject.data
template.sender = g.user.email()
template.put()
return jsonify(template.to_dict())
return json_error(400, list_errors(form), {})
def send_test_template():
'''
Sends a test template to the provided address
'''
form = SendTestTemplateForm(request.form)
if form.validate_on_submit():
report = EmailReport.make_sample()
try:
subject = render_template_string(form.subject.data, report=report)
text = render_template_string(form.text.data, report=report)
email_provider.send(
to=form.recipient.data,
sender=g.user.email(),
subject=subject,
body=text)
return jsonify({'success': True, 'message': 'Sent test email.'})
except Exception as e:
return json_error(400, str(e), {})
return json_error(400, list_errors(form), {})
def search_user():
query = request.args.get('q', '')
results = User.search(query)
simplified = list()
for result in results:
entry = {
'link': '/admin/user/manage/%s' % result.doc_id
}
for field in result.fields:
if field.name == 'created':
entry[field.name] = arrow.get(field.value).humanize()
else:
entry[field.name] = field.value
simplified.append(entry)
extra = {
'total': results.number_found,
'shown': len(results.results),
}
return render_template('admin-user-search.html', results=simplified, extra=extra)
def delete():
if request.method == 'POST':
dos = arrow.get(g.user.created).humanize()
calendars = len([c for c in Calendar.query(ancestor=g.user.key)])
todos = len([e for e in Event.query(ancestor=g.user.key)])
subject = '%s %s closed their account' % (g.user.first_name, g.user.last_name)
body = '''
%s (joined %s, made %d todos and had %d calendars)
%s
''' % (g.user.email, dos, todos, calendars, request.form.get('feedback'))
mail.send_mail(sender=EMAILS['alerts'], to=EMAILS['support'], subject=subject, body=body)
calendars = Calendar.get_all(g.user.key)
for calendar in calendars:
for event in Event.get_all(calendar.key):
event.key.delete()
calendar.key.delete()
User.unindex(g.user.key.urlsafe())
g.user.key.delete()
session.pop('user', None)
return redirect('/index.html')
return render_template('delete.html')
def update_or_delete_comment(defendant=None, comment=None):
""" Update or delete defendant comments
"""
if request.method == 'PUT':
body = request.get_json()
return CommentsController.update(
body,
comment_id=comment,
user_id=g.user.id
)
else:
return CommentsController.delete(
comment_id=comment,
defendant_id=defendant,
user_id=g.user.id
)
def update_or_delete_comment(ticket=None, comment=None):
""" Update or delete ticket comments
"""
if request.method == 'PUT':
body = request.get_json()
return CommentsController.update(
body,
comment_id=comment,
ticket_id=ticket,
user_id=g.user.id
)
else:
return CommentsController.delete(
comment_id=comment,
ticket_id=ticket,
user_id=g.user.id
)
def __call__(self, func):
@wraps(func)
def decorator(*args, **kwargs):
response = func(*args, **kwargs)
if not USE_CACHE:
return response
for path in self.routes:
route = '%s,%s,%s' % (path, json.dumps(self.args), None)
Cache.delete(unicode(route))
user = kwargs.get('user', None) if self.clear_for_user else None
Logger.debug(unicode('clear %s from cache' % (route)))
if user:
route = '%s,%s,%s' % (path, json.dumps(self.args), user)
Cache.delete(unicode(route))
Logger.debug(unicode('clear %s from cache' % (route)))
return response
return decorator
def authenticate():
# logger.debug("endpoint request: %s" % request.endpoint)
if re.search('tenant_provisioned', str(request.endpoint)):
g.user = "phone_home"
logger.info("Authentication bypassed: tenant_provisioned")
return
try:
decoded = jwt.decode(request.headers['X-Auth-Token'], credentials['tenant_secret'], algorithms=['HS256'])
g.user = decoded['user']
except KeyError:
logger.error("Error: key error.")
abort(401)
except jwt.DecodeError:
logger.error("Error: decode error")
abort(401)
def create_tenant():
logger.info("User %s requested creation", g.user)
data = request.get_json(force=True)
logger.debug("Request data: %s" % data)
mconf = data['machine_conf'] if 'machine_conf' in data else CONF.MACHINE
cconf = data['cloud_conf'] if 'cloud_conf' in data else CONF.CLOUD_CONFIG
ip, machine_id = tenant_create(tenant_name=data['tenant'],
tenant_keys=extract_keys(data['pub_key']),
image_name_or_id=data['image_id'],
credentials=credentials, cloud_conf=cconf,
machine_conf=mconf)
tenant = Tenant(tenant_name=data['tenant'], machine_id=machine_id, ip=ip)
db.session.add(tenant)
db.session.commit()
return jsonify(tenant=data['tenant'], machine_id=machine_id, ip=ip), 202
def update_query():
K = '%s_%s' %(g.user,g.secret_key)
Key = '%s_update_php' %K
Key_incr = '%s_incr' % Key
Redis.expire(Key,30)
if Redis.lrange(Key,0,-1):
data = Redis.rpop(Key)
if '_End_' in data:
Redis.expire(Key,3)
return render_template_string(data)
else:
Redis.incr(Key_incr, 1)
if int(Redis.get(Key_incr)) > 10000:
Redis.delete(Key_incr)
return render_template_string("_End_")
return render_template_string("")
def publish_java_query():
K = '%s_%s' %(g.user,g.secret_key)
messageKey = '%s_publish_java' % K
Key_incr = '%s_incr' % messageKey
myRedis.expire(messageKey,30)
if myRedis.lrange(messageKey,0,-1):
data = myRedis.rpop(messageKey)
if '_End_' in data:
myRedis.expire(messageKey,3)
return render_template_string(data)
else:
myRedis.incr(Key_incr, 1)
if int(myRedis.get(Key_incr)) > 10000:
myRedis.delete(Key_incr)
return render_template_string("_End_")
return render_template_string("")
def update_java_query():
K = '%s_%s' %(g.user,g.secret_key)
messageKey = '%s_update_java' % K
Key_incr = '%s_incr' % messageKey
myRedis.expire(messageKey,30)
if myRedis.lrange(messageKey,0,-1):
data = myRedis.rpop(messageKey)
if '_End_' in data:
myRedis.expire(messageKey,3)
return render_template_string(data)
else:
myRedis.incr(Key_incr, 1)
if int(myRedis.get(Key_incr)) > 10000:
myRedis.delete(Key_incr)
return render_template_string("_End_")
return render_template_string("")
def authenticate(func):
@wraps(func)
def authenticate_requests(*args, **kwargs):
"""
The authentication_function can be either empty, which
results in all requests being taken as granted and authenticated.
Otherwise the authentication_function must return one of these values:
1- False -> To indicate the user is not authenticated
2- g.user global user instance ->
+ not None: access is granted.
+ None: access is denied.
3- jsonified error message:
+ It is directly returned to user, e.g.:
return jsonify(error="Authentication failed!"), 403
"""
authenticated = False
if (global_config.DEBUG):
app.ext_logger.info(
request.endpoint.replace(":", "/").replace(".", "/").lower())
# authenticate users here!
if hasattr(app, "authentication_function"):
authenticated = app.authentication_function(
global_config.X_AUTH_TOKEN)
else:
return func(*args, **kwargs)
if authenticated is False:
return jsonify(errors=["Authentication failed!"]), 403
elif g.user is not None:
return func(*args, **kwargs)
else:
return authenticated
return authenticate_requests
