com.orientechnologies.orient.core.metadata.schema.OClass Java Examples

@Override
protected void onInitialize() {
    super.onInitialize();
    IModel<DisplayMode> modeModel = DisplayMode.VIEW.asModel();
    String sql = "select expand(bothV()) from " + getModelObject().getIdentity();
    OQueryDataProvider<ODocument> provider = new OQueryDataProvider<>(sql);
    OClass commonParent = provider.probeOClass(20);
    GenericTablePanel<ODocument> tablePanel = new GenericTablePanel<>("vertices",
            createColumns(commonParent, modeModel),
            provider, //setParameter does not work here
            2
    );
    OrienteerDataTable<ODocument, String> table = tablePanel.getDataTable();
    table.addCommand(new EditODocumentsCommand(table, modeModel, commonParent));
    table.addCommand(new SaveODocumentsCommand(table, modeModel));
    table.addCommand(new ExportCommand<>(table, new StringResourceModel("export.filename.vertices", new ODocumentNameModel(getModel()))));

    add(tablePanel);
    add(DisableIfDocumentNotSavedBehavior.INSTANCE, UpdateOnActionPerformedEventBehavior.INSTANCE_ALL_CONTINUE);
}
 

private List<String> loadClasses(String query) {
    List<OClass> classes = loadModel.getObject();

    if (classes == null || classes.isEmpty()) {
        return Collections.emptyList();
    }

    if (Strings.isNullOrEmpty(query)) {
        return classes.stream().map(OClass::getName).collect(Collectors.toList());
    }

    return loadModel.getObject().stream()
            .map(OClass::getName)
            .filter(c -> c.contains(query))
            .collect(Collectors.toList());
}
 

private void checkIndexes(ODocument document, TYPE hookType) {
  document = checkForLoading(document);

  final OClass cls = document.getSchemaClass();
  if (cls != null) {
    final Collection<OIndex<?>> indexes = cls.getIndexes();
    switch (hookType) {
    case BEFORE_CREATE:
      checkIndexedPropertiesOnCreation(document, indexes);
      break;
    case BEFORE_UPDATE:
      checkIndexedPropertiesOnUpdate(document, indexes);
      break;
    default:
      throw new IllegalArgumentException("Invalid hook type: " + hookType);
    }
  }
}
 

@Override
public FormComponent<Collection<String>> createFilterComponent(IModel<?> model) {
    IModel<OClass> entityModel = getEntityModel();
    IModel<List<OClass>> classesModel = new SubClassesModel(entityModel, true, false);

    return new Select2MultiChoice<String>(getFilterId(), getModel(), new OClassCollectionTextChoiceProvider(classesModel)) {
        @Override
        protected void onInitialize() {
            super.onInitialize();
            getSettings()
                    .setWidth("100%")
                    .setCloseOnSelect(true)
                    .setTheme(BOOTSTRAP_SELECT2_THEME);
            add(new AjaxFormSubmitBehavior("change") {});
        }
    };
}
 

@Override
protected void performMultiAction(AjaxRequestTarget target, List<OProperty> objects) {
	if(objects==null || objects.size()==0)
	{
		error(OrienteerWebApplication.get().getResourceSettings().getLocalizer().getString("errors.checkbox.empty", this));
		return;
	}
	else
	{
		List<String> fields = Lists.newArrayList(Lists.transform(objects, new Function<OProperty, String>() {

			@Override
			public String apply(OProperty input) {
				return input.getName();
			}
		}));
		OClass oClass = classModel!=null?classModel.getObject():null;
		if(oClass==null) oClass = objects.get(0).getOwnerClass();
		setResponsePage(new OIndexPage(new OIndexModel(OIndexPrototyper.newPrototype(oClass.getName(), fields))).setModeObject(DisplayMode.EDIT));
	}
}
 

/**
 * Assigns base class in scheme for provided model type (for example, to make class vertex type
 * it must extend V).
 *
 * @param db        database object
 * @param modelType model class
 * @param target    target super class to assign
 * @param logger    caller specific logger
 */
