text: #!/usr/bin/python
  # -*- coding: utf-8 -*-
  
  # Copyright: (c) 2021, Anvitha Jain (@anvitha-jain) <anvjain@cisco.com>
  # GNU General Public License v3.0+ (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
  
  from __future__ import absolute_import, division, print_function
  __metaclass__ = type
  
  ANSIBLE_METADATA = {'metadata_version': '1.1',
                      'status': ['preview'],
                      'supported_by': 'community'}
  
  DOCUMENTATION = r'''
  ---
  module: mso_schema_template_clone
  short_description: Clone templates
  description:
  - Clone templates on Cisco ACI Multi-Site.
  - Clones only template objects and not site objects.
  - This module can only be used on versions of MSO that are 3.3 or greater.
  author:
  - Anvitha Jain (@anvitha-jain)
  options:
    source_schema:
      description:
      - The name of the source_schema.
      type: str
    destination_schema:
      description:
      - The name of the destination_schema.
      type: str
    destination_tenant:
      description:
      - The name of the destination_schema.
      type: str
    source_template_name:
      description:
      - The name of the source template.
      type: str
    destination_template_name:
      description:
      - The name of the destination template.
      type: str
    destination_template_display_name:
      description:
      - The display name of the destination template.
      type: str
    state:
      description:
      - Use C(clone) for adding.
      type: str
      choices: [ clone ]
      default: clone
  seealso:
  - module: cisco.mso.mso_schema
  - module: cisco.mso.mso_schema_clone
  extends_documentation_fragment: cisco.mso.modules
  '''
  
  EXAMPLES = r'''
  - name: Clone template in the same schema
    cisco.mso.mso_schema_template_clone:
      host: mso_host
      username: admin
      password: SomeSecretPassword
      source_schema: Schema1
      destination_schema: Schema1
      destination_tenant: ansible_test
      source_template_name: Template1
      destination_template_name: Template1_clone
      destination_template_display_name: Template1_clone
      state: clone
    delegate_to: localhost
  
  - name: Clone template to different schema
    cisco.mso.mso_schema_template_clone:
      host: mso_host
      username: admin
      password: SomeSecretPassword
      source_schema: Schema1
      destination_schema: Schema2
      destination_tenant: ansible_test
      source_template_name: Template2
      destination_template_name: Cloned_template_1
      destination_template_display_name: Cloned_template_1
      state: clone
    delegate_to: localhost
  
  - name: Clone template in the same schema but different tenant attached
    cisco.mso.mso_schema_template_clone:
      host: mso_host
      username: admin
      password: SomeSecretPassword
      source_schema: Schema1
      destination_schema: Schema1
      destination_tenant: common
      source_template_name: Template1_clone
      destination_template_name: Template1_clone_2
      state: clone
    delegate_to: localhost
  '''
  
  RETURN = r'''
  '''
  
  from ansible.module_utils.basic import AnsibleModule
  from ansible_collections.cisco.mso.plugins.module_utils.mso import MSOModule, mso_argument_spec
  
  
  def main():
      argument_spec = mso_argument_spec()
      argument_spec.update(
          source_schema=dict(type='str'),
          destination_schema=dict(type='str'),
          destination_tenant=dict(type='str'),
          source_template_name=dict(type='str'),
          destination_template_name=dict(type='str'),
          destination_template_display_name=dict(type='str'),
          state=dict(type='str', default='clone', choices=['clone']),
      )
  
      module = AnsibleModule(
          argument_spec=argument_spec,
          supports_check_mode=True,
          required_if=[
              ['state', 'clone', ['destination_schema', 'destination_tenant']],
          ],
      )
  
      source_schema = module.params.get('source_schema')
      destination_schema = module.params.get('destination_schema')
      destination_tenant = module.params.get('destination_tenant')
      source_template_name = module.params.get('source_template_name')
      destination_template_name = module.params.get('destination_template_name')
      destination_template_display_name = module.params.get('destination_template_display_name')
      state = module.params.get('state')
  
      mso = MSOModule(module)
  
      destination_schema_id = None
  
      # Get source schema id and destination schema id
      schema_summary = mso.query_objs('schemas/list-identity', key='schemas')
  
      for schema in schema_summary:
          if schema.get('displayName') == source_schema:
              source_schema_id = schema.get('id')
          if schema.get('displayName') == destination_schema:
              destination_schema_id = schema.get('id')
              destination_schema = None
              break
      if destination_schema_id is None:
          mso.fail_json(msg="Schema with the name '{0}' does not exist.".format(destination_schema))
  
      # Get destination tenant id
      destination_tenant_id = mso.lookup_tenant(destination_tenant)
  
      path = 'schemas/cloneTemplates'
  
      if state == 'clone':
          if destination_template_display_name is None:
              destination_template_display_name = destination_template_name
  
          payload = dict(
              destTenantId=destination_tenant_id,
              destSchemaId=destination_schema_id,
              destSchemaName=destination_schema,
              templatesToBeCloned=[
                  dict(
                      schemaId=source_schema_id,
                      templateName=source_template_name,
                      destTemplateName=destination_template_name,
                      destTempDisplayName=destination_template_display_name,
                  )
              ],
          )
  
          mso.sanitize(payload, collate=True)
  
          mso.previous = {}
  
          if not mso.existing:
              if module.check_mode:
                  mso.existing = {}
              else:
                  mso.existing = mso.request(path, method='POST', data=mso.sent)
  
      mso.exit_json()
  
  
  if __name__ == "__main__":
      main()
  