def _update_entity(self, resource, desired_entity, current_entity, params, foreman_spec):
    """
    Update a given entity with given properties if any diverge

    :param resource: Plural name of the api resource to manipulate
    :type resource: str
    :param desired_entity: Desired properties of the entity
    :type desired_entity: dict
    :param current_entity: Current properties of the entity
    :type current_entity: dict
    :param params: Lookup parameters (i.e. parent_id for nested entities)
    :type params: dict, optional
    :param foreman_spec: Description of the entity structure
    :type foreman_spec: dict

    :return: The new current state of the entity
    :rtype: dict
    """
    payload = {}
    desired_entity = _flatten_entity(desired_entity, foreman_spec)
    current_flat_entity = _flatten_entity(current_entity, foreman_spec)
    for key, value in desired_entity.items():
        foreman_type = foreman_spec[key].get('type', 'str')
        new_value = value
        old_value = current_flat_entity.get(key)
        # String comparison needs extra care in face of unicode
        if foreman_type == 'str':
            old_value = to_native(old_value)
            new_value = to_native(new_value)
        # ideally the type check would happen via foreman_spec.elements
        # however this is not set for flattened entries and setting it
        # confuses _flatten_entity
        elif foreman_type == 'list' and value and isinstance(value[0], dict):
            # special handling for parameters created by ParametersMixin
            # they are defined as a list of dict, but the dicts should be really handled like
            # entities, which means we only want to update the user-provided details
            if key.endswith('_parameters_attributes'):
                for new_param in new_value:
                    old_param = next((x for x in old_value if x['name'] == new_param['name']), None)
                    if old_param is not None:
                        for pop_key in set(old_param.keys()) - set(new_param.keys()):
                            old_param.pop(pop_key)
            if 'name' in value[0]:
                sort_key = 'name'
            else:
                sort_key = list(value[0].keys())[0]
            new_value = sorted(new_value, key=operator.itemgetter(sort_key))
            old_value = sorted(old_value, key=operator.itemgetter(sort_key))
        if new_value != old_value:
            payload[key] = value
    # workaround to ensure LCE and CV are always sent together, even if only one changed
    # using the values from the existing entity, so the user doesn't need to pass it in their playbook
    if resource == 'hosts':
        if 'content_view_id' in payload and 'lifecycle_environment_id' not in payload:
            payload['lifecycle_environment_id'] = current_flat_entity['lifecycle_environment_id']
        elif 'lifecycle_environment_id' in payload and 'content_view_id' not in payload:
            payload['content_view_id'] = current_flat_entity['content_view_id']
    if self._validate_supported_payload(resource, 'update', payload):
        self.set_changed()
        payload['id'] = current_flat_entity['id']
        if not self.check_mode:
            return self.foremanapi.update(resource, payload, params)
        else:
            # In check_mode we emulate the server updating the entity
            fake_entity = current_flat_entity.copy()
            fake_entity.update(payload)
            return fake_entity
    else:
        # Nothing needs changing
        return current_entity

def ensure_entity(self, resource, desired_entity, current_entity, params=None, state=None, foreman_spec=None):
    """
    Ensure that a given entity has a certain state

    :param resource: Plural name of the api resource to manipulate
    :type resource: str
    :param desired_entity: Desired properties of the entity
    :type desired_entity: dict
    :param current_entity: Current properties of the entity or None if nonexistent
    :type current_entity: Union[dict,None]
    :param params: Lookup parameters (i.e. parent_id for nested entities)
    :type params: dict, optional
    :param state: Desired state of the entity (optionally taken from the module)
    :type state: str, optional
    :param foreman_spec: Description of the entity structure (optionally taken from module)
    :type foreman_spec: dict, optional

    :return: The new current state of the entity
    :rtype: Union[dict,None]
    """
    if state is None:
        state = self.state
    if foreman_spec is None:
        foreman_spec = self.foreman_spec
    else:
        foreman_spec, _dummy = _foreman_spec_helper(foreman_spec)

    updated_entity = None

    self.record_before(resource, _flatten_entity(current_entity, foreman_spec))

    if state == 'present_with_defaults':
        if current_entity is None:
            updated_entity = self._create_entity(resource, desired_entity, params, foreman_spec)
    elif state == 'present':
        if current_entity is None:
            updated_entity = self._create_entity(resource, desired_entity, params, foreman_spec)
        else:
            updated_entity = self._update_entity(resource, desired_entity, current_entity, params, foreman_spec)
    elif state == 'copied':
        if current_entity is not None:
            updated_entity = self._copy_entity(resource, desired_entity, current_entity, params)
    elif state == 'reverted':
        if current_entity is not None:
            updated_entity = self._revert_entity(resource, current_entity, params)
    elif state == 'new_snapshot':
        updated_entity = self._create_entity(resource, desired_entity, params, foreman_spec)
    elif state == 'absent':
        if current_entity is not None:
            updated_entity = self._delete_entity(resource, current_entity, params)
    else:
        self.fail_json(msg='Not a valid state: {0}'.format(state))

    self.record_after(resource, _flatten_entity(updated_entity, foreman_spec))
    self.record_after_full(resource, updated_entity)

    return updated_entity

