text: #
  # Copyright (c) 2008-2015 Citrix Systems, Inc.
  #
  #   Licensed under the Apache License, Version 2.0 (the "License")
  #   you may not use this file except in compliance with the License.
  #   You may obtain a copy of the License at
  #
  #       http://www.apache.org/licenses/LICENSE-2.0
  #
  #  Unless required by applicable law or agreed to in writing, software
  #   distributed under the License is distributed on an "AS IS" BASIS,
  #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  #   See the License for the specific language governing permissions and
  #   limitations under the License.
  #
  
  from nitro.resource.base.base_resource import base_resource
  from nitro.resource.base.base_resource import base_response
  from nitro.service.options import options
  from nitro.exception.nitro_exception import nitro_exception
  
  from nitro.util.nitro_util import nitro_util
  
  class vpnvserver_responderpolicy_binding(base_resource) :
      """Binding class showing the responderpolicy that can be bound to vpnvserver."""
      def __init__(self) :
          self._policy = ""
          self._priority = 0
          self._gotopriorityexpression = ""
          self._name = ""
          self._secondary = False
          self._groupextraction = False
          self._bindpoint = ""
          self.___count = 0
  
      @property
      def priority(self) :
          """The priority, if any, of the VPN virtual server policy."""
          try :
              return self._priority
          except Exception as e:
              raise e
  
      @priority.setter
      def priority(self, priority) :
          """The priority, if any, of the VPN virtual server policy.
  
          :param priority: 
  
          """
          try :
              self._priority = priority
          except Exception as e:
              raise e
  
      @property
      def gotopriorityexpression(self) :
          """Next priority expression."""
          try :
              return self._gotopriorityexpression
          except Exception as e:
              raise e
  
      @gotopriorityexpression.setter
      def gotopriorityexpression(self, gotopriorityexpression) :
          """Next priority expression.
  
          :param gotopriorityexpression: 
  
          """
          try :
              self._gotopriorityexpression = gotopriorityexpression
          except Exception as e:
              raise e
  
      @property
      def policy(self) :
          """The name of the policy, if any, bound to the VPN virtual server."""
          try :
              return self._policy
          except Exception as e:
              raise e
  
      @policy.setter
      def policy(self, policy) :
          """The name of the policy, if any, bound to the VPN virtual server.
  
          :param policy: 
  
          """
          try :
              self._policy = policy
          except Exception as e:
              raise e
  
      @property
      def groupextraction(self) :
          """Binds the authentication policy to a tertiary chain which will be used only for group extraction.  The user will not authenticate against this server, and this will only be called if primary and/or secondary authentication has succeeded."""
          try :
              return self._groupextraction
          except Exception as e:
              raise e
  
      @groupextraction.setter
      def groupextraction(self, groupextraction) :
          """Binds the authentication policy to a tertiary chain which will be used only for group extraction.  The user will not authenticate against this server, and this will only be called if primary and/or secondary authentication has succeeded.
  
          :param groupextraction: 
  
          """
          try :
              self._groupextraction = groupextraction
          except Exception as e:
              raise e
  
      @property
      def name(self) :
          """Name of the virtual server.<br/>Minimum length =  1."""
          try :
              return self._name
          except Exception as e:
              raise e
  
      @name.setter
      def name(self, name) :
          """Name of the virtual server.<br/>Minimum length =  1
  
          :param name: 
  
          """
          try :
              self._name = name
          except Exception as e:
              raise e
  
      @property
      def secondary(self) :
          """Binds the authentication policy as the secondary policy to use in a two-factor configuration. A user must then authenticate not only via a primary authentication method but also via a secondary authentication method. User groups are aggregated across both. The user name must be exactly the same for both authentication methods, but they can require different passwords."""
          try :
              return self._secondary
          except Exception as e:
              raise e
  
      @secondary.setter
      def secondary(self, secondary) :
          """Binds the authentication policy as the secondary policy to use in a two-factor configuration. A user must then authenticate not only via a primary authentication method but also via a secondary authentication method. User groups are aggregated across both. The user name must be exactly the same for both authentication methods, but they can require different passwords.
  
          :param secondary: 
  
          """
          try :
              self._secondary = secondary
          except Exception as e:
              raise e
  
      @property
      def bindpoint(self) :
          """Bind point to which to bind the policy. Applies only to rewrite and cache policies. If you do not set this parameter, the policy is bound to REQ_DEFAULT or RES_DEFAULT, depending on whether the policy rule is a response-time or a request-time expression."""
          try :
              return self._bindpoint
          except Exception as e:
              raise e
  
      @bindpoint.setter
      def bindpoint(self, bindpoint) :
          """Bind point to which to bind the policy. Applies only to rewrite and cache policies. If you do not set this parameter, the policy is bound to REQ_DEFAULT or RES_DEFAULT, depending on whether the policy rule is a response-time or a request-time expression.
  
          :param bindpoint: 
  
          """
          try :
              self._bindpoint = bindpoint
          except Exception as e:
              raise e
  
      def _get_nitro_response(self, service, response) :
          """converts nitro response into object and returns the object array in case of get request.
  
          :param service: 
          :param response: 
  
          """
          try :
              result = service.payload_formatter.string_to_resource(vpnvserver_responderpolicy_binding_response, response, self.__class__.__name__)
              if(result.errorcode != 0) :
                  if (result.errorcode == 444) :
                      service.clear_session(self)
                  if result.severity :
                      if (result.severity == "ERROR") :
                          raise nitro_exception(result.errorcode, str(result.message), str(result.severity))
                  else :
                      raise nitro_exception(result.errorcode, str(result.message), str(result.severity))
              return result.vpnvserver_responderpolicy_binding
          except Exception as e :
              raise e
  
      def _get_object_name(self) :
          """Returns the value of object identifier argument"""
          try :
              if self.name is not None :
                  return str(self.name)
              return None
          except Exception as e :
              raise e
  
  
  
      @classmethod
      def add(cls, client, resource) :
          """
  
          :param client: 
          :param resource: 
  
          """
          try :
              if resource and type(resource) is not list :
                  updateresource = vpnvserver_responderpolicy_binding()
                  updateresource.name = resource.name
                  updateresource.policy = resource.policy
                  updateresource.priority = resource.priority
                  updateresource.secondary = resource.secondary
                  updateresource.groupextraction = resource.groupextraction
                  updateresource.gotopriorityexpression = resource.gotopriorityexpression
                  updateresource.bindpoint = resource.bindpoint
                  return updateresource.update_resource(client)
              else :
                  if resource and len(resource) > 0 :
                      updateresources = [vpnvserver_responderpolicy_binding() for _ in range(len(resource))]
                      for i in range(len(resource)) :
                          updateresources[i].name = resource[i].name
                          updateresources[i].policy = resource[i].policy
                          updateresources[i].priority = resource[i].priority
                          updateresources[i].secondary = resource[i].secondary
                          updateresources[i].groupextraction = resource[i].groupextraction
                          updateresources[i].gotopriorityexpression = resource[i].gotopriorityexpression
                          updateresources[i].bindpoint = resource[i].bindpoint
                  return cls.update_bulk_request(client, updateresources)
          except Exception as e :
              raise e
  
      @classmethod
      def delete(cls, client, resource) :
          """
  
          :param client: 
          :param resource: 
  
          """
          try :
              if resource and type(resource) is not list :
                  deleteresource = vpnvserver_responderpolicy_binding()
                  deleteresource.name = resource.name
                  deleteresource.policy = resource.policy
                  deleteresource.secondary = resource.secondary
                  deleteresource.groupextraction = resource.groupextraction
                  deleteresource.bindpoint = resource.bindpoint
                  return deleteresource.delete_resource(client)
              else :
                  if resource and len(resource) > 0 :
                      deleteresources = [vpnvserver_responderpolicy_binding() for _ in range(len(resource))]
                      for i in range(len(resource)) :
                          deleteresources[i].name = resource[i].name
                          deleteresources[i].policy = resource[i].policy
                          deleteresources[i].secondary = resource[i].secondary
                          deleteresources[i].groupextraction = resource[i].groupextraction
                          deleteresources[i].bindpoint = resource[i].bindpoint
                  return cls.delete_bulk_request(client, deleteresources)
          except Exception as e :
              raise e
  
      @classmethod
      def get(cls, service, name) :
          """Use this API to fetch vpnvserver_responderpolicy_binding resources.
  
          :param service: 
          :param name: 
  
          """
          try :
              obj = vpnvserver_responderpolicy_binding()
              obj.name = name
              response = obj.get_resources(service)
              return response
          except Exception as e:
              raise e
  
      @classmethod
      def get_filtered(cls, service, name, filter_) :
          """Use this API to fetch filtered set of vpnvserver_responderpolicy_binding resources.
          Filter string should be in JSON format.eg: "port:80,servicetype:HTTP".
  
          :param service: 
          :param name: 
          :param filter_: 
  
          """
          try :
              obj = vpnvserver_responderpolicy_binding()
              obj.name = name
              option_ = options()
              option_.filter = filter_
              response = obj.getfiltered(service, option_)
              return response
          except Exception as e:
              raise e
  
      @classmethod
      def count(cls, service, name) :
          """Use this API to count vpnvserver_responderpolicy_binding resources configued on NetScaler.
  
          :param service: 
          :param name: 
  
          """
          try :
              obj = vpnvserver_responderpolicy_binding()
              obj.name = name
              option_ = options()
              option_.count = True
              response = obj.get_resources(service, option_)
              if response :
                  return response[0].__dict__['___count']
              return 0
          except Exception as e:
              raise e
  
      @classmethod
      def count_filtered(cls, service, name, filter_) :
          """Use this API to count the filtered set of vpnvserver_responderpolicy_binding resources.
          Filter string should be in JSON format.eg: "port:80,servicetype:HTTP".
  
          :param service: 
          :param name: 
          :param filter_: 
  
          """
          try :
              obj = vpnvserver_responderpolicy_binding()
              obj.name = name
              option_ = options()
              option_.count = True
              option_.filter = filter_
              response = obj.getfiltered(service, option_)
              if response :
                  return response[0].__dict__['___count']
              return 0
          except Exception as e:
              raise e
  
      class Staaddresstype:
          """ """
          IPV4 = "IPV4"
          IPV6 = "IPV6"
  
      class Bindpoint:
          """ """
          REQUEST = "REQUEST"
          RESPONSE = "RESPONSE"
          ICA_REQUEST = "ICA_REQUEST"
          OTHERTCP_REQUEST = "OTHERTCP_REQUEST"
  
  class vpnvserver_responderpolicy_binding_response(base_response) :
      """ """
      def __init__(self, length=1) :
          self.vpnvserver_responderpolicy_binding = []
          self.errorcode = 0
          self.message = ""
          self.severity = ""
          self.sessionid = ""
          self.vpnvserver_responderpolicy_binding = [vpnvserver_responderpolicy_binding() for _ in range(length)]
  
  