public static void assignSuperclass(final ODatabaseObject db, final Class<?> modelType, final String target,
                                    final Logger logger) {
    // searching for first existing scheme class to check hierarchy and avoid duplicates
    final OClass existing = findFirstExisting(db, modelType);
    final String modelName = modelType.getSimpleName();
    if (existing != null) {
        if (existing.isSubClassOf(target)) {
            return;
        }
        validateGraphTypes(modelName, existing, target);
    }
    if (existing != null && modelName.equals(existing.getName())) {
        logger.debug("Assigning superclass {} to {}", target, modelName);
        // adding superclass, not overriding!
        command(db, "alter class %s superclass +%s", modelName, target);
    } else {
        logger.debug("Creating model class scheme {} as extension to {}", modelName, target);
        command(db, "create class %s extends %s", modelName, target);
    }
}
 

private static void triggers(final OSchema schema) {
  OClass type = maybeCreateClass(schema, "QRTZ_TRIGGERS");
  maybeCreateProperty(type, SCHED_NAME, STRING, true);
  maybeCreateProperty(type, TRIGGER_NAME, STRING, true);
  maybeCreateProperty(type, TRIGGER_GROUP, STRING, true);
  maybeCreateProperty(type, JOB_NAME, STRING, true);
  maybeCreateProperty(type, JOB_GROUP, STRING, true);
  maybeCreateProperty(type, "DESCRIPTION", STRING, false);
  maybeCreateProperty(type, "NEXT_FIRE_TIME", LONG, false);
  maybeCreateProperty(type, "PREV_FIRE_TIME", LONG, false);
  maybeCreateProperty(type, "PRIORITY", INTEGER, false);
  maybeCreateProperty(type, "TRIGGER_STATE", STRING, true);
  maybeCreateProperty(type, "TRIGGER_TYPE", STRING, true);
  maybeCreateProperty(type, "START_TIME", LONG, true);
  maybeCreateProperty(type, "END_TIME", LONG, false);
  maybeCreateProperty(type, CALENDAR_NAME, STRING, false);
  maybeCreateProperty(type, "MISFIRE_INSTR", SHORT, false);
  maybeCreateProperty(type, "JOB_DATA", BINARY, false);
  maybeCreateIndex(type, "PK_QRTZ_TRIGGERS", SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP);
}
 

@SuppressWarnings("unchecked")
@Override
public <V> Component createComponent(String id, DisplayMode mode,
                                     IModel<ODocument> documentModel, IModel<OProperty> propertyModel, IModel<V> valueModel) {
    if (DisplayMode.EDIT.equals(mode)) {
        OProperty property = propertyModel.getObject();
        OClass oClass = property.getLinkedClass();
        if(oClass!=null) {
         AbstractSelect2Choice<?, ?> choice = property.getType().isMultiValue() ?
         		new Select2MultiChoice<ODocument>(id, (IModel<Collection<ODocument>>) valueModel, new ODocumentChoiceProvider(oClass))
         		: new Select2Choice<ODocument>(id, (IModel<ODocument>) valueModel, new ODocumentChoiceProvider(oClass));
         choice.getSettings()
			.setWidth("100%")
			.setCloseOnSelect(true)
			.setTheme(OClassMetaPanel.BOOTSTRAP_SELECT2_THEME);
return choice;
        } else {
        	LOG.warn("Property '"+property.getFullName()+"' doesn't have linked class specified.");
        }
    }
    
    return null;
}
 

@Before
public void setUp() {
  try (ODatabaseDocumentTx db = componentDatabase.getInstance().connect()) {
    OSchema schema = db.getMetadata().getSchema();

    OClass bucketType = schema.createClass(BUCKET_CLASS);

    OClass componentType = schema.createClass(COMPONENT_CLASS);

    componentType.createProperty(P_GROUP, OType.STRING);
    componentType.createProperty(P_NAME, OType.STRING)
        .setMandatory(true)
        .setNotNull(true);
    componentType.createProperty(P_VERSION, OType.STRING);
    componentType.createProperty(P_BUCKET, OType.LINK, bucketType).setMandatory(true).setNotNull(true);
  }

  underTest = new ComponentDatabaseUpgrade_1_2(componentDatabase.getInstanceProvider());
}
 

private IColumn<OClass, String> createCheckBoxColumn() {
    return new CheckBoxColumn<OClass, String, String>(OClassClassNameConverter.INSTANCE) {
        @Override
        public void populateItem(Item<ICellPopulator<OClass>> cellItem, String componentId, final IModel<OClass> rowModel) {
            cellItem.add(new BooleanEditPanel(componentId, getCheckBoxModel(rowModel)) {
                @Override
                protected void onConfigure() {
                    super.onConfigure();
                    List<OArchitectOClass> classes = existClasses.getObject();
                    if (classes != null) {
                        setEnabled(!OArchitectClassesUtils.isClassContainsIn(rowModel.getObject().getName(), classes));
                    }
                }
            });
        }
    };
}
 