def check_required_plugins(self):
    missing_plugins = []
    for (plugin, params) in self.required_plugins:
        for param in params:
            if (param in self.foreman_params or param == '*') and not self.has_plugin(plugin):
                if param == '*':
                    param = 'the whole module'
                missing_plugins.append("{0} (for {1})".format(plugin, param))
    if missing_plugins:
        missing_msg = "The server is missing required plugins: {0}.".format(', '.join(missing_plugins))
        self.fail_json(msg=missing_msg)

class HostMixin(ParametersMixin):
    """
    Host Mixin to extend a :class:`ForemanAnsibleModule` (or any subclass) to work with host-related entities (Hosts, Hostgroups).

    This adds many optional parameters that are specific to Hosts and Hostgroups to the module.
    It also includes :class:`ParametersMixin`.
    """

    def __init__(self, **kwargs):
        foreman_spec = dict(
            compute_resource=dict(type='entity'),
            compute_profile=dict(type='entity'),
            domain=dict(type='entity'),
            subnet=dict(type='entity'),
            subnet6=dict(type='entity', resource_type='subnets'),
            root_pass=dict(no_log=True),
            realm=dict(type='entity'),
            architecture=dict(type='entity'),
            operatingsystem=dict(type='entity'),
            medium=dict(aliases=['media'], type='entity'),
            ptable=dict(type='entity'),
            pxe_loader=dict(choices=['PXELinux BIOS', 'PXELinux UEFI', 'Grub UEFI', 'Grub2 BIOS', 'Grub2 ELF',
                                     'Grub2 UEFI', 'Grub2 UEFI SecureBoot', 'Grub2 UEFI HTTP', 'Grub2 UEFI HTTPS',
                                     'Grub2 UEFI HTTPS SecureBoot', 'iPXE Embedded', 'iPXE UEFI HTTP', 'iPXE Chain BIOS', 'iPXE Chain UEFI', 'None']),
            environment=dict(type='entity'),
            puppetclasses=dict(type='entity_list', resolve=False),
            config_groups=dict(type='entity_list'),
            puppet_proxy=dict(type='entity', resource_type='smart_proxies'),
            puppet_ca_proxy=dict(type='entity', resource_type='smart_proxies'),
            openscap_proxy=dict(type='entity', resource_type='smart_proxies'),
            content_source=dict(type='entity', scope=['organization'], resource_type='smart_proxies'),
            lifecycle_environment=dict(type='entity', scope=['organization']),
            kickstart_repository=dict(type='entity', scope=['organization'], optional_scope=['lifecycle_environment', 'content_view'],
                                      resource_type='repositories'),
            content_view=dict(type='entity', scope=['organization'], optional_scope=['lifecycle_environment']),
            activation_keys=dict(no_log=False),
        )
        foreman_spec.update(kwargs.pop('foreman_spec', {}))
        required_plugins = kwargs.pop('required_plugins', []) + [
            ('katello', ['activation_keys', 'content_source', 'lifecycle_environment', 'kickstart_repository', 'content_view']),
            ('openscap', ['openscap_proxy']),
        ]
        mutually_exclusive = kwargs.pop('mutually_exclusive', []) + [['medium', 'kickstart_repository']]
        super(HostMixin, self).__init__(foreman_spec=foreman_spec, required_plugins=required_plugins, mutually_exclusive=mutually_exclusive, **kwargs)

    def run(self, **kwargs):
        entity = self.lookup_entity('entity')

        if not self.desired_absent:
            if 'activation_keys' in self.foreman_params:
                if 'parameters' not in self.foreman_params:
                    parameters = [param for param in (entity or {}).get('parameters', []) if param['name'] != 'kt_activation_keys']
                else:
                    parameters = self.foreman_params['parameters']
                ak_param = {'name': 'kt_activation_keys', 'parameter_type': 'string', 'value': self.foreman_params.pop('activation_keys')}
                self.foreman_params['parameters'] = parameters + [ak_param]
            elif 'parameters' in self.foreman_params and entity is not None:
                current_ak_param = next((param for param in entity.get('parameters') if param['name'] == 'kt_activation_keys'), None)
                desired_ak_param = next((param for param in self.foreman_params['parameters'] if param['name'] == 'kt_activation_keys'), None)
                if current_ak_param and desired_ak_param is None:
                    self.foreman_params['parameters'].append(current_ak_param)

        self.validate_parameters()

        return super(HostMixin, self).run(**kwargs)