def get(self, name=None):
queryData = request.args.to_dict()
if name:
device = DeviceModel.find_by_name(name)
if device: return device.json(), 200
else: return {'error': 'device not found'}, 404
devices = DeviceModel.find(**queryData)
return {'devices': list(map(lambda x: x.json(), devices))}, 200
def put(self, name):
data = Device.parser.parse_args()
device = DeviceModel.find_by_name(name)
if device is None:
device = DeviceModel(name)
device.save_to_db()
return device.json(), 201
else:
device.state = data['state']
device.save_to_db()
return device.json(), 201
def _processDeviceList(self, deviceList):
'''
'''
resultCode, resultMessage = True, ""
for device_name in deviceList:
device = DeviceModel.find_by_name(device_name)
if not device:
device = DeviceModel(device_name, deviceClass=1)
try:
device.save_to_db(commit=True)
except:
resultCode, resultMessage = False, "An error occurred inserting the device."
self._hosts.append(device)
return resultCode, resultMessage
def buildCommand(self):
for deviceName in self.job.parameters["hostsConfiguration"]:
device = DeviceModel.find_by_name(deviceName)
if not device:
device = DeviceModel(deviceName, deviceClass=1)
try:
device.save_to_db(commit=False)
except:
resultCode, resultMessage = False, "An error occurred inserting the device."
command = Environment().from_string(
self.job.parameters["remoteCommand"]).render(
self.job.parameters["hostsConfiguration"][deviceName])
task = TaskModel(self.job.id, device.id)
task.parameters["command"] = command
task.save_to_db(commit=False)
return command
def delete(self, name):
device = DeviceModel.find_by_name(name)
if device:
device.delete_from_db()
else:
return {'error': 'device not found'}, 404
return {'success': 'Device deleted'}, 202
def get(self):
try:
return {
'devices':
[device.json() for device in DeviceModel.find_device_online()]
}
except:
return {'message': 'Device not found.'}, 404
def read_configurations():
for file in os.listdir(conf_dir):
if file.endswith(".lircd.conf"):
f = open(os.path.join(conf_dir, file), 'r')
device = DeviceModel(name = file[:-11])
stop = False
start = False
for row in f:
if re.search("end codes", row):
stop = True
if start and not stop:
key = KeyModel(re.findall("KEY_\w+", row)[0])
device.insert_key(key)
if re.search("begin codes", row):
start = True
f.close()
devices.append(device)
def _processDeviceList(self, deviceList):
'''
'''
ip_addr = ""
device_name = ""
resultCode, resultMessage = True, ""
for host in deviceList:
device = DeviceModel.find_by_name(
host) if DeviceModel.find_by_name(
host) is not None else DeviceModel.find_by_ipAddress(host)
if not device:
if self.validIP(host):
try:
device_name = socket.getfqdn(host)
except:
continue
ip_addr = host
else:
device_name = host
try:
ip_addr = socket.gethostbyname(host)
except:
continue
#except: ip_addr = host
device = DeviceModel(name=device_name,
ipAddress=ip_addr,
deviceClass=1)
try:
device.save_to_db(commit=False)
except:
resultCode, resultMessage = False, "An error occurred inserting the device."
self._hosts.append(device)
return resultCode, resultMessage
def _processTasks(self, job_id, hosts):
'''
'''
resultCode, resultMessage = True, ""
for deviceName in hosts:
device = DeviceModel.find_by_name(deviceName)
task = TaskModel(job_id, device.id)
task.save_to_db(commit=True)
return resultCode, resultMessage
def put(self):
data = Device.arguments_device.parse_args()
device_find = DeviceModel.find_by_mac(data['mac'])
if device_find:
device_find.update(data['status'])
device_find.save()
return device_find.json(), 200
device = DeviceModel(**data)
try:
device.save()
except:
return {
'message': 'An internal error ocurred trying to save device'
}, 500
return device, 201
def get(self):
try:
devices = DeviceModel.find_all()
except:
return {
"error": "An error occured selecting the devices"
}, 500 #internal server error
if devices:
return {'devices': [device.json() for device in devices]}
return {"error": "No devices connected to the network"}, 404
def put(self, devId):
data = Device.parser.parse_args()
device = DeviceModel.find_by_name(devId)
if device is None:
device = DeviceModel(devId, data['power'], data['voltage'],
data['current'])
else:
device.power = data['power']
device.voltage = data['voltage']
device.current = data['current']
device.save_to_db()
return device.json()
def _processPostcheck(self, parameters):
'''
'''
resultCode, resultMessage = True, ""
precheck_id = parameters["jobID"]
taskList = TaskModel.find(**{"job_id": precheck_id})
self.job.device_count = len(taskList)
for task in taskList:
device = DeviceModel.find_by_id(task.device_id)
if not device:
resultCode, resultMessage = False, "Device not found."
self._hosts.append(device)
return resultCode, resultMessage
def RuleTask(self, task_id, event_type, column, value, rule):
result = 0
if rule["element"] == "task":
rule_value = rule["value"]
if rule.get("device") and rule.get("device") != 'None':
rule_element = "device"
if rule.get("deviceClass") and rule.get("deviceClass") != 'None':
rule_element = "deviceClass"
if rule.get("group") and rule.get("group") != 'None':
rule_element = "group "
if rule.get("location") and rule.get("location") != 'None':
rule_element = "location"
get_task = TaskModel.findById(task_id)
task = get_task.__dict__
get_device = DeviceModel.find_by_id(get_task.device_id)
device = get_device.__dict__
if device[rule_element] == rule.get(
rule_element) and rule_value == value:
result = 1
return result, device[rule_element], "status", rule_value
if rule["element"] == "device":
rule_column = rule["column"]
rule_operation = rule["operation"]
rule_value = rule["value"]
get_task = TaskModel.findById(task_id)
task = get_task.__dict__
get_device = DeviceModel.find_by_id(get_task.device_id)
device_name = get_device.name
device = get_device.__dict__
try:
element_column = device[rule_column]
except:
return result, None, None, None
result = self.comparison(element_column, rule_value,
rule_operation)
return result, device_name, rule_column, rule_value
return result, None, None, None
def put(self, name):
data = json.loads(request.data)
device = DeviceModel.find_by_name(name)
if device:
cipher_suite = Fernet(KEY)
if data.get('login'):
data['login'] = cipher_suite.encrypt(
data.get('login').encode('ascii')).decode('ascii')
if data.get('password'):
data['password'] = cipher_suite.encrypt(
data.get('password').encode('ascii')).decode('ascii')
device.update(**data)
else:
return {'error': 'device not found'}, 404
return device.json(), 201
def post(self, device_name, key_name):
device = DeviceModel.find_by_name(device_name)
if device:
key = device.find_key_by_name(key_name)
if key:
result = key.press(device_name)
if result == "OK":
return {'message': 'Action executed'}, 200
else:
return {
'error':
'Something went wrong during the execution of action: {}'
.format(result)
}, 500
return {'error': 'Key not found'}, 404
return {'error': 'Device not found'}, 404
def post(self, name):
if DeviceModel.find_by_name(name):
return {
'message':
f'Bad Request: A device with name {name} already exists. '
f'No two duplicate devices can be created.'
}, 400
device = DeviceModel(name)
device.save_to_db()
return device.json(), 201
def post(self):
data = Device.arguments_device.parse_args()
if DeviceModel.find_by_mac(data['mac']):
return {"message": "The device {} already exists."}, 400
device = DeviceModel(data['mac'], "ON")
try:
device.save()
except:
return {
"message":
'An internal error ocurred trying to create a new device.'
}, 500
return device.json()
def getList(self, filter):
device_list = []
resultCode, resultMessage = True, ""
if filter["element"] == "all" or filter["value"] == "all":
try:
device_list = list(map(lambda x: x, DeviceModel.query.all()))
except:
resultCode, resultMessage = False, "An error occurred getting the device."
else:
try:
device_list = DeviceModel.find(
**{filter["element"]: filter["value"]})
except:
resultCode, resultMessage = False, "An error occurred getting the device."
if filter["device"] == "all":
self._hosts = device_list
for device in device_list:
if filter["device"] in device.name:
self._hosts.append(device)
#self.job.device_count = len(self._hosts)
return resultCode, resultMessage
def ProcessCompliance(self, status):
compliance_execution = ComplianceExecutionModel.find_by_id(self.job.compliance_execution_id)
check_list = CheckModel.find(**{"compliance_id": compliance_execution.compliance_id})
device_name = DeviceModel.find_by_id(TaskModel.findById(self.task.id).device_id).name
if status == "SUCCESSFUL":
total = 0
for check in check_list:
check_result = CheckResultModel(check.id, check.name, device_name, self.task.id, self.job.compliance_execution_id, status = 'NEW', parameters = {})
check_result.save_to_db(commit=False)
total, result_lines = self.ApplyChecks(self.task, check)
if total == len(check.rules):
check_result.status = "SUCCESSFUL"
check_result.parameters["result"] = result_lines
else:
check_result.status = "FAILED"
check_result.parameters["result"] = result_lines
check_result.commit()
elif status == "FAILED":
for check in check_list:
check_result = CheckResultModel(check.id, check.name, device_name, self.task.id, self.job.compliance_execution_id, status = 'NEW', parameters = {})
check_result.save_to_db(commit=False)
check_result.status = "FAILED"
check_result.commit()
return
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('device_id',
type=str,
help='Every device must have unique device id',
required=True,
trim=True)
parser.add_argument('name',
type=str,
help='Device name is missing',
trim=True,
required=True)
args = parser.parse_args()
if DeviceModel.find_by_device_id(args['device_id']):
return {"message": "Device name must be unique"}, 400
device = DeviceModel(args['name'], args['device_id'])
device.save_to_db()
return device.json(), 200
def post(self, devId):
if DeviceModel.find_by_name(devId):
return {
'message':
"A Device with devId '{}' already exists.".format(devId)
}, 400
data = Device.parser.parse_args()
device = DeviceModel(devId, data['power'], data['voltage'],
data['current'])
try:
device.save_to_db()
except:
return {
"message": "An error occurred inserting the device data."
}, 500
return device.json(), 201
def post(self, name=None):
data = json.loads(request.data)
print(data)
cipher_suite = Fernet(KEY)
if data.get('login'):
data['login'] = cipher_suite.encrypt(
data.get('login').encode('ascii')).decode('ascii')
if data.get('password'):
data['password'] = cipher_suite.encrypt(
data.get('password').encode('ascii')).decode('ascii')
name = data.get("name", name)
if DeviceModel.find_by_name(name):
return {
'error':
"A device with name : {}, already exists.".format(name)
}, 400
device = DeviceModel(**data)
#try:
device.save_to_db()
#except:
#return {"error": "An error occurred creating the device."}, 500
return device.json(), 201
def get(self):
data = Device.arguments_device.parse_args()
device = DeviceModel.find_by_mac(data['mac'])
if device:
return device.json()
return {'message': 'Device not found.'}, 404
def get(self, name):
device = DeviceModel.find_by_name(name)
if device:
return {'device': device.json()}
return {'message': 'Device not found'}, 404
def get_remote_control_device(name):
device = DeviceModel.find_by_name(name)
return render_template('remote_control.j2',
title='Home',
device=device.json())
def get(self, name):
device = DeviceModel.find_by_name(name)
if device:
return device.json()
return {'message': "Bad Request: Device Could Not Be Found"}, 400
def get(self, devId):
device = DeviceModel.find_by_name(devId)
if device:
return device.json()
return {'message': 'Device not found'}, 404
