How to use

CmsRelationType

in

org.opencms.relations

/**
 * Returns all relation types for relations defined in the content.<p>
 * 
 * @return a list of {@link CmsRelationType} objects
 */
public static List getAllDefinedInContent() {
  return filterDefinedInContent(getAll());
}

/**
 * Returns an extended filter with internal type restriction.<p>
 * 
 * @return an extended filter with internal type restriction
 */
public CmsRelationFilter filterInternal() {
  CmsRelationFilter filter = (CmsRelationFilter)this.clone();
  if (filter.m_types.isEmpty()) {
    filter.m_types.addAll(CmsRelationType.getAllInternal());
  } else {
    filter.m_types = new HashSet(CmsRelationType.filterInternal(filter.m_types));
  }
  return filter;
}

/**
 * Returns all relation types for relations that are not defined in the content.<p>
 * 
 * @return a list of {@link CmsRelationType} objects
 */
public static List getAllNotDefinedInContent() {
  return filterNotDefinedInContent(getAll());
}

/**
 * Returns all weak relation types.<p>
 *
 * @return a list of {@link CmsRelationType} objects
 */
public static List<CmsRelationType> getAllWeak() {
  return filterWeak(getAll());
}

/**
 * Returns all strong relation types.<p>
 * 
 * @return a list of {@link CmsRelationType} objects
 */
public static List getAllStrong() {
  return filterStrong(getAll());
}

/**
 * Returns a localized name for the given relation type.<p>
 *
 * @param locale the locale
 *
 * @return a localized name
 */
public String getLocalizedName(Locale locale) {
  return getLocalizedName(Messages.get().getBundle(locale));
}

/**
 * Adds a new relation to the given resource.<p>
 * 
 * @param dbc the database context
 * @param resource the resource to add the relation to
 * @param target the target of the relation
 * @param type the type of the relation
 * @param importCase if importing relations
 * 
 * @throws CmsException if something goes wrong
 */
public void addRelationToResource(
  CmsDbContext dbc,
  CmsResource resource,
  CmsResource target,
  CmsRelationType type,
  boolean importCase) throws CmsException {
  if (type.isDefinedInContent()) {
    throw new CmsIllegalArgumentException(Messages.get().container(
      Messages.ERR_ADD_RELATION_IN_CONTENT_3,
      dbc.removeSiteRoot(resource.getRootPath()),
      dbc.removeSiteRoot(target.getRootPath()),
      type.getLocalizedName(dbc.getRequestContext().getLocale())));
  }
  CmsRelation relation = new CmsRelation(resource, target, type);
  m_vfsDriver.createRelation(dbc, dbc.currentProject().getUuid(), relation);
  if (!importCase) {
    setDateLastModified(dbc, resource, System.currentTimeMillis());
  }
}

/**
 * Returns an extended filter with not defined in content type restriction.<p>
 * 
 * @return an extended filter with not defined in content type restriction
 */
public CmsRelationFilter filterNotDefinedInContent() {
  CmsRelationFilter filter = (CmsRelationFilter)this.clone();
  if (filter.m_types.isEmpty()) {
    filter.m_types.addAll(CmsRelationType.getAllNotDefinedInContent());
  } else {
    filter.m_types = new HashSet(CmsRelationType.filterNotDefinedInContent(filter.m_types));
  }
  return filter;
}

/**
 * Returns an extended filter with weak type restriction.<p>
 * 
 * @return an extended filter with weak type restriction
 */
public CmsRelationFilter filterWeak() {
  CmsRelationFilter filter = (CmsRelationFilter)this.clone();
  if (filter.m_types.isEmpty()) {
    filter.m_types.addAll(CmsRelationType.getAllWeak());
  } else {
    filter.m_types = new HashSet(CmsRelationType.filterWeak(filter.m_types));
  }
  return filter;
}

/**
 * Returns an extended filter with user defined type restriction.<p>
 *
 * @return an extended filter with user defined type restriction
 */
