Java Metadata.create方法代码示例

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包/类
/**
 * 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 applyFilter(Filter filterComponent) {
    Metadata metadata = AppBeans.get(Metadata.class);
    FilterEntity filterEntity = metadata.create(FilterEntity.class);
    filterEntity.setComponentId(ComponentsHelper.getFilterComponentPath(filterComponent));
    filterEntity.setName(messages.getMainMessage("dynamicAttributes.entity.filter"));
    filterEntity.setXml(createFilterXml(filterComponent));
    filterEntity.setUser(userSession.getCurrentOrSubstitutedUser());

    filterComponent.setFilterEntity(filterEntity);
    filterComponent.apply(true);
}
 

import com.haulmont.cuba.core.global.Metadata; //导入方法依赖的package包/类
public FilterEntity createFakeFilterEntity(String xml) {
    if (filterEntity != null) return filterEntity;

    Metadata metadata = AppBeans.get(Metadata.NAME);
    FilterEntity fakeFilterEntity = metadata.create(FilterEntity.class);
    fakeFilterEntity.setXml(xml);
    return fakeFilterEntity;
}
 

import com.haulmont.cuba.core.global.Metadata; //导入方法依赖的package包/类
@Override
public void setDbProperty(String name, String value) {
    Preconditions.checkNotNullArgument(name, "name is null");
    Transaction tx = persistence.getTransaction();
    try {
        EntityManager em = persistence.getEntityManager();
        Config instance = getConfigInstance(name);
        if (value != null) {
            if (instance == null) {
                Metadata metadata = AppBeans.get(Metadata.NAME);

                instance = metadata.create(Config.class);
                instance.setName(name.trim());
                instance.setValue(value.trim());
                em.persist(instance);
            } else {
                instance.setValue(value);
            }
        } else {
            if (instance != null)
                em.remove(instance);
        }
        tx.commit();
    } finally {
        tx.end();
    }
    clearCache();
}
 

import com.haulmont.cuba.core.global.Metadata; //导入方法依赖的package包/类
@Before
public void setUp() throws Exception {
    Transaction tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();
        Metadata metadata = cont.metadata();

        root =  metadata.create(CascadeEntity.class);
        root.setName("root");
        em.persist(root);

        first =  metadata.create(CascadeEntity.class);
        first.setName("first");
        first.setFather(root);
        em.persist(first);

        second =  metadata.create(CascadeEntity.class);
        second.setName("second");
        second.setFather(first);
        em.persist(second);

        third =  metadata.create(CascadeEntity.class);
        third.setName("third");
        third.setFather(second);
        em.persist(third);

        tx.commit();
    } finally {
        tx.end();
    }
}
 

import com.haulmont.cuba.core.global.Metadata; //导入方法依赖的package包/类
@PostConstruct
public void init() {
    Metadata metadata = AppBeans.get(Metadata.NAME);
    entityRef = metadata.create(ReferenceToEntity.class);
}
 

import com.haulmont.cuba.core.global.Metadata; //导入方法依赖的package包/类
@PostConstruct
public void init() {
    Metadata metadata = AppBeans.get(Metadata.NAME);
    defaultEntity = metadata.create(ReferenceToEntity.class);
}
 

import com.haulmont.cuba.core.global.Metadata; //导入方法依赖的package包/类
@PostConstruct
public void init() {
    Metadata metadata = AppBeans.get(Metadata.NAME);
    entity = metadata.create(ReferenceToEntity.class);
}
 

import com.haulmont.cuba.core.global.Metadata; //导入方法依赖的package包/类
@Before
public void setUp() throws Exception {
    Transaction tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();
        Metadata metadata = cont.metadata();

        joinF = metadata.create(JoinF.class);
        joinF.setName("joinF");
        em.persist(joinF);

        joinD = metadata.create(JoinD.class);
        joinD.setName("joinD");
        em.persist(joinD);

        joinE = metadata.create(JoinE.class);
        joinE.setName("joinE");
        joinE.setF(joinF);
        em.persist(joinE);

        joinC = metadata.create(JoinC.class);
        joinC.setName("joinC");
        joinC.setD(joinD);
        joinC.setE(joinE);
        em.persist(joinC);

        joinB = metadata.create(JoinB.class);
        joinB.setName("joinB");
        joinB.setC(joinC);
        em.persist(joinB);

        joinA = metadata.create(JoinA.class);
        joinA.setName("joinA");
        joinA.setB(joinB);
        em.persist(joinA);

        product = metadata.create(Product.class);
        product.setName("Product");
        em.persist(product);

        partyCustomer = metadata.create(Party.class);
        partyCustomer.setName("Customer");
        em.persist(partyCustomer);

        partyPerson = metadata.create(Party.class);
        partyPerson.setName("Person");
        em.persist(partyPerson);

        customer = metadata.create(Customer.class);
        customer.setParty(partyCustomer);
        customer.setCustomerNumber(1);
        em.persist(customer);

        salesPerson = metadata.create(SalesPerson.class);
        salesPerson.setParty(partyPerson);
        salesPerson.setSalespersonNumber(1);
        em.persist(salesPerson);

        order = metadata.create(Order.class);
        order.setOrderNumber(1);
        order.setOrderAmount(BigDecimal.ONE);
        order.setCustomer(customer);
        order.setSalesPerson(salesPerson);
        em.persist(order);

        orderLine = metadata.create(OrderLine.class);
        orderLine.setOrder(order);
        orderLine.setProduct(product);
        orderLine.setQuantity(1);
        em.persist(orderLine);

        tx.commit();
    } finally {
        tx.end();
    }
}