from env import config
import meraki
dashboard = meraki.DashboardAPI(config['MERAKI_KEY'])
def get_organizations():
response = dashboard.organizations.getOrganizations()
return response
if __name__ == "__main__":
for org in get_organizations():
print(f"Organization ID {org['id']} has the name {org['name']}")
def __init__(self):
self.dashboard = meraki.DashboardAPI(api_key=None, base_url='https://api.meraki.com/api/v1/',log_file_prefix=__file__[:-3], print_console=False)
self.updStart()
return
from flask import (
Flask,
render_template,
send_from_directory,
send_file,
request,
jsonify,
Response,
)
import diff
import util
import argparser
VERSION = '0.15.0'
dashboard = meraki.DashboardAPI()
def determine_path():
"""Borrowed from wxglade.py"""
try:
root = __file__
if os.path.islink(root):
root = os.path.realpath(root)
return os.path.dirname(os.path.abspath(root))
except:
print("I'm sorry, but something is wrong.")
print("There is no __file__ variable. Please contact the author.")
sys.exit()
def is_hot_reload():
__copyright__ = "Copyright (c) 2020 Cisco and/or its affiliates."
__license__ = "Cisco Sample Code License, Version 1.1"
from flask import render_template, flash, redirect, url_for, request
from app import app
import logging
import pprint
import meraki as mk
import TopDeskHelper
pp = pprint.PrettyPrinter(indent=4)
org_id = app.config['MERAKI_ORGANIZATION_ID']
user = app.config['TOPDESK_USERNAME']
password = app.config['TOPDESK_PASSWORD']
url = app.config['TOPDESK_URL']
dashboard = mk.DashboardAPI(app.config['MERAKI_API_KEY'])
logging.basicConfig(
filename='app.log',
filemode='a',
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# webhook handler
@app.route('/', methods=['POST'])
def alert():
if not request.json:
return ("invalid data", 400)
logging.warning(request.json)
print(request.json["alertType"])
TopDeskHelper.create_incident(url, user, password, request.json)
api_key = config["api_key"]
orgName = config["orgName"]
tag_prefix = 'viptela-11'
org_id = None
# function to parse list of tags for an individual network
def strip_meraki_network_tags(meraki_network_tag):
# below parses the for the specific network tag on the network w/ viptela-
meraki_tag_strip_part1 = re.findall(r'[v]+[i]+[p]+[t]+[e]+[l]+[a]+[-].*',\
str(meraki_network_tag))
return str(meraki_tag_strip_part1[0]).rstrip()
# writing function to obtain org ID via linking ORG name
mdashboard = meraki.DashboardAPI(MerakiConfig.api_key)
result_org_id = mdashboard.organizations.getOrganizations()
for x in result_org_id:
if x['name'] == MerakiConfig.org_name:
MerakiConfig.org_id = x['id']
# defining function that creates dictionary of IPsec config
def get_meraki_ipsec_config(name, public_ip, lan_subnets, secret,
network_tags) -> dict:
ipsec_config = {
"name": name,
"publicIp": public_ip,
"privateSubnets": [lan_subnets],
"secret": secret,
"ikeVersion": "2",
def ingest_dashboard_data(accounts, log):
append_log(log, "dashboard_monitor::ingest_dashboard_data::Accounts -",
accounts)
dt = make_aware(datetime.datetime.now())
for sa in accounts:
if not sa.sync_enabled:
append_log(
log,
"dashboard_monitor::digest_database_data::sync session not set to allow sync;"
)
return
a = sa.dashboard
append_log(log, "dashboard_monitor::ingest_dashboard_data::Resync -",
a.description)
dashboard = meraki.DashboardAPI(base_url=a.baseurl,
api_key=a.apikey,
print_console=False,
output_log=False,
caller=settings.CUSTOM_UA,
suppress_logging=True)
orgs = a.organization.all()
if orgs:
for org in orgs:
org_id = org.orgid
append_log(log, "dashboard_monitor::processing orgid::",
org_id)
sgts = meraki_read_sgt(dashboard, org_id)
sgacls = meraki_read_sgacl(dashboard, org_id)
sgpolicies = meraki_read_sgpolicy(dashboard, org_id)
append_log(
log, "dashboard_monitor::ingest_dashboard_data::SGTs - ",
len(sgts))
append_log(
log, "dashboard_monitor::ingest_dashboard_data::SGACLs - ",
len(sgacls))
append_log(
log,
"dashboard_monitor::ingest_dashboard_data::Policies - ",
len(sgpolicies))
merge_sgts("meraki", sgts, not sa.ise_source, sa, log, org)
merge_sgacls("meraki", sgacls, not sa.ise_source, sa, log, org)
merge_sgpolicies("meraki", sgpolicies, not sa.ise_source, sa,
log, org)
clean_sgts("meraki", sgts, not sa.ise_source, sa, log, org)
clean_sgacls("meraki", sgacls, not sa.ise_source, sa, log, org)
clean_sgpolicies("meraki", sgpolicies, not sa.ise_source, sa,
log, org)
org.raw_data = json.dumps({
"groups": sgts,
"acls": sgacls,
"bindings": sgpolicies
})
org.force_rebuild = False
org.last_sync = dt
org.last_update = dt
org.skip_sync = True
org.save()
sa.dashboard.last_sync = dt
sa.dashboard.save()
else:
append_log(
log,
"dashboard_monitor::ingest_dashboard_data::No OrgId present")
if __name__ == "__main__":
# Importing variables
api_key = credentials.api_key
baseurl = credentials.base_url
org_id = credentials.organization_id
networks = credentials.networks
cams = credentials.cams
students = student_list.student_list
webex_email = credentials.webex_email
webex_token = credentials.webex_token
# Instantiate Meraki Python SDK Client
dashboard = meraki.DashboardAPI(
api_key=api_key,
base_url=baseurl,
log_file_prefix='./logs/attendance/',
print_console=False)
# Instantiate AWS Python SDK Clients
# Must configure AWS CLI for this to work
# See https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html
rekognition = boto3.client('rekognition', region_name='us-east-2')
dynamodb = boto3.client('dynamodb', region_name='us-east-2')
webex = WebexTeamsAPI(access_token=webex_token)
# Record timestamp for snapshot name
timestr = time.strftime("%Y%m%d-%H%M%S")
file_name = snapshot.snap(
dashboard_api_client=dashboard,
import meraki # Import Meraki SDK
import firebase_admin # Import Firebase Python SDK
from firebase_admin import credentials
from firebase_admin import db
from credentials import home_api_key, home_network_id, mv_serial # Separate file with credentials
# Fetch the service account key JSON file contents
cred = credentials.Certificate('serviceAccountKey.json')
# Initialize the app with a service account, granting admin privileges
firebase_admin.initialize_app(cred, {
'databaseURL': 'https://dashboard-cisco.firebaseio.com/'
})
# Authenticate Meraki
dashboard = meraki.DashboardAPI(
api_key = home_api_key,
base_url = 'https://n255.meraki.com/api/v0'
)
# Get the snapshot from a specific timestamp
def get_snapshot_url(time):
body = {'timestamp': time, 'fullframe': False}
snapshot = dashboard.cameras.generateNetworkCameraSnapshot(network_id, serial, **body)
return snapshot['url']
if __name__ = "__main__":
photo_url = get_snapshot_url('2020-05-11T06:19:34-07:00')
# Upload to Firebase
ref = db.reference('meraki/photoURL/')
ref.set(photo_url)
import requests
import meraki
import json
from private_vars import api_key, org_id
url = "https://api.meraki.com/api/v1"
dashboard = meraki.DashboardAPI(api_key, )
payload = {}
headers = {
"Content-Type": "application/json",
"Accept": "application/json",
"X-Cisco-Meraki-API-Key": api_key
}
response = requests.request("GET",
f"{url}/organizations",
headers=headers,
data=payload).json()
org_id_dict = dict()
network_id_dict = dict()
#Iterate over each item in the response and print it separately
for i in response:
name = i['name']
id = i['id']
org_id_dict[name] = id
# print(f"The Organization {name}'s ID is {id}")
# Write the org_id_dict dictionary to a JSON file
import meraki
import credentials
api_key = credentials.api_key
access_token = credentials.access_token
# initiating meraki objects provding the access token and API key
dashboard = meraki.DashboardAPI(api_key=api_key,
print_console=False,
output_log=False)
my_orgs = dashboard.organizations.getOrganizations()
for org in my_orgs:
print("Org name: ", org["name"], "Org ID: ", org["id"])
input_org_id = input("Enter Organization ID: ")
networks = dashboard.organizations.getOrganizationNetworks(
organizationId=input_org_id)
for network in networks:
group_policies = dashboard.networks.getNetworkGroupPolicies(
networkId=network["id"])
group_policy_id = ""
# declare the policy name to be provision
provision_policy = "SmartPhone Group Policy"
# grabbing the policy ID of interest
def main():
# Check if all required parameters have been specified
parser = argparse.ArgumentParser()
api_key, org_id = parse_arguments(parser)
if not (api_key and org_id):
parser.exit(2, parser.print_help())
# Make API calls to retrieve data
dashboard = meraki.DashboardAPI(api_key)
appliance_statuses = dashboard.appliance.getOrganizationApplianceUplinkStatuses(
org_id, total_pages='all')
device_statuses = dashboard.organizations.getOrganizationDevicesStatuses(
org_id, total_pages='all')
networks = dashboard.organizations.getOrganizationNetworks(
org_id, total_pages='all')
devices_by_serial = {d['serial']: d['name'] for d in device_statuses}
networks_by_id = {n['id']: n['name'] for n in networks}
# Output appliance statuses file
output_file = 'appliance_statuses.csv'
field_names = [
'name', 'serial', 'network', 'networkId', 'lastReportedAt',
'wan1_status', 'wan1_ip', 'wan1_gateway', 'wan1_publicIp',
'wan1_primaryDns', 'wan1_secondaryDns', 'wan1_ipAssignedBy',
'wan2_status', 'wan2_ip', 'wan2_gateway', 'wan2_publicIp',
'wan2_primaryDns', 'wan2_secondaryDns', 'wan2_ipAssignedBy',
'cellular_status', 'cellular_ip', 'cellular_provider',
'cellular_publicIp', 'cellular_model', 'cellular_signalStat',
'cellular_connectionType', 'cellular_apn'
]
with open(output_file, mode='w', newline='\n') as fp:
csv_writer = csv.DictWriter(fp,
field_names,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_ALL)
csv_writer.writeheader()
for status in appliance_statuses:
status.update({
'name': devices_by_serial[status['serial']],
'network': networks_by_id[status['networkId']]
})
# Flatten objects/dictionaries, without requiring a third-party library
interfaces = [uplink['interface'] for uplink in status['uplinks']]
if 'wan1' in interfaces:
wan1 = status['uplinks'][interfaces.index('wan1')]
status.update({
'wan1_status': wan1['status'],
'wan1_ip': wan1['ip'],
'wan1_gateway': wan1['gateway'],
'wan1_publicIp': wan1['publicIp'],
'wan1_primaryDns': wan1['primaryDns'],
'wan1_secondaryDns': wan1['secondaryDns'],
'wan1_ipAssignedBy': wan1['ipAssignedBy']
})
if 'wan2' in interfaces:
wan2 = status['uplinks'][interfaces.index('wan2')]
status.update({
'wan2_status': wan2['status'],
'wan2_ip': wan2['ip'],
'wan2_gateway': wan2['gateway'],
'wan2_publicIp': wan2['publicIp'],
'wan2_primaryDns': wan2['primaryDns'],
'wan2_secondaryDns': wan2['secondaryDns'],
'wan2_ipAssignedBy': wan2['ipAssignedBy']
})
if 'cellular' in interfaces:
cellular = status['uplinks'][interfaces.index('cellular')]
status.update({
'cellular_status':
cellular['status'],
'cellular_ip':
cellular['ip'],
'cellular_provider':
cellular['provider'],
'cellular_publicIp':
cellular['publicIp'],
'cellular_model':
cellular['model'],
'cellular_signalStat':
cellular['signalStat'],
'cellular_connectionType':
cellular['connectionType'],
'cellular_apn':
cellular['apn']
})
status.pop('uplinks')
csv_writer.writerow(status)
# Output device statuses file
output_file = 'device_statuses.csv'
field_names = [
'name', 'serial', 'network', 'networkId', 'mac', 'publicIp', 'status',
'lastReportedAt', 'lanIp', 'gateway', 'ipType', 'primaryDns',
'secondaryDns', 'usingCellularFailover', 'wan1Ip', 'wan1Gateway',
'wan1IpType', 'wan1PrimaryDns', 'wan1SecondaryDns', 'wan2Ip',
'wan2Gateway', 'wan2IpType', 'wan2PrimaryDns', 'wan2SecondaryDns'
]
with open(output_file, mode='w', newline='\n') as fp:
csv_writer = csv.DictWriter(fp,
field_names,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_ALL)
csv_writer.writeheader()
for status in device_statuses:
status.update({'network': networks_by_id[status['networkId']]})
csv_writer.writerow(status)
def main(argv):
# Set default values for command line arguments
api_key = org_id = arg_mode = None
# Get command line arguments
try:
opts, args = getopt.getopt(argv, 'hk:o:')
except getopt.GetoptError:
print_help()
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print_help()
sys.exit()
elif opt == '-k':
api_key = arg
elif opt == '-o':
org_id = arg
# Check if all required parameters have been input
if api_key == None or org_id == None:
print_help()
sys.exit(2)
# Instantiate a Meraki dashboard API session
dashboard = meraki.DashboardAPI(
api_key,
output_log=False
#log_file_prefix=os.path.basename(__file__)[:-3],
#log_path='',
#print_console=False
)
# Get list of current networks in org
networks = dashboard.organizations.getOrganizationNetworks(org_id)
# Iterate through all networks and load client lists
# initialize variables
clientDetailsDst = []
clientDetailsSrc = []
for network in networks:
#print(f"Evaluating network {network['id']} : {network['name']}")
# Skip if network does not have the tag "update_whitelist"
if 'copy_client_names_src' in network['tags']:
# Get client details for src network
print(f"Matched source network {network['name']}")
netIdSrc = network['id']
clientDetailsSrc = dashboard.networks.getNetworkClients(
network['id'], timespan=2678400, perPage=1000)
elif 'copy_client_names_dst' in network['tags']:
print(f"Matched dest network {network['name']}")
netIdDst = network['id']
clientDetailsDst = dashboard.networks.getNetworkClients(
network['id'], timespan=2678400, perPage=1000)
elif network['tags'] is None or 'copy_client_names' not in network[
'tags']:
continue
# Iterate through each client in dst network and attempt to match from src
#print(f'source client json: \n {clientDetailsSrc}')
#print(f'destination client json: \n {clientDetailsDst}')
for client in clientDetailsDst:
print(f"Current Client: {client['mac']}, {client['description']}")
matchedItem = next(
(item
for item in clientDetailsSrc if item["mac"] == client["mac"]),
None)
if matchedItem is None:
continue
else:
toProvision = [{
'mac': matchedItem['mac'],
'name': matchedItem['description']
}]
dashboard.networks.provisionNetworkClients(netIdDst, toProvision,
'Normal')
import meraki
dashboard = meraki.DashboardAPI(output_log=False)
# To do
# Move AP corp network after RWS usage is finished
# Move AP to room network when RWS usage starts
ssid_definition = {
'authMode': 'psk',
'bandSelection': 'Dual band operation',
'enabled': False,
'encryptionMode': 'wpa',
'ipAssignmentMode': 'Bridge mode',
'lanIsolationEnabled': False,
'minBitrate': 11,
'name': '',
'perClientBandwidthLimitDown': 0,
'perClientBandwidthLimitUp': 0,
'psk': '',
'splashPage': 'None',
'ssidAdminAccessible': False,
'useVlanTagging': False,
'wpaEncryptionMode': 'WPA2 only'
}
def get_org_names(hotelid):
orgs = dashboard.organizations.getOrganizations()
return [org['id'] for org in orgs]
#! Python3
from datetime import datetime as dt
from re import match
import meraki
import csv
import sys
if __name__ == "__main__":
start_time = dt.now()
try:
m = meraki.DashboardAPI("7e1b8674f0cd64850602befdc8b4941bab1e28a7")
organization_id = "630503947831870169"
networks = m.organizations.getOrganizationNetworks(organization_id,
perPage=10000,
total_pages="all")
input_file = "C:\\Users\\lamin\\OneDrive\\Documents\\Repos\\Meraki\\network_names_and_syslog_server_role.csv"
search_list = {}
for network in networks:
search_list[network["name"]] = network["id"]
with open(input_file, "r") as ifile:
network_file = csv.reader(ifile, delimiter=',', quotechar='|')
for line in network_file:
network_name = line[0]
server_role = line[1]
network_id = search_list[network_name.rstrip()]
syslog_servers = [{
IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
or implied.
"""
# This script retrieves a Meraki MX L3 Firewall rule from the file NewRuleToAdd.txt and adds it to all
# networks in the Org. The rule inserted only specifies the Destination IPs (destCidr field) and uses
# the comment specified in the first line of the input file for the "comment" field of the rule
# all other parameters for the rule are specified in templateRuleDict below for all insertions.
import meraki
import time
import sys
import config
import requests
dashboard = meraki.DashboardAPI(api_key=config.meraki_api_key)
templateRuleDict= {
"comment": "",
"policy": "deny",
"protocol": "any",
"srcPort": "Any",
"srcCidr": "Any",
"destPort": "Any",
"destCidr": "",
"syslogEnabled": True
}
templateRuleDictNoSyslog= {
"comment": "",
"policy": "deny",
# This script will prompt the user to select an organization, source switch,
# source port and destination switch and port to clone a port config, before
# confirming if the user would like to proceed with the change
# Configure your API key ENV variable using 'export MERAKI_DASHBOARD_API_KEY=YOUR_KEY'
# Usage: python port-clone.py
import meraki
import os
import re
import pprint
# Instantiate the Meraki Dashboard API using the Python SDK
dashboard = meraki.DashboardAPI(os.environ['MERAKI_DASHBOARD_API_KEY'])
# Get the list of organizations that the user has priveleges on
orgs = dashboard.organizations.getOrganizations()
# Print the list of organization names
for i, org in enumerate(orgs):
print (i, ":", org['name'])
# Prompt the user for which organization they'd like to configure
selected_org = int(input("Which organization would you like to select? "))
# Get the list of devices in the selected organization
org_devices = dashboard.organizations.getOrganizationDevices(
orgs[selected_org]['id'], total_pages='all'
)
import os
import sys
import json
import meraki
from wireless import Wireless
from appliance import Appliance
from switch import Switch
from totalNetwork import TotalNetwork
baseURL = "https://api.meraki.com/api/v1"
API_KEY = 'exampleKey' # first api key
apiKey = 'exampleKey' # second api key
dashboard = meraki.DashboardAPI(api_key=API_KEY,
base_url=baseURL,
print_console=False)
organizations = dashboard.organizations.getOrganizations()
networks = dashboard.organizations.getOrganizationNetworks(
organizations[0]['id'])
# print(json.dumps(networks, indent=2))
# you can choose to set these variables manually or if they are unknown you can use the api calls above
# to find them then set the index ([0]) that coresponds to the wanted network and orginization
networkID = networks[0]['id']
orgID = organizations[0]['id']
# Retrieve list of devices
devices = dashboard.networks.getNetworkDevices(networkID)
numDevices = len(devices)
# print(json.dumps(devices, indent=2))
snapshot = {}
def main():
# getting arguments
parser = argparse.ArgumentParser()
parser.add_argument(
"-K",
"--apikey",
help="Meraki dashboard API key or set env var",
type=str,
required=False,
)
parser.add_argument("-O",
"--organization",
help="organization ID or NAME",
type=str,
required=False)
parser.add_argument("-N",
"--network",
help="network",
type=str,
required=False)
parser.add_argument(
"-P",
"--protocol",
help="filter protocol",
type=str,
choices=["cdp", "lldp"],
default="",
required=False,
)
parser.add_argument(
"-A",
"--all",
help="print information for all networks in organization",
dest="all",
action="store_true",
default=False,
required=False,
)
args = parser.parse_args()
org = args.organization
protocol = args.protocol
organization = org
all = args.all
# verify apikey is provided
if args.apikey:
apikey = args.apikey
else:
try:
apikey = os.environ["apikey"]
except:
print(
"\nERROR: MISSING MERAKI DASHBOARD API KEY IN ARGUMENTS AND ENV VAR\n"
)
sys.exit()
# verify apikey is valid and get organizations
try:
m = meraki.DashboardAPI(api_key=apikey,
print_console=False,
output_log=False,
suppress_logging=True)
orgs = m.organizations.getOrganizations()
except:
print("\nERROR GETTING ORGANIZATIONS - VERIFY API KEY IS CORRECT\n")
sys.exit()
# if no organization is provided print list of organizations
if not args.organization:
print("\nORGANIZATIONS AVAILABLE\n")
for org in orgs:
print(f"NAME: {org.get('name'):40} ID: {org.get('id'):20}")
sys.exit()
if organization:
try:
orgId, orgNname = getIdName(args.organization,
orgs) # verify organization exists
except:
print(f"\nERROR: ORGANIZATION {args.organization} NOT FOUND\n")
sys.exit()
try:
network = args.network
except:
network = False
if orgId:
networks = m.organizations.getOrganizationNetworks(orgId)
if network: # if network is provided print neighbors
try:
netId, netName = getIdName(network, networks)
except:
print(f"\nERROR: NETWORK {network} NOT FOUND\n")
sys.exit()
if netId: # verify network exists
deviceList = m.networks.getNetworkDevices(netId)
for device in deviceList:
serial, name = device.get("serial"), device.get(
"name", device.get("serial", "MISSING"))
printNei(m, serial, name, protocol)
else: # if no network is specified print network list
if not all:
print(
f'\nNETWORKS AVAILABLE FOR ORGANIZATION "{orgNname}" with ID {orgId}\n'
)
networks = m.organizations.getOrganizationNetworks(orgId)
if isinstance(networks[0], str):
print(f"ERROR GETTING NETWORKS: {networks[0]}\n")
sys.exit()
else:
for net in networks:
print(
f"NETWORK: {net.get('name'):50} ID: {net.get('id'):20}"
)
else: # if all flag is set print neigh for all networks
for net in networks:
netId = net.get("id")
deviceList = m.networks.getNetworkDevices(netId)
for device in deviceList:
serial, name = device.get("serial"), device.get(
"name", device.get("serial", "MISSING"))
printNei(m, serial, name, protocol)
def digest_database_data(sa, log):
append_log(log, "dashboard_monitor::digest_database_data::Account -", sa)
dashboard = meraki.DashboardAPI(base_url=sa.dashboard.baseurl,
api_key=sa.dashboard.apikey,
print_console=False,
output_log=False,
caller=settings.CUSTOM_UA,
suppress_logging=True)
if not sa.apply_changes:
append_log(
log,
"dashboard_monitor::digest_database_data::sync session not set to apply changes;"
)
return
tags = TagData.objects.filter(Q(tag__do_sync=True) & Q(update_failed=False)).\
exclude(organization=None)
for o in tags:
if o.source_id and o.update_dest() == "meraki":
if o.tag.push_delete:
try:
ret = meraki_delete_sgt(dashboard, o.organization.orgid,
o.source_id)
append_log(
log,
"dashboard_monitor::digest_database_data::SGT delete",
ret)
o.delete()
except Exception as e: # pragma: no cover
append_log(
log,
"dashboard_monitor::digest_database_data::SGT Delete Exception",
e, traceback.format_exc())
o.update_failed = True
o.last_update = make_aware(datetime.datetime.now())
o.last_update_state = "False"
o.last_update_data = {
"tag": str(o),
"error": "Exception: " + str(e)
}
o.save()
else:
try:
ret = meraki_update_sgt(dashboard,
o.organization.orgid,
o.source_id,
name=o.tag.name,
description=o.tag.description,
value=o.tag.tag_number)
o.last_update_data = json.dumps(ret)
if "groupId" in ret:
o.last_update_state = "True"
o.source_id = ret["groupId"]
o.source_data = json.dumps(ret)
else:
o.last_update_state = "False"
o.last_update = make_aware(datetime.datetime.now())
o.save()
append_log(
log,
"dashboard_monitor::digest_database_data::Push SGT update",
o.source_id, o.tag.name, o.tag.description, ret)
except Exception as e: # pragma: no cover
append_log(
log,
"dashboard_monitor::digest_database_data::SGT Update Exception",
e, traceback.format_exc())
o.update_failed = True
o.last_update = make_aware(datetime.datetime.now())
o.last_update_state = "False"
o.last_update_data = {
"tag": str(o),
"error": "Exception: " + str(e)
}
o.save()
elif o.update_dest() == "meraki":
try:
ret = meraki_create_sgt(dashboard,
o.organization.orgid,
value=o.tag.tag_number,
name=o.tag.name,
description=o.tag.description)
o.last_update_data = json.dumps(ret)
if "groupId" in ret:
o.last_update_state = "True"
o.source_id = ret["groupId"]
o.source_data = json.dumps(ret)
else:
o.last_update_state = "False"
o.last_update = make_aware(datetime.datetime.now())
o.save()
append_log(
log,
"dashboard_monitor::digest_database_data::Push SGT create",
o.tag.tag_number, o.tag.name, o.tag.description, ret)
except Exception as e: # pragma: no cover
append_log(
log,
"dashboard_monitor::digest_database_data::SGT Create Exception",
e, traceback.format_exc())
o.update_failed = True
o.last_update = make_aware(datetime.datetime.now())
o.last_update_state = "False"
o.last_update_data = {
"tag": str(o),
"error": "Exception: " + str(e)
}
o.save()
acls = ACLData.objects.filter(Q(acl__do_sync=True) & Q(update_failed=False)).\
exclude(organization=None)
for o in acls:
if o.source_id and o.update_dest() == "meraki":
if o.acl.push_delete:
try:
ret = meraki_delete_sgacl(dashboard, o.organization.orgid,
o.source_id)
append_log(
log,
"dashboard_monitor::digest_database_data::SGACL delete",
ret)
o.delete()
except Exception as e: # pragma: no cover
append_log(
log,
"dashboard_monitor::digest_database_data::SGACL Delete Exception",
e, traceback.format_exc())
o.update_failed = True
o.last_update = make_aware(datetime.datetime.now())
o.last_update_state = "False"
o.last_update_data = {
"acl": str(o),
"error": "Exception: " + str(e)
}
o.save()
else:
try:
ret = meraki_update_sgacl(dashboard,
o.organization.orgid,
o.source_id,
name=o.acl.name,
description=o.acl.description,
rules=o.lookup_rules(o),
ipVersion=o.lookup_version(o))
o.last_update_data = json.dumps(ret)
if "aclId" in ret:
o.last_update_state = "True"
o.source_id = ret["aclId"]
o.source_data = json.dumps(ret)
else:
o.last_update_state = "False"
o.last_update = make_aware(datetime.datetime.now())
o.save()
append_log(
log,
"dashboard_monitor::digest_database_data::Push SGACL update",
o.source_id, o.acl.name, o.acl.description, ret)
except Exception as e: # pragma: no cover
append_log(
log,
"dashboard_monitor::digest_database_data::SGACL Update Exception",
e, traceback.format_exc())
o.update_failed = True
o.last_update = make_aware(datetime.datetime.now())
o.last_update_state = "False"
o.last_update_data = {
"acl": str(o),
"error": "Exception: " + str(e)
}
o.save()
elif o.update_dest() == "meraki":
try:
ret = meraki_create_sgacl(dashboard,
o.organization.orgid,
name=o.acl.name,
description=o.acl.description,
rules=list(o.lookup_rules(o)),
ipVersion=o.lookup_version(o))
o.last_update_data = json.dumps(ret)
if "aclId" in ret:
o.last_update_state = "True"
o.source_id = ret["aclId"]
o.source_data = json.dumps(ret)
else:
o.last_update_state = "False"
o.last_update = make_aware(datetime.datetime.now())
o.save()
append_log(
log,
"dashboard_monitor::digest_database_data::Push SGACL create",
o.acl.name, o.acl.description, ret)
except Exception as e: # pragma: no cover
append_log(
log,
"dashboard_monitor::digest_database_data::SGACL Create Exception",
e, traceback.format_exc())
o.update_failed = True
o.last_update = make_aware(datetime.datetime.now())
o.last_update_state = "False"
o.last_update_data = {
"acl": str(o),
"error": "Exception: " + str(e)
}
o.save()
policies = PolicyData.objects.filter(Q(policy__do_sync=True) & Q(update_failed=False)).\
exclude(organization=None)
for o in policies:
if o.policy.push_delete and o.update_dest() == "meraki":
try:
srcsgt, dstsgt = o.policy.lookup_sgts(o)
orgs = sa.dashboard.organization.all()
for org in orgs:
ret = meraki_update_sgpolicy(dashboard,
org.orgid,
srcGroupId=srcsgt.source_id,
dstGroupId=dstsgt.source_id,
aclIds=None,
catchAllRule="global")
append_log(
log,
"dashboard_monitor::digest_database_data::Policy delete",
ret)
o.delete()
except Exception as e: # pragma: no cover
append_log(
log,
"dashboard_monitor::digest_database_data::Policy Delete Exception",
e, traceback.format_exc())
o.update_failed = True
o.last_update = make_aware(datetime.datetime.now())
o.last_update_state = "False"
o.last_update_data = {
"policy": str(o),
"error": "Exception: " + str(e)
}
o.save()
elif o.update_dest() == "meraki":
try:
srcsgt, dstsgt = o.lookup_sgt_data(o)
sgacl = o.lookup_sgacl_data(o)
acls = []
if sgacl:
for s in sgacl:
acls.append(s.source_id)
if not srcsgt or not dstsgt or sgacl is None:
o.update_failed = False # was True; disabled for now
o.last_update = make_aware(datetime.datetime.now())
o.last_update_state = "False"
o.last_update_data = {
"policy":
str(o),
"error":
"Meraki: Unable to locate sgt/acl data;" +
str(srcsgt) + ";" + str(dstsgt) + ";" + str(sgacl)
}
o.save()
continue
ret = meraki_update_sgpolicy(
dashboard,
o.organization.orgid,
name=o.policy.name,
description=o.policy.description,
srcGroupId=srcsgt.source_id,
dstGroupId=dstsgt.source_id,
aclIds=acls,
catchAllRule=o.lookup_acl_catchall(o),
bindingEnabled=True,
monitorModeEnabled=False)
o.last_update_data = json.dumps(ret)
if "srcGroupId" in ret:
o.last_update_state = "True"
o.source_id = "s" + str(ret["srcGroupId"]) + "-d" + str(
ret["dstGroupId"])
o.source_data = json.dumps(ret)
else:
o.last_update_state = "False"
o.last_update = make_aware(datetime.datetime.now())
o.save()
append_log(
log,
"dashboard_monitor::digest_database_data::Push Policy update",
o.source_id, o.policy.name, o.policy.description, ret)
except Exception as e: # pragma: no cover
append_log(
log,
"dashboard_monitor::digest_database_data::Policy Update Exception",
e, traceback.format_exc())
o.update_failed = True
o.last_update = make_aware(datetime.datetime.now())
o.last_update_state = "False"
o.last_update_data = {
"policy": str(o),
"error": "Exception: " + str(e)
}
o.save()
import meraki
from private_vars import api_key, org_id
import json
dashboard = meraki.DashboardAPI(api_key,
suppress_logging=True,
print_console=False)
all_networks = dashboard.organizations.getOrganizationNetworks(org_id)
#print(type(all_networks[0]))
network_id = all_networks[0]["id"]
#print(network_id)
network_devices = dashboard.networks.getNetworkDevices(network_id)
network_updates = dashboard.networks.getNetworkFirmwareUpgrades(network_id)
print(network_devices)
print(network_updates)
#
# --------------------------------------------------------
# Main
# --------------------------------------------------------
#
if __name__ == "__main__":
os.system('clear') # clear screen
print(info)
print(100 * '-', '\n\n')
input('press enter')
# get API key
API_KEY = get_API_KEY()
# Instantiate a Meraki dashboard API session
dashboard_call = meraki.DashboardAPI(
api_key=API_KEY,
base_url='https://api-mp.meraki.com/api/v1/',
log_file_prefix=os.path.basename(__file__)[:-3],
log_path='./logs/',
print_console=False)
# run API call
# ---------------
#
organizationId = get_org_id()
rename_org(organizationId)
list_orgs()
#
def main():
# Instantiate a Meraki dashboard API session
dashboard = meraki.DashboardAPI(
api_key='',
base_url='https://api-mp.meraki.com/api/v0/',
output_log=True,
log_file_prefix=os.path.basename(__file__)[:-3],
log_path='',
print_console=False)
# Get list of organizations to which API key has access
organizations = dashboard.organizations.getOrganizations()
# Iterate through list of orgs
for org in organizations:
print(f'\nAnalyzing organization {org["name"]}:')
org_id = org['id']
# Get list of networks in organization
try:
networks = dashboard.networks.getOrganizationNetworks(org_id)
except meraki.APIError as e:
print(f'Meraki API error: {e}')
print(f'status code = {e.status}')
print(f'reason = {e.reason}')
print(f'error = {e.message}')
continue
except Exception as e:
print(f'some other error: {e}')
continue
# Create local folder
todays_date = f'{datetime.now():%Y-%m-%d}'
folder_name = f'Org {org_id} clients {todays_date}'
if folder_name not in os.listdir():
os.mkdir(folder_name)
# Iterate through networks
total = len(networks)
counter = 1
print(
f' - iterating through {total} networks in organization {org_id}')
for net in networks:
print(
f'Finding clients in network {net["name"]} ({counter} of {total})'
)
try:
# Get list of clients on network, filtering on timespan of last 14 days
clients = dashboard.clients.getNetworkClients(
net['id'],
timespan=60 * 60 * 24 * 14,
perPage=1000,
total_pages='all')
except meraki.APIError as e:
print(f'Meraki API error: {e}')
print(f'status code = {e.status}')
print(f'reason = {e.reason}')
print(f'error = {e.message}')
except Exception as e:
print(f'some other error: {e}')
else:
if clients:
# Write to file
file_name = f'{net["name"]}.csv'
output_file = open(f'{folder_name}/{file_name}',
mode='w',
newline='\n')
field_names = clients[0].keys()
csv_writer = csv.DictWriter(output_file,
field_names,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_ALL)
csv_writer.writeheader()
csv_writer.writerows(clients)
output_file.close()
print(f' - found {len(clients)}')
counter += 1
# Stitch together one consolidated CSV per org
output_file = open(f'{folder_name}.csv', mode='w', newline='\n')
field_names = [
'id', 'mac', 'description', 'ip', 'ip6', 'ip6Local', 'user',
'firstSeen', 'lastSeen', 'manufacturer', 'os',
'recentDeviceSerial', 'recentDeviceName', 'recentDeviceMac',
'ssid', 'vlan', 'switchport', 'usage', 'status', 'notes',
'smInstalled', 'groupPolicy8021x'
]
field_names.insert(0, "Network Name")
field_names.insert(1, "Network ID")
csv_writer = csv.DictWriter(output_file,
field_names,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_ALL)
csv_writer.writeheader()
for net in networks:
file_name = f'{net["name"]}.csv'
if file_name in os.listdir(folder_name):
with open(f'{folder_name}/{file_name}') as input_file:
csv_reader = csv.DictReader(input_file,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_ALL)
next(csv_reader)
for row in csv_reader:
row['Network Name'] = net['name']
row['Network ID'] = net['id']
csv_writer.writerow(row)
def main(org_id, timespan):
# Instantiate a Meraki dashboard API session
dashboard = meraki.DashboardAPI(
base_url='https://api-mp.meraki.com/api/v0/',
print_console=False,
output_log=False,
)
# Get list of API usage data and start the output csv string
apiUsage = dashboard.api_usage.getOrganizationApiRequests(
org_id, timespan=timespan, total_pages=-1)
csvString = 'method,host,path,queryString,tsDate,tsTime,responseCode,sourceIp,userAgent,'
csvString += 'implementation,implementationVersion,distro,distroVersion,system,systemRelease,'
csvString += 'cpu,be_geo_id,caller\r\n'
cumulativeAPIcalls = 0
for use in apiUsage:
csvString += use['method'] + ','
csvString += use['host'] + ','
csvString += use['path'] + ','
csvString += use['queryString'] + ','
csvString += use['ts'].split('T')[0] + ','
csvString += use['ts'].split('T')[1].replace('Z', '') + ','
csvString += str(use['responseCode']) + ','
csvString += use['sourceIp'] + ','
# Special User-Agent processing
if 'python-meraki' in use['userAgent']:
print(use['userAgent'])
userAgent = use['userAgent'].split(' ')
csvString += userAgent[0] + ','
if len(userAgent) > 1:
if "implementation" in userAgent[1]:
userAgentDict = json.loads(
urllib.parse.unquote(userAgent[1]))
csvString += userAgentDict['implementation']['name'] + ','
csvString += userAgentDict['implementation'][
'version'] + ','
csvString += userAgentDict['distro']['name'] + ','
csvString += userAgentDict['distro']['version'] + ','
csvString += userAgentDict['system']['name'] + ','
csvString += userAgentDict['system']['release'] + ','
csvString += userAgentDict['cpu'] + ','
if "be_geo_id" in userAgentDict:
csvString += userAgentDict['be_geo_id'] + ','
else:
csvString += ','
if "application" in userAgentDict:
csvString += userAgentDict['application'] + ','
elif "caller" in userAgentDict:
csvString += userAgentDict['caller'] + ','
else:
csvString += ','
else:
csvString += ',,,,,,,,,'
else:
csvString += ',,,,,,,,,'
else:
csvString += use['userAgent'] + ','
csvString += ',,,,,,,,,'
csvString += '\r\n'
# Output the file
now = datetime.now()
dt_string = now.strftime("%Y-%m-%d_%H-%M-%S")
filename = org_id + '_' + str(timespan) + '_' + dt_string + '.csv'
file = open(filename, 'w')
file.write(csvString)
file.close()
print('Results written to ' + filename)
import meraki
apikey = '<Introduce tu llave de API aqui>'
baseurl = 'https://api.Meraki.com/api/v0'
# Declara un objeto de API del dashboard de Meraki en la variable dashboard
dashboard = meraki.DashboardAPI(api_key=apikey, base_url=baseurl)
# Obtén todas las organizaciones a las que tiene acceso esta llave de API
response = dashboard.organizations.getOrganizations()
# itera sobre la respuesta e imprime por fila
for row in response:
print(row)
print("ID de Organización: " + str(row['id']))
print("Nombre de Organización: " + row['name'])
import meraki # Import Meraki SDK
from datetime import datetime # Import Date & Time Library
import firebase_admin # Import Firebase Python SDK
from firebase_admin import credentials
from firebase_admin import db
from credentials import ise_api_key, ise_network_id # Separate file with credentials
# Fetch the service account key JSON file contents
cred = credentials.Certificate('serviceAccountKey.json')
# Initialize the app with a service account, granting admin privileges
firebase_admin.initialize_app(
cred, {'databaseURL': 'https://dashboard-cisco.firebaseio.com/'})
# Initialize Meraki Dashboard with api_key authentication
dashboard = meraki.DashboardAPI(api_key=ise_api_key,
base_url='https://n143.meraki.com/api/v0')
# Get Network Devices Models
def get_devices_model():
devices = dashboard.devices.getNetworkDevices(ise_network_id)
device_model = []
for device in devices:
device_model.append(device['model'][:2])
return device_model
# Get Network Clients
def get_network_clients():
network_clients = dashboard.clients.getNetworkClients(ise_network_id)
clients_status = []
key = None
try:
serial = sys.argv[1]
except:
print("No serial provided")
sys.exit(0)
try:
key = sys.argv[2]
except:
print("No API key provided")
sys.exit(0)
dash = meraki.DashboardAPI(key,
output_log=False,
print_console=False,
suppress_logging=False)
def on_connect(client, userData, flags, rc):
"""
* Callback function for client connection
* Means a CONNACK was received
"""
client.subscribe("/merakimv/" + serial + "/raw_detections")
previous_time = None
def on_message(client, userData, msg):
from datetime import datetime as dt
from time import sleep
from re import search
import meraki
import sys
if __name__ == "__main__":
start_time = dt.now()
try:
# Unique Meraki API key from the Meraki Dashboard
api_key = "7e1b8674f0cd64850602befdc8b4941bab1e28a7"
# Initiating the API session and creating API object to use in API queries
m = meraki.DashboardAPI(api_key)
output_file = "C:\\Users\\lamin\\OneDrive\\Documents\\Repos\\Meraki\\devices_report.csv"
with open(output_file, "w") as ofile:
orgs = m.organizations.getOrganizations()
stats = {}
for org in orgs:
count = 0
devices = m.organizations.getOrganizationInventoryDevices(
org['id'],
total_pages="all",
startingAfter="2020-03-01T00:00:00.000000Z",
usedState="used")
def main():
import time
# client_query() # this queries current org and all client information and builds database
# exit()
# Fire up Meraki API and build DB's
log_dir = os.path.join(os.getcwd(), "Logs/")
if not os.path.exists(log_dir):
os.makedirs(log_dir)
db = meraki.DashboardAPI(
api_key=g.get_api_key(),
base_url='https://api.meraki.com/api/v1/',
print_console=False,
output_log=True,
log_file_prefix=os.path.basename(__file__)[:-3],
log_path='Logs/',
)
cfg = loadCFG(db)
th_array = []
tag_target = cfg['tag_target']
tag_master = cfg['tag_master']
# adminEmails = cfg['adminEmails']
orgs_whitelist = cfg['whitelist']
WRITE = cfg['WRITE']
SWITCH = cfg['SWITCH']
th = tagHelper2.tagHelper(db, tag_target, tag_master, orgs_whitelist)
orgs = th.orgs #get a lit of orgs
#Master ChangeLog Helper
clh = changelogHelper.changelogHelper(db, orgs)
clh.ignoreAPI = False #make sure it'll trigger on API changes too, default is TRUE
clh_clones = changelogHelper.changelogHelper(db, orgs)
clh_clones.tag_target = tag_target #this sets the TAG so it'll detect additions of new networks during runtime
loop = True #Set this to false to break loop
mNets = {} #Dictionary of {'net_id': <mnet_obj>}
master_netid = None
mr_obj = [] #collect the networks
last_changes = []
longest_loop = 0
loop_count = 0
while loop:
print()
print(
f'\t{bcolors.HEADER}****************************{bcolors.FAIL}START LOOP{bcolors.HEADER}*****************************'
)
print(bcolors.ENDC)
startTime = time.time()
if WRITE:
print(
f'{bcolors.OKGREEN}WRITE MODE[{bcolors.WARNING}ENABLED{bcolors.OKGREEN}]{bcolors.ENDC}'
)
else:
print(
f'{bcolors.OKGREEN}WRITE MODE[{bcolors.WARNING}DISABLED{bcolors.OKGREEN}]{bcolors.ENDC}'
)
# TagHelper sync networks
th.sync() #taghelper, look for any new networks inscope
print()
#Master Loader section
netCount = 0
for thn in th.nets:
netCount += 1
if loop_count == 0:
print(
f'{bc.WARNING}Network #{netCount} of [{len(th.nets)}] networks {bc.ENDC}'
)
if not tag_master in th.nets[thn]['tags']:
clh_clones.addNetwork(thn) #this goes into the CLONES bucket
if not thn in mNets:
mNets[thn] = mNET(db, thn, WRITE).loadCache()
else:
if not thn in mNets:
mNets[thn] = mNET(db, thn, WRITE).loadCache()
if master_netid != thn:
master_netid = thn
clh.clearNetworks() #wipes out previous master
print(f'MASTER NETWORK change to netid[{thn}]')
clh.addNetwork(thn)
print()
print(f'Master WL[{clh.watch_list}]')
print(f'Clones WL[{clh_clones.watch_list}]')
th.show() #show inscope networks/orgs
#Cleanup for old mNET objects which have been removed from scope
delList = []
for mid in mNets: #cleanup
if not mid in th.nets:
delList.append(mid)
for mid in delList:
mNets.pop(mid)
print(f'Dropping network[{mid}] from mNets DB')
clh_clones.delNetwork(mid)
if master_netid == mid: #assuming the master is changed/removed
clh.delNetwork(mid) #remove it from changeloghelper
master_netid = None
if master_netid == None:
print(f'Something went wrong, no master netid!!!')
continue
print()
master_change = clh.hasChange()
clone_change = clh_clones.hasChange()
print(
f'{bcolors.OKGREEN}Changes Master[{bcolors.WARNING}{master_change}{bcolors.OKGREEN}] Clone[{bcolors.WARNING}{clone_change}{bcolors.OKGREEN}]'
)
print()
print(
f'{bcolors.OKGREEN}Loop Count[{bcolors.WARNING}{loop_count}{bcolors.OKGREEN}]'
)
print()
if clone_change: #if there's a change to clones, run a short loop syncing just those networks
print(
f'{bcolors.FAIL}Change in a target Network Detected:{bcolors.Blink} Initializing Sync{bcolors.ENDC}'
)
inscope_clones = clh_clones.changed_nets #gets list of networks changed
for ic in inscope_clones:
print(f'New Network detected!!!')
if not ic in mNets:
mNets[ic] = mNET(db, ic, WRITE).loadCache()
mNets[ic].cloneFrom(mNets[master_netid])
else:
mNets[ic].sync()
mNets[ic].cloneFrom(mNets[master_netid])
elif master_change:
print(
f'{bcolors.FAIL}Master change Detected:{bcolors.Blink} Syncing Networks{bcolors.ENDC}'
)
mcCount = 0
mNets[master_netid].sync()
avgTime = 0
for net in mNets:
if net == master_netid: continue
mcCount += 1
secondsGuess = avgTime * (len(th.nets) - 1 - mcCount)
print(
f'{bc.WARNING}Network #{mcCount} of [{len(th.nets)-1}] networks. AvgTime[{round(avgTime,1)}] seconds. Estimated [{round(secondsGuess/60,1)}] minutes left{bc.ENDC}'
)
startT = time.time()
#Niftly little workaround for finding "out of compliance" networks, if there's an exception or error, re-sync and try again
tries = 1
while tries > 0:
try:
mNets[net].cloneFrom(mNets[master_netid])
tries = 0
except:
#potentially something changed...
print(
f'\t{bc.FAIL}ERROR:{bc.OKBLUE} Something changed in network [{bc.WARNING}{mNets[net].name}{bc.OKBLUE}]. Re-Syncing network and trying again....{bc.ENDC}'
)
mNets[net].sync()
tries -= 1
endT = time.time()
dur = round(endT - startT, 2)
if avgTime == 0:
avgTime = dur
else:
avgTime = (avgTime + dur) / 2
else:
print(
f'{bc.OKBLUE}No changes detected in target networks{bc.ENDC}')
print()
loop_count += 1
print()
endTime = time.time()
duration = round(endTime - startTime, 2)
if duration > longest_loop: longest_loop = duration
#print()
if duration < 60:
print(
f'\t{bcolors.OKBLUE}Loop completed in {bcolors.WARNING}{duration}{bcolors.OKBLUE} seconds'
)
else:
duration = round(duration / 60, 2)
print(
f'\t{bcolors.OKBLUE}Loop completed in {bcolors.WARNING}{duration}{bcolors.OKBLUE} minutes'
)
total_networks = len(mNets)
print(
f'\t{bcolors.OKBLUE}Total Networks in scope{bcolors.BLINK_FAIL} {total_networks}{bcolors.ENDC}'
)
mins = round(longest_loop / 60, 2)
print(
f'\t{bcolors.OKBLUE}Longest Loop [{bcolors.WARNING} {mins} {bcolors.OKBLUE}] minutes{bcolors.ENDC}'
)
print()
print(
f'\t{bcolors.HEADER}****************************{bcolors.FAIL}END LOOP{bcolors.HEADER}*****************************'
)
print(bcolors.ENDC)
print()
time.sleep(5)
#while count_sleep > 0:
# time.sleep(1)
# # print(f'{bcolors.OKGREEN}z')
# count_sleep -= 1
#print(bcolors.ENDC)
print()
import meraki
# Defining your API key as a variable in source code is not recommended
API_KEY = '6bec40cf957de430a6f1f2baa056b99a4fac9ea0'
# Instead, use an environment variable as shown under the Usage section
# @ https://github.com/meraki/dashboard-api-python/
dashboard = meraki.DashboardAPI(API_KEY)
network_id = 'L_646829496481105433'
url = 'https://www.example.com/path'
response = dashboard.networks.createNetworkWebhooksWebhookTest(
network_id,
url,
sharedSecret='shhh',
payloadTemplateId='wpt_00001',
payloadTemplateName='Payload Template',
alertTypeId='power_supply_down')
print(response)
#!/usr/bin/env python
import os
import sys
import json
import meraki
#Instantiate the client (API consumer class)
DASHBOARD = meraki.DashboardAPI(api_key=os.environ['MERAKI_API_KEY'],
base_url='https://api.meraki.com/api/v1',
print_console=False)
NETWORK = os.environ['NETWORK']
#Update the attributes of an SSID or create a new SSID - definition of values in config_ssid.py file
def update_ssid():
print("Reading the configuration values from json file ...")
# Reading config variables from JSON file, this info could come from external Database as well
with open('config_ssid.json') as json_file:
config_ssid = json.load(json_file)
print("Updating Wireless SSID ...")
try:
resp = DASHBOARD.wireless.updateNetworkWirelessSsid(
networkId=NETWORK,
number=config_ssid['number'],
name=config_ssid['name'],
