from flasgger import swag_from from flask import Blueprint, jsonify, request from DBUtil import PreRequisites from Services.AppInitServices import authService from Services import HelperServices from settings import mongodb, relative_path from flask_restplus import Resource from modules.apimodels import PreRequisitesModel from modules.apimodels.Restplus import api,header_parser from modules.apimodels.GenericReponseModel import generic_post_response_model,generic_response_model # blueprint declaration preRequisitesAPI = Blueprint('PreRequisitesAPI', __name__) #restplus delaration preRequisitesAPINs = api.namespace('prerequisites', description='Prerequisites Operations') # from werkzeug import secure_filename # get global db connection db = mongodb # collections preRequisitesDB = PreRequisites.PreRequisites(db) # classes @preRequisitesAPINs.route('/add', methods=['POST']) class AddpreRequisites(Resource): @api.expect(header_parser,PreRequisitesModel.add_prerequisites_input_model,validate=True)
from DBUtil import Repository from settings import mongodb from flask import request, jsonify from flask_restplus import Resource from modules.apimodels.Restplus import api, header_parser from Services import RepositoryHelperService, HelperServices from modules.apimodels import RepositoryAPIModel from Services.AppInitServices import authService from bson.json_util import dumps import json RepositoryAPINs = api.namespace('repository', description='Repository Operations', path="/repository") # get global db connection db = mongodb # collection Repositorydb = Repository.Repository() @RepositoryAPINs.route('/add', methods=['POST']) class add_repository(Resource): @api.expect(header_parser, RepositoryAPIModel.repo_create_request, validate=True) @api.marshal_with(RepositoryAPIModel.repo_create_response) @authService.authorized def post(self): repo_data = request.get_json() repo_id = RepositoryHelperService.add_repo(repo_data)
from Services import SyncServices, FileUtils,PullServices, PushServices,SyncHelperService,Utils,CleanerServices from Services.AppInitServices import authService from settings import mongodb, import_full_path, export_full_path, export_path, relative_path, saved_export_full_path, \ saved_export_path from flask_restplus import Resource from modules.apimodels.Restplus import api, header_parser from modules.apimodels import SyncAPIModel from modules.apimodels.GenericReponseModel import generic_response_model # get global db connection db = mongodb # blueprint declaration syncAPI = Blueprint('syncAPI', __name__) # restPlus Declaration syncAPINs = api.namespace('sync', description='Sync Operations',path="/sync") # get global db connection db = mongodb # collection syncDb = Sync.Sync(db) userDb = Users.Users(db) configDb = Config.Config(db) cleanerServices = CleanerServices.CleanerServices(mongodb) SavedExportsDb = SavedExports.SavedExports() syncRequestDb = SyncRequest.SyncRequest(db)
from flask import Blueprint from DBUtil import ToolsOnMachine from Services.AppInitServices import authService from settings import mongodb from modules.apimodels import ToolsOnMachineAPIModel from flask_restplus import Resource, marshal_with from modules.apimodels.Restplus import api, header_parser from functools import wraps # blueprint declaration toolsOnMachineAPI = Blueprint('toolsOnMachineAPI', __name__) toolsOnMachineAPINs = api.namespace('deployed', description='Deployed Tools Operations') # get global db connection db = mongodb toolsOnMachineDB = ToolsOnMachine.ToolsOnMachine(db) def selective_marshal_with(responseModel, noneResponseModel): def decorator(func): @wraps(func) def wrapper(*args, **kwargs): func2 = marshal_with(responseModel)(func) response = func2(*args, **kwargs) res = response[0] if res.get("data").get("create_date"): return response else: lst = list(response) lst[0]["data"] = None
from flask import Blueprint, request from DBUtil import Tags from Services import TeamService, TagHelperService, HelperServices from Services.AppInitServices import authService from settings import mongodb from flask_restplus import Resource from modules.apimodels import TagModel from modules.apimodels.Restplus import api, header_parser from modules.apimodels.GenericReponseModel import generic_response_model tagAPI = Blueprint('TagAPI', __name__) tagAPINs = api.namespace('tag', description='Tag Operations') # get global db connection db = mongodb tagDB = Tags.Tags() teamService = TeamService.TeamService() @tagAPINs.route('/all', methods=['GET']) class getalltag(Resource): @api.expect(header_parser, validate=True) @api.marshal_with(TagModel.get_all_tags_response_model) @authService.authorized def get(self): return {"result": "success", "data": list(tagDB.get_tags())}, 200 @tagAPINs.route('/view/<id>', methods=['GET']) @api.doc(params={'id': 'Tag ID'})
from time import mktime import json from bson.json_util import dumps from flasgger import swag_from, validate from flask import Blueprint, jsonify, request from DBUtil import Config from Services import MailerService, DeploymentRequestService, CloneRequestService, SyncServices, PushServices, PullServices, DistributionCenterService, DistributionSyncServices, ContributionGitPushService, CleanerServices from Services.AppInitServices import authService from settings import mongodb, relative_path from flask_restplus import Resource from modules.apimodels.Restplus import api, header_parser from modules.apimodels import ConfigModel # blueprint declaration configAPI = Blueprint('configAPI', __name__) configAPINs = api.namespace('config', description='Config Operations') # get global db connection db = mongodb # collection configdb = Config.Config(db) mailerConfig = configdb.getConfigByName("MailerService") deploymentConfig = configdb.getConfigByName("DeploymentRequestService") cloneConfig = configdb.getConfigByName("CloneRequestService") syncConfig = configdb.getConfigByName("SyncServices") pullConfig = configdb.getConfigByName("PullServices") pushConfig = configdb.getConfigByName("PushServices") distributionCenterConfig = configdb.getConfigByName("PushServices") distributionSyncConfig = configdb.getConfigByName("DistributionSyncServices")
from flask import request from DBUtil import ProposedTools from Services.AppInitServices import authService from settings import mongodb from flask_restplus import Resource from modules.apimodels.Restplus import api, header_parser from Services import ProposedToolsHelper from modules.apimodels import ProposedToolsModel # get global db connection db = mongodb proposedToolsAPINs = api.namespace('proposedtool', description='Proposed Tools Operations', path="/proposed/tool") proposedToolsDB = ProposedTools.ProposedTools() @proposedToolsAPINs.route('/new', methods=['POST']) class CreatePT(Resource): @api.expect(ProposedToolsModel.pt_create_request, validate=True) @authService.unauthorized @api.marshal_with(ProposedToolsModel.pt_create_response) def post(self): """ Create new PT definition """ pt_create_request_details = request.get_json() proposed_data = ProposedToolsHelper.create_request( pt_create_request_details) pt_id = proposedToolsDB.add(proposed_data) ProposedToolsHelper.email_tool_proposed(pt_create_request_details)
from flasgger import swag_from from flask import Blueprint, jsonify, request from bson.json_util import dumps from DBUtil import MediaFiles, Versions from Services.AppInitServices import authService from settings import mongodb, relative_path from flask_restplus import Resource from modules.apimodels import MediaFilesModel from modules.apimodels.Restplus import api,header_parser from modules.apimodels.GenericReponseModel import generic_response_model # blueprint declaration mediafilesAPI = Blueprint('mediafilesAPI', __name__) #restplus delaration mediafilesAPINs = api.namespace('mediafiles', description='Media Files Operations') # get global db connection db = mongodb # collections mediaFilesDB = MediaFiles.MediaFiles(db) versionsDB = Versions.Versions(db) # classes @mediafilesAPINs.route('/update', methods=['PUT']) class UpdateMediaFile(Resource): @api.expect(header_parser,MediaFilesModel.update_media_files,validate=True)
from bson.json_util import dumps from flasgger import swag_from, validate from flask import Blueprint, jsonify, request from DBUtil import Machine, Users, MachineGroups, Tags, DeploymentRequestGroup, DeploymentRequest, State, Config from Services import TeamService, MachineGroupHelperService, HelperServices from Services.AppInitServices import authService from settings import mongodb, relative_path from flask_restplus import Resource from modules.apimodels import MachineGroupsModel from modules.apimodels.Restplus import api, header_parser # blueprint declaration machineGroupsAPI = Blueprint('MachineGroupsAPI', __name__) # restplus declaration machineGroupsAPINs = api.namespace('machinegroups', description='Machine Groups Operations') # collections machineDB = Machine.Machine(mongodb) tagDB = Tags.Tags() userdb = Users.Users(mongodb) machinegroupsDB = MachineGroups.MachineGroups(mongodb) teamService = TeamService.TeamService() deploymentRequestGroupDB = DeploymentRequestGroup.DeploymentRequestGroup( mongodb) deploymentRequestDb = DeploymentRequest.DeploymentRequest(mongodb) stateDb = State.State(mongodb) configDb = Config.Config(mongodb) @machineGroupsAPI.route('/machinegroups/add', methods=['POST']) @authService.authorized
sync_plugin_full_path, plugin_static_path, deployment_plugin_static_path,\ sync_plugin_static_path,repository_plugin_full_path,repository_plugin_static_path from Services import CustomClassLoaderService,DeploymentServices,PluginHelperService,\ Utils from genericpath import isfile from modules.apimodels import PluginModel, ExitPointPluginsModel from flask_restplus import Resource from modules.apimodels.Restplus import api, header_parser from modules.apimodels import GenericReponseModel from datetime import datetime import json # blueprint declaration PluginAPI = Blueprint('PluginAPI', __name__) PluginAPINs = api.namespace('plugin', description='Plugin Operations') # get global db connection db = mongodb # collections PluginsDB = Plugins.Plugins(db) exitPointPluginsDB=ExitPointPlugins.ExitPointPlugins() # classes plugins_manager = plugin_manager # PluginsManagerService() @PluginAPI.route('/plugin/reload', methods=['GET']) @authService.authorized @swag_from(relative_path + '/swgger/PluginAPI/reload_plugin.yml') def reload_plugin():
import traceback from bson.json_util import dumps from flask import Blueprint, jsonify from DBUtil import Users, SystemDetails, Reports from Services.AppInitServices import authService from settings import mongodb from flask_restplus import Resource from modules.apimodels.Restplus import api, header_parser from modules.apimodels import GenericReponseModel, ReportsModel # blueprint declaration reportAPI = Blueprint('reportAPI', __name__) reportAPINs = api.namespace('reports', description='Reports Operations') # get global db connection db = mongodb reportsDB = Reports.Reports() userDB = Users.Users(db) systemDetailsDB = SystemDetails.SystemDetails(db) @reportAPINs.route('/all', methods=['GET']) class getallreports(Resource): @api.expect(header_parser, validate=True) @api.marshal_with(ReportsModel.get_all_reports_response_model) @authService.authorized def get(self): """fetch all reports in DPM ---
from flasgger import swag_from from flask import Blueprint, jsonify from DBUtil import DeploymentUnitApprovalStatus, Users, SystemDetails from Services.AppInitServices import authService from settings import mongodb, relative_path from modules.apimodels.Restplus import api, header_parser from Services import DeploymentUnitApprovalStatusHelper from modules.apimodels import DeploymentUnitApprovalStatusAPIModel from flask_restplus import Resource from flask import request import json # blueprint declaration deploymentUnitApprovalStatusAPI = Blueprint('deploymentUnitApprovalStatusAPI', __name__) DeploymentUnitApprovalStatusAPINs = api.namespace( 'deploymentunitapprovalstatus', description='DeploymentUnitApprovalStatus Operations', path="/deploymentunitapprovalstatus") # get global db connection db = mongodb deploymentUnitApprovalStatusDB = DeploymentUnitApprovalStatus.DeploymentUnitApprovalStatus( ) userDB = Users.Users(db) systemDetailsDB = SystemDetails.SystemDetails(db) @deploymentUnitApprovalStatusAPI.route('/deploymentunitapprovalstatus/all', methods=['GET']) @authService.authorized @swag_from( relative_path +
from flasgger import swag_from from flask import Blueprint, jsonify, request from DBUtil import Users, Teams, Tags, Machine, Tool, DeploymentUnit, MachineGroups, ToolSet, DeploymentUnitSet from Services import TeamService, HelperServices from Services.AppInitServices import authService from settings import mongodb, relative_path from flask_restplus import Resource from modules.apimodels import ManageTeamsModel from modules.apimodels.Restplus import api, header_parser from modules.apimodels.GenericReponseModel import generic_post_response_model, generic_response_model # blueprint declaration manageTeamsAPI = Blueprint('ManageTeamsAPI', __name__) #restplus delaration manageTeamsAPINs = api.namespace('teams', description='Teams Operations') # get global db connection db = mongodb # collections userDB = Users.Users(db) teamDB = Teams.Teams(db) tagDB = Tags.Tags() machineDB = Machine.Machine(db) machinegroupsDB = MachineGroups.MachineGroups(db) toolDB = Tool.Tool(mongodb) toolsetdb = ToolSet.ToolSet(db) deploymentUnitDB = DeploymentUnit.DeploymentUnit() deploymentUnitSetDB = DeploymentUnitSet.DeploymentUnitSet() teamService = TeamService.TeamService()
from jsondiff import diff from werkzeug import secure_filename from DBUtil import DeploymentUnit, DeploymentUnitSet, Users, SystemDetails, State, Build, DeploymentUnitType from Services import FileUtils, HelperServices, TeamService, DuHelperService from Services.AppInitServices import authService from settings import mongodb, relative_path, logo_path, logo_full_path from flask_restplus import Resource from modules.apimodels import DeploymentUnitSetModel from modules.apimodels.Restplus import api, header_parser from modules.apimodels.GenericReponseModel import generic_post_response_model, generic_response_model # blueprint declaration deploymentUnitSetAPI = Blueprint('deploymentUnitSetAPI', __name__) deploymentUnitSetAPINs = api.namespace( 'deploymentunitset', description='Deployment Unit Set Operations') # get global db connection db = mongodb deploymentUnitSetDB = DeploymentUnitSet.DeploymentUnitSet() userDB = Users.Users(db) systemDetailsDB = SystemDetails.SystemDetails(db) teamService = TeamService.TeamService() deploymentUnitDB = DeploymentUnit.DeploymentUnit() stateDB = State.State(db) @deploymentUnitSetAPI.route('/deploymentunitset/all', methods=['GET']) @authService.authorized @swag_from(relative_path + '/swgger/DeploymentUnitSetAPI/getAllDeploymentUnitSets.yml') def getAllDeploymentUnitSets():
import json from bson.json_util import dumps from flask import Blueprint, jsonify, request from DBUtil import CloneRequest, SystemDetails from Services.AppInitServices import authService from settings import mongodb, current_path, logo_full_path, logo_path from flask_restplus import Resource from modules.apimodels import SystemDetailsModel from modules.apimodels.Restplus import api,header_parser # blueprint declaration systemdetailsAPI = Blueprint('systemdetailsAPI', __name__) #restplus delaration systemdetailsAPINs = api.namespace('systemdetails', description='System Details Operations') # get global db connection db = mongodb # collections cloneRequestDB = CloneRequest.CloneRequest(db) systemDetailsDB = SystemDetails.SystemDetails(db) # classes @systemdetailsAPI.route('/systemdetails/logoupload', methods=['POST']) @authService.authorized def upload_account_logo(): # This is the path to the upload directory
from Services import Mailer, TeamService, HelperServices from Services.SpecialUsers import SpecialUsers from Services.UserRoles import UserRoles from Services.AppInitServices import authService from settings import mongodb, dpm_type, relative_path, import_full_path from werkzeug import secure_filename from flask_restplus import Resource from modules.apimodels import UserModel from modules.apimodels.Restplus import api, header_parser from Services import LdapHelper from datetime import datetime, timedelta import re from Services.HelperServices import genrate_random_key # blueprint declaration userAPI = Blueprint('userAPI', __name__) userAPINs = api.namespace('user', description='User Operations') # get global db connection db = mongodb accountDB = Accounts.Accounts() userdb = Users.Users(db) roledb = Role.Role(db) machineFavDb = UserFavoriteMachine.UserFavoriteMachine(db) emaildb = Emails.Emails(db) perGroup = PermissionGroup.PermissionGroup(db) teamDB = Teams.Teams(db) mailer = Mailer.Mailer() systemDetailsDB = SystemDetails.SystemDetails(db) teamService = TeamService.TeamService() machine_db = Machine.Machine(db) configDb = Config.Config(db)
from flask_restplus import Resource from modules.apimodels.Restplus import api, header_parser from flask import request import json from DBUtil import Auditing from Services.AppInitServices import authService from Services import Utils auditdb = Auditing.Auditing() auditingAPINs = api.namespace('auditing', description='Auditing Operations') @auditingAPINs.route('/view/all', methods=['GET']) class get_audit_all(Resource): @api.expect(header_parser, validate=True) @authService.authorized def get(self): """ Get all auditing attributes """ limit = int(request.args.get('perpage', "0")) page = int(request.args.get('page', "0")) user = request.args.get('user', None) api_type = request.args.get('apitype', None) response_status_code = request.args.get('responsestatuscode', None) request_type = request.args.get('requesttype', None) filter = {} if user: user = user.split(",") if "any" not in user: filter["user"] = {}
from werkzeug import secure_filename from DBUtil import Tool, Versions, ToolSet, Tags, Build from Services import HelperServices, TeamService, FileUtils, ToolHelperService from Services.AppInitServices import authService from settings import mongodb, logo_path, logo_full_path, relative_path from flasgger import swag_from from flask_restplus import Resource from modules.apimodels import ToolSetModel from modules.apimodels.Restplus import api, header_parser from modules.apimodels.GenericReponseModel import generic_post_response_model, generic_response_model # blueprint declaration toolSetAPI = Blueprint('toolSetAPI', __name__) #restplus delaration toolSetAPINs = api.namespace('toolset', description='ToolSet Operations') # blueprint declaration toolSetAPI = Blueprint('toolSetAPI', __name__) # get global db connection db = mongodb # collection toolsetdb = ToolSet.ToolSet(db) tooldb = Tool.Tool(db) versionsDB = Versions.Versions(db) teamService = TeamService.TeamService() tagDB = Tags.Tags() buildDB = Build.Build()
from flask import Blueprint, jsonify, request from DBUtil import DeploymentRequest, DeploymentRequestGroup, Machine,\ Versions, MachineGroups, ToolSet, Tool, Counter,Build,DeploymentUnit,DeploymentUnitSet,Users,State from Services import DeploymentRequestService,\ HelperServices, BuildHelperService, DeploymentHelperService,StateHelperService,\ CustomClassLoaderService from Services.AppInitServices import authService from settings import mongodb, relative_path from modules.apimodels.Restplus import api, header_parser from modules.apimodels import DeploymentGroupModel # blueprint declaration deploymentgrouprequestAPI = Blueprint('deploymentgrouprequestAPI', __name__) #restplus deploymentgrouprequestAPINs = api.namespace('deploymentrequestgroup', \ description='Group Deployment Operations',path="/deploymentrequest/group") # get global db connection db = mongodb # collections deploymentRequestDB = DeploymentRequest.DeploymentRequest(db) deploymentRequestGroupDB = DeploymentRequestGroup.DeploymentRequestGroup(db) machineDB = Machine.Machine(db) versionsDB = Versions.Versions(db) machinegroupsDB = MachineGroups.MachineGroups(db) toolSetDB = ToolSet.ToolSet(db) deploymentRequestService = DeploymentRequestService.DeploymentRequestService(db) toolDB = Tool.Tool(db) CounterDB = Counter.Counter(db) buildDB = Build.Build()
from flask import request from DBUtil import FlexibleAttributes from Services.AppInitServices import authService from settings import mongodb from modules.apimodels import FlexAttributesModel from flask_restplus import Resource from modules.apimodels.Restplus import api, header_parser from Services import FlexibleAttributesHelper # get global db connection db = mongodb flexAttrDB = FlexibleAttributes.FlexibleAttributes() flexibleAttributesAPINs = api.namespace( 'flexattributes', description='Flex Attributes Operations') @flexibleAttributesAPINs.route('/new', methods=['POST']) class CreateFA(Resource): @api.expect(header_parser, FlexAttributesModel.fa_create_request, validate=True) @api.marshal_with(FlexAttributesModel.fa_create_response) @authService.authorized def post(self): """ Create new FA definition """ fa_create_request_details = request.get_json() FlexibleAttributesHelper.validate_fa(fa_create_request_details) if FlexibleAttributesHelper.is_fa_exists(fa_create_request_details): raise Exception("FA " + fa_create_request_details.get('name') +
from bson.json_util import dumps from flasgger import swag_from from flask import Blueprint, jsonify, request from werkzeug import secure_filename from DBUtil import DeploymentRequest, DeploymentRequestGroup, Machine, Versions, MachineGroups, ToolSet, Tool, DeploymentUnit, State from Services import DeploymentRequestService from Services.AppInitServices import authService from settings import mongodb, import_full_path, relative_path from modules.apimodels import DeploymentRequestModel # from time import time # from collections import OrderedDict # blueprint declaration deploymentrequestAPI = Blueprint('deploymentrequestAPI', __name__) deploymentrequestAPINs = api.namespace( 'deploymentrequest', description='Deployment Request Operations') # get global db connection db = mongodb # collections deploymentRequestDB = DeploymentRequest.DeploymentRequest(db) deploymentRequestGroupDB = DeploymentRequestGroup.DeploymentRequestGroup(db) machineDB = Machine.Machine(db) versionsDB = Versions.Versions(db) machinegroupsDB = MachineGroups.MachineGroups(db) toolSetDB = ToolSet.ToolSet(db) deploymentRequestService = DeploymentRequestService.DeploymentRequestService( db) deploymentUnitDB = DeploymentUnit.DeploymentUnit() toolDB = Tool.Tool(db)
import traceback, json from bson.json_util import dumps from flasgger import swag_from from flask import Blueprint, jsonify, request from DBUtil import Config, CloneRequest, Machine, DistributionMachine, DistributionSync, Tool, Accounts, Versions from Services import DistributionCenterService from Services.AppInitServices import authService from settings import mongodb, relative_path from flask_restplus import Resource from modules.apimodels import DistributionCenterModel from modules.apimodels.Restplus import api, header_parser # blueprint declaration distributionCenterAPI = Blueprint('distributionCenterAPI', __name__) # restplus declaration distributionCenterAPINs = api.namespace( 'clonerequest/distribution', description='Distribution Center Operations') # get global db connection db = mongodb # collection configdb = Config.Config(db) distributionCenterConfig = configdb.getConfigByName("PushServices") # collections cloneRequestDB = CloneRequest.CloneRequest(db) machineDB = Machine.Machine(db) distributionMachinetDB = DistributionMachine.DistributionMachine(db) if distributionCenterConfig: distributionCenterService = DistributionCenterService.DistributionCenterService( db)
from bson.json_util import dumps from flasgger import swag_from, validate from flask import Blueprint, jsonify, request from DBUtil import Accounts, Users, SystemDetails from Services.AppInitServices import authService from settings import mongodb, relative_path from flask_restplus import Resource from modules.apimodels import AccountAPIModel from modules.apimodels.Restplus import api,header_parser # blueprint declaration accountAPI = Blueprint('accountAPI', __name__) #restplus delaration accountAPINs = api.namespace('account', description='Account Operations') # get global db connection db = mongodb accountDB = Accounts.Accounts() userDB = Users.Users(db) systemDetailsDB = SystemDetails.SystemDetails(db) @accountAPI.route('/account/all', methods=['GET']) @authService.unauthorized @swag_from(relative_path + '/swgger/AccountAPI/getallaccounts.yml') def getallaccounts(): return jsonify(json.loads(dumps({"result": "success", "data": accountDB.get_accounts()}))), 200