import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Test
public void testCrossJoinViewParentReference() throws Exception {
    List<Group> result;
    try (Transaction tx = cont.persistence().createTransaction()) {
        EntityManager em = cont.entityManager();
        View view = new View(Group.class).addProperty("parent");
        TypedQuery<Group> query = em.createQuery("select g from sec$Group g, sec$User u where u.group = g", Group.class);
        query.setView(view);
        result = query.getResultList();
        tx.commit();
    }
    for (Group g : result) {
        g = reserialize(g);
        if (g.equals(rootGroup))
            assertNull(g.getParent());
        else if (g.equals(group))
            assertEquals(rootGroup, g.getParent());
    }
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Test
public void testReferenceToDeletedEntityThroughOneToMany() throws Exception {
    View userRoleView = new View(UserRole.class).addProperty("role", new View(Role.class).addProperty("deleteTs"));
    View userView = new View(User.class).addProperty("userRoles", userRoleView);

    Role deleted = cont.persistence().callInTransaction((em) -> em.find(Role.class, role3Id));
    assertNull(deleted);

    UserRole userRole = cont.persistence().callInTransaction((em) -> em.find(UserRole.class, userRole3Id, userRoleView));
    assertNotNull(userRole.getRole());
    assertEquals(role3Id, userRole.getRole().getId());
    assertTrue(userRole.getRole().isDeleted());

    User user = cont.persistence().callInTransaction((em) -> em.find(User.class, user1Id, userView));
    assertEquals(role3Id, user.getUserRoles().iterator().next().getRole().getId());
    Assert.assertTrue(user.getUserRoles().iterator().next().getRole().isDeleted());
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public CollectionDsWrapper(CollectionDatasource datasource, Collection<MetaPropertyPath> properties,
                           boolean autoRefresh, CollectionDsListenersWrapper collectionDsListenersWrapper) {
    this.datasource = datasource;
    this.autoRefresh = autoRefresh;
    this.collectionDsListenersWrapper = collectionDsListenersWrapper;

    final View view = datasource.getView();
    final MetaClass metaClass = datasource.getMetaClass();

    if (properties == null) {
        createProperties(view, metaClass);
    } else {
        this.properties.addAll(properties);
    }

    cdsItemPropertyChangeListener = createItemPropertyChangeListener();
    cdsStateChangeListener = createStateChangeListener();
    cdsCollectionChangeListener = createCollectionChangeListener();

    collectionDsListenersWrapper.addItemPropertyChangeListener(cdsItemPropertyChangeListener);
    collectionDsListenersWrapper.addStateChangeListener(cdsStateChangeListener);
    collectionDsListenersWrapper.addCollectionChangeListener(cdsCollectionChangeListener);
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Test
public void testCrossJoinWithToManyView() throws Exception {
    List<Group> result;
    try (Transaction tx = cont.persistence().createTransaction()) {
        EntityManager em = cont.entityManager();
        View view = new View(Group.class).addProperty("constraints");
        TypedQuery<Group> query = em.createQuery("select g from sec$Group g, sec$User u where u.group = g", Group.class);
        query.setView(view);
        result = query.getResultList();
        tx.commit();
    }
    for (Group group : result) {
        group = reserialize(group);
        group.getConstraints().size();
    }
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
/**
 * Get single query results from query cache by specified {@code queryKey}
 * If query is cached and no results found exception is thrown
 */
@SuppressWarnings("unchecked")
public <T> T getSingleResultFromCache(QueryKey queryKey, List<View> views) {
    log.debug("Looking for query in cache: {}", queryKey.printDescription());
    QueryResult queryResult = queryCache.get(queryKey);
    if (queryResult != null) {
        MetaClass metaClass = metadata.getClassNN(queryResult.getType());
        if (!metadata.getTools().isCacheable(metaClass)) {
            log.warn("Using cacheable query without entity cache for {}", queryResult.getType());
        }
        if (queryResult.getException() != null) {
            RuntimeException ex = queryResult.getException();
            ex.fillInStackTrace();
            throw queryResult.getException();
        }
        EntityManager em = persistence.getEntityManager();
        for (Object id : queryResult.getResult()) {
            return (T) em.find(metaClass.getJavaClass(), id, views.toArray(new View[views.size()]));
        }
    }
    log.debug("Query results are not found in cache: {}", queryKey.printDescription());
    return null;
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Test
public void testCheckLoaded() {
    Server server = new Server();

    cont.persistence().runInTransaction((em) -> {
        em.persist(server);
    });

    View view = new View(Server.class).addProperty("name").addProperty("data")
            .setLoadPartialEntities(true);
    Server reloadedServer = cont.persistence().callInTransaction((em) -> {
        return em.find(Server.class, server.getId(), view);
    });

    PersistenceHelper.checkLoaded(reloadedServer, "name"); // fine

    try {
        PersistenceHelper.checkLoaded(reloadedServer, "data", "running");
        Assert.fail("Must throw exception");
    } catch (IllegalArgumentException e) {
        Assert.assertTrue(e.getMessage().contains("Server.running"));
    }
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Test
public void test() throws Exception {
    User user = metadata.create(User.class);
    try (Transaction tx = persistence.createTransaction()) {
        EntityManager em = persistence.getEntityManager();

        user.setGroup(em.getReference(Group.class, UUID.fromString("0fa2b1a5-1d68-4d69-9fbd-dff348347f93")));
        user.setLogin("u-" + user.getId());
        em.persist(user);

        TypedQuery<User> query = em.createQuery("select u from sec$User u where u.loginLowerCase = :login", User.class);
        query.setParameter("login", user.getLogin());
        query.setViewName(View.LOCAL); // setting a view leads to using FlushModeType.AUTO - see QueryImpl.getQuery()
        List<User> list = query.getResultList();
        assertEquals(1, list.size());
        assertEquals(user, list.get(0));

        tx.commit();
    }
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Test
public void testFind() throws Exception {

    View view = new View(User.class, false)
            .addProperty("name")
            .addProperty("login")
            .addProperty("group", new View(Group.class)
                    .addProperty("name"));

    User user;

    try (Transaction tx = cont.persistence().createTransaction()) {
        EntityManager em = cont.persistence().getEntityManager();
        user = em.find(User.class, userId, view);

        tx.commit();
    }
    user = reserialize(user);

    assertNotNull(user.getCreatedBy());
    assertNotNull(user.getGroup());
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
private UserSetting loadUserSetting() throws Exception {
    UserSetting us;
    View usView = new View(UserSetting.class)
            .addProperty("name")
            .addProperty("user", new View(User.class)
                    .addProperty("login"));
    try (Transaction tx = cont.persistence().createTransaction()) {
        us = cont.entityManager().find(UserSetting.class, this.userSetting.getId(), usView);
        assertNotNull(us);
        tx.commit();
    }
    us = reserialize(us);
    assertEquals(userSetting, us);
    assertEquals(user, us.getUser());
    return us;
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Test
public void testDatasource() {
    OptionsList component = factory.createComponent(OptionsList.class);

    //noinspection unchecked
    Datasource<User> testDs = new DsBuilder()
            .setId("testDs")
            .setJavaClass(User.class)
            .setView(viewRepository.getView(User.class, View.LOCAL))
            .buildDatasource();

    testDs.setItem(new User());
    ((DatasourceImpl) testDs).valid();

    assertNull(component.getValue());

    component.setDatasource(testDs, "group");
    assertNotNull(component.getDatasource());
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
protected CollectionDatasource<Group, UUID> getTestCollectionDatasource() {
    // noinspection unchecked
    CollectionDatasource<Group, UUID> collectionDatasource = new DsBuilder()
            .setId("testDs")
            .setJavaClass(Group.class)
            .setView(viewRepository.getView(Group.class, View.LOCAL))
            .setRefreshMode(CollectionDatasource.RefreshMode.NEVER)
            .setAllowCommit(false)
            .buildCollectionDatasource();

    for (int i = 0; i < 3; i++) {
        Group group = metadata.create(Group.class);
        group.setName("Group #" + (i + 1));

        Group parentGroup = metadata.create(Group.class);
        parentGroup.setName("Parent group #" + (i + 1));
        group.setParent(parentGroup);

        collectionDatasource.addItem(group);
    }
    ((CollectionDatasourceImpl) collectionDatasource).valid();

    return collectionDatasource;
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Test
public void testDatasource() {
    OptionsGroup component = factory.createComponent(OptionsGroup.class);

    //noinspection unchecked
    Datasource<User> testDs = new DsBuilder()
            .setId("testDs")
            .setJavaClass(User.class)
            .setView(viewRepository.getView(User.class, View.LOCAL))
            .buildDatasource();

    testDs.setItem(new User());
    ((DatasourceImpl) testDs).valid();

    assertNull(component.getValue());

    component.setDatasource(testDs, "group");
    assertNotNull(component.getDatasource());
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
public static View intersectViews(View first, View second) {
    if (first == null)
        throw new IllegalArgumentException("View is null");
    if (second == null)
        throw new IllegalArgumentException("View is null");

    View resultView = new View(first.getEntityClass());

    Collection<ViewProperty> firstProps = first.getProperties();

    for (ViewProperty firstProperty : firstProps) {
        if (second.containsProperty(firstProperty.getName())) {
            View resultPropView = null;
            ViewProperty secondProperty = second.getProperty(firstProperty.getName());
            if ((firstProperty.getView() != null) && (secondProperty.getView() != null)) {
                resultPropView = intersectViews(firstProperty.getView(), secondProperty.getView());
            }
            resultView.addProperty(firstProperty.getName(), resultPropView);
        }
    }

    return resultView;
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
protected int migrateAttachmentsBatch() {
    List<SendingAttachment> resultList;
    Transaction tx = persistence.createTransaction();
    try {
        EntityManager em = persistence.getEntityManager();
        String qstr = "select a from sys$SendingAttachment a where a.content is not null";
        TypedQuery<SendingAttachment> query = em.createQuery(qstr, SendingAttachment.class);
        query.setMaxResults(50);
        query.setViewName(View.MINIMAL);

        resultList = query.getResultList();

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

    if (!resultList.isEmpty()) {
        emailer.migrateAttachmentsToFileStorage(resultList);
    }

    return resultList.size();
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Test
public void testLoadDeletedObject() {
    View taskView_Message = new View(SoftDelete_Task.class).addProperty("message");
    View taskView_Service = new View(SoftDelete_Task.class)
            .addProperty("service", new View(SoftDelete_Service.class).addProperty("code"));
    View taskValueView = new View(SoftDelete_TaskValue.class)
            .addProperty("task", taskView_Message);

    View projectView = new View(SoftDelete_Project.class)
            .addProperty("name")
            .addProperty("aValue", taskValueView)
            .addProperty("task", taskView_Service);

    LoadContext<SoftDelete_Project> loadContext = new LoadContext<>(SoftDelete_Project.class)
            .setView(projectView).setId(projectId);
    SoftDelete_Project project = dataManager.load(loadContext);

    Assert.assertNotNull(project);
    Assert.assertNotNull(project.getTask());
    Assert.assertTrue(project.getTask().isDeleted());
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
protected void dumpHtml(ViewProperty viewProperty, StringBuilder content, String indent) {
    content.append("<br/>").append("\n");
    content.append(indent);
    content.append("- ").append(viewProperty.getName());
    View innerView = viewProperty.getView();
    if (innerView != null) {
        if (StringUtils.isNotEmpty(innerView.getName())) {
            String metaClassName = metadata.getSession().getClass(innerView.getEntityClass()).getName();
            content.append(" -> <a href=\"#").append(metaClassName).append("__").append(innerView.getName()).append("\">")
                    .append(metaClassName)
                    .append("/")
                    .append(innerView.getName())
                    .append("</a>");
        } else {
            for (ViewProperty innerProperty : innerView.getProperties()) {
                dumpHtml(innerProperty, content, "&nbsp;&nbsp;&nbsp;&nbsp;" + indent);
            }
        }
    }
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Test
public void testLostChangeOnReloadWithView1() throws Exception {
    cont.persistence().runInTransaction((em) -> {
        User u = loadUserByName(em, View.LOCAL);

        u.setLanguage("en");

        u = loadUserByName(em, View.LOCAL);

        assertEquals("en", u.getLanguage());
    });
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Test
public void testJoinOnWithToManyView() throws Exception {
    try (Transaction tx = cont.persistence().createTransaction()) {
        EntityManager em = cont.entityManager();
        View view = new View(Group.class).addProperty("constraints");
        TypedQuery<Group> query = em.createQuery("select g from sec$Group g join sys$QueryResult qr on qr.entityId = g.id where qr.queryKey = 1", Group.class);
        query.setView(view);
        List<Group> result = query.getResultList();
        tx.commit();
    }
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
protected Project resolveProjectId(CommandLineProcessor commandLineProcessor) {
    Project project = null;
    String projectCode = commandLineProcessor.getProjectCode();
    String taskCode = commandLineProcessor.getTaskCode();
    if (projectCode != null) {
        project = projectsService.getEntityByCode(Project.class, projectCode, View.MINIMAL);
    } else if (taskCode != null) {
        Task task = projectsService.getEntityByCode(Task.class, taskCode, "task-full");
        if (task != null) {
            project = task.getProject();
        }
    }
    return project;
}
 

import com.haulmont.cuba.core.global.View; //导入依赖的package包/类
@Nullable
@Override
public List<TimeEntry> createTimeEntriesForTheCommandLine(String commandLine) {
    CommandLineProcessor commandLineProcessor = new CommandLineProcessor(commandLine);
    String taskCode = commandLineProcessor.getTaskCode();
    String activityTypeCode = commandLineProcessor.getActivityType();
    List<String> tagCodes = commandLineProcessor.getTagCodes();
    if (taskCode != null) {
        Task task = systemDataManager.getEntityByCode(Task.class, taskCode, "task-full");
        if (task != null) {
            List<Tag> tags = systemDataManager.getEntitiesByCodes(Tag.class, tagCodes, View.MINIMAL);
            ActivityType activityType = systemDataManager.getEntityByCode(ActivityType.class, activityTypeCode, View.LOCAL);

            TimeEntry timeEntry = metadata.create(TimeEntry.class);
            timeEntry.setTask(task);
            timeEntry.setActivityType(activityType);
            timeEntry.setTags(new HashSet<>(tags));
            timeEntry.getTags().addAll(task.getDefaultTags());
            String spentTime = commandLineProcessor.getSpentTime();
            if (spentTime != null) {
                HoursAndMinutes hoursAndMinutes = timeParser.parseToHoursAndMinutes(spentTime);
                timeEntry.setTimeInMinutes(hoursAndMinutes.toMinutes());
            } else {
                timeEntry.setTimeInMinutes(0);
            }
            timeEntry.setDate(timeSource.currentTimestamp());

            return Arrays.asList(timeEntry);
        }
    }

    return null;
}