class HardwareBoMDataController(RAMSTKDataController):
"""
Provide an interface between the Hardware data model and an RAMSTK view model.
A single Hardware controller can manage one or more Hardware data models.
The attributes of a Hardware data controller are:
"""
def __init__(self, dao, configuration, **kwargs):
"""
Initialize a Hardware data controller instance.
:param dao: the RAMSTK Program DAO instance to pass to the Hardware Data
Model.
:type dao: :class:`ramstk.dao.DAO`
:param configuration: the Configuration instance associated with the
current instance of the RAMSTK application.
:type configuration: :class:`ramstk.Configuration.Configuration`
"""
RAMSTKDataController.__init__(self,
configuration,
model=dtmHardwareBoM(dao),
ramstk_module='hardware BOM',
**kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
# Initialize private scalar attributes.
self._dmx_hw_rqrmnt_matrix = RAMSTKDataMatrix(dao, RAMSTKHardware,
RAMSTKRequirement)
self._dmx_hw_tstng_matrix = RAMSTKDataMatrix(dao, RAMSTKHardware,
RAMSTKTest)
self._dmx_hw_vldtn_matrix = RAMSTKDataMatrix(dao, RAMSTKHardware,
RAMSTKValidation)
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
def request_do_create(self, revision_id, matrix_type):
"""
Request to create or refresh a Hardware matrix.
:param int revision_id: the ID of the Revision the desired Matrix is
associated with.
:param str matrix_type: the type of the Matrix to select all rows and
"""
if matrix_type == 'hrdwr_rqrmnt':
self._dmx_hw_rqrmnt_matrix.do_create(revision_id,
matrix_type,
rkey='hardware_id',
ckey='requirement_id')
elif matrix_type == 'hrdwr_vldtn':
self._dmx_hw_vldtn_matrix.do_create(revision_id,
matrix_type,
rkey='hardware_id',
ckey='validation_id')
return
def request_do_select_all_matrix(self, revision_id, matrix_type):
"""
Retrieve all the Matrices associated with the Hardware.
:param int revision_id: the Revision ID to select the matrices for.
:param int matrix_type: the type of the Matrix to retrieve. Current
Hardware matrix types are:
hrdwr_rqrmnt = Hardware:Requirement
hrdwr_tstng = Hardware:Testing
hrdwr_vldtn = Hardware:Validation
:return: (_matrix, _column_hdrs, _row_hdrs); the Pandas Dataframe,
noun names to use for column headings, noun names to use for
row headings.
:rtype: (:class:`pandas.DataFrame`, dict, dict)
"""
_matrix = None
_column_hdrs = []
_row_hdrs = []
if matrix_type == 'hrdwr_rqrmnt':
self._dmx_hw_rqrmnt_matrix.do_select_all(
revision_id,
matrix_type,
rkey='hardware_id',
ckey='requirement_id',
rheader='comp_ref_des',
cheader='requirement_code')
_matrix = self._dmx_hw_rqrmnt_matrix.dtf_matrix
_column_hdrs = self._dmx_hw_rqrmnt_matrix.dic_column_hdrs
_row_hdrs = self._dmx_hw_rqrmnt_matrix.dic_row_hdrs
elif matrix_type == 'hrdwr_tstng':
self._dmx_hw_tstng_matrix.do_select_all(revision_id,
matrix_type,
rkey='hardware_id',
ckey='test_id',
rheader='comp_ref_des',
cheader='name')
_matrix = self._dmx_hw_tstng_matrix.dtf_matrix
_column_hdrs = self._dmx_hw_tstng_matrix.dic_column_hdrs
_row_hdrs = self._dmx_hw_tstng_matrix.dic_row_hdrs
elif matrix_type == 'hrdwr_vldtn':
self._dmx_hw_vldtn_matrix.do_select_all(revision_id,
matrix_type,
rkey='hardware_id',
ckey='validation_id',
rheader='comp_ref_des',
cheader='name')
_matrix = self._dmx_hw_vldtn_matrix.dtf_matrix
_column_hdrs = self._dmx_hw_vldtn_matrix.dic_column_hdrs
_row_hdrs = self._dmx_hw_vldtn_matrix.dic_row_hdrs
return (_matrix, _column_hdrs, _row_hdrs)
def request_do_insert(self, **kwargs):
"""
Request to add an RAMSTKHardware table record.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_revision_id = kwargs['revision_id']
_parent_id = kwargs['parent_id']
_part = kwargs['part']
_error_code, _msg = self._dtm_data_model.do_insert(
revision_id=_revision_id, parent_id=_parent_id, part=_part)
if _error_code == 0:
self._configuration.RAMSTK_USER_LOG.info(_msg)
_hardware_id = self.request_last_id()
_heading = self.request_do_select(_hardware_id,
table='general').ref_des
# We add a record for each of the Hardware:X matrices.
for _matrix in ['hrdwr_rqrmnt', 'hrdwr_vldtn']:
if not _part:
self.request_do_insert_matrix(_matrix,
_hardware_id,
heading=_heading,
row=True)
if not self._test:
pub.sendMessage(
'insertedHardware',
revision_id=_revision_id,
hardware_id=self._dtm_data_model.dtm_hardware.last_id,
parent_id=_parent_id)
else:
_msg = _msg + ' Failed to add a new Hardware item to the RAMSTK ' \
'Program database.'
self._configuration.RAMSTK_DEBUG_LOG.error(_msg)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_insert_matrix(self,
matrix_type,
item_id,
heading,
row=True):
"""
Request the to add a new row or column to the Data Matrix.
:param str matrix_type: the type of the Matrix to retrieve. Current
Hardware matrix types are:
hrdwr_tstng = Hardware:Testing
hrdwr_vldtn = Hardware:Validation
:param int item_id: the ID of the row or column item to insert into the
Matrix.
:param str heading: the heading for the new row or column.
:keyword bool row: indicates whether to insert a row (default) or a
column.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'hrdwr_rqrmnt':
_error_code, _msg = self._dmx_hw_rqrmnt_matrix.do_insert(item_id,
heading,
row=row)
if matrix_type == 'hrdwr_tstng':
_error_code, _msg = self._dmx_hw_tstng_matrix.do_insert(item_id,
heading,
row=row)
if matrix_type == 'hrdwr_vldtn':
_error_code, _msg = self._dmx_hw_vldtn_matrix.do_insert(item_id,
heading,
row=row)
if _error_code == 0 and not self._test:
pub.sendMessage('insertedMatrix',
matrix_type=matrix_type,
item_id=item_id,
row=row)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_delete(self, node_id):
"""
Request to delete an RAMSTKHardware table record.
:param str node_id: the PyPubSub Tree() ID of the Hardware item to
delete.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_error_code, _msg = self._dtm_data_model.do_delete(node_id)
if not self._test:
pub.sendMessage('deletedHardware', node_id=node_id)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_delete_matrix(self, matrix_type, item_id, row=True):
"""
Request to remove a row or column from the selected Data Matrix.
:param str matrix_type: the type of the Matrix to retrieve. Current
Hardware matrix types are:
hrdwr_tstng = Hardware:Testing
hrdwr_vldtn = Hardware:Validation
:param int item_id: the ID of the row or column item to remove from the
Matrix.
:keyword bool row: indicates whether to insert a row (default) or a
column.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'hrdwr_rqrmnt':
_error_code, _msg = self._dmx_hw_rqrmnt_matrix.do_delete(item_id,
row=row)
if matrix_type == 'hrdwr_tstng':
_error_code, _msg = self._dmx_hw_tstng_matrix.do_delete(item_id,
row=row)
if matrix_type == 'hrdwr_vldtn':
_error_code, _msg = self._dmx_hw_vldtn_matrix.do_delete(item_id,
row=row)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'deletedMatrix')
def request_do_update(self, node_id):
"""
Request to update an RAMSTKHardware table record.
:param str node_id: the PyPubSub Tree() ID of the Hardware item to
save.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_error_code, _msg = self._dtm_data_model.do_update(node_id)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'savedHardware')
def request_do_update_matrix(self, revision_id, matrix_type):
"""
Request to update the selected Data Matrix.
:param int revision_id: the ID of the Revision is the matrix to update
is associated with.
:param int matrix_type: the type of the Matrix to save. Current
Hardware matrix types are:
hrdwr_tstng = Hardware:Testing
hrdwr_vldtn = Hardware:Validation
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'hrdwr_rqrmnt':
_error_code, _msg = self._dmx_hw_rqrmnt_matrix.do_update(
revision_id, matrix_type)
elif matrix_type == 'hrdwr_tstng':
_error_code, _msg = self._dmx_hw_tstng_matrix.do_update(
revision_id, matrix_type)
elif matrix_type == 'hrdwr_vldtn':
_error_code, _msg = self._dmx_hw_vldtn_matrix.do_update(
revision_id, matrix_type)
else:
_error_code = 6
_msg = 'RAMSTK ERROR: Attempted to update non-existent matrix ' \
'{0:s}.'.format(matrix_type)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'savedMatrix')
def request_do_update_all(self, **kwargs):
"""
Request to update all records in the RAMSTKHardware table.
:return: (_error_code, _msg); the error code and associated message.
:rtype: (int, str)
"""
_error_code, _msg = self._dtm_data_model.do_update_all(**kwargs)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_get_attributes(self, node_id):
"""
Get the attributes of the record associated with Node ID and table.
:param int node_id: the ID of the Hardware item to get attributes for.
:return: attributes; the {attribute:value} dict.
:rtype: dict
"""
try:
_attributes = self._dtm_data_model.tree.get_node(node_id).data
except AttributeError:
_attributes = ATTRIBUTES
return _attributes
def request_set_attributes(self, node_id, attributes):
"""
Set the attributes of the record associated with the Node ID.
:param int node_id: the ID of the record in the RAMSTK Program database
table whose attributes are to be set.
:param dict attributes: the dictionary of attributes and values.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_return = False
# Set the overall BoM attributes.
self._dtm_data_model.tree.get_node(node_id).data = attributes
# Set the attributes for the individual tables.
_error_code, _msg = self._dtm_data_model.dtm_hardware.do_select(
node_id).set_attributes(attributes)
_return = (_return or RAMSTKDataController.do_handle_results(
self, _error_code, _msg, None))
_error_code, _msg = self._dtm_data_model.dtm_design_electric.do_select(
node_id).set_attributes(attributes)
_return = (_return or RAMSTKDataController.do_handle_results(
self, _error_code, _msg, None))
_error_code, _msg = self._dtm_data_model.dtm_design_mechanic.do_select(
node_id).set_attributes(attributes)
_return = (_return or RAMSTKDataController.do_handle_results(
self, _error_code, _msg, None))
_error_code, _msg = self._dtm_data_model.dtm_mil_hdbk_f.do_select(
node_id).set_attributes(attributes)
_return = (_return or RAMSTKDataController.do_handle_results(
self, _error_code, _msg, None))
_error_code, _msg = self._dtm_data_model.dtm_nswc.do_select(
node_id).set_attributes(attributes)
_return = (_return or RAMSTKDataController.do_handle_results(
self, _error_code, _msg, None))
_error_code, _msg = self._dtm_data_model.dtm_reliability.do_select(
node_id).set_attributes(attributes)
_return = (_return or RAMSTKDataController.do_handle_results(
self, _error_code, _msg, None))
return _return
def request_last_id(self, **kwargs): # pylint: disable=unused-argument
"""
Request the last Hardware ID used.
:return: _last_id; the last Hardware ID used.
:rtype: int
"""
return self._dtm_data_model.last_id
def request_do_make_composite_reference_designator(self, node_id=1):
"""
Request the composite reference designators be created.
:keyword int node_id: the Treelib tree() node ID to start with to make
composite reference designators. Defaults to the
top node.
:return: (_error_code, _msg); the error code and associated message.
:rtype: (int, str)
"""
_error_code = 0
_msg = ''
# Create the composite reference designators in the Hardware model.
if self._dtm_data_model.dtm_hardware.do_make_composite_ref_des(
node_id):
_error_code = 3005
_msg = 'RAMSTK ERROR: Failed to create all composite reference ' \
'designators for Node ID {0:d} and ' \
'children.'.format(node_id)
# If that was successful, update the BoM attributes.
if _error_code == 0:
for _node_id in self._dtm_data_model.tree.nodes:
if _node_id != 0:
_attributes = self.request_get_attributes(_node_id)
_comp_ref_des = self._dtm_data_model.dtm_hardware.do_select(
_node_id).comp_ref_des
_attributes['comp_ref_des'] = _comp_ref_des
return _error_code, _msg
def request_do_calculate(self, node_id, **kwargs):
"""
Request to calculate the hardware item.
:param int node_id: the Hardware ID to calculate.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_return = False
_attributes = self._dtm_data_model.do_calculate(node_id, **kwargs)
if (not self.request_set_attributes(node_id, _attributes)
and not self._test):
pub.sendMessage('calculatedHardware')
else:
_return = True
return _return
def request_do_calculate_all(self, **kwargs):
"""
Request to calculate the hardware item.
:param int node_id: the Hardware ID to calculate.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_return = False
self._dtm_data_model.do_calculate_all(**kwargs)
if not self._test:
for _node_id in self._dtm_data_model.tree.nodes:
if _node_id != 0:
_attributes = self.request_get_attributes(_node_id)
self.request_set_attributes(_node_id, _attributes)
pub.sendMessage('calculatedAllHardware')
else:
_return = True
return _return
class ValidationDataController(RAMSTKDataController):
"""
Provide an interface between Validation data models and RAMSTK views.
A single Validation data controller can manage one or more Failure
Validation data models.
"""
def __init__(self, dao, configuration, **kwargs):
"""
Initialize a Validation data controller instance.
:param dao: the data access object used to communicate with the
connected RAMSTK Program database.
:type dao: :class:`ramstk.dao.DAO.DAO`
:param configuration: the RAMSTK configuration instance.
:type configuration: :class:`ramstk.Configuration.Configuration`
"""
RAMSTKDataController.__init__(self,
configuration,
model=dtmValidation(dao),
ramstk_module='validation',
**kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
# Initialize private scalar attributes.
self._dmx_vldtn_rqrmnt_matrix = RAMSTKDataMatrix(
dao, RAMSTKValidation, RAMSTKRequirement)
self._dmx_vldtn_hw_matrix = RAMSTKDataMatrix(dao, RAMSTKValidation,
RAMSTKHardware)
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
def request_do_create(self, revision_id, matrix_type):
"""
Request to create or refresh a Validation matrix.
:param int revision_id: the ID of the Revision the desired Matrix is
associated with.
:param str matrix_type: the type of the Matrix to select all rows and
all columns for.
"""
if matrix_type == 'vldtn_rqrmnt':
self._dmx_vldtn_rqrmnt_matrix.do_create(revision_id,
matrix_type,
rkey='validation_id',
ckey='requirement_id')
elif matrix_type == 'vldtn_hrdwr':
self._dmx_vldtn_hw_matrix.do_create(revision_id,
matrix_type,
rkey='validation_id',
ckey='hardware_id')
return
def request_do_select_all_matrix(self, revision_id, matrix_type):
"""
Retrieve all the Matrices associated with the Requirement module.
:param int revision_id: the Revision ID to select the matrices for.
:param int matrix_type: the type of the Matrix to retrieve. Current
Validation matrix types are:
vldtn_hrdwr = Requirement:Hardware
:return: (_matrix, _column_hdrs, _row_hdrs); the Pandas Dataframe,
noun names to use for column headings, noun names to use for
row headings.
:rtype: (:class:`pandas.DataFrame`, dict, dict)
"""
_matrix = None
_column_hdrs = []
_row_hdrs = []
if matrix_type == 'vldtn_rqrmnt':
self._dmx_vldtn_rqrmnt_matrix.do_select_all(
revision_id,
matrix_type,
rkey='validation_id',
ckey='requirement_id',
rheader='description',
cheader='requirement_code')
_matrix = self._dmx_vldtn_rqrmnt_matrix.dtf_matrix
_column_hdrs = self._dmx_vldtn_rqrmnt_matrix.dic_column_hdrs
_row_hdrs = self._dmx_vldtn_rqrmnt_matrix.dic_row_hdrs
elif matrix_type == 'vldtn_hrdwr':
self._dmx_vldtn_hw_matrix.do_select_all(revision_id,
matrix_type,
rkey='validation_id',
ckey='hardware_id',
rheader='description',
cheader='comp_ref_des')
_matrix = self._dmx_vldtn_hw_matrix.dtf_matrix
_column_hdrs = self._dmx_vldtn_hw_matrix.dic_column_hdrs
_row_hdrs = self._dmx_vldtn_hw_matrix.dic_row_hdrs
return (_matrix, _column_hdrs, _row_hdrs)
def request_do_insert(self, **kwargs):
"""
Request to add an RAMSTKValidation table record.
:param int revision_id: the Revision ID this Validation will be
associated with.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_revision_id = kwargs['revision_id']
_error_code, _msg = self._dtm_data_model.do_insert(
revision_id=_revision_id)
if _error_code == 0:
self._configuration.RAMSTK_USER_LOG.info(_msg)
if not self._test:
pub.sendMessage('insertedValidation')
else:
_msg = _msg + ' Failed to add a new Validation to the ' \
'RAMSTK Program database.'
self._configuration.RAMSTK_DEBUG_LOG.error(_msg)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_insert_matrix(self,
matrix_type,
item_id,
heading,
row=True):
"""
Request the to add a new row or column to the Data Matrix.
:param str matrix_type: the type of the Matrix to retrieve. Current
Validation matrix types are:
vldtn_hrdwr = Validation:Hardware
:param int item_id: the ID of the row or column item to insert into the
Matrix.
:param str heading: the heading for the new row or column.
:keyword bool row: indicates whether to insert a row (default) or a
column.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'vldtn_rqrmnt':
_error_code, _msg = self._dmx_vldtn_rqrmnt_matrix.do_insert(
item_id, heading, row=row)
elif matrix_type == 'vldtn_hrdwr':
_error_code, _msg = self._dmx_vldtn_hw_matrix.do_insert(item_id,
heading,
row=row)
if _error_code == 0 and not self._test:
pub.sendMessage('insertedMatrix',
matrix_type=matrix_type,
item_id=item_id,
row=row)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_delete(self, node_id):
"""
Request to delete an RAMSTKValidation table record.
:param int node_id: the PyPubSub Tree() ID of the Validation task to
delete.
:return: (_error_code, _msg); the error code and associated error
message.
:rtype: (int, str)
"""
_error_code, _msg = self._dtm_data_model.do_delete(node_id)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'deletedValidation')
def request_do_delete_matrix(self, matrix_type, item_id, row=True):
"""
Request to remove a row or column from the selected Data Matrix.
:param int matrix_type: the type of the Matrix to retrieve. Current
Validation matrix types are:
rqrmnt_hrdwr = Validation:Hardware
:param int item_id: the ID of the row or column item to remove from the
Matrix.
:keyword bool row: indicates whether to insert a row (default) or a
column.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'vldtn_rqrmnt':
_error_code, _msg = self._dmx_vldtn_rqrmnt_matrix.do_delete(
item_id, row=row)
elif matrix_type == 'vldtn_hrdwr':
_error_code, _msg = self._dmx_vldtn_hw_matrix.do_delete(item_id,
row=row)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'deletedMatrix')
def request_do_update(self, node_id):
"""
Request to update an RAMSTKValidation table record.
:param int node_id: the PyPubSub Tree() ID of the Validation task to
delete.
:return: (_error_code, _msg); the error code and associated error
message.
:rtype: (int, str)
"""
_error_code, _msg = self._dtm_data_model.do_update(node_id)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'savedValidation')
def request_do_update_matrix(self, revision_id, matrix_type):
"""
Request to update the selected Data Matrix.
:param int revision_id: the ID of the Revision is the matrix to update
is associated with.
:param int matrix_type: the type of the Matrix to save. Current
Validation matrix types are:
vldtn_hrdwr = Requirement:Hardware
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'vldtn_rqrmnt':
_error_code, _msg = self._dmx_vldtn_rqrmnt_matrix.do_update(
revision_id, matrix_type)
elif matrix_type == 'vldtn_hrdwr':
_error_code, _msg = self._dmx_vldtn_hw_matrix.do_update(
revision_id, matrix_type)
else:
_error_code = 6
_msg = 'RAMSTK ERROR: Attempted to update non-existent matrix ' \
'{0:s}.'.format(matrix_type)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'savedMatrix')
def request_do_update_all(self, **kwargs):
"""
Request to update all records in the RAMSTKValidation table.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_error_code, _msg = self._dtm_data_model.do_update_all(**kwargs)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_update_status(self):
"""
Request to update program Validation task status.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_error_code, _msg = self._dtm_data_model.do_update_status()
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_calculate(self, node_id, **kwargs): # pylint: disable=unused-argument
"""
Request to calculate the Validation task metrics.
This method calls the data model methods to calculate task cost and
task time.
:param int node_id: the PyPubSub Tree() ID of the Validation task
to calculate.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_return = False
_msg = 'RAMSTK SUCCESS: Calculating Validation Task {0:d} cost and ' \
'time metrics.'.format(node_id)
_costs = self._dtm_data_model.do_calculate(node_id, metric='cost')
_time = self._dtm_data_model.do_calculate(node_id, metric='time')
if not _costs and not _time:
self._configuration.RAMSTK_USER_LOG.info(_msg)
if not self._test:
pub.sendMessage('calculatedValidation', module_id=node_id)
elif _costs:
_msg = 'RAMSTK ERROR: Calculating Validation Task {0:d} cost ' \
'metrics.'.format(node_id)
self._configuration.RAMSTK_DEBUG_LOG.error(_msg)
_return = True
elif _time:
_msg = 'RAMSTK ERROR: Calculating Validation Task {0:d} time ' \
'metrics.'.format(node_id)
self._configuration.RAMSTK_DEBUG_LOG.error(_msg)
_return = True
return _return
def request_do_calculate_all(self):
"""
Request to calculate program cost and time.
:return: (_cost_ll, _cost_mean, _cost_ul,
_time_ll, _time_mean, _time_ul); the lower bound, mean,
and upper bound for program cost and time.
:rtype: tuple
"""
(_cost_ll, _cost_mean, _cost_ul, _time_ll, _time_mean,
_time_ul) = self._dtm_data_model.do_calculate_all()
if not self._test:
pub.sendMessage('calculatedProgram')
return (_cost_ll, _cost_mean, _cost_ul, _time_ll, _time_mean, _time_ul)
def request_get_planned_burndown(self):
"""
Request the planned burndown curve.
:return: (_y_minimum, _y_average, _y_maximum)
:rtype: tuple
"""
return self._dtm_data_model.get_planned_burndown()
def request_get_assessment_points(self):
"""
Request the assessment dates, minimum, and maximum values.
:return: (_assessed_dates, _targets)
:rtype: tuple
"""
return self._dtm_data_model.get_assessment_points()
def request_get_actual_burndown(self):
"""
Request the actual burndown curve.
:return: dictionary of actual remaining times for each date the value
has been calculated. Key is the date, value is the remaining
time.
:rtype: dict
"""
return self._dtm_data_model.get_actual_burndown()
class RequirementDataController(RAMSTKDataController):
"""
Provide an interface between the Requirement data model and an RAMSTK View.
A single Requirement controller can manage one or more Requirement data
models. The attributes of a Requirement data controller are:
"""
def __init__(self, dao, configuration, **kwargs):
"""
Initialize a Requirement data controller instance.
:param dao: the RAMSTK Program DAO instance to pass to the Requirement
Data Model.
:type dao: :class:`ramstk.dao.DAO`
:param configuration: the Configuration instance associated with the
current instance of the RAMSTK application.
:type configuration: :class:`ramstk.Configuration.Configuration`
"""
RAMSTKDataController.__init__(self,
configuration,
model=dtmRequirement(dao),
ramstk_module='requirement',
**kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
# Initialize private scalar attributes.
self._dmx_rqmt_hw_matrix = RAMSTKDataMatrix(dao, RAMSTKRequirement,
RAMSTKHardware)
self._dmx_rqmt_sw_matrix = RAMSTKDataMatrix(dao, RAMSTKRequirement,
RAMSTKSoftware)
self._dmx_rqmt_val_matrix = RAMSTKDataMatrix(dao, RAMSTKRequirement,
RAMSTKValidation)
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
def request_do_create(self, revision_id, matrix_type):
"""
Request to create or refresh a Requirement matrix.
:param int revision_id: the ID of the Revision the desired Matrix is
associated with.
:param str matrix_type: the type of the Matrix to select all rows and
"""
if matrix_type == 'rqrmnt_hrdwr':
self._dmx_rqmt_hw_matrix.do_create(revision_id,
matrix_type,
rkey='requirement_id',
ckey='hardware_id')
elif matrix_type == 'rqrmnt_vldtn':
self._dmx_rqmt_val_matrix.do_create(revision_id,
matrix_type,
rkey='requirement_id',
ckey='validation_id')
return
def request_do_select_all_matrix(self, revision_id, matrix_type):
"""
Retrieve all the Matrices associated with the Requirement module.
:param int revision_id: the Revision ID to select the matrices for.
:param int matrix_type: the type of the Matrix to retrieve. Current
Requirement matrix types are:
rqrmnt_hrdwr = Requirement:Hardware
rqrmnt_sftwr = Requirement:Software
rqrmnt_vldtn = Requirement:Validation
:return: (_matrix, _column_hdrs, _row_hdrs); the Pandas Dataframe,
noun names to use for column headings, noun names to use for
row headings.
:rtype: (:class:`pandas.DataFrame`, dict, dict)
"""
_matrix = None
_column_hdrs = []
_row_hdrs = []
if matrix_type == 'rqrmnt_hrdwr':
self._dmx_rqmt_hw_matrix.do_select_all(revision_id,
matrix_type,
rkey='requirement_id',
ckey='hardware_id',
rheader='requirement_code',
cheader='comp_ref_des')
_matrix = self._dmx_rqmt_hw_matrix.dtf_matrix
_column_hdrs = self._dmx_rqmt_hw_matrix.dic_column_hdrs
_row_hdrs = self._dmx_rqmt_hw_matrix.dic_row_hdrs
elif matrix_type == 'rqrmnt_sftwr':
self._dmx_rqmt_sw_matrix.do_select_all(revision_id,
matrix_type,
rkey='requirement_id',
ckey='software_id',
rheader='requirement_code',
cheader='description')
_matrix = self._dmx_rqmt_sw_matrix.dtf_matrix
_column_hdrs = self._dmx_rqmt_sw_matrix.dic_column_hdrs
_row_hdrs = self._dmx_rqmt_sw_matrix.dic_row_hdrs
elif matrix_type == 'rqrmnt_vldtn':
self._dmx_rqmt_val_matrix.do_select_all(revision_id,
matrix_type,
rkey='requirement_id',
ckey='validation_id',
rheader='requirement_code',
cheader='name')
_matrix = self._dmx_rqmt_val_matrix.dtf_matrix
_column_hdrs = self._dmx_rqmt_val_matrix.dic_column_hdrs
_row_hdrs = self._dmx_rqmt_val_matrix.dic_row_hdrs
return (_matrix, _column_hdrs, _row_hdrs)
def request_do_insert(self, **kwargs):
"""
Request to add an RAMSTKRequirement table record.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_revision_id = kwargs['revision_id']
_parent_id = kwargs['parent_id']
_error_code, _msg = self._dtm_data_model.do_insert(
revision_id=_revision_id, parent_id=_parent_id)
if _error_code == 0:
self._configuration.RAMSTK_USER_LOG.info(_msg)
if not self._test:
pub.sendMessage('insertedRequirement',
requirement_id=self._dtm_data_model.last_id,
parent_id=_parent_id)
else:
_msg = _msg + ' Failed to add a new Requirement to the RAMSTK ' \
'Program database.'
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_insert_matrix(self,
matrix_type,
item_id,
heading,
row=True):
"""
Request the to add a new row or column to the Data Matrix.
:param str matrix_type: the type of the Matrix to retrieve. Current
Requirement matrix types are:
rqrmnt_hrdwr = Requirement:Hardware
rqrmnt_sftwr = Requirement:Software
rqrmnt_vldtn = Requirement:Validation
:param int item_id: the ID of the row or column item to insert into the
Matrix.
:param str heading: the heading for the new row or column.
:keyword bool row: indicates whether to insert a row (default) or a
column.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'rqrmnt_hrdwr':
_error_code, _msg = self._dmx_rqmt_hw_matrix.do_insert(item_id,
heading,
row=row)
elif matrix_type == 'rqrmnt_sftwr':
_error_code, _msg = self._dmx_rqmt_sw_matrix.do_insert(item_id,
heading,
row=row)
elif matrix_type == 'rqrmnt_vldtn':
_error_code, _msg = self._dmx_rqmt_val_matrix.do_insert(item_id,
heading,
row=row)
if _error_code == 0 and not self._test:
pub.sendMessage('insertedMatrix',
matrix_type=matrix_type,
item_id=item_id,
row=row)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_delete(self, node_id):
"""
Request to delete an RAMSTKRequirement table record.
:param str node_id: the PyPubSub Tree() ID of the Requirement to
delete.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_error_code, _msg = self._dtm_data_model.do_delete(node_id)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'deletedRequirement')
def request_do_delete_matrix(self, matrix_type, item_id, row=True):
"""
Request to remove a row or column from the selected Data Matrix.
:param int matrix_type: the type of the Matrix to retrieve. Current
Requirement matrix types are:
rqrmnt_hrdwr = Requirement:Hardware
rqrmnt_sftwr = Requirement:Software
rqrmnt_vldtn = Requirement:Validation
:param int item_id: the ID of the row or column item to remove from the
Matrix.
:keyword bool row: indicates whether to insert a row (default) or a
column.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'rqrmnt_hrdwr':
_error_code, _msg = self._dmx_rqmt_hw_matrix.do_delete(item_id,
row=row)
elif matrix_type == 'rqrmnt_sftwr':
_error_code, _msg = self._dmx_rqmt_sw_matrix.do_delete(item_id,
row=row)
elif matrix_type == 'rqrmnt_vldtn':
_error_code, _msg = self._dmx_rqmt_val_matrix.do_delete(item_id,
row=row)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'deletedMatrix')
def request_do_update(self, node_id):
"""
Request to update an RAMSTKRequirement table record.
:param str node_id: the PyPubSub Tree() ID of the Requirement to save.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_error_code, _msg = self._dtm_data_model.do_update(node_id)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'savedRequirement')
def request_do_update_matrix(self, revision_id, matrix_type):
"""
Request to update the selected Data Matrix.
:param int revision_id: the ID of the Revision is the matrix to update
is associated with.
:param int matrix_type: the type of the Matrix to save. Current
Requirement matrix types are:
rqrmnt_hrdwr = Requirement:Hardware
rqrmnt_sftwr = Requirement:Software
rqrmnt_vldtn = Requirement:Validation
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'rqrmnt_hrdwr':
_error_code, _msg = self._dmx_rqmt_hw_matrix.do_update(
revision_id, matrix_type)
elif matrix_type == 'rqrmnt_sftwr':
_error_code, _msg = self._dmx_rqmt_sw_matrix.do_update(
revision_id, matrix_type)
elif matrix_type == 'rqrmnt_vldtn':
_error_code, _msg = self._dmx_rqmt_val_matrix.do_update(
revision_id, matrix_type)
else:
_error_code = 6
_msg = 'RAMSTK ERROR: Attempted to update non-existent matrix ' \
'{0:s}.'.format(matrix_type)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'savedMatrix')
def request_do_update_all(self, **kwargs): # pylint: disable=unused-argument
"""
Request to update all records in the RAMSTKRequirement table.
:return: (_error_code, _msg); the error code and associated message.
:rtype: (int, str)
"""
_error_code, _msg = self._dtm_data_model.do_update_all()
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
class FunctionDataController(RAMSTKDataController):
"""
Provide interface between Function data model and RAMSTK view model.
A single Function controller can manage one or more Function data
models. The attributes of a Function data controller are:
"""
def __init__(self, dao, configuration, **kwargs):
"""
Initialize a Function data controller instance.
:param dao: the RAMSTK Program DAO instance to pass to the
Function Data Model.
:type dao: :class:`ramstk.dao.DAO`
:param configuration: the Configuration instance associated with
the current instance of the RAMSTK
application.
:type configuration: :class:`ramstk.Configuration.Configuration`
"""
RAMSTKDataController.__init__(self,
configuration,
model=dtmFunction(dao, **kwargs),
ramstk_module='function',
**kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
# Initialize private scalar attributes.
self._dmx_fctn_hw_matrix = RAMSTKDataMatrix(dao, RAMSTKFunction,
RAMSTKHardware)
self._dmx_fctn_sw_matrix = RAMSTKDataMatrix(dao, RAMSTKFunction,
RAMSTKSoftware)
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
# Subscribe to PyPubSub messages.
pub.subscribe(self.request_do_select_all, 'selected_revision')
pub.subscribe(self.request_do_delete, 'request_delete_function')
pub.subscribe(self.request_do_insert, 'request_insert_function')
pub.subscribe(self.request_do_update, 'request_update_function')
pub.subscribe(self.request_do_update_all,
'request_update_all_functions')
pub.subscribe(self.request_set_attributes, 'editing_function')
def request_do_create(self, revision_id, matrix_type):
"""
Request to create or refresh a Function matrix.
:param int revision_id: the ID of the Revision the desired Matrix is
associated with.
:param str matrix_type: the type of the Matrix to select all rows and
"""
if matrix_type == 'fnctn_hrdwr':
self._dmx_fctn_hw_matrix.do_create(revision_id,
matrix_type,
rkey='function_id',
ckey='hardware_id')
return
def request_do_select_all(self, revision_id):
"""
Retrieve the treelib Tree() from the Function Data Model.
:return: tree; the treelib Tree() of RAMSTKFunction models in the
Function tree.
:rtype: :class:`treelib.Tree`
"""
return self._dtm_data_model.do_select_all(revision_id=revision_id)
def request_do_select_all_matrix(self, revision_id, matrix_type):
"""
Retrieve all the Matrices associated with the Function.
:param int revision_id: the Revision ID to select the matrices for.
:param int matrix_type: the type of the Matrix to retrieve. Current
Function matrix types are:
fnctn_hrdwr = Function:Hardware
fnctn_sftwr = Function:Software
fnctn_vldtn = Function:Validation
:return: (_matrix, _column_hdrs, _row_hdrs); the Pandas Dataframe,
noun names to use for column headings, noun names to use for
row headings.
:rtype: (:class:`pandas.DataFrame`, dict, dict)
"""
_matrix = None
_column_hdrs = []
_row_hdrs = []
if matrix_type == 'fnctn_hrdwr':
self._dmx_fctn_hw_matrix.do_select_all(revision_id,
matrix_type,
rkey='function_id',
ckey='hardware_id',
rheader='function_code',
cheader='comp_ref_des')
_matrix = self._dmx_fctn_hw_matrix.dtf_matrix
_column_hdrs = self._dmx_fctn_hw_matrix.dic_column_hdrs
_row_hdrs = self._dmx_fctn_hw_matrix.dic_row_hdrs
return (_matrix, _column_hdrs, _row_hdrs)
def request_do_insert(self, revision_id, parent_id, **kwargs): # pylint: disable=unused-argument
"""
Request to add an RAMSTKFunction table record.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_error_code, _msg = self._dtm_data_model.do_insert(
revision_id=revision_id, parent_id=parent_id)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_insert_matrix(self,
matrix_type,
item_id,
heading,
row=True):
"""
Request the to add a new row or column to the Data Matrix.
:param str matrix_type: the type of the Matrix to retrieve. Current
Function matrix types are:
fnctn_hrdwr = Function:Hardware
fnctn_sftwr = Function:Software
fnctn_vldtn = Function:Validation
:param int item_id: the ID of the row or column item to insert into the
Matrix.
:param str heading: the heading for the new row or column.
:keyword bool row: indicates whether to insert a row (default) or a
column.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'fnctn_hrdwr':
_error_code, _msg = self._dmx_fctn_hw_matrix.do_insert(item_id,
heading,
row=row)
if _error_code == 0 and not self._test:
pub.sendMessage('insertedMatrix',
matrix_type=matrix_type,
item_id=item_id,
row=row)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_delete(self, node_id):
"""
Request to delete an RAMSTKFunction table record.
:param int node_id: the PyPubSub Tree() ID of the Function to delete.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_error_code, _msg = self._dtm_data_model.do_delete(node_id)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_delete_matrix(self, matrix_type, item_id, row=True):
"""
Request to remove a row or column from the selected Data Matrix.
:param str matrix_type: the type of the Matrix to retrieve. Current
Function matrix types are:
fnctn_hrdwr = Function:Hardware
fnctn_sftwr = Function:Software
fnctn_vldtn = Function:Validation
:param int item_id: the ID of the row or column item to remove from the
Matrix.
:keyword bool row: indicates whether to insert a row (default) or a
column.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'fnctn_hrdwr':
_error_code, _msg = self._dmx_fctn_hw_matrix.do_delete(item_id,
row=row)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'deletedMatrix')
def request_do_update(self, node_id):
"""
Request to update an RAMSTKFunction table record.
:param int node_id: the PyPubSub Tree() ID of the Function to save.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
_error_code, _msg = self._dtm_data_model.do_update(node_id)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_do_update_matrix(self, revision_id, matrix_type):
"""
Request to update the selected Data Matrix.
:param int revision_id: the ID of the Revision is the matrix to update
is associated with.
:param int matrix_type: the type of the Matrix to save.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
if matrix_type == 'fnctn_hrdwr':
_error_code, _msg = self._dmx_fctn_hw_matrix.do_update(
revision_id, matrix_type)
else:
_error_code = 6
_msg = 'RAMSTK ERROR: Attempted to update non-existent matrix ' \
'{0:s}.'.format(matrix_type)
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
'savedMatrix')
def request_do_update_all(self, **kwargs): # pylint: disable=unused-argument
"""
Request to update all records in the RAMSTKFunction table.
:return: (_error_code, _msg); the error code and associated message.
:rtype: (int, str)
"""
_error_code, _msg = self._dtm_data_model.do_update_all()
return RAMSTKDataController.do_handle_results(self, _error_code, _msg,
None)
def request_set_attributes(self, module_id, key, value):
"""
Request to set a Function attribute.
:param int module_id: the ID of the entity who's attribute is to
be set.
:param str key: the key of the attributes to set.
:param value: the value to set the attribute identified by the
key.
:return:
:rtype:
"""
_entity = self.request_do_select(module_id)
_attributes = _entity.get_attributes()
_attributes[key] = value
return _entity.set_attributes(_attributes)