class AuthCollection(Resource): def __init__(self, api=None, *args, **kwargs): super(AuthCollection, self).__init__(api, args, kwargs) self.auth = AuthController() @api.expect(auth_serializer) def post(self): data = request.json email = data.get('email') password = data.get('password') user = self.auth.login(email=email, password=password) if user: token = self.auth.generate_auth_token(id_user=user.id) if token: self.auth.save_token(token=token.decode(), id_user=user.id) response = { "status": "success", "message": "Logged successfuly", "X-API-KEY": token.decode() } return response, 200 else: response = {"status": "fail", "message": "Users does not exists"} return response, 404
def decorated(*args, **kwargs): token = request.headers.get("X-API-KEY") data, status = AuthController.auth_token_is_valid(token=token) auth_token = data.get('data') if not auth_token: return data, status return f(*args, **kwargs)
from flask import request from app.controllers.auth_controller import AuthController from library.engine.utils import json_response, cursor_to_list from library.engine.cache import cached_function EXECUTER_DATA_CACHE_TIMEOUT = 300 # 5 minutes open_ctrl = AuthController("open", __name__, require_auth=False) @cached_function(positive_only=True, cache_timeout=EXECUTER_DATA_CACHE_TIMEOUT) def get_executer_data(query, recursive=False, include_unattached=False): from app.models import Project, Datacenter, Group, Host host_fields = list(Host.FIELDS) group_fields = list(Group.FIELDS) if recursive: host_fields += ["all_tags", "all_custom_fields"] group_fields += ["all_tags", "all_custom_fields"] projects = Project.find(query) projects = cursor_to_list(projects) project_ids = [x["_id"] for x in projects] groups = Group.find({"project_id": {"$in": project_ids}}) groups = cursor_to_list(groups, fields=group_fields) group_ids = [x["_id"] for x in groups] if include_unattached: hosts = Host.find({})
from app.controllers.auth_controller import AuthController from library.engine.utils import resolve_id, json_response, paginated_data, json_exception from flask import request datacenters_ctrl = AuthController("datacenters", __name__, require_auth=True) def _get_dc_by_id(dc_id): from app.models import Datacenter dc_id = resolve_id(dc_id) return Datacenter.find_one({"$or": [{"_id": dc_id}, {"name": dc_id}]}) @datacenters_ctrl.route("/", methods=["GET"]) @datacenters_ctrl.route("/<datacenter_id>", methods=["GET"]) def show(datacenter_id=None): from app.models import Datacenter if datacenter_id is None: query = {} if "_filter" in request.values: name_filter = request.values["_filter"] if len(name_filter) >= 2: query["name"] = {"$regex": "^%s" % name_filter} datacenters = Datacenter.find(query) else: datacenter_id = resolve_id(datacenter_id) datacenters = Datacenter.find( {"$or": [{ "_id": datacenter_id }, { "name": datacenter_id
from flask import request from bson.objectid import ObjectId, InvalidId from app.controllers.auth_controller import AuthController from library.engine.utils import resolve_id, json_response, json_exception, paginated_data, diff groups_ctrl = AuthController("groups", __name__, require_auth=True) def _get_group_by_id(group_id): from app.models import Group group_id = resolve_id(group_id) return Group.find_one({ "$or": [ { "_id": group_id }, { "name": group_id } ] }) @groups_ctrl.route("/") @groups_ctrl.route("/<group_id>") def show(group_id=None): from app.models import Group if group_id is None: query = {} if "_filter" in request.values: name_filter = request.values["_filter"] if len(name_filter) >= 2: query["name"] = { "$regex": "^%s" % name_filter } if "project_id" in request.values: project_id = resolve_id(request.values["project_id"])
def update_user(user_id): data = request.get_json() controller = AuthController() controller.update(user_id, data) return jsonify(controller.content), controller.status
def signup(): return AuthController().signup()
from app.controllers.auth_controller import AuthController from flask import request, g from library.engine.utils import json_response, resolve_id, paginated_data, json_exception users_ctrl = AuthController("users", __name__, require_auth=True) @users_ctrl.route("/") @users_ctrl.route("/<user_id>") def show(user_id=None): from app.models import User if user_id is None: query = {} if "_filter" in request.values: name_filter = request.values["_filter"] if len(name_filter) >= 2: query["username"] = { "$regex": "^%s" % name_filter } users = User.find(query) else: user_id = resolve_id(user_id) users = User.find({ "$or": [ { "_id": user_id }, { "username": user_id } ] }) if users.count() == 0: return json_response({"errors":["User not found"]}, 404) try: data = paginated_data(users.sort("username")) except AttributeError as e:
def create_user (): data = request.get_json() ip_address = request.remote_addr controller = AuthController() controller.login(data, ip_address) return jsonify(controller.content), controller.status
def __init__(self, api=None, *args, **kwargs): super(AuthCollection, self).__init__(api, args, kwargs) self.auth = AuthController()
from flask import request, g from app.controllers.auth_controller import AuthController from library.engine.utils import resolve_id, paginated_data, \ json_response, clear_aux_fields, json_exception projects_ctrl = AuthController("projects", __name__, require_auth=True) @projects_ctrl.route("/", methods=["GET"]) @projects_ctrl.route("/<project_id>", methods=["GET"]) def show(project_id=None): "list/show handler for projects" from app.models import Project if project_id is None: query = {} if "_filter" in request.values: name_filter = request.values["_filter"] if len(name_filter) > 2: query["name"] = { "$regex": "^%s" % name_filter } projects = Project.find(query) else: project_id = resolve_id(project_id) projects = Project.find({ "$or": [ { "_id": project_id }, { "name": project_id } ] }) return json_response(paginated_data(projects.sort("name"))) @projects_ctrl.route("/", methods=["POST"]) def create(): from app.models import Project data = clear_aux_fields(request.json)
def logout(): return AuthController(Context(app.logger)).logout(request)
def signup(): return AuthController(Context(app.logger)).signup(request)
def delete_user(user_id): controller = AuthController() controller.remove(user_id) return jsonify(controller.content), controller.status
# Tag $puppet_class:<class_name> adds specified class # Tag $puppet_param:<param_key>=<param_value> adds classifier parameter # Tag $puppet_env:<environment_name> adds classifier environment # # All tags are processed sequentally in random order, having several parameters # with the same key results in undefined behaviour: you'll never be sure what # exact value is used # import re import yaml from flask import make_response from library.engine.utils import resolve_id, json_response, paginated_data, json_exception from app.controllers.auth_controller import AuthController puppet_ctrl = AuthController("puppet", __name__, require_auth=False) CLASS_EXPR = re.compile(r"^\$puppet_class:(.+)$") PARAM_EXPR = re.compile(r"^\$puppet_param:([^=]+)=(.+)$") ENV_EXPR = re.compile(r"^$puppet_env:(.+)$") def yaml_response(data): yaml_data = yaml.safe_dump(data, default_flow_style=False) return make_response(yaml_data, 200, {"Content-Type": "application/yaml"}) @puppet_ctrl.route("/enc/<host_id>", methods=["GET"]) def enc(host_id): from app.models import Host host_id = resolve_id(host_id)
def get_user (user_id): controller = AuthController() ip_address = request.remote_addr controller.get(user_id) return jsonify(controller.content), controller.status
from app.controllers.auth_controller import AuthController from flask import session, request, g from library.engine.utils import json_response account_ctrl = AuthController("auth", __name__, require_auth=False) @account_ctrl.route("/me", methods=["GET"]) def me(): if g.user is None: return json_response( { "errors": ["You must be authenticated first"], "state": "logged out" }, 403) else: user_data = g.user.to_dict() user_data["auth_token"] = g.user.get_auth_token().token return json_response({"data": user_data}) @account_ctrl.route("/authenticate", methods=["POST"]) def authenticate(): if g.user: user_data = g.user.to_dict() if "password_hash" in user_data: del (user_data["password_hash"]) return json_response({"status": "authenticated", "data": user_data}) from app.models import User data = request.json if data is None:
from app.blueprints.base_blueprint import Blueprint, BaseBlueprint, request, Security, Auth from app.controllers.auth_controller import AuthController url_prefix = '{}/auth'.format(BaseBlueprint.base_url_prefix) auth_blueprint = Blueprint('auth', __name__, url_prefix=url_prefix) auth_controller = AuthController(request) @auth_blueprint.route('/login', methods=['POST']) @Security.validator(['email|required', 'password|required']) def login(): return auth_controller.login() @auth_blueprint.route('/admin/login', methods=['POST']) @Security.validator(['email|required', 'password|required']) def admin_login(): return auth_controller.login(admin=True)
def login(): return AuthController().login()
from app.controllers.auth_controller import AuthController from library.engine.utils import resolve_id, json_response, paginated_data from flask import request hosts_ctrl = AuthController('hosts', __name__, require_auth=True) @hosts_ctrl.route("/", methods=["GET"]) @hosts_ctrl.route("/<host_id>", methods=["GET"]) def show(host_id=None): from app.models import Host if host_id is None: query = {} if "_filter" in request.values: name_filter = request.values["_filter"] if len(name_filter) >= 2: query["fqdn"] = { "$regex": "^%s" % name_filter } hosts = Host.find(query) else: host_id = resolve_id(host_id) hosts = Host.find({ "$or": [ { "_id": host_id }, { "fqdn": host_id }, { "short_name": host_id } ]}) data = paginated_data(hosts.sort("fqdn")) return json_response(data)
def logout(): return AuthController().logout()
def create_user(): data = request.get_json() controller = AuthController() controller.save(data) return jsonify(controller.content), controller.status