text: #!/usr/bin/python
  from __future__ import absolute_import, division, print_function
  # Copyright 2019-2020 Fortinet, Inc.
  #
  # This program is free software: you can redistribute it and/or modify
  # it under the terms of the GNU General Public License as published by
  # the Free Software Foundation, either version 3 of the License, or
  # (at your option) any later version.
  #
  # This program is distributed in the hope that it will be useful,
  # but WITHOUT ANY WARRANTY; without even the implied warranty of
  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  # GNU General Public License for more details.
  #
  # You should have received a copy of the GNU General Public License
  # along with this program.  If not, see <https://www.gnu.org/licenses/>.
  
  __metaclass__ = type
  
  ANSIBLE_METADATA = {'status': ['preview'],
                      'supported_by': 'community',
                      'metadata_version': '1.1'}
  
  DOCUMENTATION = '''
  ---
  module: fmgr_antivirus_profile_obj
  short_description: Configure AntiVirus profiles.
  description:
      - This module is able to configure a FortiManager device by allowing the
        user to [ clone delete get set update ] the following apis.
      - /pm/config/adom/{adom}/obj/antivirus/profile/{profile}
      - /pm/config/global/obj/antivirus/profile/{profile}
      - Examples include all parameters and values need to be adjusted to data sources before usage.
  
  version_added: "2.10"
  author:
      - Frank Shen (@fshen01)
      - Link Zheng (@zhengl)
  notes:
      - There are only three top-level parameters where 'method' is always required
        while other two 'params' and 'url_params' can be optional
      - Due to the complexity of fortimanager api schema, the validation is done
        out of Ansible native parameter validation procedure.
      - The syntax of OPTIONS doen not comply with the standard Ansible argument
        specification, but with the structure of fortimanager API schema, we need
        a trivial transformation when we are filling the ansible playbook
  options:
      loose_validation:
          description:
            - Do parameter validation in a loose way
          type: bool
          required: false
      workspace_locking_adom:
          description:
            - the adom name to lock in case FortiManager running in workspace mode
            - it can be global or any other custom adom names
          required: false
          type: str
      workspace_locking_timeout:
          description:
            - the maximum time in seconds to wait for other user to release the workspace lock
          required: false
          type: int
          default: 300
      method:
          description:
            - The method in request
          required: true
          type: str
          choices:
            - clone
            - delete
            - get
            - set
            - update
      params:
          description:
            - The parameters for each method
            - See full parameters list in https://ansible-galaxy-fortimanager-docs.readthedocs.io/en/latest
          type: list
          required: false
      url_params:
          description:
            - The parameters for each API request URL
            - Also see full URL parameters in https://ansible-galaxy-fortimanager-docs.readthedocs.io/en/latest
          required: false
          type: dict
  
  '''
  
  EXAMPLES = '''
   - hosts: fortimanager-inventory
     collections:
       - fortinet.fortimanager
     connection: httpapi
     vars:
        ansible_httpapi_use_ssl: True
        ansible_httpapi_validate_certs: False
        ansible_httpapi_port: 443
     tasks:
  
      - name: REQUESTING /PM/CONFIG/OBJ/ANTIVIRUS/PROFILE/{PROFILE}
        fmgr_antivirus_profile_obj:
           loose_validation: False
           workspace_locking_adom: <value in [global, custom adom]>
           workspace_locking_timeout: 300
           method: <value in [clone, set, update]>
           url_params:
              adom: <value in [none, global, custom dom]>
              profile: <value of string>
           params:
              -
                 data:
                    analytics-bl-filetype: <value of string>
                    analytics-db: <value in [disable, enable]>
                    analytics-max-upload: <value of integer>
                    analytics-wl-filetype: <value of string>
                    av-block-log: <value in [disable, enable]>
                    av-virus-log: <value in [disable, enable]>
                    comment: <value of string>
                    extended-log: <value in [disable, enable]>
                    ftgd-analytics: <value in [disable, suspicious, everything]>
                    inspection-mode: <value in [proxy, flow-based]>
                    mobile-malware-db: <value in [disable, enable]>
                    name: <value of string>
                    replacemsg-group: <value of string>
                    scan-mode: <value in [quick, full]>
  
      - name: REQUESTING /PM/CONFIG/OBJ/ANTIVIRUS/PROFILE/{PROFILE}
        fmgr_antivirus_profile_obj:
           loose_validation: False
           workspace_locking_adom: <value in [global, custom adom]>
           workspace_locking_timeout: 300
           method: <value in [get]>
           url_params:
              adom: <value in [none, global, custom dom]>
              profile: <value of string>
           params:
              -
                 option: <value in [object member, chksum, datasrc]>
  
  '''
  
  RETURN = '''
  url:
      description: The full url requested
      returned: always
      type: str
      sample: /sys/login/user
  status:
      description: The status of api request
      returned: always
      type: dict
  data:
      description: The payload returned in the request
      type: dict
      returned: always
  
  '''
  from ansible.module_utils.basic import AnsibleModule
  from ansible.module_utils.connection import Connection
  from ansible_collections.fortinet.fortimanager.plugins.module_utils.common import FAIL_SOCKET_MSG
  from ansible_collections.fortinet.fortimanager.plugins.module_utils.common import DEFAULT_RESULT_OBJ
  from ansible_collections.fortinet.fortimanager.plugins.module_utils.common import FMGRCommon
  from ansible_collections.fortinet.fortimanager.plugins.module_utils.common import FMGBaseException
  from ansible_collections.fortinet.fortimanager.plugins.module_utils.fortimanager import FortiManagerHandler
  
  
  def main():
      jrpc_urls = [
          '/pm/config/adom/{adom}/obj/antivirus/profile/{profile}',
          '/pm/config/global/obj/antivirus/profile/{profile}'
      ]
  
      url_schema = [
          {
              'name': 'adom',
              'type': 'string'
          },
          {
              'name': 'profile',
              'type': 'string'
          }
      ]
  
      body_schema = {
          'schema_objects': {
              'object0': [
                  {
                      'name': 'data',
                      'type': 'dict',
                      'dict': {
                          'analytics-bl-filetype': {
                              'type': 'string'
                          },
                          'analytics-db': {
                              'type': 'string',
                              'enum': [
                                  'disable',
                                  'enable'
                              ]
                          },
                          'analytics-max-upload': {
                              'type': 'integer'
                          },
                          'analytics-wl-filetype': {
                              'type': 'string'
                          },
                          'av-block-log': {
                              'type': 'string',
                              'enum': [
                                  'disable',
                                  'enable'
                              ]
                          },
                          'av-virus-log': {
                              'type': 'string',
                              'enum': [
                                  'disable',
                                  'enable'
                              ]
                          },
                          'comment': {
                              'type': 'string'
                          },
                          'extended-log': {
                              'type': 'string',
                              'enum': [
                                  'disable',
                                  'enable'
                              ]
                          },
                          'ftgd-analytics': {
                              'type': 'string',
                              'enum': [
                                  'disable',
                                  'suspicious',
                                  'everything'
                              ]
                          },
                          'inspection-mode': {
                              'type': 'string',
                              'enum': [
                                  'proxy',
                                  'flow-based'
                              ]
                          },
                          'mobile-malware-db': {
                              'type': 'string',
                              'enum': [
                                  'disable',
                                  'enable'
                              ]
                          },
                          'name': {
                              'type': 'string'
                          },
                          'replacemsg-group': {
                              'type': 'string'
                          },
                          'scan-mode': {
                              'type': 'string',
                              'enum': [
                                  'quick',
                                  'full'
                              ]
                          }
                      },
                      'api_tag': 0
                  },
                  {
                      'type': 'string',
                      'name': 'url',
                      'api_tag': 0
                  }
              ],
              'object1': [
                  {
                      'type': 'string',
                      'name': 'url',
                      'api_tag': 0
                  }
              ],
              'object2': [
                  {
                      'name': 'option',
                      'type': 'dict',
                      'dict': {
                          'type': 'string',
                          'enum': [
                              'object member',
                              'chksum',
                              'datasrc'
                          ]
                      },
                      'api_tag': 0
                  },
                  {
                      'type': 'string',
                      'name': 'url',
                      'api_tag': 0
                  }
              ]
          },
          'method_mapping': {
              'clone': 'object0',
              'delete': 'object1',
              'get': 'object2',
              'set': 'object0',
              'update': 'object0'
          }
      }
  
      module_arg_spec = {
          'loose_validation': {
              'type': 'bool',
              'required': False,
              'default': False
          },
          'workspace_locking_adom': {
              'type': 'str',
              'required': False
          },
          'workspace_locking_timeout': {
              'type': 'int',
              'required': False,
              'default': 300
          },
          'params': {
              'type': 'list',
              'required': False
          },
          'method': {
              'type': 'str',
              'required': True,
              'choices': [
                  'clone',
                  'delete',
                  'get',
                  'set',
                  'update'
              ]
          },
          'url_params': {
              'type': 'dict',
              'required': False
          }
      }
      module = AnsibleModule(argument_spec=module_arg_spec,
                             supports_check_mode=False)
      method = module.params['method']
      loose_validation = module.params['loose_validation']
  
      fmgr = None
      payload = None
      response = DEFAULT_RESULT_OBJ
  
      if module._socket_path:
          connection = Connection(module._socket_path)
          tools = FMGRCommon()
          if loose_validation is False:
              tools.validate_module_params(module, body_schema)
          tools.validate_module_url_params(module, jrpc_urls, url_schema)
          full_url = tools.get_full_url_path(module, jrpc_urls)
          payload = tools.get_full_payload(module, full_url)
          fmgr = FortiManagerHandler(connection, module)
          fmgr.tools = tools
      else:
          module.fail_json(**FAIL_SOCKET_MSG)
  
      try:
          response = fmgr._conn.send_request(method, payload)
          fmgr.govern_response(module=module, results=response,
                               msg='Operation Finished',
                               ansible_facts=fmgr.construct_ansible_facts(response, module.params, module.params))
      except Exception as e:
          raise FMGBaseException(e)
  
      module.exit_json(meta=response[1])
  
  
  if __name__ == '__main__':
      main()
  