예제 #1
0
 /**
  * @param parameter
  * @return
  * @throws DynamicExtensionsApplicationException
  * @throws DynamicExtensionsSystemException
  */
 private List<NameValueBean> getAttributesForForm(String formId)
     throws DynamicExtensionsSystemException, DynamicExtensionsApplicationException {
   ArrayList<NameValueBean> formAttributesList = new ArrayList<NameValueBean>();
   if (formId != null) {
     Logger.out.debug("Fetching attributes for [" + formId + "]");
     ContainerInterface container = DynamicExtensionsUtility.getContainerByIdentifier(formId);
     if (container != null) {
       // Collection<ControlInterface> controlCollection = container.getControlCollection();
       Collection<ControlInterface> controlCollection = container.getAllControls();
       if (controlCollection != null) {
         NameValueBean controlName = null;
         AbstractAttributeInterface abstractAttribute = null;
         AttributeInterface attribute = null;
         for (ControlInterface control : controlCollection) {
           if (control != null) {
             // if control contains Attribute interface object then only show on UI.
             // If control contains association objects do not show in attribute list
             abstractAttribute = control.getAbstractAttribute();
             if (abstractAttribute != null && (abstractAttribute instanceof AttributeInterface)) {
               attribute = (AttributeInterface) abstractAttribute;
               if (!(attribute.getAttributeTypeInformation()
                   instanceof FileAttributeTypeInformation)) {
                 controlName = new NameValueBean(control.getCaption(), control.getId());
                 formAttributesList.add(controlName);
               }
             }
           }
         }
       }
     }
   }
   return formAttributesList;
 }
  /**
   * Returns <code>EntityInterface</code> object for given entity name and attributes.
   *
   * @param entityName
   * @param attributes
   * @return EntityInterface
   */
  private EntityInterface createEntity(String entityName, String... attributes) {
    EntityInterface entity = DomainObjectFactory.getInstance().createEntity();
    entity.setName(entityName);

    for (String name : attributes) {
      AttributeInterface attr = DomainObjectFactory.getInstance().createStringAttribute();
      attr.setName(name);
      attr.setId(recordId++);
      entity.addAttribute(attr);
      allowedAttributes.add(attr);
    }
    return entity;
  }
예제 #3
0
  /**
   * To add the Id columns of MainEntities in the SQL if its not present. It will also populate
   * entityIdIndexMap passes it.
   *
   * @param columnIndex columnIndex
   * @param selectSql selectSql
   * @param entityIdIndexMap entityIdIndexMap
   * @param selectSqlColumnList selectSqlColumnList
   * @param outputTreeDataNode outputTreeDataNode
   * @return The modified SQL string.
   */
  private static Map putIdColumnsInSql(
      int colIndex,
      String selectSql,
      Map<EntityInterface, Integer> entityIdIndexMap,
      List<String> selectSqlColumnList,
      OutputTreeDataNode outputTreeDataNode,
      Map<String, String> specimenMap,
      Map<String, String> columnNameVsAliasMap) {
    int columnIndex = colIndex;
    StringBuffer sql = new StringBuffer(selectSql);
    Map sqlIndexMap = new HashMap();
    if (outputTreeDataNode != null) {
      List<QueryOutputTreeAttributeMetadata> attributes = outputTreeDataNode.getAttributes();
      for (QueryOutputTreeAttributeMetadata attributeMetaData : attributes) {
        AttributeInterface attribute = attributeMetaData.getAttribute();
        String sqlColumnName = attributeMetaData.getColumnName().trim();
        if (attribute.getName().equals(AQConstants.IDENTIFIER)) {
          int index =
              selectSqlColumnList.indexOf(
                  columnNameVsAliasMap.get(sqlColumnName) + " " + sqlColumnName);

          if (index >= 0) {
            entityIdIndexMap.put(attribute.getEntity(), index);
            break;
          } else {
            // appendColNameToSql(selectSql, sql, sqlColumnName);
            entityIdIndexMap.put(attribute.getEntity(), null);
            columnIndex++;
            if (outputTreeDataNode
                .getOutputEntity()
                .getDynamicExtensionsEntity()
                .getName()
                .equals("edu.wustl.catissuecore.domain.Specimen")) {
              if (specimenMap == null) {
                specimenMap = new HashMap<String, String>();
              }
              specimenMap.put("specimenKey", "edu.wustl.catissuecore.domain.Specimen");
              specimenMap.put("columnIndex", String.valueOf(columnIndex - 1));
            }
            break;
          }
        }
      }
    }
    sqlIndexMap.put(AQConstants.SQL, sql.toString());
    sqlIndexMap.put(AQConstants.ID_COLUMN_ID, columnIndex);
    return sqlIndexMap;
  }
