/**
   * Requires that Table to be done.
   *
   * @param rSession the rets session
   * @param hSession the hibernate session
   * @exception HibernateException if an error occurs
   */
  private void doValidationLookup(Session hSession) throws HibernateException {
    MetadataTable tValidationLookups = getMetadataTable(MetadataTable.VALIDATION_LOOKUP);

    Iterator i = mResources.values().iterator();
    while (i.hasNext()) {
      Resource resource = (Resource) i.next();
      Set hValidationLookups = new HashSet();
      String resourcePath = resource.getPath();
      List validationLookups = tValidationLookups.getDataRows(resourcePath);
      if (validationLookups != null) {
        Iterator j = validationLookups.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          ValidationLookup hvl = new ValidationLookup();

          hvl.setResource(resource);

          hvl.setValidationLookupName(md.getAttribute("ValidationLookupName"));

          hvl.setParent1Field(md.getAttribute("Parent1Field"));
          hvl.setParent2Field(md.getAttribute("Parent2Field"));

          hvl.updateLevel();

          hSession.save(hvl);
          hValidationLookups.add(hvl);
          mValidationLookups.put(hvl.getPath(), hvl);
        }
        resource.setValidationLookups(hValidationLookups);
        hSession.saveOrUpdate(resource);
      }
    }
  }
  private void doValidationLookupType(Session hSession) throws HibernateException {
    MetadataTable tValidationLookupTypes = getMetadataTable(MetadataTable.VALIDATION_LOOKUP_TYPE);

    Iterator i = mValidationLookups.values().iterator();
    while (i.hasNext()) {
      ValidationLookup vl = (ValidationLookup) i.next();
      Set hValdationLookupTypes = new HashSet();
      List validationLookupTypes = tValidationLookupTypes.getDataRows(vl.getPath());
      if (validationLookupTypes != null) {
        Iterator j = validationLookupTypes.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          ValidationLookupType vlt = new ValidationLookupType();

          vlt.setValidationLookup(vl);
          vlt.setValidText(md.getAttribute("ValidText"));
          vlt.setParent1Value(md.getAttribute("Parent1Value"));
          vlt.setParent2Value(md.getAttribute("Parent2Value"));

          vlt.updateLevel();

          hSession.save(vlt);
          hValdationLookupTypes.add(vlt);
        }
      }
      vl.setValidationLookupTypes(hValdationLookupTypes);
      hSession.saveOrUpdate(vl);
    }
  }
  private void doValidationExpression(Session hSession) throws HibernateException {
    MetadataTable tValidationExpressions = getMetadataTable(MetadataTable.VALIDATION_EXPRESSION);

    Iterator i = mResources.values().iterator();
    while (i.hasNext()) {
      Resource resource = (Resource) i.next();
      Set hValidationExpressions = new HashSet();
      List validationExpressions = tValidationExpressions.getDataRows(resource.getPath());
      if (validationExpressions != null) {
        Iterator j = validationExpressions.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          ValidationExpression ve = new ValidationExpression();

          ve.setResource(resource);
          ve.setValidationExpressionID(md.getAttribute("ValidationExpressionID"));
          ve.setValidationExpressionType(
              ValidationExpressionTypeEnum.fromString(md.getAttribute("ValidationExpressionType")));
          ve.setValue(md.getAttribute("value"));

          ve.updateLevel();

          hSession.save(ve);
          hValidationExpressions.add(ve);
          mValidationExpressions.put(ve.getPath(), ve);
        }
      }
      resource.setValidationExpressions(hValidationExpressions);
      hSession.saveOrUpdate(resource);
    }
  }
  private void doValidationExternal(Session hSession) throws HibernateException {
    MetadataTable tValidationExternals = getMetadataTable(MetadataTable.VALIDATION_EXTERNAL);

    Iterator i = mResources.values().iterator();
    while (i.hasNext()) {
      Resource resource = (Resource) i.next();
      Set hValidationExternals = new HashSet();
      List validationExternals = tValidationExternals.getDataRows(resource.getPath());
      if (validationExternals != null) {
        Iterator j = validationExternals.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          ValidationExternal hValidationExternal = new ValidationExternal();

          hValidationExternal.setResource(resource);

          hValidationExternal.setValidationExternalName(md.getAttribute("ValidationExternalName"));

          // get the search class
          String path = md.getAttribute("SearchResource") + ":" + md.getAttribute("SearchClass");
          MClass clazz = (MClass) mClasses.get(path);
          hValidationExternal.setSearchClass(clazz);

          hValidationExternal.updateLevel();

          hSession.save(hValidationExternal);
          hValidationExternals.add(hValidationExternal);
          mValidationExternals.put(hValidationExternal.getPath(), hValidationExternal);
        }
      }
      resource.setValidationExternals(hValidationExternals);
      hSession.saveOrUpdate(resource);
    }
  }
  private void doUpdateHelp(Session hSession) throws HibernateException {
    MetadataTable tUpdateHelps = getMetadataTable(MetadataTable.UPDATE_HELP);

    Iterator i = mResources.values().iterator();
    while (i.hasNext()) {
      Resource resource = (Resource) i.next();
      Set hUpdateHelps = new HashSet();
      List updateHelps = tUpdateHelps.getDataRows(resource.getPath());
      if (updateHelps != null) {
        Iterator j = updateHelps.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          UpdateHelp hUpdateHelp = new UpdateHelp();

          hUpdateHelp.setResource(resource);
          hUpdateHelp.setUpdateHelpID(md.getAttribute("UpdateHelpID"));
          hUpdateHelp.setValue(md.getAttribute("Value"));

          hUpdateHelp.updateLevel();

          hSession.save(hUpdateHelp);
          hUpdateHelps.add(hUpdateHelp);
          mUpdateHelps.put(hUpdateHelp.getPath(), hUpdateHelp);
        }
      }
      resource.setUpdateHelps(hUpdateHelps);
      hSession.saveOrUpdate(resource);
    }
  }
  private void doObjects(Session hSession) throws HibernateException {
    MetadataTable tObject = getMetadataTable(MetadataTable.OBJECT);

    Iterator i = mResources.values().iterator();
    while (i.hasNext()) {
      Resource resource = (Resource) i.next();
      Set hObjects = new HashSet();
      List objects = tObject.getDataRows(resource.getPath());
      if (objects != null) {
        Iterator j = objects.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          MObject hObject = new MObject();

          hObject.setResource(resource);

          hObject.setObjectType(ObjectTypeEnum.fromString(md.getAttribute("ObjectType")));
          hObject.setMimeType(md.getAttribute("MimeType"));
          hObject.setVisibleName(md.getAttribute("VisibleName"));
          hObject.setDescription(StringUtils.substring(md.getAttribute("Description"), 0, 64));

          // Should we have an updateLevel?

          hSession.save(hObject);
          hObjects.add(hObject);
        }
      }

      resource.setObjects(hObjects);
      hSession.saveOrUpdate(resource);
    }
  }
  private void doUpdate(Session hSession) throws HibernateException {
    MetadataTable tUpdates = getMetadataTable(MetadataTable.UPDATE);

    Iterator i = mClasses.values().iterator();
    while (i.hasNext()) {
      MClass clazz = (MClass) i.next();
      Set hUpdates = new HashSet();
      List updates = tUpdates.getDataRows(clazz.getPath());
      if (updates != null) {
        Iterator j = updates.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          Update hUpdate = new Update();

          hUpdate.setMClass(clazz);

          hUpdate.setUpdateName(md.getAttribute("UpdateName"));
          hUpdate.setDescription(md.getAttribute("Description"));
          hUpdate.setKeyField(md.getAttribute("KeyField"));

          hUpdate.updateLevel();

          hSession.save(hUpdate);
          hUpdates.add(hUpdate);
          mUpdates.put(hUpdate.getPath(), hUpdate);
        }
      }
      clazz.setUpdates(hUpdates);
      hSession.saveOrUpdate(clazz);
    }
  }
  private void doResource(Session hSession, MSystem hSystem) throws HibernateException {
    MetadataTable tResource = getMetadataTable(MetadataTable.RESOURCE);

    Set hResources = new HashSet();
    List resources = tResource.getDataRows("");
    Iterator i = resources.iterator();
    while (i.hasNext()) {
      Metadata md = (Metadata) i.next();
      Resource hResource = new Resource();

      hResource.setSystem(hSystem);
      String resourceID = md.getAttribute("ResourceID");
      hResource.setResourceID(resourceID);
      hResource.setStandardName(
          ResourceStandardNameEnum.fromString(md.getAttribute("StandardName")));
      hResource.setVisibleName(md.getAttribute("VisibleName"));
      hResource.setDescription(md.getAttribute("Description"));
      hResource.setKeyField(md.getAttribute("KeyField"));

      hResource.updateLevel();

      hSession.save(hResource);
      hResources.add(hResource);
      mResources.put(hResource.getPath(), hResource);
    }

    hSystem.setResources(hResources);
    hSession.saveOrUpdate(hSystem);
  }
  /**
   * Meant to be called only from do Lookup.
   *
   * @param rSession the rets session
   * @param hSession the hibernate session
   * @exception HibernateException if an error occurs
   */
  private void doLookupTypes(Session hSession) throws HibernateException {
    MetadataTable tLookupTypes = getMetadataTable(MetadataTable.LOOKUP_TYPE);

    Iterator i = mLookups.values().iterator();
    while (i.hasNext()) {
      Lookup lookup = (Lookup) i.next();
      List lookupTypes = tLookupTypes.getDataRows(lookup.getPath());
      Set hLookupTypes = new HashSet();
      if (lookupTypes != null) {
        Iterator j = lookupTypes.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          LookupType hLookupType = new LookupType();

          hLookupType.setLookup(lookup);

          hLookupType.setLongValue(md.getAttribute("LongValue"));
          hLookupType.setShortValue(md.getAttribute("ShortValue"));
          hLookupType.setValue(md.getAttribute("Value"));

          hLookupType.updateLevel();

          hSession.save(hLookupType);
          hLookupTypes.add(hLookupType);
        }
      }
      lookup.setLookupTypes(hLookupTypes);
      hSession.saveOrUpdate(lookup);
    }
  }
  private void doLookup(Session hSession) throws HibernateException {
    MetadataTable tLookup = getMetadataTable(MetadataTable.LOOKUP);

    Iterator i = mResources.values().iterator();
    while (i.hasNext()) {
      Resource resource = (Resource) i.next();
      Set hLookups = new HashSet();
      List lookups = tLookup.getDataRows(resource.getPath());
      if (lookups != null) {
        Iterator j = lookups.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          Lookup hLookup = new Lookup();

          hLookup.setResource(resource);

          String lookupName = md.getAttribute("LookupName");
          hLookup.setLookupName(lookupName);

          hLookup.setVisibleName(md.getAttribute("VisibleName"));

          hLookup.updateLevel();
          hSession.save(hLookup);
          // doLookupTypes(hLookup, rSession, hSession);
          hLookups.add(hLookup);
          mLookups.put(hLookup.getPath(), hLookup);
        }
      }
      resource.setLookups(hLookups);
      hSession.saveOrUpdate(resource);
    }
  }
  private void doEditMask(Session hSession) throws HibernateException {
    MetadataTable tEditMask = getMetadataTable(MetadataTable.EDITMASK);

    Iterator i = mResources.values().iterator();
    while (i.hasNext()) {
      Resource resource = (Resource) i.next();
      Set hEditMasks = new HashSet();
      List editMasks = tEditMask.getDataRows(resource.getPath());
      if (editMasks != null) {
        Iterator j = editMasks.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          EditMask hEditMask = new EditMask();

          hEditMask.setResource(resource);
          hEditMask.setEditMaskID(md.getAttribute("EditMaskID"));
          hEditMask.setValue(md.getAttribute("Value"));

          hEditMask.updateLevel();

          hSession.save(hEditMask);
          hEditMasks.add(hEditMask);
          mEditMasks.put(hEditMask.getPath(), hEditMask);
        }
      }
      resource.setEditMasks(hEditMasks);
      hSession.saveOrUpdate(resource);
    }
  }