@Override
protected Object handleGet(String propName, Class<?> returnType) {
	if(CLUSTER_SELECTION.equals(propName)) {
		String clusterSelection = (String) values.get(CLUSTER_SELECTION);
		return clusterSelection==null?null:new OClusterSelectionFactory().newInstance(clusterSelection);
	} else if (SUPER_CLASSES.equals(propName)){
		List<OClass> ret = new ArrayList<OClass>();
		List<String> superClassesNames = (List<String>) values.get(SUPER_CLASSES_NAMES);
		if(superClassesNames!=null && !superClassesNames.isEmpty()) {
			OSchema schema = OrientDbWebSession.get().getDatabase().getMetadata().getSchema();
			for (String superClassName : superClassesNames) {
				OClass superClass = schema.getClass(superClassName);
				if(superClass!=null) ret.add(superClass);
			}
		}
		return ret;
	} else {
		return super.handleGet(propName, returnType);
	}
}
 

@Override
protected void onConfigure() {
	super.onConfigure();
	String critery = getPropertyObject();
	if(OClassPrototyper.SUPER_CLASSES.equals(critery))
	{
		Collection<OClass> superClasses = (Collection<OClass>)getEnteredValue();
		AbstractMetaPanel<OClass, String, ?> onCreateFieldsPanel = getMetaComponent(CustomAttribute.ON_CREATE_FIELDS.getName());
		AbstractMetaPanel<OClass, String, ?> onCreateIdentityTypePanel = getMetaComponent(CustomAttribute.ON_CREATE_IDENTITY_TYPE.getName());
		if(onCreateFieldsPanel!=null || onCreateIdentityTypePanel!=null) {
			boolean visibility = false;
			for(OClass superClass : superClasses) {
				if(visibility = superClass.isSubClassOf(OSecurityShared.RESTRICTED_CLASSNAME)) break;
			}
			if(onCreateFieldsPanel!=null) onCreateFieldsPanel.setVisibilityAllowed(visibility);
			if(onCreateIdentityTypePanel!=null) onCreateIdentityTypePanel.setVisibilityAllowed(visibility);
		}
	}
}
 

public static boolean checkIndexExistence(final OClass iSchemaClass, final OIndexSearchResult result) {
  if (!iSchemaClass.areIndexed(result.fields()))
    return false;

  if (result.lastField.isLong()) {
    final int fieldCount = result.lastField.getItemCount();
    OClass cls = iSchemaClass.getProperty(result.lastField.getItemName(0)).getLinkedClass();

    for (int i = 1; i < fieldCount; i++) {
      if (cls == null || !cls.areIndexed(result.lastField.getItemName(i))) {
        return false;
      }

      cls = cls.getProperty(result.lastField.getItemName(i)).getLinkedClass();
    }
  }
  return true;
}
 

@Override
public void begin() {
  final OClass cls = pipeline.getGraphDatabase().getEdgeType(edgeClass);
  if (cls == null)
    pipeline.getGraphDatabase().createEdgeType(edgeClass);
  super.begin();
}
 

protected void enrichWhereByMap(OPersistenceSession session, AbstractQuery q, OClass schemaClass, Map<String, ?> query, List<Object> args, List<String> ignore) {
	checkMapping(session);
	for(Map.Entry<String, ?> entry : query.entrySet()) {
		if((mappingFromEntityToDoc.containsKey(entry.getKey()) || mappingFromEntityToDoc.containsKey(entry.getKey()))
				&& (ignore==null || !ignore.contains(entry.getKey()))) {
			String docMapping = mappingFromEntityToDoc.get(entry.getKey());
			if(docMapping==null) docMapping = mappingFromQueryToDoc.get(entry.getKey());
			Object value = entry.getValue();
			if(value!=null) {
				where(q, clause(docMapping, Operator.EQ, Parameter.PARAMETER));
				args.add(convertValueFromEntity(entry.getKey(), value));
			}
		}
	}
}
 

