def process_management_grp_subscriptions(self, management_grp):
"""
The method finds all the subscriptions in a management group and then returns all the subscriptions underneath
The method then finds all the policy insights for each subscription and aggregates them
:param management_grp:
:return: pandas dataframe
"""
subscriptions = Subscriptions().dataframe_management_grp_subcriptions(
management_grp=management_grp)
aggregate_df = None
data_frame_list = list()
for index, row in subscriptions.iterrows():
try:
df_policy_insights = self.capture_policy_insights_for_subscription(
index)
if not df_policy_insights.empty:
print(df_policy_insights.shape)
print(len(df_policy_insights.index))
data_frame_list.append(df_policy_insights)
except QueryFailureException:
print("Subscription off limits: ", index)
if len(data_frame_list) > 0:
tmp_dataframe = data_frame_list[0]
for i in data_frame_list[1:]:
aggregate_df = tmp_dataframe.append(i)
tmp_dataframe = aggregate_df
return aggregate_df
def test_list(self):
response = Subscriptions().list()
if response.status_code in range(200, 299):
subscriptions = response.json()
if 'value' in subscriptions:
print('Total Number of subscriptions {}'.format(
len(subscriptions['value'])))
self.assertGreater(len(subscriptions['value']), 0)
for subscription in subscriptions['value']:
print(subscription['displayName'],
subscription['subscriptionId'])
else:
self.assertEqual(True, False)
def capture_subscriptions(self,
management_grp,
save_file=False,
filename=""):
"""
Grab all the subscriptions associated with a management group
:param management_grp:
:return:
"""
if management_grp is None:
raise ValueError
subscriptions = Subscriptions(
self.credentials).dataframe_management_grp_subcriptions(
management_grp=management_grp)
df = pd.DataFrame(
data=subscriptions,
columns=[
"subscription", "tenant_id", "subscription_name",
"managment_grp"
],
)
df.set_index("subscription", inplace=True)
self.subscriptions = df
if save_file:
df.to_csv(filename)
def test_list_subscriptions(self):
"""
:return:
"""
results = Subscriptions().list_subscriptions()
print(results)
def test_get_tags(self):
subscription_id = self.config['DEFAULT']['subscription_id']
subscription_tags = Subscriptions().get_tags_dictionary(
subscription_id, 'functional owner', 'financial owner',
'billing contact')
self.assertEqual(len(subscription_tags) == 3, True)
def test_list_subscription(self):
"""
:return:
"""
subscription_id = self.config['DEFAULT']['subscription_id']
results = Subscriptions().get(subscription_id)
print(results)
def __init__(self):
load_dotenv()
self.credentials = AzureConnections().get_authenticated_client()
with change_dir(OPERATIONSPATH):
self.config = ConfigParser()
self.config.read(CONFVARIABLES)
self.subscriptions = Subscriptions().list_displayname_and_id()
self.resource_cls = Resource()
def test_subscription_list_displayname_id(self):
"""
:return:
"""
credentials = AzureConnections().get_authenticated_client()
results = Subscriptions().list_displayname_and_id()
self.assertGreater(len(results), 0)
for i in results:
logging.debug(i)
def compile_tags(self):
'''
Storing subscription tags in a database table
'''
# create a configured "Session" class
# create a Session
batch_uuid = uuid.uuid4()
created = datetime.datetime.utcnow()
session = self.Session()
# Execute returns a method the can be executed anywhere more than once
models = self.get_db_model(self.engine)
subscription_facade = Subscriptions()
subscription_cls = models.classes.subscriptions
subscription_tags2 = models.classes.subscription_tags2
subscriptions = session.query(subscription_cls).all()
subscription_tag_list = list()
for subscription in subscriptions:
tag_dictionary = subscription_facade.get_tags_dictionary(
subscription.subscription_id)
if tag_dictionary:
for tag_name in tag_dictionary:
print(tag_name, tag_dictionary[tag_name])
for tag_value in tag_dictionary[tag_name]:
tag = subscription_tags2(
subscription_id=subscription.subscription_id,
tag_name=tag_name,
tag_value=tag_value,
created=created,
batch_uuid=batch_uuid)
subscription_tag_list.append(tag)
session.bulk_save_objects(subscription_tag_list)
session.commit()
def identify_subscription_owners(self):
# create a Session
session = self.Session()
# Execute returns a method the can be executed anywhere more than once
models = self.get_db_model(self.engine)
subscription_facade = Subscriptions()
subscription_cls = models.classes.subscriptions
subscription_tags2_cls = models.classes.subscription_tags2
subscriptions = session.query(subscription_cls).all()
technical_owner_dict = self.get_filtered_tags(session,
subscription_tags2_cls,
'tech%')
financial_owner_dict = self.get_filtered_tags(session,
subscription_tags2_cls,
'financial%')
functional_owner_dict = self.get_filtered_tags(session,
subscription_tags2_cls,
'function%')
market_dict = self.get_filtered_tags(session, subscription_tags2_cls,
'market')
for subscription in subscriptions:
if subscription.subscription_id in functional_owner_dict:
subscription.functional_owner = functional_owner_dict[
subscription.subscription_id]
if subscription.subscription_id in financial_owner_dict:
subscription.financial_owner = financial_owner_dict[
subscription.subscription_id]
if subscription.subscription_id in technical_owner_dict:
subscription.billing_contact = technical_owner_dict[
subscription.subscription_id]
if subscription.subscription_id in market_dict:
subscription.market = market_dict[subscription.subscription_id]
session.bulk_save_objects(subscriptions, update_changed_only=True)
session.commit()
def test_pandas_dataframe_subscriptions_to_sql_pluggy(self):
pm = pluggy.PluginManager("Analysis")
pm.add_hookspecs(DatbasePlugins)
pm.register(SQLServerDatabase())
engine_list = pm.hook.get_db_engine(
driver=self.driver,
server=self.server,
database=self.database,
user=self.user,
password=self.password,
)
engine = engine_list[0]
management_grp = os.environ["MANGRP"]
subscriptions = Subscriptions().dataframe_management_grp_subcriptions(
management_grp=management_grp)
subscriptions.reset_index(inplace=True)
subscriptions.to_sql('subscriptions',
index=False,
con=engine,
if_exists='append',
chunksize=1000)
def get_managment_grp_subscriptions(self, management_grp):
subscriptions = Subscriptions()
return subscriptions.dataframe_management_grp_subcriptions(
management_grp)
def test_list_subscriptions_api(self):
execute = Subscriptions().list_subscriptions()
results = execute()
print(type(results))