Ignore path related fields as they're never returned by the server
        and are only added to entity to be able to use proper path.
517831
def read(self, entity=None, attrs=None, ignore=None, params=None):
        
        if entity is None:
            entity = type(self)(
                self._server_config,
                **{self._parent_type: self._parent_id}
            )
        if ignore is None:
            ignore = set()
        for field_name in self._path_fields:
            ignore.add(field_name)
        return super(Parameter, self).read(entity, attrs, ignore, params)
524721
public Set<String> getNotAttributeFields() {
		Set<String> notAttributeFields = new HashSet<>();
		for (ResourceField relationshipField : relationshipFields) {
			notAttributeFields.add(relationshipField.getJsonName());
		}
		notAttributeFields.add(idField.getJsonName());
		if (metaField != null) {
			notAttributeFields.add(metaField.getUnderlyingName());
		}
		if (linksField != null) {
			notAttributeFields.add(linksField.getUnderlyingName());
		}
		return notAttributeFields;
	}
1210488
protected List<FileMeta> handleGetEntityMetaFiles(Class<? extends FileEntity> type, Integer entityId) {
        Map<String, String> uriVariables = restUriVariablesFactory.getUriVariablesForGetEntityMetaFiles(
                BullhornEntityInfo.getTypesRestEntityName(type), entityId);
        String url = restUrlFactory.assembleGetEntityMetaFilesUrl();
        String jsonString = this.performGetRequest(url, String.class, uriVariables);
        EntityMetaFiles<? extends FileMeta> entityMetaFiles = restJsonConverter.jsonToEntityDoNotUnwrapRoot(jsonString,
                StandardEntityMetaFiles.class);
        if (entityMetaFiles == null || entityMetaFiles.getFileMetas() == null) {
            return Collections.emptyList();
        }
        return (List<FileMeta>) entityMetaFiles.getFileMetas();
    }
382762
function(field, value) {
        if (field in this) {
            if (this.get(field) !== value && !([
                null,
                undefined
            ].indexOf(this.get(field)) > -1 && [
                null,
                undefined
            ].indexOf(value) > -1)) {
                if (CRUD.EntityManager.entities[this.getType()].autoSerialize.indexOf(field) > -1) {
                    if (JSON.stringify(this.get(field)) != JSON.stringify(value)) {
                        this.__dirtyValues__[field] = value;
                    }
                } else {
                    this.__dirtyValues__[field] = value;
                }
            }
        } else {
            CRUD.log('Could not find field \'' + field + '\' in \'' + this.getType() + '\' (for set)');
        }
    }
1339273
def _should_ignore(self, path):
        
        for ignore in self.options.ignores:
            if fnmatch.fnmatch(path, ignore):
                return True
        return False
1141403
function _removeMappedFields(mapping, path) {
    if (typeof path === 'number') {
        delete mapping[path];
        return mapping;
    }
    var keys = path.split(_separator);
    if (keys.length <= 1) {
        delete mapping[path];
        return mapping;
    }
    return _removeMappedFields(
        mapping[path[0]],
        keys
            .slice(1)
            .join(_separator)
    );
}
1364760
def _from_rest_ignore(model, props):
    

    fields = model.all_fields

    for prop in props.keys():
        if prop not in fields:
            del props[prop]
171899
private String evaluateFieldPath(MappedFieldMetaData fieldMetaData) {
        ResourcePaths.ResourcePath path = fieldMetaData.getPath();
        return (path.hasPlaceholders() ? path.resolve(this.placeholderVariableResolvers::resolve) : path).getPath();
    }
604901
def _ignore_keys(endpoint_props):
    '''
    
    '''
    return dict(
        (prop_name, prop_val)
        for prop_name, prop_val in six.iteritems(endpoint_props)
        if prop_name not in _DO_NOT_COMPARE_FIELDS
    )
115211
function filterValidPaths(type, paths, version) {
		var valid = [];
		
		version = env.schema[version] || env.schema['5.1'];
		
		_.forEach(paths, function(p) {
			if (env.schema.hasProperty(version, type, p)) {
				valid.push(p);
			}
		});
		
		return valid;
	}
746074
void removeNonExistingSystemEntityTypes() {
    // get all system entities
    List<EntityType> removedSystemEntityMetas =
        dataService
            .findAll(ENTITY_TYPE_META_DATA, EntityType.class)
            .filter(EntityTypeUtils::isSystemEntity)
            .filter(this::isNotExists)
            .collect(toList());

    dataService.getMeta().deleteEntityType(removedSystemEntityMetas);
    removedSystemEntityMetas.forEach(
        entityType ->
            mutableAclClassService.deleteAclClass(EntityIdentityUtils.toType(entityType)));
  }
