@Override public List<Group> findByMetadataField(Context context, String searchValue, MetadataField metadataField) throws SQLException { StringBuilder queryBuilder = new StringBuilder(); String groupTableName = "g"; queryBuilder.append("SELECT ").append(groupTableName).append(" FROM Group as ").append(groupTableName); addMetadataLeftJoin(queryBuilder, groupTableName, Collections.singletonList(metadataField)); addMetadataValueWhereQuery(queryBuilder, Collections.singletonList(metadataField), "=", null); Query query = createQuery(context, queryBuilder.toString()); query.setParameter(metadataField.toString(), metadataField.getID()); query.setParameter("queryParam", searchValue); return list(query); }
@Override public Iterator<Item> findBySubmitter(Context context, EPerson eperson, MetadataField metadataField, int limit) throws SQLException { StringBuilder query = new StringBuilder(); query.append("SELECT item FROM Item as item "); addMetadataLeftJoin(query, Item.class.getSimpleName().toLowerCase(), Collections.singletonList(metadataField)); query.append(" WHERE item.inArchive = :in_archive"); query.append(" AND item.submitter =:submitter"); //submissions should sort in reverse by date by default addMetadataSortQuery(query, Collections.singletonList(metadataField), null, Collections.singletonList("desc")); Query hibernateQuery = createQuery(context, query.toString()); hibernateQuery.setParameter(metadataField.toString(), metadataField.getID()); hibernateQuery.setParameter("in_archive", true); hibernateQuery.setParameter("submitter", eperson); hibernateQuery.setMaxResults(limit); return iterate(hibernateQuery); }
@Override public int hashCode() { int hash = 7; hash = 47 * hash + getID(); hash = 47 * hash + getMetadataSchema().getID(); return hash; }
@Override public Iterator<Item> findBySubmitter(Context context, EPerson eperson, MetadataField metadataField, int limit) throws SQLException { StringBuilder query = new StringBuilder(); query.append("SELECT item FROM Item as item "); addMetadataLeftJoin(query, Item.class.getSimpleName().toLowerCase(), Collections.singletonList(metadataField)); query.append(" WHERE item.inArchive = :in_archive"); query.append(" AND item.submitter =:submitter"); //submissions should sort in reverse by date by default addMetadataSortQuery(query, Collections.singletonList(metadataField), null, Collections.singletonList("desc")); Query hibernateQuery = createQuery(context, query.toString()); hibernateQuery.setParameter(metadataField.toString(), metadataField.getID()); hibernateQuery.setParameter("in_archive", true); hibernateQuery.setParameter("submitter", eperson); hibernateQuery.setMaxResults(limit); return iterate(hibernateQuery); }
@Override public Iterator<Item> detectDuplicateItems(Context context, MetadataField field, String value, int maxDistance) throws SQLException { // Postgresql's implementation of Levenshtein supports 255 characters only for performance reasons. Query query = createQuery(context, "SELECT item FROM Item item " + "JOIN item.metadata field " + "WITH field.metadataField.id = :field_id " + "WHERE levenshtein_less_equal(lower(substring(:value, 0, 254)), lower(substring(field.value, 0, 254)), :distance) <= :distance " + "ORDER BY levenshtein_less_equal(lower(substring(:value, 0, 254)), lower(substring(field.value, 0, 254)), :distance), text_value ASC nulls last" // "WHERE levenshtein(:value, field.value) <= :distance" ); query.setParameter("field_id", field.getID()); query.setParameter("value", value); query.setParameter("distance", maxDistance); return iterate(query); } }
@Override public List<Community> findAllNoParent(Context context, MetadataField sortField) throws SQLException { StringBuilder queryBuilder = new StringBuilder(); queryBuilder.append("SELECT community FROM Community as community "); addMetadataLeftJoin(queryBuilder, Community.class.getSimpleName().toLowerCase(), Arrays.asList(sortField)); addMetadataValueWhereQuery(queryBuilder, Collections.EMPTY_LIST, null, " community.parentCommunities IS EMPTY"); addMetadataSortQuery(queryBuilder, Arrays.asList(sortField), Collections.EMPTY_LIST); Query query = createQuery(context, queryBuilder.toString()); query.setParameter(sortField.toString(), sortField.getID()); query.setHint("org.hibernate.cacheable", Boolean.TRUE); return findMany(context, query); }
@Override public List<Collection> findAll(Context context, MetadataField order, Integer limit, Integer offset) throws SQLException { StringBuilder query = new StringBuilder(); query.append("SELECT ").append(Collection.class.getSimpleName()).append(" FROM Collection as ") .append(Collection.class.getSimpleName()).append(" "); addMetadataLeftJoin(query, Collection.class.getSimpleName(), Arrays.asList(order)); addMetadataSortQuery(query, Arrays.asList(order), null); Query hibernateQuery = createQuery(context, query.toString()); if (offset != null) { hibernateQuery.setFirstResult(offset); } if (limit != null) { hibernateQuery.setMaxResults(limit); } hibernateQuery.setParameter(order.toString(), order.getID()); return list(hibernateQuery); }
@Override public List<Community> findAll(Context context, MetadataField sortField, Integer limit, Integer offset) throws SQLException { StringBuilder queryBuilder = new StringBuilder(); queryBuilder.append("SELECT ").append(Community.class.getSimpleName()).append(" FROM Community as ") .append(Community.class.getSimpleName()).append(" "); addMetadataLeftJoin(queryBuilder, Community.class.getSimpleName(), Arrays.asList(sortField)); addMetadataSortQuery(queryBuilder, Arrays.asList(sortField), Collections.EMPTY_LIST); Query query = createQuery(context, queryBuilder.toString()); if (offset != null) { query.setFirstResult(offset); } if (limit != null) { query.setMaxResults(limit); } query.setParameter(sortField.toString(), sortField.getID()); return list(query); }
@Override public List<MetadataValue> findByField(Context context, MetadataField metadataField) throws SQLException { CriteriaBuilder criteriaBuilder = getCriteriaBuilder(context); CriteriaQuery criteriaQuery = getCriteriaQuery(criteriaBuilder, MetadataValue.class); Root<MetadataValue> metadataValueRoot = criteriaQuery.from(MetadataValue.class); Join<MetadataValue, MetadataField> join = metadataValueRoot.join("metadataField"); criteriaQuery.select(metadataValueRoot); criteriaQuery.where(criteriaBuilder.equal(join.get(MetadataField_.id), metadataField.getID())); return list(context, criteriaQuery, false, MetadataValue.class, -1, -1); }
@Override public List<Group> findAll(Context context, List<MetadataField> sortMetadataFields, int pageSize, int offset) throws SQLException { StringBuilder queryBuilder = new StringBuilder(); String groupTableName = "g"; queryBuilder.append("SELECT ").append(groupTableName).append(" FROM Group as ").append(groupTableName); addMetadataLeftJoin(queryBuilder, groupTableName, sortMetadataFields); addMetadataSortQuery(queryBuilder, sortMetadataFields, null); Query query = createQuery(context, queryBuilder.toString()); if (pageSize > 0) { query.setMaxResults(pageSize); } if (offset > 0) { query.setFirstResult(offset); } for (MetadataField sortField : sortMetadataFields) { query.setParameter(sortField.toString(), sortField.getID()); } return list(query); }
/** * Return <code>true</code> if <code>other</code> is the same MetadataField * as this object, <code>false</code> otherwise * * @param obj object to compare to * @return <code>true</code> if object passed in represents the same * MetadataField as this object */ @Override public boolean equals(Object obj) { if (obj == null) { return false; } Class<?> objClass = HibernateProxyHelper.getClassWithoutInitializingProxy(obj); if (getClass() != objClass) { return false; } final MetadataField other = (MetadataField) obj; if (this.getID() != other.getID()) { return false; } if (!getMetadataSchema().equals(other.getMetadataSchema())) { return false; } return true; }
query.setParameter(metadataField.toString(), metadataField.getID());
private void setup(org.dspace.content.MetadataSchema schema, org.dspace.content.MetadataField field, String expand, Context context) throws SQLException { List<String> expandFields = new ArrayList<String>(); if (expand != null) { expandFields = Arrays.asList(expand.split(",")); } StringBuilder sb = new StringBuilder(); sb.append(schema.getName()); sb.append("."); sb.append(field.getElement()); if (field.getQualifier() != null) { sb.append("."); sb.append(field.getQualifier()); } this.setName(sb.toString()); this.setFieldId(field.getID()); this.setElement(field.getElement()); this.setQualifier(field.getQualifier()); this.setDescription(field.getScopeNote()); if (expandFields.contains("parentSchema") || expandFields.contains("all")) { this.addExpand("parentSchema"); parentSchema = new MetadataSchema(schema, "", context); } }
@Override public void delete(Context context, MetadataField metadataField) throws SQLException, AuthorizeException { // Check authorisation: Only admins may create DC types if (!authorizeService.isAdmin(context)) { throw new AuthorizeException( "Only administrators may modify the metadata registry"); } // Check for existing usages of this field List<MetadataValue> values = null; try { values = metadataValueService.findByField(context, metadataField); } catch (IOException io) { // ignore } // Only remove this field if it is NOT in use (as we don't want to bulk delete metadata values) if (CollectionUtils.isEmpty(values)) { metadataFieldDAO.delete(context, metadataField); } else { throw new IllegalStateException("Metadata field " + metadataField .toString() + " cannot be deleted as it is currently used by one or more objects."); } log.info(LogManager.getHeader(context, "delete_metadata_field", "metadata_field_id=" + metadataField.getID())); }
System.exit(1); System.out.println("Loooking for field " + metadataField.toString() + " (" + metadataField.getID() + ").");
@Override public int getFieldID(Context context, String field) throws InvalidMetadataFieldException, SQLException { if (metadataFieldCache == null) { metadataFieldCache = new MetadataFieldCache(); } if (!metadataFieldCache.hasField(field)) { String[] pieces = field.split(Pattern.quote(".")); if (pieces.length > 1) { String schema = pieces[0]; String element = pieces[1]; String qualifier = null; if (pieces.length > 2) { qualifier = pieces[2]; } MetadataField metadataField = metadataFieldService.findByElement(context, schema, element, qualifier); if (null != metadataField) { metadataFieldCache.add(field, metadataField.getID()); } else { throw new InvalidMetadataFieldException(); } } else { throw new InvalidMetadataFieldException(); } } return metadataFieldCache.getField(field); } }
@Override public void update(Context context, MetadataField metadataField) throws SQLException, AuthorizeException, NonUniqueMetadataException, IOException { // Check authorisation: Only admins may update the metadata registry if (!authorizeService.isAdmin(context)) { throw new AuthorizeException( "Only administrators may modiffy the Dublin Core registry"); } // Ensure the element and qualifier are unique within a given schema. if (hasElement(context, metadataField.getID(), metadataField.getMetadataSchema(), metadataField.getElement(), metadataField.getQualifier())) { throw new NonUniqueMetadataException( "Please make " + metadataField.getMetadataSchema().getName() + "." + metadataField.getElement() + "." + metadataField.getQualifier()); } metadataFieldDAO.save(context, metadataField); log.info(LogManager.getHeader(context, "update_metadatafieldregistry", "metadata_field_id=" + metadataField.getID() + "element=" + metadataField .getElement() + "qualifier=" + metadataField.getQualifier())); }
@Override public MetadataField create(Context context, MetadataSchema metadataSchema, String element, String qualifier, String scopeNote) throws AuthorizeException, SQLException, NonUniqueMetadataException { // Check authorisation: Only admins may create DC types if (!authorizeService.isAdmin(context)) { throw new AuthorizeException( "Only administrators may modify the metadata registry"); } // Ensure the element and qualifier are unique within a given schema. if (hasElement(context, -1, metadataSchema, element, qualifier)) { throw new NonUniqueMetadataException("Please make " + element + "." + qualifier + " unique within schema #" + metadataSchema.getID()); } // Create a table row and update it with the values MetadataField metadataField = new MetadataField(); metadataField.setElement(element); metadataField.setQualifier(qualifier); metadataField.setScopeNote(scopeNote); metadataField.setMetadataSchema(metadataSchema); metadataField = metadataFieldDAO.create(context, metadataField); metadataFieldDAO.save(context, metadataField); log.info(LogManager.getHeader(context, "create_metadata_field", "metadata_field_id=" + metadataField.getID())); return metadataField; }