public CmsRelationFilter filterUserDefined() {
  CmsRelationFilter filter = (CmsRelationFilter)clone();
  if (filter.m_types.isEmpty()) {
    filter.m_types.addAll(CmsRelationType.getAllUserDefined());
  } else {
    filter.m_types = new HashSet<CmsRelationType>(CmsRelationType.filterUserDefined(filter.m_types));
  }
  return filter;
}

/**
 * Returns an extended filter with defined in content type restriction.<p>
 *
 * @return an extended filter with defined in content type restriction
 */
public CmsRelationFilter filterDefinedInContent() {
  CmsRelationFilter filter = (CmsRelationFilter)clone();
  if (filter.m_types.isEmpty()) {
    filter.m_types.addAll(CmsRelationType.getAllDefinedInContent());
  } else {
    filter.m_types = new HashSet<CmsRelationType>(CmsRelationType.filterDefinedInContent(filter.m_types));
  }
  return filter;
}

/**
 * Returns an extended filter with strong type restriction.<p>
 *
 * @return an extended filter with strong type restriction
 */
public CmsRelationFilter filterStrong() {
  CmsRelationFilter filter = (CmsRelationFilter)clone();
  if (filter.m_types.isEmpty()) {
    filter.m_types.addAll(CmsRelationType.getAllStrong());
  } else {
    filter.m_types = new HashSet<CmsRelationType>(CmsRelationType.filterStrong(filter.m_types));
  }
  return filter;
}

/**
 * Gets a relation type by name.<p>
 *
 * @param typeName the relation type name
 *
 * @return the relation type with the matching name
 */
protected static CmsRelationType getRelationType(String typeName) {
  for (CmsRelationType relType : CmsRelationType.getAll()) {
    if (relType.getName().equalsIgnoreCase(typeName)) {
      return relType;
    }
  }
  return null;
}

/**
 * Adds a new relation type from the XML configuration to the list of user defined relation types.<p>
 *
 * @param name the name of the relation type
 * @param type the type of the relation type, weak or strong
 *
 * @return the new created relation type instance
 *
 * @throws CmsConfigurationException in case the resource manager configuration is already initialized
 */
public CmsRelationType addRelationType(String name, String type) throws CmsConfigurationException {
  // check if new relation types can still be added
  if (m_frozen) {
    throw new CmsConfigurationException(Messages.get().container(Messages.ERR_NO_CONFIG_AFTER_STARTUP_0));
  }
  CmsRelationType relationType = new CmsRelationType(m_configuredRelationTypes.size(), name, type);
  m_configuredRelationTypes.add(relationType);
  return relationType;
}

addTypeInternal(relationshipType);
for (CmsRelationType relType : CmsRelationType.getAll()) {
  createRelationshipType(relType);

/**
 * Returns a localized name for the given relation type.<p>
 * 
 * @param locale the locale
 * 
 * @return a localized name
 */
public String getLocalizedName(Locale locale) {
  return getLocalizedName(Messages.get().getBundle(locale));
}

throws CmsException {
  if (type.isDefinedInContent()) {
    throw new CmsIllegalArgumentException(
      Messages.get().container(
        dbc.removeSiteRoot(resource.getRootPath()),
        dbc.removeSiteRoot(target.getRootPath()),
        type.getLocalizedName(dbc.getRequestContext().getLocale())));

/**
 * Returns all weak relation types.<p>
 * 
 * @return a list of {@link CmsRelationType} objects
 */
public static List getAllWeak() {
  return filterWeak(getAll());
}

/**
 * Returns all strong relation types.<p>
 *
 * @return a list of {@link CmsRelationType} objects
 */
public static List<CmsRelationType> getAllStrong() {
  return filterStrong(getAll());
}

/**
 * Returns an extended filter with not defined in content type restriction.<p>
 *
 * @return an extended filter with not defined in content type restriction
 */
public CmsRelationFilter filterNotDefinedInContent() {
  CmsRelationFilter filter = (CmsRelationFilter)clone();
  if (filter.m_types.isEmpty()) {
    filter.m_types.addAll(CmsRelationType.getAllNotDefinedInContent());
  } else {
    filter.m_types = new HashSet<CmsRelationType>(CmsRelationType.filterNotDefinedInContent(filter.m_types));
  }
  return filter;
}