import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
@Nullable
@Override
public User loadUser(String login) throws LoginException {
    // first check if login is a valid user's email, and find the corresponding login name
    // to pass to the super impl
    if (login == null)
        throw new IllegalArgumentException("Login is null");

    EntityManager em = persistence.getEntityManager();
    String queryStr = "select u.loginLowerCase from sec$User u where lower(u.email) = ?1 and (u.active = true or u.active is null)";

    Query q = em.createQuery(queryStr);
    q.setParameter(1, login.toLowerCase());
    List results = q.getResultList();
    if (!results.isEmpty())
        return super.loadUser((String) results.get(0));

    return super.loadUser(login);
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
@Test
public void testNotLoadingJoinB() throws Exception {
    try (Transaction tx = cont.persistence().createTransaction()) {
        EntityManager em = cont.persistence().getEntityManager();

        View fView = new View(JoinF.class).addProperty("name");
        View eView = new View(JoinE.class).addProperty("name").addProperty("f", fView, FetchMode.JOIN);
        View dView = new View(JoinD.class).addProperty("name");
        View cView = new View(JoinC.class).addProperty("name")
                .addProperty("d", dView, FetchMode.JOIN)
                .addProperty("e", eView, FetchMode.JOIN);
        View bView = new View(JoinB.class).addProperty("name")
                .addProperty("c", cView, FetchMode.JOIN);
        View aView = new View(JoinA.class).addProperty("name")
                .addProperty("b", bView, FetchMode.JOIN);

        JoinA loadedA = em.find(JoinA.class, joinA.getId(), aView);
        assertNotNull(loadedA);
        assertNotNull(loadedA.getB().getC().getD());
        assertNotNull(loadedA.getB().getC().getE());
        assertNotNull(loadedA.getB().getC().getE().getF());
        tx.commit();
    }
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
@Nullable
protected User loadUser(String login) throws LoginException {
    if (login == null) {
        throw new IllegalArgumentException("Login is null");
    }

    EntityManager em = persistence.getEntityManager();
    String queryStr = "select u from sec$User u where u.loginLowerCase = ?1 and (u.active = true or u.active is null)";

    Query q = em.createQuery(queryStr);
    q.setParameter(1, login.toLowerCase());

    List list = q.getResultList();
    if (list.isEmpty()) {
        log.debug("Unable to find user: {}", login);
        return null;
    } else {
        //noinspection UnnecessaryLocalVariable
        User user = (User) list.get(0);
        return user;
    }
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
protected void storeAccessTokenToDatabase(String tokenValue,
                                          byte[] accessTokenBytes,
                                          String authenticationKey,
                                          byte[] authenticationBytes,
                                          Date tokenExpiry,
                                          String userLogin,
                                          @Nullable Locale locale,
                                          @Nullable String refreshTokenValue) {
    try (Transaction tx = persistence.getTransaction()) {
        EntityManager em = persistence.getEntityManager();
        AccessToken accessToken = metadata.create(AccessToken.class);
        accessToken.setCreateTs(timeSource.currentTimestamp());
        accessToken.setTokenValue(tokenValue);
        accessToken.setTokenBytes(accessTokenBytes);
        accessToken.setAuthenticationKey(authenticationKey);
        accessToken.setAuthenticationBytes(authenticationBytes);
        accessToken.setExpiry(tokenExpiry);
        accessToken.setUserLogin(userLogin);
        accessToken.setLocale(locale != null ? locale.toString() : null);
        accessToken.setRefreshTokenValue(refreshTokenValue);
        em.persist(accessToken);
        tx.commit();
    }
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
protected void storeRefreshTokenToDatabase(String tokenValue,
                                          byte[] tokenBytes,
                                          byte[] authenticationBytes,
                                          Date tokenExpiry,
                                          String userLogin) {
    try (Transaction tx = persistence.getTransaction()) {
        EntityManager em = persistence.getEntityManager();
        RefreshToken refreshToken = metadata.create(RefreshToken.class);
        refreshToken.setCreateTs(timeSource.currentTimestamp());
        refreshToken.setTokenValue(tokenValue);
        refreshToken.setTokenBytes(tokenBytes);
        refreshToken.setAuthenticationBytes(authenticationBytes);
        refreshToken.setExpiry(tokenExpiry);
        refreshToken.setUserLogin(userLogin);
        em.persist(refreshToken);
        tx.commit();
    }
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
@Test
public void testNormalMode() {
    System.out.println("===================== BEGIN testNormalMode =====================");

    Transaction tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();

        Role role = em.find(Role.class, role2Id);
        assertNull(role);

        tx.commit();
    } finally {
        tx.end();
    }
    System.out.println("===================== END testNormalMode =====================");
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
public UUID createRole() {
    Transaction tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();

        User user = em.find(User.class, UUID.fromString("60885987-1b61-4247-94c7-dff348347f93"));

        Role role = new Role();
        role.setName("RelationTest");
        em.persist(role);

        UserRole userRole = new UserRole();
        userRole.setUser(user);
        userRole.setRole(role);
        em.persist(userRole);

        tx.commit();

        return role.getId();
    } finally {
        tx.end();
    }
}
 

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

        resultList = query.getResultList();
        tx.commit();
    } finally {
        tx.end();
    }

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

    return resultList.size();
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
@Override
public List<String> getAvailableUsers() {
    List<String> result = new ArrayList<>();

    Transaction tx = persistence.createTransaction();
    try {
        EntityManager em = persistence.getEntityManager();
        Query query = em.createQuery("select u from sec$User u");
        List<User> userList = query.getResultList();
        for (User user : userList) {
            result.add(user.getLogin());
        }
        tx.commit();
    } finally {
        tx.end();
    }

    return result;
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的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.EntityManager; //导入依赖的package包/类
@Test
public void testOneToOneLazy() {
    System.out.println("===================== BEGIN testOneToOneLazy =====================");
    Transaction tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();
        SoftDeleteOneToOneA oneToOneA = em.find(SoftDeleteOneToOneA.class, oneToOneA2Id);
        assertNotNull(oneToOneA);
        assertNotNull(oneToOneA.getB());
        assertEquals(oneToOneA.getB().getId(), oneToOneB2Id);
        tx.commit();
    } finally {
        tx.end();
    }
    System.out.println("===================== END testOneToOneLazy =====================");
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
protected ScheduledExecution registerExecutionStart(ScheduledTask task, long now) {
    if (!BooleanUtils.isTrue(task.getLogStart()) && !BooleanUtils.isTrue(task.getSingleton()) && task.getSchedulingType() != SchedulingType.FIXED_DELAY)
        return null;

    log.trace("{}: registering execution start", task);

    Transaction tx = persistence.createTransaction();
    try {
        EntityManager em = persistence.getEntityManager();

        ScheduledExecution execution = metadata.create(ScheduledExecution.class);
        execution.setTask(em.getReference(ScheduledTask.class, task.getId()));
        execution.setStartTime(new Date(now));
        execution.setServer(serverInfo.getServerId());

        em.persist(execution);
        tx.commit();

        return execution;
    } finally {
        tx.end();
    }
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
@Test
public void testEntityListenerOnUpdate() throws Exception {
    EntityListenerManager entityListenerManager = AppBeans.get(EntityListenerManager.class);
    entityListenerManager.addListener(CascadeEntity.class, UpdateCascadeEntityListener.class);
    try (Transaction tx = cont.persistence().createTransaction()) {
        EntityManager em = cont.persistence().getEntityManager();
        CascadeEntity loadedThird =  em.find(CascadeEntity.class, third.getId());
        CascadeEntity loadedSecond = em.find(CascadeEntity.class, second.getId());
        loadedThird.setName("third#1");
        tx.commit();
    }
    entityListenerManager.removeListener(CascadeEntity.class, UpdateCascadeEntityListener.class);
    assertEquals(2, UpdateCascadeEntityListener.updatedEvents.size());
    assertTrue(UpdateCascadeEntityListener.updatedEvents.contains(second.getId().toString()));
    assertTrue(UpdateCascadeEntityListener.updatedEvents.contains(third.getId().toString()));
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
@Test
public void testNew() {
    createGroups();

    Transaction tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();
        Group group2 = em.find(Group.class, group2Id);
        for (GroupHierarchy hierarchy : group2.getHierarchyList()) {
            assertEquals(group2, hierarchy.getGroup());
            if (hierarchy.getLevel() == 0)
                assertEquals(rootId, hierarchy.getParent().getId());
            else if (hierarchy.getLevel() == 1)
                assertEquals(group1Id, hierarchy.getParent().getId());
        }
        tx.commit();
    } finally {
        tx.end();
    }
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
@Test
public void testOneToMany_Query() {
    System.out.println("===================== BEGIN testOneToMany_Query =====================");

    Transaction tx = cont.persistence().createTransaction();
    try {
        EntityManager em = cont.persistence().getEntityManager();

        Query q = em.createQuery("select u from sec$User u where u.id = ?1");
        q.setParameter(1, userId);
        User user = (User) q.getSingleResult();

        List<UserRole> userRoles = user.getUserRoles();
        assertEquals(1, userRoles.size());
        for (UserRole ur : userRoles) {
            assertNotNull(ur.getRole());
        }

        tx.commit();
    } finally {
        tx.end();
    }
    System.out.println("===================== END testOneToMany_Query =====================");
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
@Override
public SecurityState computeSecurityState(Entity entity) {
    Preconditions.checkNotNullArgument(entity, "entity is null");

    SecurityState state;
    String storeName = metadataTools.getStoreName(metadata.getClassNN(entity.getClass()));
    Transaction tx = persistence.createTransaction(storeName);
    try {
        EntityManager em = persistence.getEntityManager(storeName);
        Entity managedEntity = em.merge(entity);
        support.setupAttributeAccess(managedEntity);
        state = BaseEntityInternalAccess.getSecurityState(managedEntity);
        // do not commit the transaction
    } finally {
        tx.end();
    }
    return state;
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
protected Object executeScript(String domain, String sqlScript) {
    EntityManager em = persistence.getEntityManager(getDataStore(domain));
    StrTokenizer tokenizer = new StrTokenizer(sqlScript, SequenceSupport.SQL_DELIMITER);
    Object value = null;
    Connection connection = em.getConnection();
    while (tokenizer.hasNext()) {
        String sql = tokenizer.nextToken();
        try {
            PreparedStatement statement = connection.prepareStatement(sql);
            try {
                if (statement.execute()) {
                    ResultSet rs = statement.getResultSet();
                    if (rs.next())
                        value = rs.getLong(1);
                }
            } finally {
                DbUtils.closeQuietly(statement);
            }
        } catch (SQLException e) {
            throw new IllegalStateException("Error executing SQL for getting next number", e);
        }
    }
    return value;
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
@Override
public void clearScheduledTasks() {
    Transaction tx = persistence.createTransaction();
    try {
        EntityManager em = persistence.getEntityManager();

        Query query = em.createNativeQuery("delete from SYS_SCHEDULED_EXECUTION");
        query.executeUpdate();

        query = em.createNativeQuery("delete from SYS_SCHEDULED_TASK");
        query.executeUpdate();

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

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
protected Object executeScript(String entityName, String sqlScript) {
    EntityManager em = persistence.getEntityManager(getDataStore(entityName));
    StrTokenizer tokenizer = new StrTokenizer(sqlScript, SequenceSupport.SQL_DELIMITER);
    Object value = null;
    Connection connection = em.getConnection();
    while (tokenizer.hasNext()) {
        String sql = tokenizer.nextToken();
        try {
            PreparedStatement statement = connection.prepareStatement(sql);
            try {
                if (statement.execute()) {
                    ResultSet rs = statement.getResultSet();
                    if (rs.next())
                        value = rs.getLong(1);
                }
            } finally {
                DbUtils.closeQuietly(statement);
            }
        } catch (SQLException e) {
            throw new IllegalStateException("Error executing SQL for getting next number", e);
        }
    }
    return value;
}
 

import com.haulmont.cuba.core.EntityManager; //导入依赖的package包/类
@Override
public List<EntitySnapshot> getSnapshots(MetaClass metaClass, Object id) {
    metaClass = extendedEntities.getOriginalOrThisMetaClass(metaClass);
    Entity entity = dataManager.load(new LoadContext<>(metaClass).setId(id).setView(View.LOCAL));
    checkCompositePrimaryKey(entity);
    List<EntitySnapshot> resultList = null;
    View view = metadata.getViewRepository().getView(EntitySnapshot.class, "entitySnapshot.browse");
    Transaction tx = persistence.createTransaction();
    try {
        EntityManager em = persistence.getEntityManager();
        TypedQuery<EntitySnapshot> query = em.createQuery(format(
                "select s from sys$EntitySnapshot s where s.entity.%s = :entityId and s.entityMetaClass = :metaClass " +
                        "order by s.snapshotDate desc", referenceToEntitySupport.getReferenceIdPropertyName(metaClass)), EntitySnapshot.class);
        query.setParameter("entityId", referenceToEntitySupport.getReferenceId(entity));
        query.setParameter("metaClass", metaClass.getName());
        query.setView(view);
        resultList = query.getResultList();

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

    return resultList;
}