def __init__(self, db):
"""Initializing Variable """
self.configdb = Config.Config(db)
self.distributionMachinetDB = DistributionMachine.DistributionMachine(
db)
self.syncService = SyncServices.SyncServices()
self.machineDB = Machine.Machine(db)
self.mailer = Mailer.Mailer()
self.current_path = distribution_center_export_full_path
self.systemDetailsDb = SystemDetails.SystemDetails(db)
if not os.path.exists(self.current_path):
os.makedirs(self.current_path)
if not os.access(os.path.dirname(self.current_path), os.W_OK):
raise ValueError("The directory does not have write access :" +
self.current_path)
systemDetail = self.systemDetailsDb.get_system_details_single()
if not systemDetail:
raise Exception("systemDeatils not found")
if not systemDetail.get("hostname"):
raise Exception("hostname not found in systemDeatils")
self.remote_trigger_api_path = "/clonerequest/distribution/pull/" + \
systemDetail.get("hostname")
self.config_id = 12
self.load_configuration()
self.schedulerService = SchedulerService.SchedulerService()
self.remote_authentication_service = RemoteAuthenticationService.RemoteAuthenticationService(
)
def __init__(self):
self.versionsDB = Versions.Versions(mongodb)
self.toolDB = Tool.Tool(mongodb)
self.tagDB = Tags.Tags()
self.toolsetdb = ToolSet.ToolSet(mongodb)
self.deploymentunitsetdb = DeploymentUnitSet.DeploymentUnitSet()
self.deploymentunitdb = DeploymentUnit.DeploymentUnit()
self.teamDB = Teams.Teams(mongodb)
self.machineDB = Machine.Machine(mongodb)
self.machinegroupsDB = MachineGroups.MachineGroups(mongodb)
self.toolsetdb = ToolSet.ToolSet(mongodb)
self.userdb = Users.Users(mongodb)
self.roledb = Role.Role(mongodb)
def __init__(self):
self.db = mongodb
self.current_import_path = import_full_path
if self.current_import_path in [None, ""]:
raise ValueError("Import path was not provided")
if not os.path.exists(self.current_import_path):
os.makedirs(self.current_import_path)
if not os.access(os.path.dirname(self.current_import_path), os.W_OK):
raise ValueError("The directory does not have write access :" +
self.current_import_path)
self.current_export_path = export_full_path
if self.current_export_path in [None, ""]:
raise ValueError("Export path was not provided")
if not os.path.exists(self.current_export_path):
os.makedirs(self.current_export_path)
if not os.access(os.path.dirname(self.current_export_path), os.W_OK):
raise ValueError("The directory does not have write access :" +
self.current_export_path)
self.configdb = Config.Config(self.db)
self.versionsDB = Versions.Versions(self.db)
self.toolDB = Tool.Tool(self.db)
self.deploymentFieldsDB = DeploymentFields.DeploymentFields(self.db)
self.machineDB = Machine.Machine(self.db)
self.syncDb = Sync.Sync(self.db)
self.mailer = Mailer.Mailer()
self.syncRequestDb = SyncRequest.SyncRequest(self.db)
self.buildsDB = Build.Build()
self.documentsDB = Documents.Documents(self.db)
self.toolDB = Tool.Tool(self.db)
self.deploymentunitDB = DeploymentUnit.DeploymentUnit()
self.deploymentunitsetDB = DeploymentUnitSet.DeploymentUnitSet()
self.mediaFilesDB = MediaFiles.MediaFiles(self.db)
self.tagsDB = Tags.Tags()
self.preRequisitesDB = PreRequisites.PreRequisites(self.db)
self.logo_path = logo_path
self.full_logo_path = logo_full_path
self.media_files_path = media_path
self.full_media_files_path = media_full_path
self.systemDetailsDb = SystemDetails.SystemDetails(self.db)
self.systemDetail = self.systemDetailsDb.get_system_details_single()
self.statedb = State.State(self.db)
if not self.systemDetail:
raise Exception("systemDeatils not found")
self.config_id = 9
self.load_configuration()
self.schedulerService = SchedulerService.SchedulerService()
self.flexAttrDB = FlexibleAttributes.FlexibleAttributes()
# 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)
distributionsyncDB = DistributionSync.DistributionSync(db)
tooldb = Tool.Tool(db)
versionsDB = Versions.Versions(db)
accountDB = Accounts.Accounts()
distributionMachinetDB = DistributionMachine.DistributionMachine(db)
# classes
@distributionCenterAPI.route('/clonerequest/distribution/all', methods=['GET'])
@authService.authorized
@swag_from(
import unittest
import requests
from GetAuthToken import getToken
import json
from settings import mongodb,unittest_test_url
from DBUtil import MachineGroups,Accounts,Users,MachineType,Machine
import verifyResponse
UsersDb=Users.Users(mongodb)
AccountsDb=Accounts.Accounts()
MachineDb=Machine.Machine(mongodb)
MachineTypeDb=MachineType.MachineType(mongodb)
MachineGroupdb=MachineGroups.MachineGroups(mongodb)
Baseurl = unittest_test_url+"machinegroups/"
header = {'content-type': "application/json",
'token':str(getToken())}
class AddMachineGroupTest(unittest.TestCase):
oid=None;
MacOid1=None;
MacOid2=None
def runTest(self):
CreateMachinesForMachineGroup()
url=Baseurl+"add"
print "--------------------------------------------------------------------------------------------------------"
print "Calling API :"+url + " For Create MachineGroup test"
payload={"group_name":"UnitTestMachineGroup",
"machine_id_list":[AddMachineGroupTest.MacOid1,
AddMachineGroupTest.MacOid2]}
response = requests.request("POST", url, data=json.dumps(payload), headers=header,verify=False)
verifyResponse.PositiveTesting(response)
'''
Created on Jan 5, 2018
@author: vijasing
'''
from DBUtil import Teams, Machine, Users, Role, UserFavoriteMachine
from settings import mongodb
from Services.AppInitServices import authService
from flask import jsonify
teamsdb = Teams.Teams(mongodb)
machinedb = Machine.Machine(mongodb)
userdb = Users.Users(mongodb)
roledb = Role.Role(mongodb)
machineFavDb = UserFavoriteMachine.UserFavoriteMachine(mongodb)
def delete_user(uid):
"""Start User Deletion"""
user_id = authService.get_userid_by_auth_token()
if user_id is None:
return jsonify({
"result": "failed",
"message": "Token verification failed"
}), 404
loggedInUser = userdb.get_user_by_id(user_id, False)
UserToDelete = userdb.get_user_by_id(uid, False)
loggedInUserRole = roledb.get_role_by_id(loggedInUser["roleid"], True)
if loggedInUserRole["name"].lower() == "superadmin":
pass
else:
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)
@userAPINs.route('/new', methods=['POST'])
class addNewUser(Resource):
@api.expect(header_parser, UserModel.add_user_input_model, validate=True)
@api.marshal_with(UserModel.add_user_response_model)
@authService.authorized
def post(self):
user = request.get_json()
HelperServices.validate_name(user.get("user"), "username")
user_id = authService.get_userid_by_auth_token()
if user_id is None:
raise Exception("Token verification failed")
loggedInUser = userdb.get_user_by_id(user_id, False)
'''
Created on Jan 5, 2018
@author: vijasing
'''
from DBUtil import Teams,Machine,DeploymentRequest,DeploymentUnitSet,DeploymentUnit,MachineGroups,\
DistributionMachine,DeploymentRequestGroup,CloneRequest,ToolsOnMachine,UserFavoriteMachine,MachineType,\
Accounts,Tags,Users, Tool, Versions, Build
from settings import mongodb
from Services import HelperServices, TeamService, FlexibleAttributesHelper, EnvironmentVariablesHelper, Utils, AccountHelperService
teamsdb = Teams.Teams(mongodb)
machinedb = Machine.Machine(mongodb)
deploymentrequestdb = DeploymentRequest.DeploymentRequest(mongodb)
deploymentrequestgroupdb = DeploymentRequestGroup.DeploymentRequestGroup(
mongodb)
deploymentunitsetdb = DeploymentUnitSet.DeploymentUnitSet()
deploymentunitdb = DeploymentUnit.DeploymentUnit()
machinegroupdb = MachineGroups.MachineGroups(mongodb)
distributionmachinetdb = DistributionMachine.DistributionMachine(mongodb)
clonerequestdb = CloneRequest.CloneRequest(mongodb)
toolsonmachinedb = ToolsOnMachine.ToolsOnMachine(mongodb)
machineFavDb = UserFavoriteMachine.UserFavoriteMachine(mongodb)
machineTypeDb = MachineType.MachineType(mongodb)
accountDB = Accounts.Accounts()
machineDB = Machine.Machine(mongodb)
tagDB = Tags.Tags()
teamsDb = Teams.Teams(mongodb)
teamService = TeamService.TeamService()
machinegroupDB = MachineGroups.MachineGroups(mongodb)
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
@swag_from(relative_path + '/swgger/MachineGroupsAPI/AddMachineGroups.yml')
def AddMachineGroups():