예제 #4
0
 /**
  * @param strToCreateObject strToCreateObject
  * @param oprVsLstOfVals Map
  * @param expression expression
  */
 private static void processRules(
     StringBuffer strToCreateObject,
     Map<RelationalOperator, List<String>> oprVsLstOfVals,
     IExpression expression) {
   ICondition idCondition = null;
   Rule rule = ((Rule) (expression.getOperand(0)));
   for (ICondition condition : rule) {
     AttributeInterface conditionAttr = condition.getAttribute();
     String attrName = conditionAttr.getName();
     if (attrName.equalsIgnoreCase("id")) {
       idCondition = processRuleForId(oprVsLstOfVals, condition);
     } else {
       processRuleForOtherAttributes(strToCreateObject, condition, conditionAttr, attrName);
     }
   }
   // rule.removeCondition(idCondition);
 }
  /**
   * Mock method for creating category records.
   *
   * @param catClass
   * @param howMany
   * @return
   */
  private List<ICategorialClassRecord> createRecord(CategorialClass catClass, int howMany) {
    List<ICategorialClassRecord> records = new ArrayList<ICategorialClassRecord>(howMany);
    Collection<AttributeInterface> collection =
        catClass.getCategorialClassEntity().getAttributeCollection();
    Set<AttributeInterface> set = new HashSet<AttributeInterface>(collection);

    for (int i = 0; i < howMany; i++) {
      ICategorialClassRecord record =
          QueryResultFactory.createCategorialClassRecord(
              catClass, set, new RecordId(recordId++ + "", ""));
      for (AttributeInterface attr : record.getAttributes()) {
        record.putStringValueForAttribute(attr, attr.getName() + "_R_" + counter);
      }
      records.add(record);
      counter++;
    }
    return records;
  }
예제 #6
0
  /**
   * @see
   *     edu.common.dynamicextensions.validation.ValidatorRuleInterface#validate(edu.common.dynamicextensions.domaininterface.AttributeInterface,
   *     java.lang.Object, java.util.Map)
   * @throws DynamicExtensionsValidationException
   */
  public boolean validate(
      AttributeInterface attribute, Object valueObject, Map<String, String> parameterMap)
      throws DynamicExtensionsValidationException {
    boolean valid = false;
    String attributeName = attribute.getName();
    AttributeTypeInformationInterface attributeTypeInformation =
        attribute.getAttributeTypeInformation();

    if (((valueObject != null) && (!((String) valueObject).trim().equals("")))
        && ((attributeTypeInformation != null)
            && (attributeTypeInformation instanceof DateAttributeTypeInformation))) {
      DateAttributeTypeInformation dateAttributeTypeInformation =
          (DateAttributeTypeInformation) attributeTypeInformation;
      String dateFormat = dateAttributeTypeInformation.getFormat();
      String value = (String) valueObject;

      if (dateFormat.equals(ProcessorConstants.MONTH_YEAR_FORMAT)) {
        value = DynamicExtensionsUtility.formatMonthAndYearDate(value);
        value = value.substring(0, value.length() - 4);
      }
      if (dateFormat.equals(ProcessorConstants.YEAR_ONLY_FORMAT)) {
        value = DynamicExtensionsUtility.formatYearDate(value);
        value = value.substring(0, value.length() - 4);
      }

      try {
        Date date = null;
        date = Utility.parseDate(value, "MM-dd-yyyy");
        if (date != null) {
          valid = true;
        }
      } catch (ParseException parseException) {
        List<String> placeHolders = new ArrayList<String>();
        placeHolders.add(attributeName);
        placeHolders.add(dateFormat);
        throw new DynamicExtensionsValidationException(
            "Validation failed", null, "dynExtn.validation.Date", placeHolders);
      }
    }
    return valid;
  }
 /**
  * Writes output into csv file.
  *
  * @param masterList
  * @param num
  * @throws Exception
  */
 private void write(List<Map<AttributeInterface, Object>> masterList, int num) throws Exception {
   BufferedWriter bos = new BufferedWriter(new FileWriter(new File("c:/test" + num + ".csv")));
   for (AttributeInterface a : allowedAttributes) {
     bos.write(a.getName());
     bos.write(",");
   }
   bos.write("\n");
   for (Map<AttributeInterface, Object> map : masterList) {
     for (AttributeInterface a : allowedAttributes) {
       System.out.println(a.getName());
       Object obj = map.get(a);
       String str = "-";
       if (obj != null) {
         str = obj.toString();
       }
       bos.write(str);
       bos.write(",");
     }
     bos.write("\n");
   }
   bos.flush();
 }
