Exemplo n.º 1
0
  /**
   * Get the existing key value, or prepare a new key value for calculating.
   *
   * @param def the def
   * @param primaryRecordId the primary record id
   * @param secondaryRecordId the secondary record id
   * @param tertiaryRecordId the tertiary record id
   * @return the key value
   */
  private static KeyValue prepareKeyValue(
      final Definition def,
      final String primaryRecordId,
      final String secondaryRecordId,
      final String tertiaryRecordId) {

    MetahivePreferences preferences = MetahivePreferences.load();

    String primaryId = primaryRecordId;
    String secondaryId = "";
    String tertiaryId = "";

    if (StringUtils.isNotBlank(secondaryRecordId)) {
      secondaryId = parseRecordId(secondaryRecordId);
    }
    if (StringUtils.isNotBlank(tertiaryRecordId)) {
      tertiaryId = parseRecordId(tertiaryRecordId);
    }

    if (StringUtils.isBlank(secondaryId)
        && StringUtils.isNotBlank(preferences.getSecondaryRecordDefault())) {
      secondaryId = preferences.getSecondaryRecordDefault();
    }

    if (StringUtils.isBlank(tertiaryId)
        && StringUtils.isNotBlank(preferences.getTertiaryRecordDefault())) {
      tertiaryId = preferences.getTertiaryRecordDefault();
    }

    Record recd = Record.findRecordByRecordIdEquals(primaryId);

    if (recd == null) {
      throw new IllegalArgumentException("A valid primaryRecordId is required");
    }

    KeyValue kv = KeyValue.findKeyValue(def, primaryId, secondaryId, tertiaryId);

    if (kv != null) {
      logger.info("Key value id: " + kv.getId());
    } else {
      logger.info("Key value is null");
    }

    // If the key value is still null then this is a new record
    if (kv == null) {
      kv = new KeyValue();
      kv.setDefinition(def);
      kv.setRecord(recd);
      kv.setKeyValueType(KeyValueType.CALCULATED);
      kv.setPrimaryRecordId(primaryId);
      kv.setSecondaryRecordId(secondaryId);
      kv.setTertiaryRecordId(tertiaryId);
    }

    return kv;
  }
Exemplo n.º 2
0
  /**
   * Calculate the key value.
   *
   * @param def the def
   * @param primaryId the primary id
   * @param secondaryId the secondary id
   * @param tertiaryId the tertiary id
   */
  public static void calculateKeyValue(
      final Definition def,
      final String primaryId,
      final String secondaryId,
      final String tertiaryId) {

    if (def == null) {
      throw new IllegalArgumentException("A valid definition is required");
    }
    if (StringUtils.isBlank(primaryId)) {
      throw new IllegalArgumentException("A valid primaryId is required");
    }
    // Check that the record exists
    Record record = Record.findRecordByRecordIdEquals(primaryId);
    if (record == null) {
      throw new IllegalArgumentException(
          "A valid primaryId is required," + " no record exists in the Metahive");
    }

    KeyValue kv = prepareKeyValue(def, primaryId, secondaryId, tertiaryId);

    if (kv.getId() != null) {
      logger.info("Key value id: " + kv.getId());
      logger.info("Key value type: " + kv.getKeyValueType());
    }

    // If the key value is overridden then there's no need to recalculate it
    if (kv.getKeyValueType() != KeyValueType.OVERRIDDEN) {
      if (def.getDefinitionType() == DefinitionType.STANDARD) {
        calculateStandardKeyValue(def, kv);
      }
      if (def.getDefinitionType() == DefinitionType.SUMMARY) {
        calculateSummarisedKeyValue(def, kv);
      }
      if (def.getDefinitionType() == DefinitionType.CALCULATED) {
        calculateCalculatedKeyValue(def, kv);
      }
    } else {
      // There's no need to recalculate the value,
      // but the related definitions need updating.
      recalculateRelatedDefinitions(def, kv);
    }
  }