# coding: utf-8


"""
IGNORE:
    Nutanix Security APIs

    Manage security features, such as encryption, certificates, or platform hardening.  # noqa: E501

    OpenAPI spec version: 4.0.1
    
    Generated by: https://github.com/swagger-api/swagger-codegen.git
IGNORE
"""
import pprint
import json
import ast
import re  # noqa: F401

import six
from pathlib import Path
from ntnx_security_py_client.models.common.v1.response.ApiLink import ApiLink  # noqa: F401,E501
from ntnx_security_py_client.models.common.v1.response.ExternalizableAbstractModel import ExternalizableAbstractModel  # noqa: F401,E501
from ntnx_security_py_client.models.security.v4.report.Severity import Severity  # noqa: F401,E501
from ntnx_security_py_client.models.security.v4.report.StigStatus import StigStatus  # noqa: F401,E501

class Stig(ExternalizableAbstractModel):

    """Contains information of a specific STIG.

    :param title: (:attr:`title`) Title of the STIG control.
    :type title: 
     max=199 chars
    
    :param rule_id: (:attr:`rule_id`) Rule ID of the STIG control.
    :type rule_id: 
    
    
    :param stig_version: (:attr:`stig_version`) STIG ID of the control.
    :type stig_version: 
    
    
    :param identifiers: (:attr:`identifiers`) Additional identifiers used to describe this control.
    :type identifiers: 
    
    
    :param affected_clusters: (:attr:`affected_clusters`) List of clusters that failed the STIG control.
    :type affected_clusters: 
    
    
    :param severity: (:attr:`severity`) 
    :type severity: 
    
    
    :param status: (:attr:`status`) 
    :type status: 
    
    
    :param comments: (:attr:`comments`) The comments to explain why a STIG rule applies or does not apply to the cluster.
    :type comments: 
     max=499 chars
    
    :param fix_text: (:attr:`fix_text`) The command/steps to fix the STIG rule failure.
    :type fix_text: 
     max=499 chars
    
    :param benchmark_id: (:attr:`benchmark_id`) Benchmark ID of the STIG rules.
    :type benchmark_id: 
    
    

    """
    """
    IGNORE:
    Attributes:
      swagger_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    IGNORE
    """  # noqa: E501
    swagger_types = {
        'title': 'str',
        'rule_id': 'str',
        'stig_version': 'str',
        'identifiers': 'list[str]',
        'affected_clusters': 'list[str]',
        'severity': 'security.v4.report.Severity',
        'status': 'security.v4.report.StigStatus',
        'comments': 'str',
        'fix_text': 'str',
        'benchmark_id': 'str',
        'ext_id': 'str',
        'links': 'list[common.v1.response.ApiLink]',
        'tenant_id': 'str',
        '_reserved': 'dict(str, object)',
        '_object_type': 'str',
        '_unknown_fields': 'dict(str, object)',
    }

    attribute_map = {
        'title': 'title',
        'rule_id': 'ruleId',
        'stig_version': 'stigVersion',
        'identifiers': 'identifiers',
        'affected_clusters': 'affectedClusters',
        'severity': 'severity',
        'status': 'status',
        'comments': 'comments',
        'fix_text': 'fixText',
        'benchmark_id': 'benchmarkId',
        'ext_id': 'extId',
        'links': 'links',
        'tenant_id': 'tenantId',
        '_reserved': '$reserved',
        '_object_type': '$objectType',
        '_unknown_fields': '$unknownFields',
    }



    def __init__(self, title=None, rule_id=None, stig_version=None, identifiers=None, affected_clusters=None, severity=None, status=None, comments=None, fix_text=None, benchmark_id=None, ext_id=None, links=None, tenant_id=None, *args, **kwargs):  # noqa: E501
        ExternalizableAbstractModel.__init__(self, ext_id, links, tenant_id, *args, **kwargs)
        self.__title = None
        self.__rule_id = None
        self.__stig_version = None
        self.__identifiers = None
        self.__affected_clusters = None
        self.__severity = None
        self.__status = None
        self.__comments = None
        self.__fix_text = None
        self.__benchmark_id = None
        self.discriminator = None
        if title is not None:
            self.__title = title
        if rule_id is not None:
            self.__rule_id = rule_id
        if stig_version is not None:
            self.__stig_version = stig_version
        if identifiers is not None:
            self.__identifiers = identifiers
        if affected_clusters is not None:
            self.__affected_clusters = affected_clusters
        if severity is not None:
            self.__severity = severity
        if status is not None:
            self.__status = status
        if comments is not None:
            self.__comments = comments
        if fix_text is not None:
            self.__fix_text = fix_text
        if benchmark_id is not None:
            self.__benchmark_id = benchmark_id

    def _initialize_object_type(self):
        return 'security.v4.report.Stig'

    def _initialize_object_version(self):
        return 'v4.r0'


    @property
    def title(self):
        """
        Title of the STIG control.

        :type:
                :class:`~str`
        """  # noqa: E501
        return self.__title

    @title.setter
    def title(self, title):
        if title is not None and len(title) > 199:
            raise ValueError("Invalid value for `title`, length must be less than or equal to `199`")  # noqa: E501

        self.__title = title

    @property
    def rule_id(self):
        """
        Rule ID of the STIG control.

        :type:
                :class:`~str`
        """  # noqa: E501
        return self.__rule_id

    @rule_id.setter
    def rule_id(self, rule_id):
        if rule_id is not None and not re.search('^SV-\\d{6}r\\d{6}_rule$', rule_id):  # noqa: E501
            raise ValueError(r"Invalid value for `rule_id`, must be a follow pattern or equal to `/^SV-\\d{6}r\\d{6}_rule$/`")  # noqa: E501

        self.__rule_id = rule_id

    @property
    def stig_version(self):
        """
        STIG ID of the control.

        :type:
                :class:`~str`
        """  # noqa: E501
        return self.__stig_version

    @stig_version.setter
    def stig_version(self, stig_version):
        if stig_version is not None and not re.search('^RHEL-\\d{2}-\\d{6}$', stig_version):  # noqa: E501
            raise ValueError(r"Invalid value for `stig_version`, must be a follow pattern or equal to `/^RHEL-\\d{2}-\\d{6}$/`")  # noqa: E501

        self.__stig_version = stig_version

    @property
    def identifiers(self):
        """
        Additional identifiers used to describe this control.

        :type:
            list[ :class:`~str` ]
        """  # noqa: E501
        return self.__identifiers

    @identifiers.setter
    def identifiers(self, identifiers):

        self.__identifiers = identifiers

    @property
    def affected_clusters(self):
        """
        List of clusters that failed the STIG control.

        :type:
            list[ :class:`~str` ]
        """  # noqa: E501
        return self.__affected_clusters

    @affected_clusters.setter
    def affected_clusters(self, affected_clusters):

        self.__affected_clusters = affected_clusters

    @property
    def severity(self):
        """
        

        :type:
            :class:`~ntnx_security_py_client.models.security.v4.report.Severity`
        """  # noqa: E501
        return self.__severity

    @severity.setter
    def severity(self, severity):

        self.__severity = severity

    @property
    def status(self):
        """
        

        :type:
            :class:`~ntnx_security_py_client.models.security.v4.report.StigStatus`
        """  # noqa: E501
        return self.__status

    @status.setter
    def status(self, status):

        self.__status = status

    @property
    def comments(self):
        """
        The comments to explain why a STIG rule applies or does not apply to the cluster.

        :type:
                :class:`~str`
        """  # noqa: E501
        return self.__comments

    @comments.setter
    def comments(self, comments):
        if comments is not None and len(comments) > 499:
            raise ValueError("Invalid value for `comments`, length must be less than or equal to `499`")  # noqa: E501

        self.__comments = comments

    @property
    def fix_text(self):
        """
        The command/steps to fix the STIG rule failure.

        :type:
                :class:`~str`
        """  # noqa: E501
        return self.__fix_text

    @fix_text.setter
    def fix_text(self, fix_text):
        if fix_text is not None and len(fix_text) > 499:
            raise ValueError("Invalid value for `fix_text`, length must be less than or equal to `499`")  # noqa: E501

        self.__fix_text = fix_text

    @property
    def benchmark_id(self):
        """
        Benchmark ID of the STIG rules.

        :type:
                :class:`~str`
        """  # noqa: E501
        return self.__benchmark_id

    @benchmark_id.setter
    def benchmark_id(self, benchmark_id):
        if benchmark_id is not None and not re.search('^RHEL_\\d+_V\\d+R\\d+$', benchmark_id):  # noqa: E501
            raise ValueError(r"Invalid value for `benchmark_id`, must be a follow pattern or equal to `/^RHEL_\\d+_V\\d+R\\d+$/`")  # noqa: E501

        self.__benchmark_id = benchmark_id

    def _to_dict(self, sanitize):
        """Returns the model properties as a dict. Omits None properties based on the provided "sanitize" parameter.

        :param sanitize: A flag to omit None properties if set to True
        :type sanitize: bool
        """

        result = {}
        for attr, attr_type in six.iteritems(self.swagger_types):

            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x._to_dict(sanitize) if hasattr(x, "_to_dict") else x,
                    value
                ))
            elif hasattr(value, "_to_dict"):
                result[attr] = value._to_dict(sanitize)
            elif isinstance(value, Path):
                result[attr] = str(value)
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1]._to_dict(sanitize)) if hasattr(item[1], "_to_dict")
                    else (
                        (item[0], str(item[1])) if item[0] == 'path' and '$objectType' in value and value['$objectType'] == 'pathlib.Path'
                        else item
                    ),
                    six.iteritems(value)
                ))
            else:
                if sanitize:
                    if value is not None:
                        result[attr] = value
                else:
                    result[attr] = value
        if issubclass(Stig, dict):
            for key, value in six.iteritems(self):
                result[key] = value

        return result

    def to_dict(self):
        """Returns the model properties as a dictionary"""
        return self._to_dict(False)

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self._to_dict(True))

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, Stig):
            return False

        return self.__dict__ == other.__dict__

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        return not self == other