예제 #8
0
 /**
  * Modify rule for attributes other than id.
  *
  * @param strToCreateObject strToCreateObject
  * @param condition condition
  * @param conditionAttr conditionAttr
  * @param attrName attrName
  */
 private static void processRuleForOtherAttributes(
     StringBuffer strToCreateObject,
     ICondition condition,
     AttributeInterface conditionAttr,
     String attrName) {
   Long attrId = conditionAttr.getId();
   RelationalOperator operator = condition.getRelationalOperator();
   strToCreateObject
       .append("@#condition#@")
       .append(attrName)
       .append(attrId)
       .append(AQConstants.CONDITION_SEPERATOR)
       .append(operator.getStringRepresentation());
   if (operator.equals(RelationalOperator.In) || operator.equals(RelationalOperator.NotIn)) {
     modifyQueryStringForInNotIn(strToCreateObject, condition.getValues());
   } else if (!(operator.equals(RelationalOperator.IsNotNull)
       || operator.equals(RelationalOperator.IsNull))) {
     strToCreateObject.append(AQConstants.CONDITION_SEPERATOR).append(condition.getValue());
   }
   strToCreateObject.append(';');
 }
예제 #9
0
  /**
   * @param request
   * @param gridControlsIds
   * @return
   */
  private String updateControlsSequence(HttpServletRequest request, String controlsSeqNumbers) {
    System.out.println("ControlsId " + controlsSeqNumbers);
    ContainerInterface containerInterface = WebUIManager.getCurrentContainer(request);
    if (containerInterface != null) {
      Collection<ControlInterface> oldControlsCollection =
          containerInterface.getControlCollection();
      if (oldControlsCollection != null) {
        Integer[] sequenceNumbers =
            DynamicExtensionsUtility.convertToIntegerArray(
                controlsSeqNumbers, ProcessorConstants.CONTROLS_SEQUENCE_NUMBER_SEPARATOR);
        ControlInterface[] oldControlsArray =
            oldControlsCollection.toArray(new ControlInterface[oldControlsCollection.size()]);

        // adding id attribute to attributecollection
        AttributeInterface idAttribute = null;
        Collection<AttributeInterface> attributeCollection =
            containerInterface.getEntity().getAttributeCollection();
        for (AttributeInterface attributeIterator : attributeCollection) {
          // Added null check for bug 6013
          if (attributeIterator.getColumnProperties() != null
              && attributeIterator.getColumnProperties().getName() != null
              && attributeIterator
                  .getColumnProperties()
                  .getName()
                  .equals(DynamicExtensionsQueryBuilderConstantsInterface.IDENTIFIER)) {
            idAttribute = attributeIterator;
            break;
          }
        }

        // remove old controls from collection
        containerInterface.removeAllControls();
        containerInterface.getEntity().removeAllAbstractAttributes();
        ControlInterface control = null;
        if (sequenceNumbers != null) {
          for (int i = 0; i < sequenceNumbers.length; i++) {
            control =
                DynamicExtensionsUtility.getControlBySequenceNumber(
                    oldControlsArray, sequenceNumbers[i].intValue());
            System.out.println(control);
            if (control != null) {
              containerInterface.addControl(control);
              containerInterface.getEntity().addAbstractAttribute(control.getAbstractAttribute());
            }
          }
        }
        if (idAttribute != null) {
          containerInterface.getEntity().addAbstractAttribute(idAttribute);
        }
        // Added by Rajesh for removing deleted associations and it's path from path tables.
        List<Long> deletedIdList =
            (List<Long>)
                CacheManager.getObjectFromCache(
                    request, WebUIManagerConstants.DELETED_ASSOCIATION_IDS);
        List<Long> listOfIds =
            DynamicExtensionsUtility.getDeletedAssociationIds(oldControlsArray, sequenceNumbers);
        if (deletedIdList == null) {
          deletedIdList = listOfIds;
        } else {
          deletedIdList.addAll(listOfIds);
        }
        CacheManager.addObjectToCache(
            request, WebUIManagerConstants.DELETED_ASSOCIATION_IDS, deletedIdList);
        //				System.out.println("deletedIdList : " + deletedIdList.size());
      }
    }

    System.out.println("Coontrols Colln : ");
    Collection<ControlInterface> controlCollection = containerInterface.getControlCollection();
    for (ControlInterface control : controlCollection) {
      System.out.println("[" + control.getSequenceNumber() + "] = [" + control.getCaption() + "]");
    }
    return "";
  }