403730
def _clear_ignore(endpoint_props):
    '''
    
    '''
    return dict(
        (prop_name, prop_val)
        for prop_name, prop_val in six.iteritems(endpoint_props)
        if prop_name not in _DO_NOT_COMPARE_FIELDS and prop_val is not None
    )
1134489
def check_params_and_object_consistent(path_params, object)
      errors = {}
      path_params.each do |(k, v)|
        if object.key?(k) && object[k] != v
          errors[k] = [I18n.t('app.errors.inconsistent_uri_and_entity',
            :key => k,
            :uri_value => v,
            :entity_value => object[k],
            :default => "Inconsistent data given in the request URI and request entity: %{key} was specified as %{uri_value} in the URI but %{entity_value} in the entity",
          )]
        end
      end
      if errors.any?
        halt_error(422, errors)
      end
    end
692354
@Override
    protected void ignoreDuplicatedChangeItemRequests() {
        if (getItems() != null) {
            final List<RESTCSRelatedNodeCollectionItemV1> items = new ArrayList<RESTCSRelatedNodeCollectionItemV1>(getItems());
        
            /* on the second loop, remove any items that are marked for both add and remove is separate items */
            for (int i = 0; i < items.size(); ++i) {
                final RESTCSRelatedNodeCollectionItemV1 child1 = items.get(i);
                final RESTCSRelatedNodeV1 childItem1 = child1.getItem();

                // New Entity so ignore it
                if (childItem1.getId() == null) continue;
                
                /* at this point we know that either add1 or remove1 will be true, but not both */
                final boolean add1 = child1.getState().equals(ADD_STATE);
                final boolean remove1 = child1.getState().equals(REMOVE_STATE);
                final boolean update1 = child1.getState().equals(UPDATE_STATE);
                
                /* Loop a second time, looking for duplicates */
                for (int j = i + 1; j < items.size(); ++j) {
                    final RESTCSRelatedNodeCollectionItemV1 child2 = items.get(j);
                    final RESTCSRelatedNodeV1 childItem2 = child2.getItem();

                    // New Entity so ignore it
                    if (childItem2.getId() == null) continue;

                    final boolean relationshipIdEqual = childItem1.getRelationshipId() == null && childItem2.getRelationshipId() == null
                            || childItem1.getRelationshipId() != null && childItem1.getRelationshipId().equals(
                            childItem2.getRelationshipId());
                    
                    /* Check the RelatedNode objects for their value as well as their IDs to ensure duplicates are removed*/
                    if (childItem1.getId().equals(childItem2.getId()) && relationshipIdEqual) {
                        final boolean add2 = child2.getState().equals(ADD_STATE);
                        final boolean remove2 = child2.getState().equals(REMOVE_STATE);
                        final boolean update2 = child2.getState().equals(UPDATE_STATE);
                        
                        /* Do some checks on values that could be null */
                        final boolean typeEqual = childItem1.getRelationshipType() == null && childItem2.getRelationshipType() == null ||
                                childItem1.getRelationshipType() != null && childItem1.getRelationshipType().equals(
                                childItem2.getRelationshipType());
                        
                        /* check for double add, double remove, double update, and remove one instance */
                        if ((add1 && add2) || (remove1 && remove2) || (update1 && update2)) {
                            /* 
                             * If the relationship types are equal then we only need to remove one item. If
                             * the are different then both should be removed. 
                             */
                            if (typeEqual) {
                                getItems().remove(child1);
                            } else {
                                getItems().remove(child1);
                                getItems().remove(child2);
                            }
                        }
                        
                        /* check for double add, double remove, add and remove, remove and add */
                        if ((add1 && remove2) || (remove1 && add2) || (update1 && remove2) || (update2 && remove1) || (update1 && add2)
                                || (update2 && add1)) {
                            getItems().remove(child1);
                            getItems().remove(child2);
                        }
                    }
                }
            }
        }
    }
1261172
FieldScopeLogic ignoringFields(Iterable<Integer> fieldNumbers) {
    if (isEmpty(fieldNumbers)) {
      return this;
    }
    return and(
        this,
        new NegationFieldScopeLogic(new FieldNumbersLogic(fieldNumbers, /* isRecursive = */ true)));
  }
344117
public function clearPagePaths()
    {
        $em = Database::connection()->getEntityManager();
        $paths = $this->getPagePaths();
        foreach ($paths as $path) {
            $em->remove($path);
        }
        $em->flush();
    }
1267087
@Override
    public ResponseToRoom ignore(String... params) {
        excludedVars.addAll(Arrays.asList(params));
        return this;
    }