import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
/**
 * Used by the framework to transfer file between application tiers.
 */
public static FileDescriptor fromUrlParam(String urlParam) {
    String[] parts = urlParam.split(",");
    if (parts.length != 3 && parts.length != 4) {
        throw new IllegalArgumentException("Invalid FileDescriptor format");
    }
    Metadata metadata = AppBeans.get(Metadata.NAME);
    FileDescriptor fd = metadata.create(FileDescriptor.class);
    fd.setId(UuidProvider.fromString(parts[0]));
    fd.setExtension(parts[1]);
    fd.setCreateDate(new Date(Long.parseLong(parts[2])));
    if (parts.length == 4) {
        fd.setSize(Long.parseLong(parts[3]));
    }
    return fd;
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
public KeyValueMetaProperty(MetaClass metaClass, String name, Class javaClass) {
    this.name = name;
    this.javaClass = javaClass;
    this.metaClass = metaClass;
    this.mandatory = false;

    Metadata metadata = AppBeans.get(Metadata.NAME);
    Session metadataSession = metadata.getSession();
    if (Entity.class.isAssignableFrom(javaClass)) {
        range = new ClassRange(metadataSession.getClass(javaClass));
        this.type = Type.ASSOCIATION;
    } else if (EnumClass.class.isAssignableFrom(javaClass)) {
        @SuppressWarnings("unchecked")
        EnumerationImpl enumeration = new EnumerationImpl(javaClass);
        this.range = new EnumerationRange(enumeration);
        this.type = Type.ENUM;
    } else {
        this.range = new DatatypeRange(Datatypes.getNN(javaClass));
        this.type = Type.DATATYPE;
    }
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
public DynamicAttributesMetaProperty(MetaClass metaClass, CategoryAttribute attribute) {
    this.attribute = attribute;
    this.javaClass = DynamicAttributesUtils.getAttributeClass(attribute);
    this.metaClass = metaClass;
    this.name = DynamicAttributesUtils.encodeAttributeCode(attribute.getCode());
    this.mandatory = attribute.getRequired();

    Metadata metadata = AppBeans.get(Metadata.NAME);
    Session metadataSession = metadata.getSession();
    if (Entity.class.isAssignableFrom(javaClass)) {
        range = new ClassRange(metadataSession.getClass(javaClass));
        this.type = Type.ASSOCIATION;
    } else {
        this.range = new DatatypeRange(Datatypes.getNN(javaClass));
        this.type = Type.DATATYPE;
    }
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
@Override
public void loadComponent() {
    super.loadComponent();

    SearchPickerField searchPickerField = (SearchPickerField) resultComponent;

    String metaClass = element.attributeValue("metaClass");
    if (!StringUtils.isEmpty(metaClass)) {
        Metadata metadata = AppBeans.get(Metadata.NAME);
        searchPickerField.setMetaClass(metadata.getSession().getClass(metaClass));
    }

    loadActions(searchPickerField, element);
    if (searchPickerField.getActions().isEmpty()) {
        searchPickerField.addLookupAction();
        searchPickerField.addOpenAction();
    }

    String minSearchStringLength = element.attributeValue("minSearchStringLength");
    if (StringUtils.isNotEmpty(minSearchStringLength)) {
        searchPickerField.setMinSearchStringLength(Integer.parseInt(minSearchStringLength));
    }
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
public EntityCacheConnection(RemoteCommandManager rcm, ClusterManagerAPI clusterManager) {
    super(rcm);
    this.metadata = AppBeans.get(Metadata.NAME);
    this.queryCacheManager = AppBeans.get(QueryCacheManager.NAME);
    this.clusterManager = clusterManager;
    rcm.logDebug("creating_broadcast_connection", getInfo());
    try {
        this.clusterManager.addListener(Message.class, new ClusterListenerAdapter<Message>() {
            @Override
            public void receive(Message message) {
                onMessage(message);
            }
        });
        rcm.logDebug("broadcast_connection_created", getInfo());
    } catch (RuntimeException ex) {
        rcm.logDebug("failed_to_create_broadcast_connection", getInfo());
        close();
        throw ex;
    }
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
    super.setUp();
    try {
        if (!initialized) {
            System.setProperty("cuba.unitTestMode", "true");
            cont = new CommonTestContainer();
            cont.setAppComponents(getTestAppComponents());
            cont.setAppPropertiesFiles(getTestAppProperties());
            cont.setSpringConfig(getTestSpringConfig());
            ((CommonTestContainer) cont).before();
            initialized = true;
        }

        ((CommonTestContainer) cont).setupContext();

        persistence = AppBeans.get(Persistence.class);
        metadata = AppBeans.get(Metadata.class);
        passwordEncryption = AppBeans.get(PasswordEncryption.class);
    } catch (Throwable throwable) {
        if (throwable instanceof Exception)
            throw (Exception) throwable;
        else
            throw new RuntimeException(throwable);
    }
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
protected boolean isInversePropertyAssignableFromDsClass(MetaProperty inverseProp) {
    Metadata metadata = AppBeans.get(Metadata.NAME);
    ExtendedEntities extendedEntities = metadata.getExtendedEntities();

    Class inversePropClass = extendedEntities.getEffectiveClass(inverseProp.getDomain());
    Class dsClass = extendedEntities.getEffectiveClass(datasource.getMetaClass());

    //noinspection unchecked
    return inversePropClass.isAssignableFrom(dsClass);
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
private String getCollectionString(Object collection) {
    if (DynamicAttributesUtils.isDynamicAttribute(propertyName)) {
        Metadata metadata = AppBeans.get(Metadata.class);
        com.haulmont.chile.core.model.MetaClass metaClass = metadata.getClassNN(metaClassName);
        MetaPropertyPath path = DynamicAttributesUtils.getMetaPropertyPath(metaClass, propertyName);
        return metadata.getTools().format(collection, path.getMetaProperty());
    }
    return String.valueOf(beforeValue);
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
public EntityImportView addLocalProperties() {
    Metadata metadata = AppBeans.get(Metadata.class);
    MetaClass metaClass = metadata.getClassNN(entityClass);
    MetadataTools metadataTools = metadata.getTools();
    metaClass.getProperties().stream()
            .filter(property -> !property.getRange().isClass() && !metadataTools.isSystem(property))
            .forEach(metaProperty -> addLocalProperty(metaProperty.getName()));
    return this;
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
public EntityImportView addSystemProperties() {
    Metadata metadata = AppBeans.get(Metadata.class);
    MetaClass metaClass = metadata.getClassNN(entityClass);
    MetadataTools metadataTools = metadata.getTools();
    metaClass.getProperties().stream()
            .filter(metadataTools::isSystem)
            .forEach(metaProperty -> addLocalProperty(metaProperty.getName()));
    return this;
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
protected MetaClass resolveTargetMetaClass(MetaClass metaClass) {
    if (metaClass == null) {
        return null;
    }

    Metadata metadata = AppBeans.get(Metadata.NAME);
    MetaClass targetMetaClass = metadata.getExtendedEntities().getOriginalMetaClass(metaClass);
    if (targetMetaClass == null) {
        targetMetaClass = metaClass;
    }
    return targetMetaClass;
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
private boolean isEntityClass(String className) {
    Metadata metadata = AppBeans.get(Metadata.NAME);
    try {
        Class entityClass = ReflectionHelper.loadClass(className);
        MetaClass metaClass = metadata.getClass(entityClass);
        return metaClass != null;
    } catch (ClassNotFoundException e) {
        return false;
    }
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
public MetaPropertyInfo(MetaProperty metaProperty) {
    Messages messages = AppBeans.get(Messages.class);
    Metadata metadata = AppBeans.get(Metadata.class);
    this.name = metaProperty.getName();
    this.attributeType = metaProperty.getType();
    switch (attributeType) {
        case DATATYPE:
            Datatype<Object> datatype = metaProperty.getRange().asDatatype();
            try {
                this.type = metadata.getDatatypes().getId(datatype);
            } catch (Exception e) {
                this.type = datatype.toString();
            }
            break;
        case ASSOCIATION:
        case COMPOSITION:
            this.type = metaProperty.getRange().asClass().getName();
            break;
        case ENUM:
            this.type = metaProperty.getRange().asEnumeration().getJavaClass().getName();
            break;
    }
    this.cardinality = metaProperty.getRange().getCardinality();
    this.readOnly = metaProperty.isReadOnly();
    this.mandatory = metaProperty.isMandatory();
    this.isPersistent = metadata.getTools().isPersistent(metaProperty);
    this.isTransient = metadata.getTools().isNotPersistent(metaProperty);
    this.description = messages.getTools().getPropertyCaption(metaProperty);
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
public InstanceRef(EntityLoadInfo loadInfo) throws InstantiationException, IllegalAccessException {
    if (loadInfo == null)
        throw new NullPointerException("No load info passed");

    this.loadInfo = loadInfo;
    MetaClass childMetaClass = loadInfo.getMetaClass();
    if (!Strings.isNullOrEmpty(loadInfo.getViewName()) && !loadInfo.isNewEntity()) {
        DataService dataService = AppBeans.get(DataService.class);
        LoadContext<BaseGenericIdEntity<Object>> ctx = new LoadContext<>(loadInfo.getMetaClass());
        ctx.setId(loadInfo.getId()).setView(loadInfo.getViewName());
        instance = dataService.load(ctx);
        if (instance == null) {
            throw new RuntimeException("Entity with loadInfo " + loadInfo + " not found");
        }
    } else {
        //noinspection unchecked
        instance = (BaseGenericIdEntity<Object>) AppBeans.get(Metadata.class).create(childMetaClass);
        if (!loadInfo.isNewEntity()) {
            for (MetaProperty metaProperty : childMetaClass.getProperties()) {
                if (!metaProperty.getRange().isClass()) {
                    try {
                        instance.setValue(metaProperty.getName(), null);
                    } catch (Exception ignored) {
                    }
                }
            }
        }
    }
    instance.setId(this.loadInfo.getId());
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
public OperationPermissionTarget(Class entityClass, String id, String caption, String permissionValue) {
    super(id, caption);
    Metadata metadata = AppBeans.get(Metadata.class);
    Messages messages = AppBeans.get(Messages.class);
    MetaClass metaclass = metadata.getClassNN(entityClass);

    this.entityMetaClass = metaclass;
    this.entityMetaClassName = metaclass.getName();
    this.localName = messages.getTools().getEntityCaption(metaclass);
    this.permissionValue = permissionValue;
    this.entityClass = entityClass;
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
public MultiplePermissionTarget(Class entityClass, String id, String caption, String permissionValue) {
    super(id, caption);
    Metadata metadata = AppBeans.get(Metadata.class);
    Messages messages = AppBeans.get(Messages.class);
    MetaClass metaclass = metadata.getClassNN(entityClass);

    this.entityMetaClass = metaclass;
    this.entityMetaClassName = metaclass.getName();
    this.localName = messages.getTools().getEntityCaption(metaclass);
    this.entityClass = entityClass;
    this.caption = caption;
    this.permissionValue = permissionValue;
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
public EntityNameFilter(Metadata metadata, CheckBox assignedOnlyCheckBox, CheckBox systemLevelCheckBox,
                        TextField entityFilter) {
    this.metadata = metadata;
    this.assignedOnlyCheckBox = assignedOnlyCheckBox;
    this.systemLevelCheckBox = systemLevelCheckBox;
    this.entityFilter = entityFilter;
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
/**
 * Add or edit permission item in datasource
 * @param ds Datasource
 * @param roleDs Role datasource
 * @param permissionTarget Permission identifier
 * @param type Permission type
 * @param value Permission value
 */
public static void createPermissionItem(CollectionDatasource<Permission, UUID> ds, Datasource<Role> roleDs,
                                        final String permissionTarget, PermissionType type, Integer value) {
    Permission permission = null;
    for (Permission p : ds.getItems()) {
        if (Objects.equals(p.getTarget(), permissionTarget)) {
            permission = p;
            break;
        }
    }

    if (permission == null) {
        // workaround for idx_sec_permission_unique
        // restore entity instead of create
        if (ds instanceof RestorablePermissionDatasource) {
            RestorablePermissionDatasource datasource = (RestorablePermissionDatasource) ds;

            permission = datasource.findRemovedEntity(p ->
                p != null && Objects.equals(p.getTarget(), permissionTarget)
            );
            if (permission != null) {
                datasource.restoreEntity(permission);
            }
        }
    }

    if (permission == null) {
        Metadata metadata = AppBeans.get(Metadata.NAME);

        Permission newPermission = metadata.create(Permission.class);
        newPermission.setRole(roleDs.getItem());
        newPermission.setTarget(permissionTarget);
        newPermission.setType(type);
        newPermission.setValue(value);

        ds.addItem(newPermission);
    } else {
        permission.setValue(value);
    }
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
protected void loadMetaClass(SuggestionPickerField suggestionField, Element element) {
    String metaClass = element.attributeValue("metaClass");
    if (!StringUtils.isEmpty(metaClass)) {
        Metadata metadata = AppBeans.get(Metadata.NAME);
        suggestionField.setMetaClass(metadata.getSession().getClass(metaClass));
    }
}
 

import com.haulmont.cuba.core.global.Metadata; //导入依赖的package包/类
@Override
public void loadComponent() {
    super.loadComponent();

    loadTabIndex(resultComponent, element);

    String captionProperty = element.attributeValue("captionProperty");
    if (!StringUtils.isEmpty(captionProperty)) {
        resultComponent.setCaptionMode(CaptionMode.PROPERTY);
        resultComponent.setCaptionProperty(captionProperty);
    }

    final String metaClass = element.attributeValue("metaClass");
    if (!StringUtils.isEmpty(metaClass)) {
        Metadata metadata = AppBeans.get(Metadata.NAME);
        resultComponent.setMetaClass(metadata.getClassNN(metaClass));
    }

    loadActions(resultComponent, element);
    if (resultComponent.getActions().isEmpty()) {
        boolean actionsByMetaAnnotations = ComponentsHelper.createActionsByMetaAnnotations(resultComponent);
        if (!actionsByMetaAnnotations) {
            resultComponent.addLookupAction();
            resultComponent.addClearAction();
        }
    }

    loadBuffered(resultComponent, element);
}