def __init__(self, code):
"""Function for intializing the class.
Args:
code: Department code
Returns:
None
"""
# Initialize important variables
value = code.encode()
self.data_dict = defaultdict(dict)
keys = ['idx_department', 'code', 'name', 'enabled']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Department).filter(Department.code == value)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx_department'] = instance.idx_department
self.data_dict['code'] = general.decode(instance.code)
self.data_dict['name'] = general.decode(instance.name)
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
def __init__(self, idx_datapoint):
"""Function for intializing the class.
Args:
idx_datapoint: Datapoint Index
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = [
'idx_datapoint', 'id_datapoint', 'idx_deviceagent',
'idx_department',
'idx_billcode', 'agent_label', 'agent_source', 'enabled',
'billable', 'base_type', 'timefixed_value', 'last_timestamp']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Only work if the value is an integer
if (isinstance(idx_datapoint, int) is True) and (
idx_datapoint is not None):
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(
Datapoint).filter(Datapoint.idx_datapoint == idx_datapoint)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx_datapoint'] = instance.idx_datapoint
self.data_dict[
'id_datapoint'] = general.decode(
instance.id_datapoint)
self.data_dict[
'idx_deviceagent'] = instance.idx_deviceagent
self.data_dict['idx_department'] = instance.idx_department
self.data_dict['idx_billcode'] = instance.idx_billcode
self.data_dict[
'agent_label'] = general.decode(
instance.agent_label)
self.data_dict[
'agent_source'] = general.decode(
instance.agent_source)
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['billable'] = bool(instance.billable)
self.data_dict['base_type'] = instance.base_type
self.data_dict[
'timefixed_value'] = instance.timefixed_value
self.data_dict['last_timestamp'] = instance.last_timestamp
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
def listing(idx_deviceagent, base_type=None):
"""List of datapoint data for a specific idx_device, idx_agent combination.
Args:
idx_deviceagent: DeviceAgent index
base_type: base_type to filter by
Returns:
dict_list: List of dicts containing data
"""
# Initialize key variables
dict_list = []
# Process information
deviceagent = db_deviceagent.GetIDXDeviceAgent(idx_deviceagent)
if deviceagent.exists() is True:
# Establish a database session
database = db.Database()
session = database.session()
if base_type is None:
result = session.query(Datapoint).filter(
Datapoint.idx_deviceagent == idx_deviceagent)
else:
result = session.query(Datapoint).filter(
and_(
Datapoint.base_type == base_type,
Datapoint.idx_deviceagent == idx_deviceagent)
)
# Add to the list of device idx_datapoint values
for instance in result:
data_dict = {}
data_dict['idx_datapoint'] = instance.idx_datapoint
data_dict['id_datapoint'] = general.decode(instance.id_datapoint)
data_dict['idx_deviceagent'] = instance.idx_deviceagent
data_dict['idx_department'] = instance.idx_department
data_dict['idx_billcode'] = instance.idx_billcode
data_dict[
'agent_label'] = general.decode(instance.agent_label)
data_dict[
'agent_source'] = general.decode(instance.agent_source)
data_dict['enabled'] = bool(instance.enabled)
data_dict['billable'] = bool(instance.billable)
data_dict['base_type'] = instance.base_type
data_dict[
'timefixed_value'] = general.decode(instance.timefixed_value)
data_dict['last_timestamp'] = instance.last_timestamp
data_dict['exists'] = True
dict_list.append(data_dict)
# Return the connection to the pool
database.close()
# Return
return dict_list
def _dp_device_agent(idx_device, idx_agent, charted_data=True):
"""List of datapoint data for a specific device_idx, idx_agent combination.
Args:
idx_device: Device index
idx_agent: Agent index
charted_data: Return data for charted points if True.
Uncharted if False.
Returns:
dict_list: List of dicts containing data
"""
# Initialize key variables
dict_list = []
# Establish a database session
database = db.Database()
session = database.session()
if charted_data is True:
result = session.query(Datapoint).filter(
and_(Datapoint.timefixed_value == None,
Datapoint.idx_device == idx_device,
Datapoint.idx_agent == idx_agent))
else:
result = session.query(Datapoint).filter(
and_(Datapoint.timefixed_value != None,
Datapoint.idx_device == idx_device,
Datapoint.idx_agent == idx_agent))
# Add to the list of device idx_datapoint values
for instance in result:
data_dict = {}
data_dict['idx_datapoint'] = instance.idx_datapoint
data_dict['id_datapoint'] = general.decode(instance.id_datapoint)
data_dict['idx_agent'] = instance.idx_agent
data_dict['idx_device'] = instance.idx_device
data_dict['idx_department'] = instance.idx_department
data_dict['idx_billcode'] = instance.idx_billcode
data_dict['agent_label'] = general.decode(instance.agent_label)
data_dict['agent_source'] = general.decode(instance.agent_source)
data_dict['enabled'] = bool(instance.enabled)
data_dict['billable'] = bool(instance.billable)
data_dict['base_type'] = instance.base_type
data_dict['timefixed_value'] = general.decode(instance.timefixed_value)
data_dict['last_timestamp'] = instance.last_timestamp
data_dict['exists'] = True
dict_list.append(data_dict)
# Return the connection to the pool
database.close()
# Return
return dict_list
def __init__(self, idx_agent):
"""Function for intializing the class.
Args:
idx_agent: Agent idx_agent
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = ['idx_agent', 'idx_agentname', 'id_agent', 'enabled', 'agent']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Fix values passed
if isinstance(idx_agent, int) is False:
idx_agent = None
# Only work if the value is an integer
if isinstance(idx_agent, int) is True and idx_agent is not None:
# Get the result
database = db.Database()
session = database.session()
result = session.query(Agent).filter(Agent.idx_agent == idx_agent)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx_agent'] = idx_agent
self.data_dict['idx_agentname'] = instance.idx_agentname
self.data_dict['id_agent'] = general.decode(
instance.id_agent)
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
# Add the agent name to dict
if bool(self.data_dict['exists']) is True:
database = db.Database()
session = database.session()
result = session.query(AgentName.name).filter(
and_(
Agent.idx_agent == self.data_dict['idx_agent'],
Agent.idx_agentname == AgentName.idx_agentname)).one()
self.data_dict['agent'] = general.decode(result.name)
database.close()
def get_all_names():
"""Get data on all names in the database.
Args:
None
Returns:
data: List of dicts of agent data.
"""
# Initialize important variables
data = []
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(AgentName)
# Massage data
for instance in result:
# Get next record
data_dict = defaultdict(dict)
data_dict['name'] = general.decode(instance.name)
data_dict['idx_agentname'] = instance.idx_agentname
data_dict['enabled'] = bool(instance.enabled)
data_dict['exists'] = True
# Append to list
data.append(data_dict)
# Return the session to the database pool after processing
database.close()
# Return
return data
def __init__(self, idx_device):
"""Function for intializing the class.
Args:
idx_device: Device Index
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = [
'idx_device', 'devicename', 'description', 'enabled',
'ip_address']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Only work if the value is an integer
if isinstance(idx_device, int) is True and idx_device is not None:
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Device).filter(Device.idx_device == idx_device)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx_device'] = instance.idx_device
self.data_dict['devicename'] = general.decode(
instance.devicename)
self.data_dict['description'] = general.decode(
instance.description)
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['ip_address'] = general.decode(
instance.ip_address)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
def __init__(self, idx_billcode):
"""Function for intializing the class.
Args:
idx_billcode: Billcode Index
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = ['idx_billcode', 'code', 'name', 'enabled']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Fix values passed
if isinstance(idx_billcode, int) is False:
idx_billcode = None
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Billcode).filter(
Billcode.idx_billcode == idx_billcode)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx_billcode'] = instance.idx_billcode
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['code'] = general.decode(instance.code)
self.data_dict['name'] = general.decode(instance.name)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
def __init__(self, idx_configuration):
"""Function for intializing the class.
Args:
idx_configuration: Configuration Index
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = ['idx_configuration', 'config_key', 'config_value']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(
Configuration).filter(
Configuration.idx_configuration == idx_configuration)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict[
'idx_configuration'] = instance.idx_configuration
self.data_dict[
'config_key'] = general.decode(instance.config_key)
self.data_dict[
'config_value'] = general.decode(instance.config_value)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
def __init__(self, id_agent):
"""Function for intializing the class.
Args:
id_agent: Identifier of agent
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = ['idx_agent', 'idx_agentname', 'id_agent', 'enabled', 'agent']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Encode the id_agent
if isinstance(id_agent, str) is True:
value = id_agent.encode()
else:
value = None
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Agent).filter(Agent.id_agent == value)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['id_agent'] = id_agent
self.data_dict['idx_agent'] = instance.idx_agent
self.data_dict['idx_agentname'] = instance.idx_agentname
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
# Add the agent name to dict
if bool(self.data_dict['exists']) is True:
database = db.Database()
session = database.session()
result = session.query(AgentName.name).filter(
and_(Agent.idx_agent == self.data_dict['idx_agent'],
Agent.idx_agentname == AgentName.idx_agentname)).one()
self.data_dict['agent'] = general.decode(result.name)
database.close()
def __init__(self, devicename):
"""Function for intializing the class.
Args:
devicename: Devicename
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = [
'idx_device', 'devicename', 'description', 'enabled']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Encode the id_agent
if isinstance(devicename, str) is True:
value = devicename.encode()
else:
value = None
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Device).filter(Device.devicename == value)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx_device'] = instance.idx_device
self.data_dict[
'devicename'] = devicename
self.data_dict[
'description'] = general.decode(instance.description)
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
def test_decode(self):
"""Test function test_decode."""
# Initialize key variables
expected = 'carrot'
result = general.decode(b"carrot")
self.assertEqual(result, expected)
def _datapoint_summary(aslist=False):
"""Get summary datapoint information.
Args:
None
Returns:
return_value: Dict keyed by idx_datapoint OR list of dicts
"""
# Initialize key variables
data = defaultdict(lambda: defaultdict(dict))
data_list = []
return_value = None
# Establish a database session
database = db.Database()
session = database.session()
# Get result of query
rows = session.query(
Datapoint.idx_datapoint,
Datapoint.agent_label,
Datapoint.agent_source,
DeviceAgent.idx_deviceagent,
AgentName.name,
Agent.id_agent,
Device.devicename).filter(
and_(
Datapoint.idx_deviceagent == DeviceAgent.idx_deviceagent,
Agent.idx_agent == DeviceAgent.idx_agent,
Agent.idx_agentname == AgentName.idx_agentname,
Device.idx_device == DeviceAgent.idx_device)
)
# Process query results
for row in rows:
idx_datapoint = row.idx_datapoint
data_dict = {}
data_dict['name'] = general.decode(row.name)
data_dict['agent_label'] = general.decode(row.agent_label)
data_dict['agent_source'] = general.decode(row.agent_source)
data_dict['id_agent'] = general.decode(row.id_agent)
data_dict['devicename'] = general.decode(row.devicename)
data_dict['idx_deviceagent'] = row.idx_deviceagent
# Assign values to data structures dependent on 'aslist' value
if aslist is True:
data_dict['idx_datapoint'] = idx_datapoint
data_list.append(data_dict)
else:
data[idx_datapoint] = data_dict
# Return the session to the database pool after processing
database.close()
# Assign values to data structures dependent on 'aslist' value
if aslist is True:
return_value = copy.deepcopy(data_list)
else:
return_value = copy.deepcopy(data)
# Return
return return_value
