git.aero2k.de Git - tmp/jakarta-migration.git/blob

   1 /**\r
   2  *  This document is a part of the source code and related artifacts\r
   3  *  for CollectionSpace, an open source collections management system\r
   4  *  for museums and related institutions:\r
   5 \r
   6  *  http://www.collectionspace.org\r
   7  *  http://wiki.collectionspace.org\r
   8 \r
   9  *  Copyright 2009 University of California at Berkeley\r
  10 \r
  11  *  Licensed under the Educational Community License (ECL), Version 2.0.\r
  12  *  You may not use this file except in compliance with this License.\r
  13 \r
  14  *  You may obtain a copy of the ECL 2.0 License at\r
  15 \r
  16  *  https://source.collectionspace.org/collection-space/LICENSE.txt\r
  17 \r
  18  *  Unless required by applicable law or agreed to in writing, software\r
  19  *  distributed under the License is distributed on an "AS IS" BASIS,\r
  20  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  21  *  See the License for the specific language governing permissions and\r
  22  *  limitations under the License.\r
  23  */\r
  24 package org.collectionspace.services.common.vocabulary;\r
  25 \r
  26 import java.util.ArrayList;\r
  27 import java.util.Collection;\r
  28 import java.util.HashMap;\r
  29 import java.util.Iterator;\r
  30 import java.util.List;\r
  31 import java.util.Map;\r
  32 \r
  33 import org.nuxeo.ecm.core.api.ClientException;\r
  34 import org.nuxeo.ecm.core.api.DocumentModel;\r
  35 import org.nuxeo.ecm.core.api.DocumentModelList;\r
  36 import org.slf4j.Logger;\r
  37 import org.slf4j.LoggerFactory;\r
  38 \r
  39 import org.collectionspace.services.common.ServiceMain;\r
  40 import org.collectionspace.services.common.context.ServiceContext;\r
  41 import org.collectionspace.services.common.authorityref.AuthorityRefDocList;\r
  42 import org.collectionspace.services.common.authorityref.AuthorityRefList;\r
  43 import org.collectionspace.services.common.config.TenantBindingConfigReaderImpl;\r
  44 import org.collectionspace.services.common.context.ServiceBindingUtils;\r
  45 import org.collectionspace.services.common.document.DocumentException;\r
  46 import org.collectionspace.services.common.document.DocumentNotFoundException;\r
  47 import org.collectionspace.services.common.document.DocumentUtils;\r
  48 import org.collectionspace.services.common.document.DocumentWrapper;\r
  49 import org.collectionspace.services.common.repository.RepositoryClient;\r
  50 import org.collectionspace.services.common.service.ServiceBindingType;\r
  51 import org.collectionspace.services.jaxb.AbstractCommonList;\r
  52 import org.collectionspace.services.nuxeo.util.NuxeoUtils;\r
  53 \r
  54 /**\r
  55  * RefNameServiceUtils is a collection of services utilities related to refName usage.\r
  56  *\r
  57  * $LastChangedRevision: $\r
  58  * $LastChangedDate: $\r
  59  */\r
  60 public class RefNameServiceUtils {\r
  61 \r
  62     private final Logger logger = LoggerFactory.getLogger(RefNameServiceUtils.class);\r
  63 \r
  64     public static AuthorityRefDocList getAuthorityRefDocs(ServiceContext ctx,\r
  65             RepositoryClient repoClient,\r
  66             String serviceType,\r
  67             String refName,\r
  68             int pageSize, int pageNum, boolean computeTotal) throws DocumentException, DocumentNotFoundException {\r
  69         AuthorityRefDocList wrapperList = new AuthorityRefDocList();\r
  70         AbstractCommonList commonList = (AbstractCommonList) wrapperList;\r
  71         commonList.setPageNum(pageNum);\r
  72         commonList.setPageSize(pageSize);\r
  73 \r
  74         \r
  75         List<AuthorityRefDocList.AuthorityRefDocItem> list =\r
  76                 wrapperList.getAuthorityRefDocItem();\r
  77         TenantBindingConfigReaderImpl tReader =\r
  78                 ServiceMain.getInstance().getTenantBindingConfigReader();\r
  79         List<ServiceBindingType> servicebindings = tReader.getServiceBindingsByType(ctx.getTenantId(), serviceType);\r
  80         if (servicebindings == null || servicebindings.isEmpty()) {\r
  81             return null;\r
  82         }\r
  83         // Need to escape the quotes in the refName\r
  84         // TODO What if they are already escaped?\r
  85         String escapedRefName = refName.replaceAll("'", "\\\\'");\r
  86 //      String domain = \r
  87 //              tReader.getTenantBinding(ctx.getTenantId()).getRepositoryDomain();\r
  88         ArrayList<String> docTypes = new ArrayList<String>();\r
  89         Map<String, ServiceBindingType> queriedServiceBindings = new HashMap<String, ServiceBindingType>();\r
  90         Map<String, Map<String, String>> authRefFieldsByService = new HashMap<String, Map<String, String>>();\r
  91         StringBuilder whereClause = new StringBuilder();\r
  92         boolean fFirst = true;\r
  93         List<String> authRefFieldPaths = new ArrayList<String>();\r
  94         for (ServiceBindingType sb : servicebindings) {\r
  95                 // Gets the property names for each part, qualified with the part label (which\r
  96                 // is also the table name, the way that the repository works).\r
  97             authRefFieldPaths =\r
  98                     ServiceBindingUtils.getAllPartsPropertyValues(sb,\r
  99                     ServiceBindingUtils.AUTH_REF_PROP, ServiceBindingUtils.QUALIFIED_PROP_NAMES);\r
 100             if (authRefFieldPaths.isEmpty()) {\r
 101                 continue;\r
 102             }\r
 103             String authRefPath = "";\r
 104             String ancestorAuthRefFieldName = "";\r
 105             Map<String, String> authRefFields = new HashMap<String, String>();\r
 106             for (int i = 0; i < authRefFieldPaths.size(); i++) {\r
 107                 // fieldName = DocumentUtils.getDescendantOrAncestor(authRefFields.get(i));\r
 108                 // For simple field values, we just search on the item.\r
 109                 // For simple repeating scalars, we just search the group field \r
 110                 // For repeating complex types, we will need to do more.\r
 111                 authRefPath = authRefFieldPaths.get(i);\r
 112                 ancestorAuthRefFieldName = DocumentUtils.getAncestorAuthRefFieldName(authRefFieldPaths.get(i));\r
 113                 authRefFields.put(authRefPath, ancestorAuthRefFieldName);\r
 114             }\r
 115 \r
 116             String docType = sb.getObject().getName();\r
 117             queriedServiceBindings.put(docType, sb);\r
 118             authRefFieldsByService.put(docType, authRefFields);\r
 119             docTypes.add(docType);\r
 120             Collection<String> fields = authRefFields.values();\r
 121             for (String field : fields) {\r
 122                 // Build up the where clause for each authRef field\r
 123                 if (fFirst) {\r
 124                     fFirst = false;\r
 125                 } else {\r
 126                     whereClause.append(" OR ");\r
 127                 }\r
 128                 //whereClause.append(prefix);\r
 129                 whereClause.append(field);\r
 130                 whereClause.append("='");\r
 131                 whereClause.append(escapedRefName);\r
 132                 whereClause.append("'");\r
 133             }\r
 134         }\r
 135         String whereClauseStr = whereClause.toString(); // for debugging\r
 136         if (fFirst) // found no authRef fields - nothing to query\r
 137         {\r
 138             return wrapperList;\r
 139         }\r
 140         String fullQuery = whereClause.toString(); // for debug\r
 141         // Now we have to issue the search\r
 142         DocumentWrapper<DocumentModelList> docListWrapper = repoClient.findDocs(ctx,\r
 143                 docTypes, whereClause.toString(), pageSize, pageNum, computeTotal);\r
 144         // Now we gather the info for each document into the list and return\r
 145         DocumentModelList docList = docListWrapper.getWrappedObject();\r
 146         // Set num of items in list. this is useful to our testing framework.\r
 147         commonList.setItemsInPage(docList.size());\r
 148         // set the total result size\r
 149         commonList.setTotalItems(docList.totalSize());\r
 150         Iterator<DocumentModel> iter = docList.iterator();\r
 151         while (iter.hasNext()) {\r
 152             DocumentModel docModel = iter.next();\r
 153             AuthorityRefDocList.AuthorityRefDocItem ilistItem = new AuthorityRefDocList.AuthorityRefDocItem();\r
 154             String csid = NuxeoUtils.getCsid(docModel);//NuxeoUtils.extractId(docModel.getPathAsString());\r
 155             String docType = docModel.getDocumentType().getName();\r
 156             ServiceBindingType sb = queriedServiceBindings.get(docType);\r
 157             if (sb == null) {\r
 158                 throw new RuntimeException(\r
 159                         "getAuthorityRefDocs: No Service Binding for docType: " + docType);\r
 160             }\r
 161             String serviceContextPath = "/" + sb.getName().toLowerCase() + "/";\r
 162             // The id and URI are the same on all doctypes\r
 163             ilistItem.setDocId(csid);\r
 164             ilistItem.setUri(serviceContextPath + csid);\r
 165             ilistItem.setDocType(docType);\r
 166             ilistItem.setDocNumber(\r
 167                     ServiceBindingUtils.getMappedFieldInDoc(sb, ServiceBindingUtils.OBJ_NUMBER_PROP, docModel));\r
 168             ilistItem.setDocName(\r
 169                     ServiceBindingUtils.getMappedFieldInDoc(sb, ServiceBindingUtils.OBJ_NAME_PROP, docModel));\r
 170             // Now, we have to loop over the authRefFieldsByService to figure\r
 171             // out which field matched this. Ignore multiple matches.\r
 172             Map<String,String> matchingAuthRefFields = authRefFieldsByService.get(docType);\r
 173             if (matchingAuthRefFields == null || matchingAuthRefFields.isEmpty()) {\r
 174                 throw new RuntimeException(\r
 175                         "getAuthorityRefDocs: internal logic error: can't fetch authRefFields for DocType.");\r
 176             }\r
 177             String authRefAncestorField = "";\r
 178             String authRefDescendantField = "";\r
 179             String sourceField = "";\r
 180             boolean fRefFound = false;\r
 181             // Use this if we go to qualified field names\r
 182             for (String path : matchingAuthRefFields.keySet()) {\r
 183                 try {\r
 184                         // This is the field name we show in the return info\r
 185                     authRefAncestorField = (String) matchingAuthRefFields.get(path);\r
 186                     // This is the qualified field we have to get from the doc model\r
 187                     authRefDescendantField = DocumentUtils.getDescendantOrAncestor(path);\r
 188                     // The ancestor field is part-schema (tablename) qualified\r
 189                     String[] strings = authRefAncestorField.split(":");\r
 190                     if (strings.length != 2) {\r
 191                         throw new RuntimeException(\r
 192                                 "getAuthorityRefDocs: Bad configuration of path to authority reference field.");\r
 193                     }\r
 194                     // strings[0] holds a schema name, such as "intakes_common"\r
 195                     //\r
 196                     // strings[1] holds:\r
 197                     // * The name of an authority reference field, such as "depositor";\r
 198                     //   or\r
 199                     // * The name of an ancestor (e.g. parent, grandparent ...) field,\r
 200                     //   such as "fieldCollectors", of a repeatable authority reference\r
 201                     //   field, such as "fieldCollector".\r
 202                     // TODO - if the value is not simple, or repeating scalar, need a more\r
 203                     // sophisticated fetch. \r
 204                     Object fieldValue = docModel.getProperty(strings[0], strings[1]);\r
 205                     // We cannot be sure why we have this doc, so look for matches\r
 206                     boolean fRefMatches = refNameFoundInField(refName, fieldValue);\r
 207                     if (fRefMatches) {\r
 208                         sourceField = authRefDescendantField;\r
 209                         // Handle multiple fields matching in one Doc. See CSPACE-2863.\r
 210                         if(fRefFound) {\r
 211                                 // We already added ilistItem, so we need to clone that and add again\r
 212                             ilistItem = cloneAuthRefDocItem(ilistItem, sourceField);\r
 213                         } else {\r
 214                                 ilistItem.setSourceField(sourceField);\r
 215                             fRefFound = true;\r
 216                         }\r
 217                         list.add(ilistItem);\r
 218                     }\r
 219 \r
 220                 } catch (ClientException ce) {\r
 221                     throw new RuntimeException(\r
 222                             "getAuthorityRefDocs: Problem fetching: " + sourceField, ce);\r
 223                 }\r
 224             }\r
 225             if (!fRefFound) {\r
 226                 throw new RuntimeException(\r
 227                         "getAuthorityRefDocs: Could not find refname in object:"\r
 228                         + docType + ":" + csid);\r
 229             }\r
 230         }\r
 231         return wrapperList;\r
 232     }\r
 233     \r
 234     private static AuthorityRefDocList.AuthorityRefDocItem cloneAuthRefDocItem(\r
 235                 AuthorityRefDocList.AuthorityRefDocItem ilistItem, String sourceField) {\r
 236         AuthorityRefDocList.AuthorityRefDocItem newlistItem = new AuthorityRefDocList.AuthorityRefDocItem();\r
 237         newlistItem.setDocId(ilistItem.getDocId());\r
 238         newlistItem.setDocName(ilistItem.getDocName());\r
 239         newlistItem.setDocNumber(ilistItem.getDocNumber());\r
 240         newlistItem.setDocType(ilistItem.getDocType());\r
 241         newlistItem.setUri(ilistItem.getUri());\r
 242         newlistItem.setSourceField(sourceField);\r
 243         return newlistItem;\r
 244     }\r
 245 \r
 246     /*\r
 247      * Identifies whether the refName was found in the supplied field.\r
 248      *\r
 249      * Only works for:\r
 250      * * Scalar fields\r
 251      * * Repeatable scalar fields (aka multi-valued fields)\r
 252      *\r
 253      * Does not work for:\r
 254      * * Structured fields (complexTypes)\r
 255      * * Repeatable structured fields (repeatable complexTypes)\r
 256      */\r
 257     private static boolean refNameFoundInField(String refName, Object fieldValue) {\r
 258 \r
 259         boolean result = false;\r
 260         if (fieldValue instanceof List) {\r
 261             List<String> fieldValueList = (List) fieldValue;\r
 262             for (String listItemValue : fieldValueList) {\r
 263                 if (refName.equalsIgnoreCase(listItemValue)) {\r
 264                     result = true;\r
 265                     break;\r
 266                 }\r
 267 \r
 268             }\r
 269         } else if (fieldValue instanceof String){\r
 270             if (refName.equalsIgnoreCase((String)fieldValue)) {\r
 271                 result = true;\r
 272             }\r
 273         }\r
 274         return result;\r
 275     }\r
 276 }\r
 277 \r