def list(self):
validate_creds_exists(self.app)
db = DBWrapper(self.app.creds)
group_client = APIClient(db.get_configure()).get_group_api_client()
enterprise_id = db.get_enterprise_id()
name = self.app.pargs.name
limit = self.app.pargs.limit
offset = self.app.pargs.offset
kwargs = {}
if name:
kwargs['name'] = name
try:
response = group_client.get_all_groups(enterprise_id,
limit=limit,
offset=offset,
**kwargs)
except ApiException as e:
self.app.log.error(f"[group-list] Failed to list groups: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
if not self.app.pargs.json:
groups = []
label = {
'id': "ID",
'name': "NAME",
'device_count': "DEVICE COUNT"
}
for group in response.results:
groups.append({
label['id']:
group.id,
label['name']:
group.name,
label['device_count']:
group.device_count if group.device_count else 0
})
self.app.render(f"Number of Groups: {response.count}")
self.app.render(groups,
format=OutputFormat.TABULATED.value,
headers="keys",
tablefmt="plain")
else:
groups = []
for group in response.results:
groups.append({
'id':
group.id,
'name':
group.name,
'device_count':
group.device_count if group.device_count else 0
})
self.app.render(f"Number of Groups: {response.count}")
self.app.render(groups, format=OutputFormat.JSON.value)
def get_groups_list(self, limit=20, offset=0):
validate_creds_exists(self.app)
db = DBWrapper(self.app.creds)
group_client = APIClient(db.get_configure()).get_group_api_client()
enterprise_id = db.get_enterprise_id()
try:
response = group_client.get_all_groups(enterprise_id,
limit=limit,
offset=offset)
except ApiException as e:
self.app.log.error(f"[group-list] Failed to list groups: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}\n")
return
groups = []
for group in response.results:
groups.append({
'id':
group.id,
'name':
group.name,
'device_count':
group.device_count if group.device_count else 0
})
return response.count, groups
def delete(self):
validate_creds_exists(self.app)
db = DBWrapper(self.app.creds)
group_client = APIClient(db.get_configure()).get_group_api_client()
enterprise_id = db.get_enterprise_id()
group_name = self.app.pargs.name
kwargs = {'name': group_name}
try:
search_response = group_client.get_all_groups(enterprise_id, limit=1, offset=0, **kwargs)
if not search_response.results or len(search_response.results) == 0:
self.app.log.debug(f'[group-delete] Group does not exist with name {group_name}')
self.app.render(f'Group does not exist with name {group_name}')
return
response = search_response.results[0]
group_id = response.id
except ApiException as e:
self.app.log.error(f"[group-update] Failed to list groups: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
try:
group_client.delete_group(group_id, enterprise_id)
self.app.log.debug(f"[group-update] Group with name {group_name} deleted successfully")
self.app.render(f"Group with name {group_name} deleted successfully")
# Unset current group if matching
group = db.get_group()
if group and group.get('id') and group_id == group.get('id'):
db.unset_group()
self.app.log.debug(f'[group-update] Unset the active group {group_name}')
except ApiException as e:
self.app.log.error(f"[group-update] Failed to delete group: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
def show(self):
validate_creds_exists(self.app)
db = DBWrapper(self.app.creds)
group_client = APIClient(db.get_configure()).get_group_api_client()
enterprise_id = db.get_enterprise_id()
group_name = self.app.pargs.group_name
kwargs = {'name': group_name}
try:
search_response = group_client.get_all_groups(enterprise_id, limit=1, offset=0, **kwargs)
response = None
for group in search_response.results:
if group.name == group_name:
response = group
break
if not response:
self.app.log.info(f'[group-show] Group does not exist with name {group_name}')
self.app.render(f'Group does not exist with name {group_name}')
return
except ApiException as e:
self.app.log.error(f"[group-show] Failed to list groups: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
if self.app.pargs.active:
db.set_group({'id': response.id, 'name': group_name})
if not self.app.pargs.json:
renderable = self._group_basic_response(response)
self.app.render(renderable, format=OutputFormat.TABULATED.value, headers="keys", tablefmt="plain")
else:
renderable = self._group_basic_response(response, OutputFormat.JSON)
self.app.render(renderable, format=OutputFormat.JSON.value)
def set_active(self):
validate_creds_exists(self.app)
db = DBWrapper(self.app.creds)
group_client = APIClient(db.get_configure()).get_group_api_client()
enterprise_id = db.get_enterprise_id()
if self.app.pargs.name:
group_name = self.app.pargs.name
kwargs = {'name': group_name}
try:
search_response = group_client.get_all_groups(enterprise_id,
limit=1,
offset=0,
**kwargs)
if not search_response.results or len(
search_response.results) == 0:
self.app.log.info(
f'[group-active] Group does not exist with name {group_name}'
)
self.app.render(
f'Group does not exist with name {group_name}')
return
response = search_response.results[0]
db.set_group({'id': response.id, 'name': group_name})
except ApiException as e:
self.app.log.error(
f"[group-active] Failed to list groups: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
else:
group = db.get_group()
if group is None or group.get('name') is None:
self.app.log.debug('[group-active] There is no active group.')
self.app.render('There is no active group.')
return
group_id = group.get('id')
try:
response = group_client.get_group_by_id(
group_id, enterprise_id)
except ApiException as e:
self.app.log.error(
f"[group-active] Failed to show active group: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
if not self.app.pargs.json:
renderable = self._group_basic_response(response)
self.app.render(renderable,
format=OutputFormat.TABULATED.value,
headers="keys",
tablefmt="plain")
else:
renderable = self._group_basic_response(response,
OutputFormat.JSON)
self.app.render(renderable, format=OutputFormat.JSON.value)
def update(self):
validate_creds_exists(self.app)
db = DBWrapper(self.app.creds)
group_client = APIClient(db.get_configure()).get_group_api_client()
enterprise_id = db.get_enterprise_id()
data = DeviceGroupUpdate()
group_name = self.app.pargs.name
kwargs = {'name': group_name}
try:
search_response = group_client.get_all_groups(enterprise_id,
limit=1,
offset=0,
**kwargs)
if not search_response.results or len(
search_response.results) == 0:
self.app.log.debug(
f'[group-update] Group does not exist with name {group_name}'
)
self.app.render(f'Group does not exist with name {group_name}')
return
response = search_response.results[0]
group_id = response.id
except ApiException as e:
self.app.log.error(f"[group-update] Failed to list groups: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
if self.app.pargs.new_name:
data.name = self.app.pargs.new_name
else:
self.app.log.debug('[group-update] name cannot be empty.')
self.app.render('name cannot be empty.')
return
try:
response = group_client.partial_update_group(
group_id, enterprise_id, data)
except ApiException as e:
self.app.log.error(
f"[group-update] Failed to update details of a group: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
if not self.app.pargs.json:
renderable = self._group_basic_response(response)
self.app.render(renderable,
format=OutputFormat.TABULATED.value,
headers="keys",
tablefmt="plain")
else:
renderable = self._group_basic_response(response,
OutputFormat.JSON)
self.app.render(renderable, format=OutputFormat.JSON.value)
def validate_group_name(self, name) -> DeviceGroup:
validate_creds_exists(self.app)
db = DBWrapper(self.app.creds)
group_client = APIClient(db.get_configure()).get_group_api_client()
enterprise_id = db.get_enterprise_id()
response = group_client.get_all_groups(enterprise_id, name=name)
if response.count > 0:
return response.results[0]
else:
raise ApiException("No such Group-Name found!")
def list(self):
"""Command to list devices"""
validate_creds_exists(self.app)
db = DBWrapper(self.app.creds)
device_client = APIClient(db.get_configure()).get_device_api_client()
enterprise_id = db.get_enterprise_id()
state = self.app.pargs.state
name = self.app.pargs.name
group_name = self.app.pargs.group
imei = self.app.pargs.imei
brand = self.app.pargs.brand
gms = self.app.pargs.gms
limit = self.app.pargs.limit
offset = self.app.pargs.offset
kwargs = {}
if state:
kwargs['state'] = DeviceState[state.upper()].value
if name:
kwargs['name'] = name
if group_name:
kw = {'name': group_name}
group_id = None
try:
group_client = APIClient(
db.get_configure()).get_group_api_client()
search_response = group_client.get_all_groups(enterprise_id,
limit=1,
offset=0,
**kw)
for group in search_response.results:
if group.name == group_name:
group_id = group.id
break
except ApiException as e:
self.app.log.error(f"[device-list] Failed to list groups: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
if not group_id:
group_id = str(uuid.uuid4()) # random uuid
kwargs['group'] = group_id
if imei:
kwargs['imei'] = imei
if brand:
kwargs['brand'] = brand
if gms:
kwargs['is_gms'] = gms
try:
# Find devices in an enterprise
response = device_client.get_all_devices(enterprise_id,
limit=limit,
offset=offset,
**kwargs)
except ApiException as e:
self.app.log.error(f"[device-list] Failed to list devices: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
self.app.render(f"Number of Devices: {response.count}")
if not self.app.pargs.json:
devices = []
label = {
'id': "ID",
'name': "NAME",
'model': "MODEL",
'state': "CURRENT STATE"
}
for device in response.results:
current_state = DeviceState(device.status).name
devices.append({
label['id']:
device.id,
label['name']:
device.device_name,
label['model']:
device.hardware_info.get("manufacturer"),
label['state']:
current_state
})
self.app.render(devices,
format=OutputFormat.TABULATED.value,
headers="keys",
tablefmt="plain")
else:
devices = []
for device in response.results:
current_state = DeviceState(device.status).name
devices.append({
'id':
device.id,
'device':
device.device_name,
'model':
device.hardware_info.get("manufacturer"),
'state':
current_state
})
self.app.render(devices, format=OutputFormat.JSON.value)
def devices(self):
validate_creds_exists(self.app)
db = DBWrapper(self.app.creds)
device_client = APIClient(db.get_configure()).get_device_api_client()
group_client = APIClient(db.get_configure()).get_group_api_client()
enterprise_id = db.get_enterprise_id()
if self.app.pargs.group:
group_name = self.app.pargs.group
kwargs = {'name': group_name}
try:
search_response = group_client.get_all_groups(enterprise_id,
limit=1,
offset=0,
**kwargs)
if not search_response.results or len(
search_response.results) == 0:
self.app.log.debug(
f'[group-devices] Group does not exist with name {group_name}'
)
self.app.render(
f'Group does not exist with name {group_name}')
return
response = search_response.results[0]
group_id = response.id
except ApiException as e:
self.app.log.error(
f"[group-devices] Failed to list groups: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
else:
group = db.get_group()
if group is None or group.get('name') is None:
self.app.log.debug('[group-devices] There is no active group.')
self.app.render('There is no active group.')
return
group_id = group.get('id')
limit = self.app.pargs.limit
offset = self.app.pargs.offset
try:
response = device_client.get_all_devices(enterprise_id,
group=group_id,
limit=limit,
offset=offset)
except ApiException as e:
self.app.log.error(
f"[group-devices] Failed to list group devices: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
self.app.render(f"Number of Devices: {response.count}")
if not self.app.pargs.json:
devices = []
label = {
'id': "ID",
'name': "NAME",
'model': "MODEL",
'state': "CURRENT STATE"
}
for device in response.results:
devices.append({
label['id']:
device.id,
label['name']:
device.device_name,
label['model']:
device.hardware_info.get("manufacturer"),
label['state']:
DeviceState(device.status).name
})
self.app.render(devices,
format=OutputFormat.TABULATED.value,
headers="keys",
tablefmt="plain")
else:
devices = []
for device in response.results:
devices.append({
'id':
device.id,
'device':
device.device_name,
'model':
device.hardware_info.get("manufacturer"),
'state':
DeviceState(device.status).name
})
self.app.render(devices, format=OutputFormat.JSON.value)
def remove(self):
validate_creds_exists(self.app)
db = DBWrapper(self.app.creds)
group_client = APIClient(db.get_configure()).get_group_api_client()
enterprise_id = db.get_enterprise_id()
data = DeviceGroupUpdate()
if self.app.pargs.group:
group_name = self.app.pargs.group
kwargs = {'name': group_name}
try:
search_response = group_client.get_all_groups(enterprise_id,
limit=1,
offset=0,
**kwargs)
if not search_response.results or len(
search_response.results) == 0:
self.app.log.debug(
f'[group-remove] Group does not exist with name {group_name}'
)
self.app.render(
f'Group does not exist with name {group_name}')
return
response = search_response.results[0]
group_id = response.id
except ApiException as e:
self.app.log.error(
f"[group-remove] Failed to list groups: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
else:
group = db.get_group()
if group is None or group.get('name') is None:
self.app.log.debug('[group-remove] There is no active group.')
self.app.render('There is no active group.')
return
group_id = group.get('id')
devices = self.app.pargs.devices
if not devices or len(devices) == 0:
self.app.log.debug('[group-remove] devices cannot be empty.')
self.app.render('devices cannot be empty.')
return
device_client = APIClient(db.get_configure()).get_device_api_client()
request_device_ids = []
for device_name in devices:
kwargs = {'name': device_name}
try:
search_response = device_client.get_all_devices(enterprise_id,
limit=1,
offset=0,
**kwargs)
if not search_response.results or len(
search_response.results) == 0:
self.app.log.debug(
f'[group-remove] Device does not exist with name {device_name}'
)
self.app.render(
f'Device does not exist with name {device_name}')
return
response = search_response.results[0]
request_device_ids.append(response.id)
except ApiException as e:
self.app.log.error(f"Failed to list devices: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
device_client = APIClient(db.get_configure()).get_device_api_client()
current_device_ids = self._get_group_device_ids(
device_client, enterprise_id, group_id)
if current_device_ids is None:
return
latest_devices = list(
set(current_device_ids) - set(request_device_ids))
data.device_ids = latest_devices
try:
response = group_client.partial_update_group(
group_id, enterprise_id, data)
except ApiException as e:
self.app.log.error(
f"[group-remove] Failed to remove device from group: {e}")
self.app.render(f"ERROR: {parse_error_message(self.app, e)}")
return
if not self.app.pargs.json:
renderable = self._group_basic_response(response)
self.app.render(renderable,
format=OutputFormat.TABULATED.value,
headers="keys",
tablefmt="plain")
else:
renderable = self._group_basic_response(response,
OutputFormat.JSON)
self.app.render(renderable, format=OutputFormat.JSON.value)
