def get_all_devices(organization_id=None, network_id=None) -> list:
"""Get all devices.
Returns:
Optional[dict]: Devices list
"""
passFilter = False if organization_id is not None else True
avai_devices = []
client = MerakiSdkClient(config.MERAKI_AUTH_TOKEN)
orgs = client.organizations.get_organizations()
avai_orga = [
{
'organization_id': orgs[x]
} for x in orgs
if (not passFilter and orgs[x] == organization_id) or passFilter
]
networks = client.networks.get_organization_networks(avai_orga)
if networks:
for network in networks:
if network_id:
if network['id'] == network_id:
avai_devices.append(
client.devices.get_network_devices(network['id']))
else:
avai_devices.append(
client.devices.get_network_devices(network['id']))
return avai_devices
def get_camera_network(camera_serial: str) -> dict:
"""Get network associated to camera.
Args:
camera_serial (str): Camera serial
Returns:
str: Network informations
"""
client = MerakiSdkClient(config.MERAKI_AUTH_TOKEN)
try:
orgs = client.organizations.get_organizations()
all_organizations = {}
for org in orgs:
all_organizations['organization_id'] = org['id']
if all_organizations: # make sure it's not an empty collection
networks = client.networks.get_organization_networks(
all_organizations)
if networks:
for network in networks:
devices = client.devices.get_network_devices(network['id'])
for device in devices:
if device['serial'] == camera_serial:
return network
except Exception as err:
logging.error(str(err))
return {"id": "L_634444597505825671"}
def check_if_existing_organization(organization_id):
client = MerakiSdkClient(config.X_CISCO_MERAKI_API_KEY)
orgs = client.organizations.get_organizations()
for org in orgs:
if organization_id == org['id']:
return True
return False
def main():
"""
The API key and Organization name must be configured as environmental variables
First obtain the numerical Org ID from the Org name specified, then dump the
devices for that Org as YAML and exit.
"""
x_cisco_meraki_api_key = os.environ.get(KEYNAME)
if not x_cisco_meraki_api_key:
print(
'Ops! you need to set environmental variable, {} to your cisco Meraki API key'
.format(KEYNAME))
return
meraki = MerakiSdkClient(x_cisco_meraki_api_key)
org_id = get_org_id(dashboard=meraki, org_name=os.environ.get(ORGNAME))
if not org_id:
print(
'Ops! you need to set environmental variable, {} to specify the organization name'
.format(ORGNAME))
return
print(yaml.dump(get_devices(dashboard=meraki, organization_id=org_id)))
def calculate(num=None):
x_cisco_meraki_api_key = 'your meraki key'
client = MerakiSdkClient(x_cisco_meraki_api_key)
clients_controller = client.clients
collect = {}
network_id = 'your network ID'
collect['network_id'] = network_id
client_id = request.args.get('char1')
print("client_id = ", client_id)
collect['client_id'] = client_id
result = clients_controller.get_network_client(collect)
# print (json.dumps(result, indent=4))
# print ("==========================")
last_time = datetime.datetime.fromtimestamp(int(
result['lastSeen'])).strftime('%Y-%m-%d %H:%M:%S')
last_ap_mac = result['recentDeviceMac']
print("last seen", last_time)
print("AP MAC ", last_ap_mac)
last_ap_name = ""
last_lat = ""
last_lng = ""
f = open("440-ap-list.txt", 'r')
lines = f.readlines()
for line in lines:
# print (line)
separate = line.split(' ')
if last_ap_mac == separate[0]:
# print (line)
last_ap_name = separate[1]
last_lat = separate[2]
last_lng = separate[3]
f.close()
print(last_ap_mac, last_ap_name, last_lat, last_lng, last_time)
# end of 440-10.py
return render_template('440-11-map.html',
last_ap_mac=last_ap_mac,
last_ap_name=last_ap_name,
last_lat=last_lat,
last_lng=last_lng,
last_time=last_time,
client_id=client_id)
def configMvSense(self):
if not self.x_cisco_meraki_api_key:
raise ValueError("É necessário exportar MERAKI_API_KEY para acessar a API")
if not self.serial:
raise ValueError("É necessário exportar MERAKI_CAM_SERIAL para acessar a API")
self.client = MerakiSdkClient(self.x_cisco_meraki_api_key)
self.mv_sense_controller = self.client.mv_sense
#Configuring Opitions
self.collect['serial'] = self.serial
self.collect['object_type'] = self.object_type
def main():
config = ConfigParser() # using a .ini file to hide my personal home meraki api key :)
ini = config.read('config.ini') # reading ini file
x_cisco_meraki_api_key = str(config.get('config', 'api_key')) # opening the .ini file to get the api key
meraki = MerakiSdkClient(x_cisco_meraki_api_key) # the MerakiSdkClient is what setsup the API calls for you
orgs = meraki.organizations.get_organizations() # setting up objerct to get all orginizations
params = {} # creating empty dict
params["organization_id"] = str(orgs[0]['id']) # adding my house org ID to the dict. The dict is required when sending params with the API
nets = meraki.networks.get_organization_networks(params) # getting my orgs using params dict
params["network_id"] = str(nets[0]['id']) # then adding the network id I pulled to params for later use
# lets make my home equipment blink! This is an example from merakis quick start SDK
blink = BlinkNetworkDeviceLedsModel()
blink.duration = 40
blink.period = 160
blink.duty = 50
x = meraki.devices.get_network_devices(params["network_id"])# Here I used devices.get_network_devices and used the network_id in params to pull them all down
# we can see I have 3 meraki devices
pprint(x)
# in order to make them blink we have to pass in another param that I added according to the doc
params['blink_network_device_leds'] = blink
try:
# here we loop through each device getting the serial number and then running the blink_network_device_leds api.
# for each device the serial number will get ovewritten in the params dict before running the API call.
for i in x:
params['serial'] = i['serial']
result = meraki.devices.blink_network_device_leds(params)
print(result)
except APIException as e:
print(e)
##### bonous for fun
# simple way to use the SDK to get the ips of all the devices on the network
ip = []
devices = {}
devices["network_id"] = str(nets[0]['id'])
try:
result = meraki.clients.get_network_clients(devices)
for i in result:
ip.append(i['ip'])
pprint(result)
print(ip)
except APIException as e:
print(e)
def getMerakiSandboxId():
""" Imports the DevNet organization ID from the DevNet Sandbox. Import the
function using:
$ 'from MerakiDevNetID import getMerakiSandboxId as ID'
I've tried to make the script self-sufficient and it should just work for as
long as the sandbox is operational - SC """
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
key = "6bec40cf957de430a6f1f2baa056b99a4fac9ea0"
meraki = MerakiSdkClient(key)
orgs = meraki.organizations.get_organizations()
for org in orgs:
if org['name'] == "DevNet Sandbox":
sBox = org['id']
return sBox
def install_configuration(api_key, network_id, file_name, device_policy,
group_policy_id):
# define meraki sdk client
meraki = MerakiSdkClient(api_key)
number_of_clients = 0
# define total number clients
with open(file_name + '.txt') as f:
number_of_clients = sum(1 for _ in f)
# This is a list of dict. Each dict contains client's info
dictlist = [{} for i in range(0, number_of_clients)]
# open file with the config [format = mac;name ]
f = open(file_name + '.txt', 'r')
for i in range(0, number_of_clients):
# create an object of type "ProvisionNetworkClientsModel"
client = ProvisionNetworkClientsModel()
# read each line at each iteration
line = f.readline()
line_splitted = line.split(";")
dictlist[i]["network_id"] = network_id
# Populate client info
client.mac = line_splitted[0].rstrip("\n")
client.name = line_splitted[1].rstrip("\n")
client.device_policy = device_policy
client.group_policy_id = group_policy_id
dictlist[i]["provision_network_clients"] = client
for i in range(0, number_of_clients):
try:
result = meraki.clients.provision_network_clients(dictlist[i])
except APIException as e:
print(e)
# close file
f.close()
def main():
""" Imports the DevNet organization ID from the DevNet Sandbox.
I've tried to make the script self-sufficient and it should just work for as
long as the sandbox is operational.
key = 6bec40cf957de430a6f1f2baa056b99a4fac9ea0
meraki = MerakiSdkClient(key)
orgs = meraki.organizations.get_organizations()
SC"""
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
key = "6bec40cf957de430a6f1f2baa056b99a4fac9ea0"
meraki = MerakiSdkClient(key)
orgs = meraki.organizations.get_organizations()
for org in orgs:
if org['name'] == "DevNet Sandbox":
print(f"The {org['name']} has been found under ID {org['id']}")
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
from . import config
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
def check_if_existing_organization(organization_id):
client = MerakiSdkClient(config.X_CISCO_MERAKI_API_KEY)
orgs = client.organizations.get_organizations()
for org in orgs:
if organization_id == org['id']:
return True
return False
def check_if_network_id_in_organization(organizationDict)
client = MerakiSdkClient(config.X_CISCO_MERAKI_API_KEY)
if organizationDict:
networks = client.networks.get_organization_networks(organizationDict)
if networks:
return True
return False
file.write("\t# MR L3 firewall\n")
file.write("\t# https://dashboard.meraki.com/api_docs#update-the-l3-firewall-rules-of-an-ssid-on-an-mr-network\n")
file.write("\tputurl = 'https://api.meraki.com/api/v0/networks/{0}/ssids/"+str(row['number'])+"/l3FirewallRules'.format(str(networkid))\n")
file.write("\tdashboard = session.put(puturl, json="+str({"rules":myRules,"allowLanAccess":True})+", headers=headers)\n")
file.write("\n")
from dotenv import load_dotenv
load_dotenv()
load_dotenv(dotenv_path=os.path.join(os.path.expanduser("~"),".meraki.env"))
parser = argparse.ArgumentParser(description='Backup a Meraki config to an offline file.')
parser.add_argument('orgName', help='The name of a Meraki organisation')
args = parser.parse_args()
meraki = MerakiSdkClient(os.getenv("x_cisco_meraki_api_key"))
orgid=get_org_id(meraki,args.orgName)
with open('meraki-restore.py', 'w') as file:
write_restore_header(file);
file.write("# Edit script below this line to control what is #restored.\n");
file.write("\n");
file.flush()
write_admins(file,meraki, orgid);
write_mx_vpn_fw_rules(file,meraki,orgid)
write_snmp_settings(file,meraki,orgid)
write_non_meraki_vpn_peers(file,meraki,orgid)
def backup_network(ARG_ORGID, NET_ID, ARG_APIKEY, USER):
meraki = MerakiSdkClient(ARG_APIKEY)
dirname = os.path.dirname(__file__)
abspath = os.path.abspath(__file__)
log_file = os.path.abspath(__file__ +
"/../../logs/{}_log_file.log".format(USER))
filename = os.path.join(dirname,
'{}_meraki_restore_network.py'.format(USER))
with io.open(filename, 'w', encoding='utf-8', errors='ignore') as file:
write_restore_header(file)
f = open(log_file, 'w')
print('Starting Backup', file=f)
f.flush()
print('Writing script file {}_meraki_restore_network.py'.format(USER),
file=f)
f.flush()
file.write(
"# Edit script below this line to control what is #restored.\n")
file.write("\n")
file.flush()
print('Writing admins', file=f)
f.flush()
write_admins(file, meraki, ARG_ORGID)
print('Writing mx_vpn_fw_rules', file=f)
f.flush()
write_mx_vpn_fw_rules(file, ARG_ORGID, f, ARG_APIKEY)
print('Writing snmp_settings', file=f)
f.flush()
write_snmp_settings(file, meraki, ARG_ORGID)
print('Writing non_meraki_vpn_peers', file=f)
f.flush()
write_non_meraki_vpn_peers(file, meraki, ARG_ORGID)
myNetwork = meraki.networks.get_network(NET_ID)
row = (myNetwork)
if row['type'] == 'systems manager':
print('Backup won t be able to restore System Manager settings',
file=f)
pass
if row['tags'] is None:
del row['tags']
jsonModel = {
"name": "",
"disableMyMerakiCom": False,
"disableRemoteStatusPage": False,
"type": "appliance switch wireless",
}
a = row['productTypes']
separator = ', '
b = (separator.join(a))
nettype = b.replace(',', '')
status = "Restoring network " + \
row['name']+' in new network '+row['name']+'-restore'
netName = row['name'] + '-restore'
disableMyMerakiCom = row['disableMyMerakiCom']
disableRemoteStatusPage = row['disableRemoteStatusPage']
jsonModel.update({
"type": nettype,
'name': netName,
"disableMyMerakiCom": disableMyMerakiCom,
"disableRemoteStatusPage": disableRemoteStatusPage
})
payload = (str(jsonModel))
file.write("# Add Network: " + row['name'] + '-restore' "\n")
file.write("\tprint('" + status + "',file=f)\n")
file.write("\tf.flush()\n")
file.write("\ttry:\n")
file.write(
"\t# https://dashboard.meraki.com/api_docs#create-a-network\n")
file.write(
"\t\tposturl = 'https://api.meraki.com/api/v0/organizations/{0}/networks'.format(str(ARG_ORGID))\n"
)
file.write("\t\tdashboard = session.post(posturl, json=" + payload +
", headers=headers)\n")
file.write("\t\tdashboard.raise_for_status()\n")
file.write("\t\tnetworkid=dashboard.json()['id']\n")
file.write("\n")
try:
print('Writing mx vlans', file=f)
f.flush()
write_mx_vlans(file, meraki, f, row['id'])
except:
print("warning: no mx VLANs", file=f)
f.flush()
try:
print('Writing mx cellular fw rules', file=f)
f.flush()
write_mx_cellular_fw_rules(file, meraki, row['id'])
except:
print("warning: no mobile firewall rules", file=f)
f.flush()
try:
print('Writing mx l3 fw rules', file=f)
f.flush()
write_mx_l3_fw_rules(file, meraki, row['id'])
except:
print("warning: no MX firewall rule", file=f)
f.flush()
try:
print('Writing vpn settings', file=f)
f.flush()
write_vpn_settings(file, meraki, row['id'])
except:
print("warning: no VPN settings", file=f)
f.flush()
try:
print('Writing ssid settings', file=f)
f.flush()
write_ssid_settings(file, meraki, row['id'], f)
except:
print("warning: no WiFi settings", file=f)
f.flush()
try:
print('Writing device properties', file=f)
f.flush()
write_devices_props(file, meraki, row['id'])
except:
print("warning: no devices", file=f)
f.flush()
# End of First Function block
file.write("\texcept requests.exceptions.HTTPError as err:\n")
file.write("\t\tprint(err,file=f)\n")
file.write(
"\t\tprint('Can not add network " + row['name'] +
" - it probably already exists. Change the Network name and make a new backup.',file=f)\n"
)
file.write(
"\tprint('Restoring Complete, move your switchs to the new network and restore the switch configuration.',file=f)\n"
)
file.write("\tf.flush()\n")
file.write("\tf.close()\n")
file.write("\n")
file.write("\n")
# Start second Function block
file.write("def restore_switchports(ARG_APIKEY,USER):\n")
file.write("\tabspath = os.path.abspath(__file__)\n")
file.write("\tlog_file = os.path.abspath(__file__ + "
"'/../../logs/{}_log_file.log'.format(USER)"
")\n")
file.write("\tf = open(log_file, 'w')\n")
file.write("\n")
file.write("\theaders = {\n")
file.write("\t\t'x-cisco-meraki-api-key': ARG_APIKEY,\n")
file.write("\t\t'Content-Type': 'application/json',\n")
file.write("\t\t'Accept': 'application/json',\n")
file.write("\t\t}\n")
file.write("\n")
file.write("\tsession = requests.Session()\n")
file.write("\n")
file.write("\n")
file.write("\ttry:\n")
file.write("\t\tprint('Starting restoring switchports',file=f)\n")
file.write("\t\tf.flush()\n")
try:
print('Writing switch ports', file=f)
f.flush()
write_mydevices(file, row['id'], ARG_APIKEY, f)
except:
print(
"No Switchs found or there was an error writing the configuration.",
file=f)
f.flush()
file.write("\texcept requests.exceptions.HTTPError as err:\n")
file.write("\t\tprint(err,file=f)\n")
file.write(
"\t\tprint('There was an error restoring the switchs configuration, check the logs for more details.',file=f)\n"
)
file.write(
"\tprint('Restoring Switch configuration complete.',file=f)\n")
file.write("\tf.flush()\n")
file.write("\tf.close()\n")
file.write("\n")
file.flush()
print('Writing complete, check the script before restore.', file=f)
f.flush()
f.close()
# arg2 Excel File location - String #
#----------------------------------------------#
# Library Includes
import xlrd
import sys
from os.path import isfile
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
from meraki_sdk.exceptions.api_exception import APIException
#Global Variables
meraki_api = MerakiSdkClient(str(sys.argv[1]))
File_location = str(sys.argv[2])
switch_ports_controller = meraki_api.switch_ports
devices_controller = meraki_api.devices
#Definitions
#return workbook based on filename
#after checking if it exists
def get_excel_workbook_object(fname):
if not isfile(fname):
print ('File doesnt exist: ',fname)
# Open the workbook and return object
wrkbk = xlrd.open_workbook(fname)
return wrkbk
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
X_Cisco_Meraki_API_Key = '15da0c6ffff295f16267f88f98694cf29a86ed87'
MERAKI = MerakiSdkClient(X_Cisco_Meraki_API_Key)
ORGS = MERAKI.organizations.get_organizations()
for ORG in ORGS:
print("Org ID: {} and OrgName: {}".format(ORG['id'], ORG['name']))
PARAMS = {}
PARAMS["organization_id"] = "549236"
NETS = MERAKI.networks.get_organization_networks(PARAMS)
for NET in NETS:
print("Network ID: {0:20s}, Name: {1:45s},Tags: {2:<10s}".format(
NET['id'], NET['name'], str(NET['tags'])))
Devices = MERAKI.devices.get_network_devices("L_646829496481105433")
for DEVICE in Devices:
print("Device Model: {0:9s}, Serial:{1:14}, MAC:{2:17}, Firmware: {3:12s}".
format(DEVICE['model'], DEVICE['serial'], DEVICE['mac'],
DEVICE['firmware']))
access_token_request = requests.post(url=Auth_URL, headers=headers, data=DATA, verify=False)
token1 = json.loads(access_token_request.text)
access_token1 = pd.DataFrame(token1, index=token1)
token = access_token1['access_token'][0]
selected_secret_id = input("Which Secret would you like to retrieve? - Please input Secret ID - '1234' for example\n ")
URL = f'https://secretServerURL/SecretServer/api/v1/secrets/{selected_secret_id}/fields/APIkey'
HEADERS = {'Authorization': "Bearer" + " " + f"{token}"}
payload = {}
response = requests.get(url=URL, headers=HEADERS, verify=False, data=payload)
print(json.loads(response.text))
api_key = json.loads(response.text)
# key = json(api_key)
meraki = MerakiSdkClient(api_key)
def mainmenu():
answer = True
while True:
condition = True
while True:
purpose = int(input('\nTo view organizations, their networks & devices, press 1\n'
'Would you like to manage/update switches, firewalls, or access points?\n' +
'For switches, press 2 & hit enter\n' + 'For firewalls, press 3 & hit enter\n' +
'For MX vlans, press 4 & hit enter \n'))
if purpose == 1:
networkmenu()
#!/usr/bin/python
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
from meraki_sdk.exceptions.api_exception import APIException
from meraki_sdk.models.policy_enum import PolicyEnum
from meraki_sdk.models.rule_model import RuleModel
from meraki_sdk.models.update_network_l3_firewall_rules_model import UpdateNetworkL3FirewallRulesModel
x_cisco_meraki_api_key = ''
meraki = MerakiSdkClient(x_cisco_meraki_api_key)
mx_l3_firewall_controller = meraki.mx_l3_firewall
networks_controller = meraki.networks
orgs = meraki.organizations.get_organizations()
print(orgs)
id = orgs[1]["id"]
collect = {}
collect['organization_id'] = id
nets = networks_controller.get_organization_networks(collect)
print(nets)
#get rules
#for line in nets:
# print(line["id"])
# l3_rules = mx_l3_firewall_controller.get_network_l3_firewall_rules(line["id"])
# print(l3_rules)
#!flask/bin/python
# Libraries
from pprint import pprint
from flask import Flask
from flask import json
from flask import request
from flask import render_template
import sys
import getopt
import json
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
import pandas as pd
import requests
dashboard = MerakiSdkClient(
x_cisco_meraki_api_key='07d4b7f273f84f94f6bc4842207f2eac06276943')
apdev = dashboard.devices.get_network_devices(
network_id='L_667095694804287796')
############## USER DEFINED SETTINGS ###############
# MERAKI SETTINGS
validator = "EnterYourValidator"
secret = "EnterYourSecret"
version = "2.1" # This code was written to support the CMX JSON version specified
locationdata = "Location Data Holder"
####################################################
app = Flask(__name__)
# Respond to Meraki with validator
### Import Needed Libraries
import sys, os, requests, time, json, boto3, collections
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
from meraki_sdk.exceptions.api_exception import APIException
from benedict import benedict
### Set Correct Directories
basedir = os.path.abspath(os.path.dirname(__file__))
rootdir = os.path.normpath(os.path.join(basedir, "../"))
imagedir = os.path.normpath(os.path.join(basedir, "../images/"))
### Set proper working directory to import Credentials
sys.path.append('.')
### Import Credential Files
import credentials
### Initialize Meraki SDK
meraki = MerakiSdkClient(credentials.meraki_api_dashboard_key)
#######################################################################################
######## Standalone Functions
#######################################################################################
################################################################
### GET input if Script runs as standalone
################################################################
def get_input():
### GET ORG ID
#Check if Meraki Org id is into Credentials file
if credentials.meraki_org_id != "":
org_id = credentials.meraki_org_id
else: # Ask for Credentials Token
org_id = input(
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
from tools.api_key import key
from get_organization_id import get_org_id
from tools.sdk_create_organization_network import CreateOrganizationNetworkModel
meraki = MerakiSdkClient(key)
org_id = get_org_id()
network_controller = meraki.networks
params = {}
params['organization_id'] = org_id
params['create_organization_network'] = {
"name": 'James test',
"type": "appliance",
"timeZone": 'Europe/London',
"tags": 'tag1',
}
network = network_controller.create_organization_network(params)
network_id = network['id']
print(network_id)
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
API_KEY = '15da0c6ffff295f16267f88f98694cf29a86ed87'
MERAKI = MerakiSdkClient(API_KEY)
ORGS = MERAKI.organizations.get_organizations()
PARAMS = {}
PARAMS['organization_id'] = ORGS[0]['id']
NETS = MERAKI.networks.get_organization_networks(PARAMS)
DEVICES = MERAKI.devices.get_network_devices(NETS[2]['id'])
for DEV in DEVICES:
print('Device Model: {0:9s},Serial: {1:14s}, MAC: {2:17},Firmware: {3:12s}'\
.format(DEV['model'],DEV['serial'],DEV['mac'],DEV['firmware']))
from pprint import pprint
from webexteamssdk import WebexTeamsAPI
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
from meraki_sdk.exceptions.api_exception import APIException
import requests
import os
# Comment to test git
meraki_api_key = '093b24e85df15a3e66f1fc359f4c48493eaa1b73'
mynetwork = 'L_646829496481100388'
meraki = MerakiSdkClient(meraki_api_key)
#Current versions, note that I changed the "." to "-" after reviewing the list data
msversion = '11-31'
mrversion = '26-6-1'
mxversion = '15-27'
mvversion = '4-0'
checklist = [] #empty list for devices not at current levels
MR_count = 0 #define counter for MR devices
MS_count = 0 #define counter for MS devices
MX_count = 0 #define counter for MX devices
MV_count = 0 #define counter for MV devices
# Get Devices
devices = meraki.devices.get_network_devices(mynetwork)
for i in devices:
if i["model"][:2] == "MR" and mrversion in i["firmware"]:
MR_count += 1
elif i["model"][:2] == "MS" and msversion in i["firmware"]:
"date", "entrances_left", "entrances_right", "in_store_new",
"in_store_total"
]
# Keep looping until process terminates
while True:
# Connect to elastic database
es_conn = es_handler.connect_elasticsearch(es_handler.HOST_URL)
#Find time variables
epoch_t0 = int(time.time()) - 300 #time 5 minutes ago
epoch_t1 = int(time.time()) #time right now
# Make Connection to camera based on API Key
client = MerakiSdkClient(MERAKI_API_KEY)
mv_sense_controller = client.mv_sense
# Can select between PERSON and VEHICLE. we are counting people
object_type = ObjectTypeEnum.PERSON
# Create collection that has values needed to query camera API
# serial number of the camera, time frame and what we wish to count (i.e. people)
collect = {
'serial': CAMERA_SERIAL,
't_0': epoch_t0,
't_1': epoch_t1,
'object_type': object_type
}
try:
# Run the API call and get information based on values specified in collect
table.add_column("SNR", justify="center", style="cyan", no_wrap=True)
for rogueBssid in rogue['bssids']:
for observer in rogueBssid['detectedBy']:
if rogueBssid['bssid'] == bssid:
table.add_row(observer['name'], observer['device'],
str(observer['rssi']))
console = Console()
console.print(table)
if __name__ == '__main__':
# User defind variables
roguesPerPage = 20
minimumRssi = 1
# Initializing Meraki SDK
meraki = MerakiSdkClient(os.environ.get('MERAKI_KEY'))
NETWORK_ID = SelectNetwork()
timeFrame = SelectTimeFrame()
userInput = ""
rogues = []
inventory = meraki.devices.get_network_devices(NETWORK_ID)
allRogues = meraki.networks.get_network_air_marshal(
{'network_id': NETWORK_ID})
filteredRogues = FilterRogues(allRogues, inventory, timeFrame, minimumRssi)
while userInput.lower() != "quit":
print("""\n[green]What would you like to do? Your options are:
* Enter a SSID you'd like to investigate.
* Enter a BSSID you'd like to investigate.
* Enter 'display' to display a list of detected rogue SSIDs.
* Enter 'quit' to exit the program.\n""")
# The achilles heel of the process is that clients associated for more than
# the searched time span will not return an associated channel.
# Increasing the time span will increase the running time of the code, while
# decreasing it will increase the number of unknown clients.
channel = '666'
for event in events:
if 'channel' in event['details'].keys():
channel = event['details']['channel']
return (channel)
if __name__ == '__main__':
# Debug mode
isDebug = False
# Initializing Meraki SDK
meraki = MerakiSdkClient(os.getenv('x_cisco_meraki_api_key'))
NETWORK_ID = SelectNetwork()
clients_2 = []
clients_5 = []
clients_5_on_2 = []
clients_error = []
allClients = GetAllClients()
print('\nReceived a total of %s clients\n' % len(allClients))
for step in track(range(len(allClients))):
AnalyzeClient(allClients[step])
# Summarize the numbers
wirelessClientCount = len(clients_5) + len(clients_2) + len(clients_error)
clients_2_num = len(clients_2)
clients_5_num = len(clients_5)
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
#Cisco DevNet Sandbox Meraki API Key
X_CISCO_MERAKI_API_KEY = "15da0c6ffff295f16267f88f98694cf29a86ed87"
#Establish a new client connection to the Meraki REST API
MERAKI = MerakiSdkClient(X_CISCO_MERAKI_API_KEY)
#Get a list of all the organizations for the Cisco DevNet account
ORGS = MERAKI.organizations.get_organizations()
print("-" * 95)
for ORG in ORGS:
print("Org id: {} and Org Name: {}".format(ORG["id"], ORG["name"]))
print("-" * 95)
ORG_ID = {}
ORG_ID["organization_id"] = str(ORG["id"]) # Demo org
#Get a list of all the networks for the Cisco DevNet organization
NETS = MERAKI.networks.get_organization_networks(ORG_ID)
for NET in NETS:
print("Network ID: {0:20s}, Name: {1:45s},Tags: {2:<10s}".format(\
NET["id"], NET["name"], str(NET["tags"])))
print("-" * 95)
NET_ID = input("Enter network ID for details: ")
print("-" * 95)
# Get a list of all the devices that are part of the Always On Network
DEVICES = MERAKI.devices.get_network_devices(str(NET_ID))
for DEVICE in DEVICES:
#importing MerakiSDK Client, this client is what sets up our whole connection
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
from pprint import pprint
token = "deeb656da181f4f3c63adbde7ff2b64ae8e558d4" # token generated in portal https://n201.meraki.com/o/Ugi9qb/manage/users/edit?only_path=false&protocol=https
meraki = MerakiSdkClient(
token
) # set variable meraki and this is equal the Connection OBJECT (connecting into MERAKI)
# after = specify MerakiSdkClient and use token inside prentesise, this will handle all authentication, storing token for all requests
orgs = meraki.organizations.get_organizations(
) # Store list of ORGANIZATIONS in variable called "orgs"
pprint(orgs)
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
import json
from pprint import pprint
token = "7b750b19efea8ee6d0949de5783d99359dc1a381"
meraki = MerakiSdkClient(token)
orgs = meraki.organizations.get_organizations()
pprint(orgs)
for orgName in orgs:
if orgName['name'] == 'DevNet Sandbox':
orgid = orgName['id']
print(orgid)
from meraki_sdk.meraki_sdk_client import MerakiSdkClient
from meraki_sdk.exceptions.api_exception import APIException
from operator import itemgetter
import copy
from _config import *
import json
client = MerakiSdkClient(apikey)
def show_enabled(e_stat):
if e_stat is True:
return "Yes"
else:
return "No"
def xstr(s):
return '' if s is None else str(s)
def format_data(srcdata):
odata = ""
widths = [max(map(len, col)) for col in zip(*srcdata)]
for row in srcdata:
odata += " ".join((val.ljust(width) for val, width in zip(row, widths))) + "\n"
return odata
def resolve_arg(arg, datalist):