def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that parameter URL is a non-empty, non-None string. # - existence of the url will also be checked in run_command(). pv_URL = self.get_parameter_value( parameter_name='URL', command_parameters=command_parameters) if not validators.validate_string(pv_URL, False, False): message = "URL parameter has no value." recommendation = "Specify the URL parameter to indicate the URL of the file to download." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter OutputFile is a non-empty string (can be None). # - existence of the folder will also be checked in run_command(). pv_OutputFile = self.get_parameter_value( parameter_name='OutputFile', command_parameters=command_parameters) if not validators.validate_string(pv_OutputFile, True, False): message = "OutputFile parameter has no value." recommendation = "Specify the OutputFile parameter to indicate the output file." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) else: # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" logger = logging.getLogger(__name__) # Unlike most commands, set internal data here because it is needed by initial call to next() # before calls to run_command # Name is required pv_Name = self.get_parameter_value( parameter_name='Name', command_parameters=command_parameters) if not validators.validate_string(pv_Name, False, False): message = "A name for the If block must be specified" recommendation = "Specify the Name." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Condition is required pv_Condition = self.get_parameter_value( parameter_name='Condition', command_parameters=command_parameters) if not validators.validate_string(pv_Condition, False, False): message = "A condition for the If command must be specified" recommendation = "Specify the condition." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty # triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception if len(warning) > 0: logger.warn(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that parameter GeoLayerIDs is a non-empty, non-None string. pv_GeoLayerIDs = self.get_parameter_value( parameter_name='GeoLayerIDs', command_parameters=command_parameters) if not validators.validate_string(pv_GeoLayerIDs, False, False): message = "GeoLayerIDs parameter has no value." recommendation = "Specify the GeoLayerIDs parameter to indicate the GeoLayers to merge." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter OutputGeoLayerID is a non-empty, non-None string. pv_OutputGeoLayerID = self.get_parameter_value( parameter_name='OutputGeoLayerID', command_parameters=command_parameters) if not validators.validate_string(pv_OutputGeoLayerID, False, False): message = "OutputGeoLayerID parameter has no value." recommendation = "Specify the OutputGeoLayerID parameter to indicate the ID of the merged GeoLayer." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: Nothing. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning_message = "" logger = logging.getLogger(__name__) # SearchFolder is required pv_SearchFolder = self.get_parameter_value(parameter_name='SearchFolder', command_parameters=command_parameters) if not validators.validate_string(pv_SearchFolder, False, False): message = "SearchFolder parameter has no value." warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, "Specify the search folder.")) print(message) # FilenamePattern is optional, will default to "test-*" at runtime # OutputFile is required pv_OutputFile = self.get_parameter_value(parameter_name='OutputFile', command_parameters=command_parameters) if not validators.validate_string(pv_OutputFile, False, False): message = "OutputFile parameter has no value." warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, "Specify the output file.")) print(message) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty # triggers an exception below. warning_message = command_util.validate_command_parameter_names(self, warning_message) # If any warnings were generated, throw an exception if len(warning_message) > 0: logger.warning(warning_message) raise ValueError(warning_message) # Refresh the phase severity self.command_status.refresh_phase_severity(CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that parameter GeoLayerID is a non-empty, non-None string. pv_GeoLayerID = self.get_parameter_value( parameter_name='GeoLayerID', command_parameters=command_parameters) if not validators.validate_string(pv_GeoLayerID, False, False): message = "GeoLayerID parameter has no value." recommendation = "Specify the GeoLayerID parameter to indicate the GeoLayer to copy." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter IfGeoLayerIDExists is either `Replace`, `ReplaceAndWarn`, `Warn`, `Fail`, None. pv_IfGeoLayerIDExists = self.get_parameter_value( parameter_name="IfGeoLayerIDExists", command_parameters=command_parameters) acceptable_values = ["Replace", "ReplaceAndWarn", "Warn", "Fail"] if not validators.validate_string_in_list(pv_IfGeoLayerIDExists, acceptable_values, none_allowed=True, empty_string_allowed=True, ignore_case=True): message = "IfGeoLayerIDExists parameter value ({}) is not recognized.".format( pv_IfGeoLayerIDExists) recommendation = "Specify one of the acceptable values ({}) for the IfGeoLayerIDExists parameter.".format( acceptable_values) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) else: # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: Nothing. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" logger = logging.getLogger("gp") # Message is required pv_Message = self.get_parameter_value( parameter_name='Message', command_parameters=command_parameters) if not validators.validate_string(pv_Message, False, False): message = "Message parameter has no value." recommendation = "Specify text for the Message parameter." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) pv_CommandStatus = self.get_parameter_value( parameter_name='CommandStatus', command_parameters=command_parameters) if not validators.validate_string_in_list( pv_CommandStatus, CommandStatusType.get_command_status_types_as_str(), True, True): message = 'The requested command status "' + pv_CommandStatus + '"" is invalid.' recommendation = "Specify a valid command status." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty # triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception if len(warning) > 0: logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that parameter SpatialDataFile is a non-empty, non-None string. # - existence of the file will also be checked in run_command(). pv_SpatialDataFile = self.get_parameter_value(parameter_name='SpatialDataFile', command_parameters=command_parameters) if not validators.validate_string(pv_SpatialDataFile, False, False): message = "SpatialDataFile parameter has no value." recommendation = "Specify the SpatialDataFile parameter to indicate the spatial data layer file." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter IfGeoLayerIDExists is one of the acceptable values or is None. pv_IfGeoLayerIDExists = self.get_parameter_value(parameter_name="IfGeoLayerIDExists", command_parameters=command_parameters) if not validators.validate_string_in_list(pv_IfGeoLayerIDExists, self.__choices_IfGeoLayerIDExists, none_allowed=True, empty_string_allowed=True, ignore_case=True): message = "IfGeoLayerIDExists parameter value ({}) is not recognized.".format(pv_IfGeoLayerIDExists) recommendation = "Specify one of the acceptable values ({}) for the IfGeoLayerIDExists parameter.".format( self.__choices_IfGeoLayerIDExists) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) else: # Refresh the phase severity self.command_status.refresh_phase_severity(CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: Nothing. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning_message = "" logger = logging.getLogger(__name__) # CommandFile is required pv_CommandFile = self.get_parameter_value(parameter_name='CommandFile', command_parameters=command_parameters) if not validators.validate_string(pv_CommandFile, False, False): message = "The CommandFile must be specified." recommendation = "Specify the command file." warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # ExpectedStatus is optional, will default to Success at runtime pv_ExpectedStatus = self.get_parameter_value(parameter_name='ExpectedStatus', command_parameters=command_parameters) if not validators.validate_string_in_list(pv_ExpectedStatus, self.__choices_ExpectedStatus, True, True): message = "ExpectedStatus parameter is invalid." recommendation = "Specify the ExpectedStatus parameter as blank or one of " + \ str(self.__choices_ExpectedStatus) warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty # triggers an exception below. warning_message = command_util.validate_command_parameter_names(self, warning_message) # If any warnings were generated, throw an exception if len(warning_message) > 0: logger.warning(warning_message) raise ValueError(warning_message) # Refresh the phase severity self.command_status.refresh_phase_severity(CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: Nothing. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" logger = logging.getLogger(__name__) # LogFile is required pv_LogFile = self.get_parameter_value(parameter_name='LogFile', command_parameters=command_parameters) if not validators.validate_string(pv_LogFile, False, False): message = "The log file must be specified." recommendation = "Specify the log file." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) print(message) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty # triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception if len(warning) > 0: logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity(CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that parameter TableID is a non-empty, non-None string. pv_TableID = self.get_parameter_value( parameter_name='TableID', command_parameters=command_parameters) if not validators.validate_string(pv_TableID, False, False): message = "TableID parameter has no value." recommendation = "Specify the TableID parameter to indicate the Table to write." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter OutputFile is a non-empty, non-None string. pv_OutputFile = self.get_parameter_value( parameter_name='OutputFile', command_parameters=command_parameters) if not validators.validate_string(pv_OutputFile, False, False): message = "OutputFile parameter has no value." recommendation = "Specify the OutputFile parameter (relative or absolute pathname) to indicate the " \ "location and name of the output delimited file." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that the required parameters are valid Boolean values or None. parameters = ['WriteIndexColumn', 'WriteHeaderRow'] for parameter in parameters: parameter_value = self.get_parameter_value( parameter_name=parameter, command_parameters=command_parameters) if not validators.validate_bool(parameter_value, True, False): message = "{} parameter ({}) is not a valid Boolean value.".format( parameter, parameter_value) recommendation = "Specify a valid Boolean value for the {} parameter.".format( parameter) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter ArrayFormat is one of the acceptable values or is None. pv_ArrayFormat = self.get_parameter_value( parameter_name="ArrayFormat", command_parameters=command_parameters) if not validators.validate_string_in_list(pv_ArrayFormat, self.__choices_ArrayFormat, none_allowed=True, empty_string_allowed=False, ignore_case=True): message = "ArrayFormat parameter value ({}) is not recognized.".format( pv_ArrayFormat) recommendation = "Specify one of the acceptable values ({}) for the ArrayFormat parameter.".format( self.__choices_ArrayFormat) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter NullValueFormat is one of the acceptable values or is None. pv_NullValueFormat = self.get_parameter_value( parameter_name="NullValueFormat", command_parameters=command_parameters) if not validators.validate_string_in_list( pv_NullValueFormat, self.__choices_NullValueFormat, none_allowed=True, empty_string_allowed=False, ignore_case=True): message = "NullValueFormat parameter value ({}) is not recognized.".format( pv_NullValueFormat) recommendation = "Specify one of the acceptable values ({}) for the NullValueFormat parameter.".format( self.__choices_NullValueFormat) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: Nothing. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" logger = logging.getLogger(__name__) # PropertyName is required pv_PropertyName = self.get_parameter_value( parameter_name='PropertyName', command_parameters=command_parameters) if not validators.validate_string(pv_PropertyName, False, False): message = "PropertyName parameter has no value." recommendation = "Specify a property name." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # PropertyType is required pv_PropertyType = self.get_parameter_value( parameter_name='PropertyType', command_parameters=command_parameters) if not validators.validate_string_in_list( pv_PropertyType, self.__choices_PropertyType, False, False): message = 'The requested property type "' + pv_PropertyType + '"" is invalid.' recommendation = "Specify a valid property type: " + str( property_types) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # TODO smalers 2017-12-28 add other parameters similar to TSTool to set special values property_value_parameter_count = 0 # increment for PropertyValue or PropertyValues, only one is allowed # PropertyValue or PropertyValues are required pv_PropertyValue = self.get_parameter_value( parameter_name='PropertyValue', command_parameters=command_parameters) if pv_PropertyValue is not None and pv_PropertyValue != "": property_value_parameter_count += 1 if not validators.validate_string(pv_PropertyValue, True, True): message = "PropertyValue parameter is not specified." recommendation = "Specify a property value." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) pv_PropertyValues = self.get_parameter_value( parameter_name='PropertyValues', command_parameters=command_parameters) if pv_PropertyValues is not None and pv_PropertyValues != "": property_value_parameter_count += 1 if not validators.validate_list( pv_PropertyValues, True, True, brackets_required=False): message = "PropertyValues parameter is not valid." recommendation = "Specify a list of values separated by commas and optional spaces." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) if property_value_parameter_count != 1: message = "PropertyValue (single value) or PropertyValues (for list) parameter must be specified." recommendation = "Specify a single value with PropertyValue or list of values with PropertyValues." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty # triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception if len(warning) > 0: # Message.printWarning ( warning_level, # MessageUtil.formatMessageTag(command_tag, warning_level), routine, warning ); logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that the required parameters are non-empty, non-None strings. required_parameters = ["TableID", "DataStoreID", "DataStoreTable"] for parameter in required_parameters: parameter_value = self.get_parameter_value( parameter_name=parameter, command_parameters=command_parameters) if not validators.validate_string(parameter_value, False, False): message = "{} parameter has no value.".format(parameter) recommendation = "Specify a valid value for the {} parameter.".format( parameter) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter WriteMode is one of the acceptable values or is None. pv_WriteMode = self.get_parameter_value( parameter_name="WriteMode", command_parameters=command_parameters) if not validators.validate_string_in_list(pv_WriteMode, self.__choices_WriteMode, none_allowed=False, empty_string_allowed=False, ignore_case=True): message = "WriteMode parameter value ({}) is not recognized.".format( pv_WriteMode) recommendation = "Specify one of the acceptable values ({}) for the WriteMode parameter.".format( self.__choices_WriteMode) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that parameter GeoLayerID is a non-empty, non-None string. # - existence of the GeoLayer will also be checked in run_command(). pv_GeoLayerID = self.get_parameter_value( parameter_name='GeoLayerID', command_parameters=command_parameters) if not validators.validate_string(pv_GeoLayerID, False, False): message = "GeoLayerID parameter has no value." recommendation = "Specify the GeoLayerID parameter to indicate the GeoLayer to write." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter OutputFile is a non-empty, non-None string. # - existence of the folder will also be checked in run_command(). pv_OutputFile = self.get_parameter_value( parameter_name='OutputFile', command_parameters=command_parameters) if not validators.validate_string(pv_OutputFile, False, False): message = "OutputFile parameter has no value." recommendation = "Specify the OutputFile parameter (relative or absolute pathname) to indicate the " \ "location and name of the output spatial data file in GeoJSON format." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional ZipOutput parameter value is a valid Boolean value or is None. pv_ZipOutput = self.get_parameter_value( parameter_name="ZipOutput", command_parameters=command_parameters) if not validators.validate_bool( pv_ZipOutput, none_allowed=True, empty_string_allowed=False): message = "ZipOutput parameter value ({}) is not a recognized boolean value.".format( pv_ZipOutput) recommendation = "Specify either 'True' or 'False for the ZipOutput parameter." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: Nothing. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" logger = logging.getLogger(__name__) # GeoLayerID is required # - non-empty, non-None string. # - existence of the GeoLayer will also be checked in run_command(). pv_GeoLayerID = self.get_parameter_value( parameter_name='GeoLayerID', command_parameters=command_parameters) if not validators.validate_string(pv_GeoLayerID, False, False): message = "GeoLayerID parameter has no value." recommendation = "Specify the GeoLayerID parameter to indicate the GeoLayer to process." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # PropertyName is required pv_PropertyName = self.get_parameter_value( parameter_name='PropertyName', command_parameters=command_parameters) if not validators.validate_string(pv_PropertyName, False, False): message = "PropertyName parameter has no value." recommendation = "Specify a property name." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # PropertyType is required pv_PropertyType = self.get_parameter_value( parameter_name='PropertyType', command_parameters=command_parameters) property_types = ["bool", "float", "int", "long", "str"] if not validators.validate_string_in_list( pv_PropertyType, property_types, False, False): message = 'The requested property type "' + pv_PropertyType + '"" is invalid.' recommendation = "Specify a valid property type: " + str( property_types) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # PropertyValue is required pv_PropertyValue = self.get_parameter_value( parameter_name='PropertyValue', command_parameters=command_parameters) if not validators.validate_string(pv_PropertyValue, False, False): # TODO smalers 2017-12-28 add other parameters similar to TSTool to set special values message = "PropertyValue parameter is not specified." recommendation = "Specify a property value." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty # triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception if len(warning) > 0: logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that the appropriate parameters have a string value. for parameter in ['GeoLayerID', 'OutputFile']: # Get the parameter value. parameter_value = self.get_parameter_value( parameter_name=parameter, command_parameters=command_parameters) # Check that the parameter value is a non-empty, non-None string. If not, raise a FAILURE. if not validators.validate_string(parameter_value, False, False): message = "{} parameter has no value.".format(parameter) recommendation = "Specify the {} parameter.".format(parameter) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter OutputGeometryFormat is either `WKT`, `XYZ`, `XY`, `YX` or None. pv_OutputGeometryFormat = self.get_parameter_value( parameter_name="OutputGeometryFormat", command_parameters=command_parameters) acceptable_values = ["WKT", "XYZ", "XY", "YZ"] if not validators.validate_string_in_list(pv_OutputGeometryFormat, acceptable_values, none_allowed=True, empty_string_allowed=False, ignore_case=True): message = "OutputGeometryFormat parameter value ({}) is not recognized.".format( pv_OutputGeometryFormat) recommendation = "Specify one of the acceptable values ({}) for the OutputGeometryFormat parameter.".format( acceptable_values) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter OutputDelimiter is either `COMMA`, `SPACE`, `TAB`, `SEMICOLON` or None. pv_OutputDelimiter = self.get_parameter_value( parameter_name="OutputDelimiter", command_parameters=command_parameters) acceptable_values = ["COMMA", "SEMICOLON", "TAB", "SPACE"] if not validators.validate_string_in_list(pv_OutputDelimiter, acceptable_values, none_allowed=True, empty_string_allowed=False, ignore_case=True): message = "OutputDelimiter parameter value ({}) is not recognized.".format( pv_OutputDelimiter) recommendation = "Specify one of the acceptable values ({}) for the OutputDelimiter parameter.".format( acceptable_values) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that either the parameter File is a non-empty, non-None string. pv_File = self.get_parameter_value( parameter_name='File', command_parameters=command_parameters) if not validators.validate_string(pv_File, False, False): message = "File parameter has no value." recommendation = "Specify the File parameter to indicate the compressed file to extract." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter FileType is an acceptable value or is None. pv_FileType = self.get_parameter_value( parameter_name="FileType", command_parameters=command_parameters) acceptable_values = ["Zip", "Tar"] if not validators.validate_string_in_list(pv_FileType, acceptable_values, none_allowed=True, empty_string_allowed=False, ignore_case=True): message = "FileType parameter value ({}) is not recognized.".format( pv_FileType) recommendation = "Specify one of the acceptable values ({}) for the" \ " FileType parameter.".format(acceptable_values) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional DeleteFile parameter value is a valid Boolean value or is None. pv_DeleteFile = self.get_parameter_value( parameter_name="DeleteFile", command_parameters=command_parameters) if not validators.validate_bool( pv_DeleteFile, none_allowed=True, empty_string_allowed=False): message = "DeleteFile parameter value ({}) is not a recognized boolean value.".format( pv_DeleteFile) recommendation = "Specify either 'True' or 'False for the DeleteFile parameter." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) else: # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" logger = logging.getLogger(__name__) # Unlike most commands, set internal data here because it is needed by initial call to next() # before calls to run_command # Options for iterating, will be changed based on parameters that are set self.iterator_is_list = False self.iterator_is_sequence = False self.iterator_is_table = False option_count = 0 # How many iteration options are specified (should only be 1) # Name is required pv_Name = self.get_parameter_value( parameter_name='Name', command_parameters=command_parameters) if not validators.validate_string(pv_Name, False, False): message = "A name for the For block must be specified" recommendation = "Specify the Name." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # -------------------------------- # Iterator option 1 - use a sequence # SequenceStart is currently required since no other iteration types are implemented pv_SequenceStart = self.get_parameter_value( parameter_name='SequenceStart', command_parameters=command_parameters) if pv_SequenceStart is not None and pv_SequenceStart != "": self.iterator_is_sequence = True # Will be checked below to make sure only one option is used option_count += 1 if not validators.validate_number(pv_SequenceStart, False, False): message = "The SequenceStart value must be specified as a number" recommendation = "Specify the SequenceStart as a number." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) else: if pv_SequenceStart.find(".") >= 0: # Decimal self.iterator_sequence_start = float(pv_SequenceStart) else: # Assume integer self.iterator_sequence_start = int(pv_SequenceStart) # The other sequence parameters only make sense if the start is specified # SequenceEnd is currently required since no other iteration types are implemented pv_SequenceEnd = self.get_parameter_value( parameter_name='SequenceEnd', command_parameters=command_parameters) if not validators.validate_number(pv_SequenceEnd, False, False): message = "The SequenceEnd value must be specified as a number" recommendation = "Specify the SequenceEnd as a number." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) else: if pv_SequenceEnd.find(".") >= 0: # Decimal self.iterator_sequence_end = float(pv_SequenceEnd) else: # Assume integer self.iterator_sequence_end = int(pv_SequenceEnd) # SequenceIncrement is currently required since no other iteration types are implemented pv_SequenceIncrement = self.get_parameter_value( parameter_name='SequenceIncrement', command_parameters=command_parameters) if not validators.validate_number(pv_SequenceIncrement, False, False): message = "The SequenceIncrement value must be specified as a number" recommendation = "Specify the SequenceIncrement as a number." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) else: if pv_SequenceIncrement.find(".") >= 0: # Decimal self.iterator_sequence_increment = float( pv_SequenceIncrement) else: # Assume integer self.iterator_sequence_increment = int( pv_SequenceIncrement) # -------------------------------- # Iterator option 2 - use a processor property that contains a list pv_ListProperty = self.get_parameter_value( parameter_name='ListProperty', command_parameters=command_parameters) if pv_ListProperty is not None and pv_ListProperty != "": self.iterator_is_list = True # Will be checked below to make sure only one option is used option_count += 1 # No further validation is done - ListProperty property must be defined at run time # -------------------------------- # Iterator option 3 - use a table pv_TableID = self.get_parameter_value( parameter_name='TableID', command_parameters=command_parameters) if pv_TableID is not None and pv_TableID != "": self.iterator_is_table = True option_count += 1 # TableColumn is required pv_TableColumn = self.get_parameter_value( parameter_name='TableColumn', command_parameters=command_parameters) if not validators.validate_string(pv_TableColumn, False, False): message = "The TableColumn parameter must be specified" recommendation = "Specify the TableColumn." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # -------------------------------- # Only allow one of the iteration properties to be specified because otherwise the command will be confused. if option_count > 1: message = "Parameters for multiple iterator types have been specified." recommendation = "Specify parameters for only one iteration type." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Allow multiple iteration types to be set since they will be processed in order when running # and the preferred approach will take precedent # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty # triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception if len(warning) > 0: logger.warn(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that parameter InputFile is a non-empty, non-None string. pv_InputFile = self.get_parameter_value( parameter_name='InputFile', command_parameters=command_parameters) if not validators.validate_string(pv_InputFile, False, False): message = "InputFile parameter has no value." recommendation = "Specify the InputFile parameter (relative or absolute pathname) to indicate the " \ "location and name of the output Excel file." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter TableID is a non-empty, non-None string. pv_TableID = self.get_parameter_value( parameter_name='TableID', command_parameters=command_parameters) if not validators.validate_string(pv_TableID, False, False): message = "TableID parameter has no value." recommendation = "Specify the TableID parameter." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter IfTableIDExists is either `Replace`, `ReplaceAndWarn`, `Warn`, `Fail`, None. pv_IfTableIDExists = self.get_parameter_value( parameter_name="IfTableIDExists", command_parameters=command_parameters) acceptable_values = ["Replace", "ReplaceAndWarn", "Warn", "Fail"] if not validators.validate_string_in_list(pv_IfTableIDExists, acceptable_values, none_allowed=True, empty_string_allowed=True, ignore_case=True): message = "IfTableIDExists parameter value ({}) is not recognized.".format( pv_IfTableIDExists) recommendation = "Specify one of the acceptable values ({}) for the IfTableIDExists parameter.".format( acceptable_values) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # If the HeaderLines is used, continue with the checks. pv_HeaderLines = self.get_parameter_value( "HeaderLines", command_parameters=command_parameters) if pv_HeaderLines: # Check that the HeaderLines parameter is an integer or None. if not validators.validate_int(pv_HeaderLines, True, False): message = "HeaderLines parameter value ({}) is not a valid integer value.".format( pv_HeaderLines) recommendation = "Specify a positive integer for the HeaderLines parameter to specify how" \ " many rows represent the header contnet of the delimited file." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: Nothing. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning_message = "" logger = logging.getLogger(__name__) # OutputFile is required pv_OutputFile = self.get_parameter_value( parameter_name='OutputFile', command_parameters=command_parameters) if not validators.validate_string(pv_OutputFile, False, False): message = "The OutputFile must be specified." recommendation = "Specify the output file." warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # IncludeProperties is optional, default to * at runtime # WriteMode is optional, will default to Overwrite at runtime pv_WriteMode = self.get_parameter_value( parameter_name='WriteMode', command_parameters=command_parameters) if not validators.validate_string_in_list( pv_WriteMode, self.__choices_WriteMode, True, True): message = "WriteMode parameter is invalid." recommendation = "Specify the WriteMode parameter as blank or one of " + \ str(self.__choices_WriteMode) warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # FileFormat is optional, will default to NameTypeValue at runtime pv_FileFormat = self.get_parameter_value( parameter_name='FileFormat', command_parameters=command_parameters) if not validators.validate_string_in_list( pv_FileFormat, self.__choices_FileFormat, True, True): message = "FileFormat parameter is invalid." recommendation = "Specify the FileFormat parameter as blank or one of " + \ str(self.__choices_FileFormat) warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # SortOrder is optional, will default to None (no sort) at runtime pv_SortOrder = self.get_parameter_value( parameter_name='SortOrder', command_parameters=command_parameters) if not validators.validate_string_in_list( pv_SortOrder, self.__choices_SortOrder, True, True): message = "SortOrder parameter is invalid." recommendation = "Specify the SortOrder parameter as blank or one of " + \ str(self.__choices_SortOrder) warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty # triggers an exception below. warning_message = command_util.validate_command_parameter_names( self, warning_message) # If any warnings were generated, throw an exception if len(warning_message) > 0: logger.warning(warning_message) raise ValueError(warning_message) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that either the parameter Folder or the parameter URL is a non-empty, non-None string. pv_Folder = self.get_parameter_value( parameter_name='Folder', command_parameters=command_parameters) pv_URL = self.get_parameter_value( parameter_name='URL', command_parameters=command_parameters) folder_is_string = validators.validate_string(pv_Folder, False, False) url_is_string = validators.validate_string(pv_URL, False, False) if folder_is_string and url_is_string: message = "The Folder parameter and the URL parameter cannot both be enabled in the same command." recommendation = "Specify only the Folder parameter or only the URL parameter." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) if not folder_is_string and not url_is_string: message = "Both the Folder parameter and the URL have no value." recommendation = "Specify EITHER the Folder parameter OR the URL parameter." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional ListFiles parameter value is a valid Boolean value or is None. pv_ListFiles = self.get_parameter_value( parameter_name="ListFiles", command_parameters=command_parameters) if not validators.validate_bool( pv_ListFiles, none_allowed=True, empty_string_allowed=False): message = "ListFiles parameter value ({}) is not a recognized boolean value.".format( pv_ListFiles) recommendation = "Specify either 'True' or 'False for the ListFiles parameter." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional ListFolders parameter value is a valid Boolean value or is None. pv_ListFolders = self.get_parameter_value( parameter_name="ListFolders", command_parameters=command_parameters) if not validators.validate_bool( pv_ListFolders, none_allowed=True, empty_string_allowed=False): message = "ListFolders parameter value ({}) is not a recognized boolean value.".format( pv_ListFolders) recommendation = "Specify either 'True' or 'False for the ListFolders parameter." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter ListProperty is a non-empty, non-None string. pv_ListProperty = self.get_parameter_value( parameter_name='ListProperty', command_parameters=command_parameters) if not validators.validate_string(pv_ListProperty, False, False): message = "ListProperty parameter has no value." recommendation = "Specify the ListProperty parameter." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter IfPropertyExists is either `Replace`, `ReplaceAndWarn`, `Warn`, `Fail`, None. pv_IfPropertyExists = self.get_parameter_value( parameter_name="IfPropertyExists", command_parameters=command_parameters) acceptable_values = ["Replace", "ReplaceAndWarn", "Warn", "Fail"] if not validators.validate_string_in_list(pv_IfPropertyExists, acceptable_values, none_allowed=True, empty_string_allowed=True, ignore_case=True): message = "IfPropertyExists parameter value ({}) is not recognized.".format( pv_IfPropertyExists) recommendation = "Specify one of the acceptable values ({}) for the IfPropertyExists parameter.".format( acceptable_values) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) else: # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that parameters GeoLayerID and is a non-empty, non-None string. pv_GeoLayerID = self.get_parameter_value( parameter_name='GeoLayerID', command_parameters=command_parameters) if not validators.validate_string(pv_GeoLayerID, False, False): message = "GeoLayerID parameter has no value." recommendation = "Specify the GeoLayerID parameter to indicate the input GeoLayer." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter AttributeName is a non-empty, non-None string. pv_AttributeName = self.get_parameter_value( parameter_name='AttributeName', command_parameters=command_parameters) if not validators.validate_string(pv_AttributeName, False, False): message = "AttributeName parameter has no value." recommendation = "Specify the AttributeName parameter to indicate the name of attribute to add." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter AttributeType is either 'string', 'date', 'int' and 'double'. pv_AttributeType = self.get_parameter_value( parameter_name="AttributeType", command_parameters=command_parameters) acceptable_values = ["string", "date", "int", "double"] if not validators.validate_string_in_list( pv_AttributeType, acceptable_values, ignore_case=True): message = "AttributeType parameter value ({}) is not recognized.".format( pv_AttributeType) recommendation = "Specify one of the acceptable values ({}) for the AttributeType parameter.".format( acceptable_values) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) else: # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that the DataStoreID is a non-empty, non-None string. pv_DataStoreID = self.get_parameter_value(parameter_name="DataStoreID", command_parameters=command_parameters) if not validators.validate_string(pv_DataStoreID, False, False): message = "DataStoreID parameter has no value." recommendation = "Specify a valid DataStore ID." warning += "\n" + message self.command_status.add_to_log(CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that one (and only one) sql method is a non-empty and non-None string. is_string_list = [] sql_method_parameter_list = ["Sql", "SqlFile", "DataStoreProcedure"] for parameter in sql_method_parameter_list: parameter_value = self.get_parameter_value(parameter_name=parameter, command_parameters=command_parameters) is_string_list.append(validators.validate_string(parameter_value, False, False)) if not is_string_list.count(True) == 1: message = "Must enable one (and ONLY one) of the following parameters: {}".format(sql_method_parameter_list) recommendation = "Specify the value for one (and ONLY one) of the following parameters: {}".format( sql_method_parameter_list) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # TEMPORARY CHECK: Check that the DataStoreProcedure method is not being used. Currently disabled until future # development. Once developed, this check can be removed. else: pv_DataStoreProcedure = self.get_parameter_value(parameter_name="DataStoreProcedure", command_parameters=command_parameters) if validators.validate_string(pv_DataStoreProcedure, none_allowed=False, empty_string_allowed=False): message = "DataStoreProcedure is not currently enabled." recommendation = "Specify the Sql method or the SqlFile method. " warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity(CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that the DataStoreID is a non-empty, non-None string. pv_DataStoreID = self.get_parameter_value( parameter_name="DataStoreID", command_parameters=command_parameters) if not validators.validate_string(pv_DataStoreID, False, False): message = "DataStoreID parameter has no value." recommendation = "Specify a valid DataStore ID." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional IfDataStoreIDExists param is `Replace`, `Open`, `Warn`, `Fail`, `ReplaceAndWarn` or None. pv_IfDataStoreIDExists = self.get_parameter_value( parameter_name="IfDataStoreIDExists", command_parameters=command_parameters) if not validators.validate_string_in_list( pv_IfDataStoreIDExists, self.__choices_IfDataStoreIDExists, none_allowed=True, empty_string_allowed=False, ignore_case=True): message = "IfDataStoreIDExists parameter value ({}) is not recognized.".format( pv_IfDataStoreIDExists) recommendation = "Specify one of the acceptable values ({}) for the IfDataStoreIDExists parameter.". \ format(self.__choices_IfDataStoreIDExists) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check if the ConfigFile parameter is a non-empty, non-None string. pv_ConfigFile = self.get_parameter_value( parameter_name="ConfigFile", command_parameters=command_parameters) # If there is a value for ConfigFile, assume "Configuration file configures datastore" method. if validators.validate_string(pv_ConfigFile, False, False): pass # If the IfDataStoreIDExists parameter is set to "Open", ignore all checks. elif validators.validate_string_in_list(pv_IfDataStoreIDExists, ["OPEN"], False, False, True): pass # If there is no value for ConfigFile, assume "Parameters configure datastore" method. else: # Check that the required parameters are non-empty, non-None string. required_parameters = [ "DatabaseServer", "DatabaseName", "DatabaseUser", "DatabasePassword" ] for parameter in required_parameters: parameter_value = self.get_parameter_value( parameter_name=parameter, command_parameters=command_parameters) if not validators.validate_string(parameter_value, False, False): message = "{} parameter has no value.".format(parameter) recommendation = "Specify a valid {} parameter.".format( parameter) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter DatabaseDialect is one of the acceptable values. pv_DatabaseDialect = self.get_parameter_value( parameter_name="DatabaseDialect", command_parameters=command_parameters) if not validators.validate_string_in_list( pv_DatabaseDialect, self.__choices_DatabaseDialect, False, False, True): message = "DatabaseDialect parameter value ({}) is not recognized.".format( pv_DatabaseDialect) recommendation = "Specify one of the acceptable values ({}) for the DatabaseDialect parameter.".format( self.__choices_DatabaseDialect) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that parameter TableID is a non-empty, non-None string. pv_TableID = self.get_parameter_value( parameter_name='TableID', command_parameters=command_parameters) if not validators.validate_string(pv_TableID, False, False): message = "TableID parameter has no value." recommendation = "Specify the TableID parameter to indicate the Table to write." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter DataStoreID is a non-empty, non-None string. pv_DataStoreID = self.get_parameter_value( parameter_name='DataStoreID', command_parameters=command_parameters) if not validators.validate_string(pv_DataStoreID, False, False): message = "DataStoreID parameter has no value." recommendation = "Specify the DataStoreID parameter (relative or absolute pathname) to indicate the " \ "location and name of the output delimited file." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that one (and only one) selection method is a non-empty and non-None string. is_string_list = [] selection_method_parameter_list = ["Sql", "SqlFile", "DataStoreTable"] for parameter in selection_method_parameter_list: parameter_value = self.get_parameter_value( parameter_name=parameter, command_parameters=command_parameters) is_string_list.append( validators.validate_string(parameter_value, False, False)) if not is_string_list.count(True) == 1: message = "Must enable one (and ONLY one) of the following parameters: {}".format( selection_method_parameter_list) recommendation = "Specify the value for one (and ONLY one) of the following parameters: {}".format( selection_method_parameter_list) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Run the checks for the Top parameter. pv_Top = self.get_parameter_value( parameter_name='Top', command_parameters=command_parameters) pv_DataStoreTable = self.get_parameter_value( parameter_name="DataStoreTable", command_parameters=command_parameters) if pv_Top: # Check that the Top parameter is only used with the DataStoreTable selection. if is_string_list.count(True) == 1 and not pv_DataStoreTable: message = "The Top parameter is only valid when the DataStoreTable is enabled. The Top parameter" \ " value ({}) will be ignored.".format(pv_Top) recommendation = "To use the Top parameter, specify a value for the DataStoreTable parameter." self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.WARNING, message, recommendation)) # If the DataStoreTable parameter is enabled, check that the Top parameter is an integer or None. if pv_DataStoreTable and not validators.validate_int( pv_Top, True, False): message = "Top parameter value ({}) is not a valid integer value.".format( pv_Top) recommendation = "Specify a positive integer for the Top parameter to specify how many rows to return." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # If the DataStoreTable parameter is enabled, check that the Top parameter is positive. elif pv_DataStoreTable and not int(pv_Top) > 0: message = "Top parameter value ({}) is not a positive, non-zero integer value.".format( pv_Top) recommendation = "Specify a positive integer for the Top parameter to specify how many rows to return." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter IfTableIDExists is one of the acceptable values or is None. pv_IfTableIDExists = self.get_parameter_value( parameter_name="IfTableIDExists", command_parameters=command_parameters) if not validators.validate_string_in_list( pv_IfTableIDExists, self.__choices_IfTableIDExists, none_allowed=True, empty_string_allowed=False, ignore_case=True): message = "IfTableIDExists parameter value ({}) is not recognized.".format( pv_IfTableIDExists) recommendation = "Specify one of the acceptable values ({}) for the IfTableIDExists parameter.".format( self.__choices_IfTableIDExists) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: Nothing. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning_message = "" logger = logging.getLogger(__name__) # CommandLine is required, pending other options pv_CommandLine = self.get_parameter_value( parameter_name='CommandLine', command_parameters=command_parameters) if not validators.validate_string(pv_CommandLine, False, False): message = "The CommandLine must be specified." recommendation = "Specify the command line." warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # IncludeParentEnvVars is optional, will default to True at runtime pv_IncludeParentEnvVars = self.get_parameter_value( parameter_name='IncludeParentEnvVars', command_parameters=command_parameters) if not validators.validate_string_in_list( pv_IncludeParentEnvVars, self.__choices_IncludeParentEnvVars, True, True): message = "IncludeParentEnvVars parameter is invalid." recommendation = "Specify the IncludeParentEnvVars parameter as blank or one of " + \ str(self.__choices_IncludeParentEnvVars) warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # UseCommandShell is optional, will default to False at runtime pv_UseCommandShell = self.get_parameter_value( parameter_name='UseCommandShell', command_parameters=command_parameters) if not validators.validate_string_in_list( pv_UseCommandShell, self.__choices_UseCommandShell, True, True): message = "UseCommandShell parameter is invalid." recommendation = "Specify the UseCommandShell parameter as blank or one of " + \ str(self.__choices_UseCommandShell) warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # TODO smalers 2018-12-16 need to make sure IncludeEnvVars and ExcludeEnvVars are valid lists # - for now allow any string to be specified # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty # triggers an exception below. warning_message = command_util.validate_command_parameter_names( self, warning_message) # If any warnings were generated, throw an exception if len(warning_message) > 0: logger.warning(warning_message) raise ValueError(warning_message) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: Nothing. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning_message = "" logger = logging.getLogger(__name__) # InputFile1 is required pv_InputFile1 = self.get_parameter_value( parameter_name='InputFile1', command_parameters=command_parameters) if not validators.validate_string(pv_InputFile1, False, False): message = "The InputFile1 parameter must be specified." recommendation = "Specify the first input file." warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # InputFile2 is required pv_InputFile2 = self.get_parameter_value( parameter_name='InputFile2', command_parameters=command_parameters) if not validators.validate_string(pv_InputFile2, False, False): message = "The InputFile2 parameter must be specified." recommendation = "Specify the second input file." warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # CommentLineChar is optional, defaults to # at runtime, for now no checks # MatchCase is optional, defaults to True at runtime pv_MatchCase = self.get_parameter_value( parameter_name='MatchCase', command_parameters=command_parameters) if not validators.validate_string_in_list( pv_MatchCase, self.__choices_MatchCase, True, True): message = "MatchCase parameter is invalid." recommendation = "Specify the MatchCase parameter as blank or one of " + str( self.__choices_MatchCase) warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # IgnoreWhitespace is optional, defaults to True at runtime pv_IgnoreWhitespace = self.get_parameter_value( parameter_name='IgnoreWhitespace', command_parameters=command_parameters) if not validators.validate_string_in_list( pv_IgnoreWhitespace, self.__choices_MatchCase, True, True): message = "IgnoreWhitespace parameter is invalid." recommendation = "Specify the IgnoreWhitespace parameter as blank or one of " + \ str(self.__choices_IgnoreWhitespace) warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # AllowedDiffCount is optional, defaults to 0 at runtime, but must be a number if specified pv_AllowedDiffCount = self.get_parameter_value( parameter_name='AllowedDiffCount', command_parameters=command_parameters) if not validators.validate_int(pv_AllowedDiffCount, True, True): message = "The AllowedDiffCount parameter is invalid." recommendation = "Specify the allowed difference count as an integer." warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # IfDifferent is optional, defaults to Ignore at runtime pv_IfDifferent = self.get_parameter_value( parameter_name='IfDifferent', command_parameters=command_parameters) if not validators.validate_string_in_list( pv_IfDifferent, self.__choices_IfDifferent, True, True): message = "IfDifferent parameter is invalid." recommendation = "Specify the IfDifferent parameter as blank or one of " + str( self.__choices_IfDifferent) warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # IfSame is optional, defaults to Ignore at runtime pv_IfSame = self.get_parameter_value( parameter_name='IfSame', command_parameters=command_parameters) if not validators.validate_string_in_list( pv_IfSame, self.__choices_IfSame, True, True): message = "IfSame parameter is invalid." recommendation = "Specify the IfSame parameter as blank or one of " + str( self.__choices_IfSame) warning_message += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty # triggers an exception below. warning_message = command_util.validate_command_parameter_names( self, warning_message) # If any warnings were generated, throw an exception if len(warning_message) > 0: logger.warning(warning_message) raise ValueError(warning_message) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that the appropriate parameters have a string value. for parameter in ['DelimitedFile', 'Delimiter', 'CRS', 'GeoLayerID']: # Get the parameter value. parameter_value = self.get_parameter_value( parameter_name=parameter, command_parameters=command_parameters) # Check that the parameter value is a non-empty, non-None string. If not, raise a FAILURE. if not validators.validate_string(parameter_value, False, False): message = "{} parameter has no value.".format(parameter) recommendation = "Specify the {} parameter.".format(parameter) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that the GeometryFormat is either `XY` or `WKT`. pv_GeometryFormat = self.get_parameter_value( parameter_name="GeometryFormat", command_parameters=command_parameters) acceptable_values = ["WKT", "XY"] if not validators.validate_string_in_list(pv_GeometryFormat, acceptable_values, none_allowed=False, empty_string_allowed=False, ignore_case=True): message = "GeometryFormat parameter value ({}) is not recognized.".format( pv_GeometryFormat) recommendation = "Specify one of the acceptable values ({}) for the GeometryFormat parameter.".format( acceptable_values) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that the correct ColumnName variables are correct. else: # If the pv_GeometryFormat is "WKT" then check that the WKTColumn has a string value. if pv_GeometryFormat is not None and pv_GeometryFormat.upper( ) == "WKT": # Check that the parameter value is a non-None string. If not, raise a FAILURE. if not validators.validate_string("WKTColumn", False, True): message = "WKTColumn parameter has no value." recommendation = "Specify the WKTColumn parameter." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) else: # Check that the appropriate parameters have a string value. for parameter in ['XColumn', 'YColumn']: # Get the parameter value. parameter_value = self.get_parameter_value( parameter_name=parameter, command_parameters=command_parameters) # Check that the parameter value is a non-None string. If not, raise a FAILURE. if not validators.validate_string(parameter_value, False, True): message = "{} parameter has no value.".format( parameter) recommendation = "Specify the {} parameter.".format( parameter) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that optional parameter IfGeoLayerIDExists is either `Replace`, `ReplaceAndWarn`, `Warn`, `Fail`, None. pv_IfGeoLayerIDExists = self.get_parameter_value( parameter_name="IfGeoLayerIDExists", command_parameters=command_parameters) acceptable_values = ["Replace", "ReplaceAndWarn", "Warn", "Fail"] if not validators.validate_string_in_list(pv_IfGeoLayerIDExists, acceptable_values, none_allowed=True, empty_string_allowed=True, ignore_case=True): message = "IfGeoLayerIDExists parameter value ({}) is not recognized.".format( pv_IfGeoLayerIDExists) recommendation = "Specify one of the acceptable values ({}) for the IfGeoLayerIDExists parameter.".format( acceptable_values) warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) else: # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)
def check_command_parameters(self, command_parameters): """ Check the command parameters for validity. Args: command_parameters: the dictionary of command parameters to check (key:string_value) Returns: None. Raises: ValueError if any parameters are invalid or do not have a valid value. The command status messages for initialization are populated with validation messages. """ warning = "" # Check that parameter TableID is a non-empty, non-None string. pv_TableID = self.get_parameter_value( parameter_name='TableID', command_parameters=command_parameters) if not validators.validate_string(pv_TableID, False, False): message = "TableID parameter has no value." recommendation = "Specify the TableID parameter to indicate the Table to write." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter OutputFile is a non-empty, non-None string. pv_OutputFile = self.get_parameter_value( parameter_name='OutputFile', command_parameters=command_parameters) if not validators.validate_string(pv_OutputFile, False, False): message = "OutputFile parameter has no value." recommendation = "Specify the OutputFile parameter (relative or absolute pathname) to indicate the " \ "location and name of the output Excel file." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check that parameter WriteIndexColumn is a valid Boolean value or None. pv_WriteIndexColumn = self.get_parameter_value( parameter_name='WriteIndexColumn', command_parameters=command_parameters) if not validators.validate_bool(pv_WriteIndexColumn, True, False): message = "WriteIndexColumn parameter is not a valid Boolean value." recommendation = "Specify a valid Boolean value for the WriteIndexColumn parameter." warning += "\n" + message self.command_status.add_to_log( CommandPhaseType.INITIALIZATION, CommandLogRecord(CommandStatusType.FAILURE, message, recommendation)) # Check for unrecognized parameters. # This returns a message that can be appended to the warning, which if non-empty triggers an exception below. warning = command_util.validate_command_parameter_names(self, warning) # If any warnings were generated, throw an exception. if len(warning) > 0: self.logger.warning(warning) raise ValueError(warning) # Refresh the phase severity self.command_status.refresh_phase_severity( CommandPhaseType.INITIALIZATION, CommandStatusType.SUCCESS)