@Override
public List<OProperty> getDisplayableProperties(OClass oClass) {
	Collection<OProperty> properties =  oClass.properties();
	IFilterPredicateFactory factory = OrienteerWebApplication.get().getServiceInstance(IFilterPredicateFactory.class);
	Collection<OProperty> filteredProperties = Collections2.filter(properties, factory.getGuicePredicateForTableProperties());
	if(filteredProperties==null || filteredProperties.isEmpty()) filteredProperties = properties;
	return ORDER_PROPERTIES_BY_ORDER.sortedCopy(filteredProperties);
}
 

@Override
protected void defineType(final OClass type) {
  type.createProperty(P_NAME, OType.STRING).setNotNull(true);
  type.createProperty(P_TYPE, OType.STRING).setNotNull(true);
  type.createProperty(P_CONTENT, OType.STRING).setNotNull(true);

  //ensure name is unique as it serves as the ID for a script
  type.createIndex(I_NAME, INDEX_TYPE.UNIQUE, P_NAME);
}
 

@Override
protected String doEncode(final OClass type, final ORID rid) throws Exception {
  Cipher cipher = crypto.createCipher(TRANSFORMATION);
  // rid is 10 byte long, need to be in multiples of 8 for cipher
  byte[] plain = ByteBuffer.allocate(16).put(rid.toStream()).array();
  cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
  byte[] encrypted = cipher.doFinal(plain);
  return Hex.encode(encrypted);
}
 

protected void delete(final OPersistenceSession session, org.camunda.bpm.engine.query.Query<?, ? super T> query, Function<Query, Query> queryManger, String... ignoreFileds) {
	try {
		OClass schemaClass = session.getClass(getSchemaClass());
		Query q = new Query().from(getSchemaClass());
		List<Object> args = new ArrayList<>();
		enrichWhereByBean(session, q, schemaClass, query, args, Arrays.asList(ignoreFileds));
		if(queryManger!=null) q = queryManger.apply(q);
		command(session, q.toString(), args.toArray());
	} catch (Exception e) {
		throw new ProcessEngineException("Problems with read method of "+query.getClass().getName(), e);
	} 
}
 

@BeforeClass
public void init() {
  initDB();
  OSchema schema = databaseDocumentTx.getMetadata().getSchema();
  OClass v = schema.getClass("V");
  OClass song = schema.createClass("Person");
  song.setSuperClass(v);
  song.createProperty("isDeleted", OType.BOOLEAN);

  databaseDocumentTx.command(new OCommandSQL("create index Person.isDeleted on Person (isDeleted) FULLTEXT ENGINE LUCENE"))
      .execute();

}
 

@Override
protected void defineType(final OClass type) {
  type.createProperty(P_ENABLED, OType.BOOLEAN);
  type.createProperty(P_HOST, OType.STRING);
  type.createProperty(P_PORT, OType.INTEGER);
  type.createProperty(P_USERNAME, OType.STRING);
  type.createProperty(P_PASSWORD, OType.STRING);
  type.createProperty(P_FROM_ADDRESS, OType.STRING);
  type.createProperty(P_SUBJECT_PREFIX, OType.STRING);
  type.createProperty(P_START_TLS_ENABLED, OType.BOOLEAN);
  type.createProperty(P_START_TLS_REQUIRED, OType.BOOLEAN);
  type.createProperty(P_SSL_ON_CONNECT_ENABLED, OType.BOOLEAN);
  type.createProperty(P_SSL_CHECK_SERVER_IDENTITY_ENABLED, OType.BOOLEAN);
  type.createProperty(P_NEXUS_TRUST_STORE_ENABLED, OType.BOOLEAN);
}
 

@Override
public boolean isSupportedMethod(IMethodContext dataObject) {
	if (orientPermission!=null){
		Object obj = dataObject.getDisplayObjectModel().getObject();
		if(obj instanceof ODocument){
			return OSecurityHelper.isAllowed((ODocument)obj, orientPermission);
		}else if(obj instanceof OClass){
			return OSecurityHelper.isAllowed((OClass)obj, orientPermission);
		}
	}
	return true;
}
 

private void createBucketNameIndex() {
  try (ODatabaseDocumentTx db = componentDatabaseInstance.get().connect()) {
    if (db.getMetadata().getIndexManager().getIndex(I_BUCKET_NAME_VERSION) == null) {
      OSchema schema = db.getMetadata().getSchema();
      OClass type = schema.getClass(COMPONENT_CLASS);
      if (type != null) {
        type.createIndex(I_BUCKET_NAME_VERSION, INDEX_TYPE.NOTUNIQUE, new String[] { P_BUCKET, P_NAME, P_VERSION });
      }
    }
  }
}
 