Beispiel #12
0
  public void addAdmin(Admin admin) throws DBException {
    Session session;
    Transaction tx = null;
    try {
      session = HibernateSessionFactory.currentSession();
      tx = session.beginTransaction();
      session.saveOrUpdate(admin);
      tx.commit();
    } catch (HibernateException e) {

      try {
        tx.rollback();

      } catch (HibernateException e1) {
        e1.printStackTrace();
      }
      e.printStackTrace();
      throw new DBException("保存对象失败!");
    } finally {
      try {
        HibernateSessionFactory.closeSession();
      } catch (HibernateException e) {
        e.printStackTrace();
      }
    }
  }
  private void doForeignKey(Session hSession, MSystem hSystem) throws HibernateException {
    MetadataTable tForeignKeys = getMetadataTable(MetadataTable.FOREIGN_KEYS);

    Set hForeignKeys = new HashSet();
    List foreignKeys = tForeignKeys.getDataRows("");
    if (foreignKeys != null) {
      Iterator i = foreignKeys.iterator();
      while (i.hasNext()) {
        Metadata md = (Metadata) i.next();
        ForeignKey hFk = new ForeignKey();

        hFk.setSystem(hSystem);

        hFk.setForeignKeyID(md.getAttribute("ForeignKeyID"));
        String path[] = new String[3];
        path[0] = md.getAttribute("ParentResourceID");
        path[1] = md.getAttribute("ParentClassID");
        path[2] = md.getAttribute("ParentSystemName");
        String tablePath = StringUtils.join(path, ":");
        Table table = (Table) mTables.get(tablePath);
        hFk.setParentTable(table);

        path[0] = md.getAttribute("ChildResourceID");
        path[1] = md.getAttribute("ChildClassID");
        path[2] = md.getAttribute("ChildSystemName");
        tablePath = StringUtils.join(path, ":");
        table = (Table) mTables.get(tablePath);
        hFk.setChildTable(table);
        if (table == null) {
          LOG.error("table is null for path: " + tablePath);
        }

        hSession.save(hFk);
        hForeignKeys.add(hFk);
      }
    }
    hSystem.setForeignKeys(hForeignKeys);
    hSession.saveOrUpdate(hSystem);
  }
  private void doClasses(Session hSession) throws HibernateException {
    MetadataTable tClass = getMetadataTable(MetadataTable.CLASS);

    Iterator i = mResources.values().iterator();
    while (i.hasNext()) {
      Resource resource = (Resource) i.next();
      Set hClasses = new HashSet();
      List classes = tClass.getDataRows(resource.getPath());
      Iterator j = classes.iterator();
      while (j.hasNext()) {
        Metadata md = (Metadata) j.next();
        MClass hClass = new MClass();

        hClass.setResource(resource);
        String className = md.getAttribute("ClassName");
        hClass.setClassName(className);
        hClass.setStandardName(ClassStandardNameEnum.fromString(md.getAttribute("StandardName")));
        hClass.setVisibleName(md.getAttribute("VisibleName"));
        hClass.setDescription(md.getAttribute("Description"));

        StringBuffer tmp = new StringBuffer("rets_");
        tmp.append(resource.getResourceID()).append("_");
        tmp.append(hClass.getClassName());
        hClass.setDbTable(tmp.toString());

        hClass.updateLevel();

        hSession.save(hClass);
        hClasses.add(hClass);
        mClasses.put(hClass.getPath(), hClass);
      }

      resource.setClasses(hClasses);
      hSession.saveOrUpdate(resource);
    }
  }
  public void doUpdateType(Session hSession) throws HibernateException {
    MetadataTable tUpdateTypes = getMetadataTable(MetadataTable.UPDATE_TYPE);

    Iterator i = mUpdates.values().iterator();
    while (i.hasNext()) {
      Update update = (Update) i.next();
      Set hUpdateTypes = new HashSet();
      List updateTypes = tUpdateTypes.getDataRows(update.getPath());
      if (updateTypes != null) {
        Iterator j = updateTypes.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          UpdateType updateType = new UpdateType();

          updateType.setUpdate(update);
          String level = update.getLevel();
          String systemName = md.getAttribute("SystemName");
          String tablePath = level + ":" + systemName;
          Table table = (Table) mTables.get(tablePath);
          updateType.setTable(table);
          // Hack to get around metadata bug
          if (table == null) {
            LOG.error("null table for path: " + tablePath);
            System.exit(1);
          }

          updateType.setSequence(Integer.parseInt(md.getAttribute("Sequence")));

          String joinedAttributes = md.getAttribute("Attributes");
          String attributes[] = StringUtils.split(joinedAttributes, ",");
          Set attributeSet = new HashSet();
          for (int c = 0; c < attributes.length; c++) {
            attributeSet.add(UpdateTypeAttributeEnum.fromInt(Integer.parseInt(attributes[c])));
          }
          updateType.setAttributes(attributeSet);

          updateType.setDefault(md.getAttribute("Default"));

          String valExp[] = StringUtils.split(md.getAttribute("ValidationExpressionID"), ",");
          Set valExpSet = new HashSet();
          String resourcePath = update.getMClass().getResource().getPath();
          for (int c = 0; c < valExp.length; c++) {
            String vePath = resourcePath + ":" + valExp[c];
            ValidationExpression ve = (ValidationExpression) mValidationExpressions.get(vePath);
            valExpSet.add(ve);
          }
          updateType.setValidationExpressions(valExpSet);

          String updateHelpPath = resourcePath + ":" + md.getAttribute("UpdateHelpID");
          updateType.setUpdateHelp((UpdateHelp) mUpdateHelps.get(updateHelpPath));

          String vlPath = resourcePath + ":" + md.getAttribute("ValdiationLookupName");
          updateType.setValidationLookup((ValidationLookup) mValidationLookups.get(vlPath));

          String vePath = resourcePath + ":" + md.getAttribute("ValdationExternalName");
          updateType.setValidationExternal((ValidationExternal) mValidationExternals.get(vePath));

          hSession.save(updateType);
          hUpdateTypes.add(updateType);
        }
      }
      update.setUpdateTypes(hUpdateTypes);
      hSession.saveOrUpdate(update);
    }
  }
  private void doTable(Session hSession) throws HibernateException {
    MetadataTable tTables = getMetadataTable(MetadataTable.TABLE);

    Iterator i = mClasses.values().iterator();
    while (i.hasNext()) {
      MClass hClass = (MClass) i.next();
      Set hTables = new HashSet();
      List tables = tTables.getDataRows(hClass.getPath());
      if (tables != null) {
        Iterator j = tables.iterator();
        while (j.hasNext()) {
          Metadata md = (Metadata) j.next();
          Table hTable = new Table();

          hTable.setMClass(hClass);

          hTable.setSystemName(md.getAttribute("SystemName"));

          String standardName = md.getAttribute("StandardName");
          TableStandardName tsn = lookupTableStandardName(standardName);
          if (tsn == null) {
            if (!standardName.equals("")) {
              tsn = new TableStandardName(standardName);
              mTableStandardNames.put(standardName, tsn);
              hSession.save(tsn);
            }
          }
          hTable.setStandardName(tsn);

          hTable.setLongName(md.getAttribute("LongName"));

          String tmp = md.getAttribute("DbName");
          if (tmp.startsWith("r_")) {
            hTable.setDbName(StringUtils.substring(tmp, 0, 10));
          } else {
            hTable.setDbName(StringUtils.substring("r_" + tmp, 0, 10));
          }

          hTable.setShortName(md.getAttribute("ShortName"));
          hTable.setMaximumLength(Integer.parseInt(md.getAttribute("MaximumLength")));
          hTable.setDataType(DataTypeEnum.fromString(md.getAttribute("DataType")));
          hTable.setPrecision(Integer.parseInt(md.getAttribute("Precision")));
          hTable.setSearchable(boolValue(md.getAttribute("Searchable")));
          hTable.setInterpretation(
              InterpretationEnum.fromString(md.getAttribute("Interpretation")));
          hTable.setAlignment(AlignmentEnum.fromString(md.getAttribute("Alignment")));
          hTable.setUseSeparator(boolValue(md.getAttribute("UseSeparator")));

          String editMasksJoined = md.getAttribute("EditMaskID");
          String resourcePath = hClass.getResource().getPath();
          String path = null;
          Set hEditMasks = new HashSet();
          if (editMasksJoined != null) {
            String editMasks[] = StringUtils.split(editMasksJoined, ",");

            for (int c = 0; c < editMasks.length; c++) {
              path = resourcePath + ":" + StringUtils.trimToEmpty(editMasks[c]);
              EditMask em = (EditMask) mEditMasks.get(path);
              hEditMasks.add(em);
              if (em == null) {
                LOG.error("edit mask null for path: " + path);
              }
            }
          }
          hTable.setEditMasks(hEditMasks);

          String lookupName = md.getAttribute("LookupName");
          path = resourcePath + ":" + lookupName;
          Lookup lookup = (Lookup) mLookups.get(path);
          hTable.setLookup(lookup);

          hTable.setMaxSelect(Integer.parseInt(md.getAttribute("MaxSelect")));

          hTable.setUnits(UnitEnum.fromString(md.getAttribute("Units")));

          hTable.setIndex(Integer.parseInt(md.getAttribute("Index")));

          hTable.setMinimum(Integer.parseInt(md.getAttribute("Minimum")));

          hTable.setMaximum(Integer.parseInt(md.getAttribute("Maximum")));

          hTable.setDefault(Integer.parseInt(md.getAttribute("Default")));

          hTable.setRequired(Integer.parseInt(md.getAttribute("Required")));

          String searchHelpID = md.getAttribute("SearchHelpID");
          path = resourcePath + ":" + searchHelpID;
          SearchHelp searchHelp = (SearchHelp) mSearchHelps.get(path);
          hTable.setSearchHelp(searchHelp);

          // String = md.getAttribute("unique");
          hTable.setUnique(boolValue(md.getAttribute("Unique")));

          hTable.updateLevel();

          hSession.save(hTable);
          hTables.add(hTable);
          mTables.put(hTable.getPath(), hTable);
        }
        hClass.setTables(hTables);
        hSession.saveOrUpdate(hClass);
      }
    }
  }