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