@Test
public void testRegister() {
  try (ODatabaseDocumentTx db = database.getInstance().connect()) {
    entityAdapter.register(db);
    OSchema schema = db.getMetadata().getSchema();
    assertThat(schema.getClass(entityAdapter.getTypeName()), is(notNullValue()));
    verify(componentEntityAdapterExtension).defineType(any(ODatabaseDocumentTx.class), any(OClass.class));
  }
}
 

@Override
protected void defineType(final OClass type) {
  type.createProperty(P_ID, OType.STRING)
      .setNotNull(true);
  type.createProperty(P_NAME, OType.STRING)
      .setNotNull(true);
  type.createProperty(P_DESCRIPTION, OType.STRING);
  type.createProperty(P_PRIVILEGES, OType.EMBEDDEDSET);
  type.createProperty(P_ROLES, OType.EMBEDDEDSET);

  type.createIndex(I_ID, INDEX_TYPE.UNIQUE, P_ID);
}
 

public static OArchitectOClass toArchitectOClass(OClass oClass) {
    OArchitectOClass architectOClass = new OArchitectOClass(oClass.getName());
    architectOClass.setExistsInDb(true);

    architectOClass.setProperties(toOArchitectProperties(oClass, oClass.getSuperClasses()));
    architectOClass.setSuperClasses(toOArchitectClassNames(oClass.getSuperClasses()));
    architectOClass.setSubClasses(toOArchitectClassNames(oClass.getSubclasses()));
    architectOClass.setPageUrl("/class/" + oClass.getName());
    return architectOClass;
}
 

@BeforeClass
public void init() {
  initDB();

  OSchema schema = databaseDocumentTx.getMetadata().getSchema();
  OClass oClass = schema.createClass("City");

  oClass.createProperty("name", OType.STRING);
  databaseDocumentTx.command(new OCommandSQL("create index City.name on City (name) FULLTEXT ENGINE LUCENE")).execute();
}
 

@Override
protected void defineType(final ODatabaseDocumentTx db, final OClass type) {
  defineType(type);

  // primary index that guarantees path uniqueness for nodes in a given repository
  type.createIndex(I_REPOSITORY_NAME_PARENT_PATH_NAME, INDEX_TYPE.UNIQUE, P_REPOSITORY_NAME, P_PARENT_PATH, P_NAME);

  // save space and ignore nulls because we'll never query on a null component/asset id
  ODocument ignoreNullValues = db.newInstance().field("ignoreNullValues", true);
  type.createIndex(I_COMPONENT_ID, INDEX_TYPE.NOTUNIQUE.name(), null, ignoreNullValues, new String[] { P_COMPONENT_ID });
  type.createIndex(I_ASSET_ID, INDEX_TYPE.UNIQUE.name(), null, ignoreNullValues, new String[] { P_ASSET_ID });
}
 

private static OIndex<?> maybeCreateIndex(final OClass clazz, final String name, final String... props) {
  OIndex<?> index = clazz.getClassIndex(name);
  if (index == null) {
    index = clazz.createIndex(name, UNIQUE, props);
  }
  return index;
}
 

@Override
	public void onRecordAfterDelete(ODocument doc) {
		if(enter(doc))
		{
			try
			{
				OClass thisOClass = doc.getSchemaClass();
//				if(thisOClass==null) return;
				Collection<OProperty> refProperties = getCache().get(thisOClass);
				for (OProperty oProperty : refProperties)
				{
					OProperty inverseProperty = CustomAttribute.PROP_INVERSE.getValue(oProperty);
					Object value = doc.field(oProperty.getName());
					if(value instanceof OIdentifiable) value = Arrays.asList(value);
					if(inverseProperty!=null && value!=null && value instanceof Collection)
					{
						for(Object otherObj: (Collection<?>)value)
						{
							if(otherObj instanceof OIdentifiable)
							{
								ODocument otherDoc = ((OIdentifiable) otherObj).getRecord();
								removeLink(otherDoc, inverseProperty, doc);
							}
						}
					}
				}
			} catch (ExecutionException e)
			{
				LOG.error("Can't update reverse links onDelete", e);
			}
			finally
			{
				exit(doc);
			}
		}
	}