from flask_yoloapi import endpoint, parameter
from sqlalchemy import func
from findex_common.static_variables import FileProtocols
from findex_gui.web import app, db
from findex_gui.bin import validators
from findex_gui.bin.reachability import TestReachability
from findex_gui.orm.models import ResourceGroup
from findex_gui.controllers.amqp.amqp import MqController
from findex_gui.controllers.resources.resources import ResourceController
from findex_gui.controllers.resources.groups import ResourceGroupController
from findex_gui.controllers.user.decorators import admin_required
@app.route("/api/v2/resource/add", methods=["POST"])
@endpoint.api(parameter("server_name", type=str, required=False),
parameter("server_address", type=str, required=False),
parameter("server_id", type=int, required=False),
parameter("resource_port", type=int, required=True),
parameter("resource_protocol",
type=int,
required=False,
validator=validators.server_protocol),
parameter("auth_user", type=str, required=False),
parameter("auth_pass", type=str, required=False),
parameter("auth_type", type=str, required=False),
parameter("user_agent", type=str, required=False),
parameter("recursive_sizes", type=bool, required=False),
parameter("basepath", type=str, required=True),
parameter("display_url", type=str, required=False),
parameter("description", type=str, required=False),
import flask
from flask_yoloapi import endpoint, parameter
from findex_gui.web import app, locales
from findex_gui.bin import validators
from findex_gui.orm.models import User
from findex_gui.controllers.auth.auth import get_current_user_data
from findex_gui.controllers.user.decorators import login_required
from findex_gui.controllers.user.user import UserController
@app.route("/api/v2/user/delete", methods=["POST"])
@endpoint.api(
parameter("username", type=str, required=True)
)
def api_user_delete(username):
"""
Deletes an user.
:param username: the username in question
:return:
"""
user = UserController.user_delete(username=username)
return "user '%s' deleted" % username
@app.route("/api/v2/user/register", methods=["POST"])
@endpoint.api(
parameter("username", type=str, required=True),
parameter("password", type=str, required=True, validator=validators.strong_password)
)
def api_user_register(username, password):
from flask_yoloapi import endpoint, parameter
from findex_gui.web import app
from findex_gui.controllers.news.news import NewsController
from findex_gui.controllers.user.decorators import admin_required
@app.route("/api/v2/news/add", methods=["POST"])
@admin_required
@endpoint.api(parameter("content", type=str, required=True),
parameter("title", type=str, required=True))
def api_news_add(content, title):
NewsController.add(content=content, title=title)
return "post added"
@app.route("/api/v2/news/update", methods=["POST"])
@admin_required
@endpoint.api(parameter("uid", type=int, required=True),
parameter("content", type=str, required=False),
parameter("title", type=str, required=False))
def api_news_update(uid, content, title):
NewsController.update(uid=uid, content=content, title=title)
return "post updated"
def create_app():
app = Flask(__name__)
@app.route('/api/test_get')
@endpoint.api(parameter('name', type=str, required=True))
def api_test_get(name):
return name
@app.route('/api/test_get_coerce')
@endpoint.api(parameter('name', type=str, required=True),
parameter('age', type=int, required=True))
def api_test_get_coerce(name, age):
return [name, age]
@app.route('/api/test_any')
@endpoint.api(parameter('name', type=ANY, required=True))
def api_test_any(name):
return name
@app.route('/api/test_post', methods=['POST'])
@endpoint.api(parameter('name', type=str))
def api_test_post(name):
return name
@app.route('/api/test_get_default')
@endpoint.api(parameter('name', type=str, default='default'))
def api_test_get_default(name):
return name
@app.route('/api/test_datetime')
@endpoint.api(parameter('date', type=datetime, required=True))
def api_test_datetime(date):
return date
@app.route('/api/test_bool', methods=['GET', 'POST'])
@endpoint.api(parameter('flag', type=bool, required=True))
def api_test_bool(flag):
return flag
def age_validator(value):
# test custom exception
if value >= 150:
raise Exception("you can't possibly be that old!")
# test custom response
if value >= 120:
return Response('all lies', status=403)
# test invalid response
if value >= 110:
return 1, 1
@app.route('/api/test_validator')
@endpoint.api(
parameter('age', type=int, required=True, validator=age_validator))
def api_test_age_validator(age):
return age
@app.route('/api/test_broken_route')
@endpoint.api(parameter('age', type=int, required=False, default=28))
def api_test_broken_route(age):
raise Exception('whoops')
@app.route('/api/test_status_code')
@endpoint.api(parameter('age', type=int, required=False, default=28))
def api_test_status_code(age):
return "203 test", 203
@app.route('/api/test_bad_status_code')
@endpoint.api(parameter('age', type=int, required=False, default=28))
def api_test_bad_status_code(age):
return "203 test", 203, 1
class UFO:
def __init__(self):
self.foo = 'bar'
@app.route('/api/test_unknown_return')
@endpoint.api(parameter('age', type=int, required=False, default=28))
def api_test_unknown_return(age):
return UFO()
@app.route('/api/test_empty_return')
@endpoint.api()
def api_test_empty_return():
return
@app.route('/api/test_custom_return')
@endpoint.api()
def api_test_custom_return():
return Response("foo", 203)
@app.route('/api/test_docstring')
@endpoint.api(parameter("foo", default="bar", type=str))
def api_test_docstring(foo):
"""
Just a test. With multiple
lines.
:param foo: bar!
:param faulty line, should be ignored as a param.
:return: Nothing, really.
"""
raise Exception('whoops')
@app.route('/api/test_types', methods=["GET", 'POST'])
@endpoint.api(parameter('a', type=str, required=True),
parameter('b', type=int, required=True),
parameter('c', type=dict, required=False),
parameter('d', type=list, required=False),
parameter('e', type=datetime, required=True),
parameter('f', type=bool, required=False))
def api_test_types(a, b, c, d, e, f):
return [a, b, c, d, e, f]
if sys.version_info >= (3, 5):
@app.route('/api/test_type_annotations')
@endpoint.api(parameter('name', required=True),
parameter('age', required=False))
def api_test_type_annotations(name: str,
age: int,
location: str = "Amsterdam"):
return {"name": name, "age": age, "location": location}
@app.route('/api/test_type_annotations_fail')
@endpoint.api(parameter('name', required=True),
parameter('age', required=False))
def api_test_type_annotations_fail(name: str, age):
return {"name": name, "age": age}
return app
from datetime import datetime
from flask import request, redirect, Response, abort, render_template, url_for, flash, make_response, send_from_directory, jsonify
from flask.ext.login import login_user, logout_user, current_user, login_required, current_user
from flask_yoloapi import endpoint, parameter
import settings
from wowfunding.factory import app, db_session
from wowfunding.orm.orm import Proposal, User
@app.route('/api/1/proposals')
@endpoint.api(parameter('status', type=int, location='args', default=1),
parameter('cat', type=str, location='args'),
parameter('limit', type=int, location='args', default=20),
parameter('offset', type=int, location='args', default=0))
def api_proposals_get(status, cat, limit, offset):
try:
proposals = Proposal.find_by_args(status=status,
cat=cat,
limit=limit,
offset=offset)
except Exception as ex:
print(ex)
return 'error', 500
return [p.json for p in proposals]
@app.route('/api/1/convert/wow-usd')
@endpoint.api(parameter('wow', type=int, location='args', required=True))
def api_wow_usd(wow):
from flask_yoloapi import endpoint, parameter
from findex_common.utils_time import TimeMagic
from findex_gui.web import app
from findex_gui.controllers.user.decorators import admin_required
from findex_gui.controllers.admin.logs.logs import LogController
@app.route("/api/v2/admin/logs/get")
@admin_required
@endpoint.api(parameter("category", type=str),
parameter("limit", type=int, default=10),
parameter("offset", type=int, default=0))
def api_admin_scheduler_logs_get(category, limit, offset):
entries = LogController.get(category=category, limit=limit, offset=offset)
rtn = []
for entry in entries:
blob = entry.get_json()
blob["date_added_ago"] = TimeMagic().ago_dt(blob["date_added"])
rtn.append(blob)
return {
"records": rtn,
"totalRecordCount": len(rtn),
"queryRecordCount": -1
}
@app.route('/proposal/add/disclaimer')
def proposal_add_disclaimer():
return make_response(render_template(('proposal/disclaimer.html')))
@app.route('/proposal/add')
def proposal_add():
if current_user.is_anonymous:
return make_response(redirect(url_for('login')))
default_content = settings.PROPOSAL_CONTENT_DEFAULT
return make_response(render_template('proposal/edit.html', default_content=default_content))
@app.route('/proposal/comment', methods=['POST'])
@endpoint.api(
parameter('pid', type=int, required=True),
parameter('text', type=str, required=True),
parameter('cid', type=int, required=False)
)
def proposal_comment(pid, text, cid):
if current_user.is_anonymous:
flash('not logged in', 'error')
return redirect(url_for('proposal', pid=pid))
if len(text) <= 3:
flash('comment too short', 'error')
return redirect(url_for('proposal', pid=pid))
try:
Comment.add_comment(user_id=current_user.id, message=text, pid=pid, cid=cid)
except Exception as ex:
flash('Could not add comment: %s' % str(ex), 'error')
return redirect(url_for('proposal', pid=pid))
from flask import session
from flask_yoloapi import endpoint, parameter
from findex_gui.web import app
KEYS = ["search_display_view"]
VALUES = ["table", "fancy"]
@app.route("/api/v2/session/set", methods=["POST"])
@endpoint.api(parameter("key", type=str, required=True),
parameter("val", type=str, required=False))
def api_session_set(key, val):
if key not in KEYS:
return Exception("key \"%s\" doesn't exist" % key)
if val not in VALUES:
return Exception("could not set val \"%s\" - doesn't exist" % val)
session[key] = val
return "session key set"
@app.route("/api/v2/session/get", methods=["POST"])
@endpoint.api(parameter("key", type=str, required=True),
parameter("val", type=str, required=True))
def api_session_get(key, val):
if key not in KEYS:
return Exception("key \"%s\" doesn't exist" % key)
if key not in session:
session[key] = "fancy"
return session[key]
import re
import requests
from flask import jsonify, send_from_directory, Response
from flask_yoloapi import endpoint, parameter
from funding.bin.utils import get_ip
from funding.bin.qr import QrCodeGenerator
from funding.factory import app, cache
from funding.orm import Proposal
@app.route('/api/1/proposals')
@endpoint.api(
parameter('status', type=int, location='args', default=1),
parameter('cat', type=str, location='args'),
parameter('limit', type=int, location='args', default=20),
parameter('offset', type=int, location='args', default=0)
)
def api_proposals_get(status, cat, limit, offset):
try:
proposals = Proposal.find_by_args(status=status, cat=cat, limit=limit, offset=offset)
except Exception as ex:
print(ex)
return 'error', 500
return [p.json for p in proposals]
@app.route('/api/1/convert/wow-usd')
@endpoint.api(
parameter('amount', type=int, location='args', required=True)
@blueprint.route("/checklogin", methods=["GET"])
@cross_origin(supports_credentials=True)
@endpoint.api()
def loggedin():
if 'username' in session:
return {"isLoggedIn": True}
if 'username' not in session:
return {"isLoggedIn": False}
@blueprint.route("/login", methods=["POST"])
@cross_origin(supports_credentials=True)
@endpoint.api(
parameter('username', type=str, required=False),
parameter('password', type=str, required=False),
)
def login(username, password):
pass_salt = ('%s%s' % (password, admin_auth['salt'])).encode('utf-8')
pass_hash = sha256(pass_salt).hexdigest()
if username == admin_auth['username'] and pass_hash == admin_auth[
'password']:
session['username'] = username
return {"isLoggedIn": True}
else:
return {"message": "Username or password incorrect."}, 401
@blueprint.route("/logout", methods=["GET"])
@cross_origin(supports_credentials=True)
from flask import jsonify
from flask_yoloapi import endpoint, parameter
from sqlalchemy import func
from findex_gui.web import app, db
from findex_gui.orm.models import NmapRule
from findex_gui.controllers.user.decorators import admin_required
from findex_gui.controllers.nmap.nmap import NmapController
@app.route("/api/v2/admin/server/nmap/add", methods=["POST"])
@admin_required
@endpoint.api(parameter("rule", type=str, required=True),
parameter("name", type=str, required=True),
parameter("interval", type=str, required=False, default=None),
parameter("group", type=str, required=False, default="Default"))
def api_admin_server_nmap_add(rule, name, interval, group):
if isinstance(interval, str) and not interval.isdigit():
interval = None
else:
interval = int(interval)
return NmapController.add(cmd=rule,
name=name,
interval=interval,
group=group)
@app.route("/api/v2/admin/server/nmap/delete", methods=["POST"])
@admin_required
@endpoint.api(parameter("uid", type=int, required=True))
from flask_yoloapi import endpoint, parameter
from findex_gui.web import app
from findex_gui.bin import validators
from findex_gui.controllers.user.decorators import admin_required
from findex_gui.controllers.amqp.amqp import MqController
from findex_gui.controllers.amqp.amqp import AmqpConnectionController
@app.route("/api/v2/admin/mq/add", methods=["POST"])
@admin_required
@endpoint.api(
parameter("name", type=str, required=True),
parameter("broker",
type=str,
required=True,
default="rabbitmq",
validator=validators.amqp_broker),
parameter("host", type=str, required=True),
parameter("port", type=int, required=True),
parameter("vhost", type=str, required=True),
parameter("queue", type=str, required=True),
parameter("ssl", type=bool, required=False, default=False),
parameter("auth_user", type=str, required=True),
parameter("auth_pass", type=str, required=True),
)
def api_admin_mq_add(name, broker, host, port, vhost, queue, ssl, auth_user,
auth_pass):
"""
Adds a MQ server, for now, only rabbitmq is supported
:param name: name of the 'mq' broker
from flask import Blueprint, g
from flask_yoloapi import endpoint, parameter
from grant.proposal.models import Proposal, proposal_team
from grant.utils.auth import requires_sm, requires_same_user_auth, verify_signed_auth, BadSignatureException
from .models import User, SocialMedia, Avatar, users_schema, user_schema, db
blueprint = Blueprint('user', __name__, url_prefix='/api/v1/users')
@blueprint.route("/", methods=["GET"])
@endpoint.api(parameter('proposalId', type=str, required=False))
def get_users(proposal_id):
proposal = Proposal.query.filter_by(id=proposal_id).first()
if not proposal:
users = User.query.all()
else:
users = User.query.join(proposal_team).join(Proposal) \
.filter(proposal_team.c.proposal_id == proposal.id).all()
result = users_schema.dump(users)
return result
@blueprint.route("/me", methods=["GET"])
@requires_sm
@endpoint.api()
def get_me():
dumped_user = user_schema.dump(g.current_user)
return dumped_user
proposal = Proposal.query.filter_by(id=proposal_id).first()
if proposal:
dumped_proposal = proposal_schema.dump(proposal)
return {
"proposalId": proposal_id,
"totalComments": len(dumped_proposal["comments"]),
"comments": dumped_proposal["comments"]
}
else:
return {"message": "No proposal matching id"}, 404
@blueprint.route("/<proposal_id>/comments", methods=["POST"])
@requires_sm
@endpoint.api(
parameter('content', type=str, required=True)
)
def post_proposal_comments(proposal_id, user_id, content):
proposal = Proposal.query.filter_by(id=proposal_id).first()
if proposal:
comment = Comment(
proposal_id=proposal_id,
user_id=g.current_user.id,
content=content
)
db.session.add(comment)
db.session.commit()
dumped_comment = comment_schema.dump(comment)
return dumped_comment, 201
else:
return {"message": "No proposal matching id"}, 404
from findex_gui.controllers.search.search import SearchController
from flask_yoloapi import endpoint, parameter
from findex_common.static_variables import FileCategories
@app.route("/api/v2/search/<string:key>", methods=["GET"])
def api_search_get(key):
controller = SearchController()
result = controller.search(key=key)
return flask.jsonify(**result.get_json())
@app.route("/api/v2/search/<string:key>", methods=["POST"])
@endpoint.api(
parameter("file_categories", type=list),
parameter("file_extensions", type=list),
parameter("file_type", type=list),
parameter("file_size", type=str),
parameter("page", type=int, default=0),
parameter("per_page", type=int),
parameter("lazy_search", type=bool),
parameter("autocomplete", type=bool),
)
def api_search_post(key: str,
file_categories: list = None,
file_extensions: list = None,
file_size: list = None,
file_type: str = "both",
page: int = 0,
per_page: int = 30,
file_content = ""
with open(os.path.join(HERE_PATH, "../resources/" + ".".join((name, locale, extension))), "r", encoding="utf-8") as f:
file_content = f.read()
return file_content
@app.route("/resource/<name>/<locale>/<file_type>", methods=["GET"])
@endpoint.api()
def get_resource(name: str, locale: str, file_type: str = 'json'):
content = get_file_content(name.lower(), locale.lower(), file_type)
if (file_type == 'json'):
return json.loads(content)
return content
@app.route("/submitContactForm", methods=["POST"])
@endpoint.api(
parameter("name", type=str, required=True),
parameter("email", type=str, required=True),
parameter("message", type=str, required=True)
)
def submit_contact_form(name, email, message):
msg = EmailMessage()
msg.set_content(message)
msg["Subject"] = name + " - " + email
msg["From"] = "*****@*****.**"
msg["To"] = "*****@*****.**"
if MAILJET_SECRET != "":
with SMTP(MAILJET_URL, MAILJET_PORT) as smtp:
smtp.starttls()
smtp.login(MAILJET_USERNAME, MAILJET_SECRET)
smtp.send_message(msg)
else:
