Example usage for org.hibernate.transform AliasToEntityMapResultTransformer INSTANCE

List of usage examples for org.hibernate.transform AliasToEntityMapResultTransformer INSTANCE

Introduction

In this page you can find the example usage for org.hibernate.transform AliasToEntityMapResultTransformer INSTANCE.

Prototype

AliasToEntityMapResultTransformer INSTANCE

To view the source code for org.hibernate.transform AliasToEntityMapResultTransformer INSTANCE.

Click Source Link

Usage

From source file:br.com.hslife.orcamento.repository.RelatorioCustomizadoRepository.java

License:Open Source License

@SuppressWarnings("unchecked")
public List<Map<String, Object>> executeCustomNativeSQL(String nativeSQL) {
    return getSession().createSQLQuery(nativeSQL)
            .setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE).list();
}

From source file:com.axelor.meta.service.MetaService.java

License:Open Source License

public Response getChart(final String name, final Request request) {

    final Response response = new Response();
    final MetaView view = views.findByName(name);

    if (view == null) {
        return response;
    }//from w w w  . ja va2 s . c  o m

    ChartView chart = (ChartView) XMLViews.findView(null, name, "chart");
    if (chart == null) {
        return response;
    }

    final Map<String, Object> data = new HashMap<>();

    response.setData(data);
    response.setStatus(Response.STATUS_SUCCESS);

    boolean hasDataSet = request.getFields() != null && request.getFields().contains("dataset");

    if (hasDataSet) {

        final String string = chart.getDataSet().getText();
        final Map<String, Object> context = Maps.newHashMap();
        if (request.getData() != null) {
            context.putAll(request.getData());
        }
        if (AuthUtils.getUser() != null) {
            context.put("__user__", AuthUtils.getUser());
            context.put("__userId__", AuthUtils.getUser().getId());
            context.put("__userCode__", AuthUtils.getUser().getCode());
        }

        if ("rpc".equals(chart.getDataSet().getType())) {
            ActionRequest req = new ActionRequest();
            ActionResponse res = new ActionResponse();
            Map<String, Object> reqData = new HashMap<>();

            reqData.put("context", context);

            req.setModel(request.getModel());
            req.setData(reqData);
            req.setAction(string);

            if (req.getModel() == null) {
                req.setModel(ScriptBindings.class.getName());
            }

            res = new ActionHandler(req).execute();

            data.put("dataset", res.getData());

        } else {
            Query query = "sql".equals(chart.getDataSet().getType()) ? JPA.em().createNativeQuery(string)
                    : JPA.em().createQuery(string);

            // return result as list of map
            ((org.hibernate.ejb.QueryImpl<?>) query).getHibernateQuery()
                    .setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE);

            if (request.getData() != null) {
                QueryBinder.of(query).bind(context);
            }

            data.put("dataset", query.getResultList());
        }
    }

    if (hasDataSet) {
        return response;
    }

    data.put("title", chart.getLocalizedTitle());
    data.put("stacked", chart.getStacked());

    data.put("xAxis", chart.getCategory().getKey());
    data.put("xType", chart.getCategory().getType());
    data.put("xTitle", chart.getCategory().getLocalizedTitle());

    List<Object> series = Lists.newArrayList();
    Map<String, Object> config = Maps.newHashMap();

    for (ChartSeries cs : chart.getSeries()) {
        Map<String, Object> map = Maps.newHashMap();
        map.put("key", cs.getKey());
        map.put("type", cs.getType());
        map.put("groupBy", cs.getGroupBy());
        map.put("aggregate", cs.getAggregate());
        map.put("title", cs.getLocalizedTitle());
        series.add(map);
    }

    if (chart.getConfig() != null) {
        for (ChartConfig c : chart.getConfig()) {
            config.put(c.getName(), c.getValue());
        }
    }

    data.put("series", series);
    data.put("config", config);
    data.put("search", chart.getSearchFields());
    data.put("onInit", chart.getOnInit());

    return response;
}

From source file:com.axelor.meta.service.MetaService.java

License:Open Source License

public Response getDataSet(final String viewName, final Request request) {

    final Response response = new Response();
    final MetaView metaView = views.findByName(viewName);

    if (metaView == null) {
        return response;
    }/*w w w  .j a va2 s . c o m*/

    CustomView report = (CustomView) XMLViews.findView(null, viewName, "report");
    if (report == null) {
        return response;
    }

    final DataSet dataSet = report.getDataSet();
    final Map<String, Object> data = new HashMap<>();

    response.setData(data);
    response.setStatus(Response.STATUS_SUCCESS);

    final Map<String, Object> context = new HashMap<>();
    if (request.getData() != null) {
        context.putAll(request.getData());
    }
    if (AuthUtils.getUser() != null) {
        context.put("__user__", AuthUtils.getUser());
        context.put("__userId__", AuthUtils.getUser().getId());
        context.put("__userCode__", AuthUtils.getSubject());
    }

    if ("rpc".equals(dataSet.getType())) {
        ActionRequest req = new ActionRequest();
        ActionResponse res = new ActionResponse();

        req.setModel(request.getModel());
        req.setData(request.getData());
        req.setAction(dataSet.getText());

        if (req.getModel() == null) {
            req.setModel(ScriptBindings.class.getName());
        }

        res = new ActionHandler(req).execute();

        data.put("dataset", res.getData());
    } else {
        Query query = "sql".equals(report.getDataSet().getType())
                ? JPA.em().createNativeQuery(dataSet.getText())
                : JPA.em().createQuery(dataSet.getText());

        if (request.getLimit() > 0) {
            query.setMaxResults(request.getLimit());
        }
        if (request.getOffset() > 0) {
            query.setFirstResult(request.getOffset());
        }
        if (dataSet.getLimit() != null && dataSet.getLimit() > 0) {
            query.setMaxResults(dataSet.getLimit());
        }

        // return result as list of map
        ((org.hibernate.ejb.QueryImpl<?>) query).getHibernateQuery()
                .setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE);

        if (request.getData() != null) {
            QueryBinder.of(query).bind(context);
        }

        data.put("dataset", query.getResultList());
    }

    return response;
}

From source file:com.formkiq.core.dao.FolderDaoImpl.java

License:Apache License

@SuppressWarnings({ "unchecked", "resource" })
@Override/*w w  w .j a  v  a2s .com*/
public FolderUserListDTO findFolderUsers(final String folder, final String token) {

    int offset = Strings.getOffset(token);
    int max = Strings.getMaxResults(token, DEFAULT_MAX_RESULTS);

    String sql = "select u.email as \"email\"," + " u.user_id as \"uuid\"," + " f.folder_id as \"folder.uuid\","
            + " f.name as \"folder.name\"," + " fa.permissions as \"folder.permissionsasstring\""
            + " from folders_access fa" + " join folders f on f.folder_id=fa.folder_id"
            + " join users u on u.user_id=fa.user_id" + " where fa.folder_id=:folder";

    StringBuilder sb = new StringBuilder(sql);
    sb.append(" order by u.email");
    sb.append(" OFFSET " + offset + " FETCH FIRST " + (max + 1) + " ROWS ONLY");

    FolderUserListDTO dto = new FolderUserListDTO();

    Session session = getEntityManager().unwrap(Session.class);

    List<Map<String, Object>> list = session.createSQLQuery(sb.toString())
            .addScalar("folder.uuid", PostgresUUIDType.INSTANCE).addScalar("folder.name", StringType.INSTANCE)
            .addScalar("uuid", PostgresUUIDType.INSTANCE).addScalar("email", StringType.INSTANCE)
            .addScalar("folder.permissionsasstring", StringType.INSTANCE)
            .setParameter("folder", UUID.fromString(folder), PostgresUUIDType.INSTANCE)
            .setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE).list();

    List<UserDTO> transform = transformMapListToObject(list, UserDTO.class);
    List<UserDTO> truncate = updatePagination(dto, offset, max, transform);
    dto.setUsers(truncate);

    return dto;
}

From source file:com.formkiq.core.dao.FolderDaoImpl.java

License:Apache License

@SuppressWarnings({ "unchecked", "resource" })
@Override/*from   w w w.  j a v  a  2  s  .c  o  m*/
public List<FolderFormLedgerDTO> findFormLedger(final String folder, final String uuid) {

    List<FolderFormLedgerDTO> results = new ArrayList<>();

    List<String> steps = findWorkflowSteps(folder, uuid);

    if (CollectionUtils.isEmpty(steps)) {
        steps = Arrays.asList(uuid);
    }

    for (String step : steps) {

        String sql = "select ffl.folder_id as \"folder.uuid\"," + "u.user_id as \"user.uuid\","
                + "u.email as \"user.email\"," + "ff.type as \"form.type\","
                + "ff.data #>> '{\"label1\"}' as \"form.label1\","
                + "ff.data #>> '{\"label2\"}' as \"form.label2\","
                + "ff.data #>> '{\"label3\"}' as \"form.label3\","
                + "ff.data #>> '{\"name\"}' as \"form.name\"," + "ff.data #>> '{\"uuid\"}' as \"form.uuid\","
                + "ff.data #>> '{\"inserted_date\"}' as \"form.inserteddate\","
                + "ff.data #>> '{\"updated_date\"}' as \"form.updateddate\"" + "from folder_form_ledgers ffl "
                + "join folder_forms ff on " + "ff.folder_id=ffl.folder_id and ff.uuid=ffl.uuid "
                + "join users u on u.user_id=ffl.user_id " + "where ffl.folder_id=:folder and ffl.uuid=:uuid";

        Session session = getEntityManager().unwrap(Session.class);

        List<Map<String, Object>> list = session.createSQLQuery(sql)
                .addScalar("folder.uuid", PostgresUUIDType.INSTANCE)
                .addScalar("user.uuid", PostgresUUIDType.INSTANCE).addScalar("user.email", StringType.INSTANCE)
                .addScalar("form.type", StringType.INSTANCE).addScalar("form.label1", StringType.INSTANCE)
                .addScalar("form.label2", StringType.INSTANCE).addScalar("form.label3", StringType.INSTANCE)
                .addScalar("form.name", StringType.INSTANCE).addScalar("form.uuid", StringType.INSTANCE)
                .addScalar("form.inserteddate", StringType.INSTANCE)
                .addScalar("form.updateddate", StringType.INSTANCE)
                .setParameter("folder", UUID.fromString(folder), PostgresUUIDType.INSTANCE)
                .setParameter("uuid", UUID.fromString(step), PostgresUUIDType.INSTANCE)
                .setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE).list();

        List<FolderFormLedgerDTO> transform = transformMapListToObject(list, FolderFormLedgerDTO.class);

        results.addAll(transform);
    }

    return results;
}

From source file:com.formkiq.core.dao.MigrationDaoImpl.java

License:Apache License

@SuppressWarnings({ "unchecked", "resource" })
@Override//from   www  .  j a  v a 2  s  . c om
public MapPaginationDTO findFolderAssetList(final String token) {

    int offset = Strings.getOffset(token);
    int max = Strings.getMaxResults(token, DEFAULT_MAX_RESULTS);

    StringBuilder sql = new StringBuilder("select folder_id as folder, asset_id as asset "
            + "from folder_forms " + "where folder_id is not null and asset_id is not null ");

    sql.append(" OFFSET " + offset + " FETCH FIRST " + (max + 1) + " ROWS ONLY");

    Session session = getEntityManager().unwrap(Session.class);

    List<Map<String, String>> list = session.createSQLQuery(sql.toString())
            .addScalar("folder", StringType.INSTANCE).addScalar("asset", StringType.INSTANCE)
            .setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE).list();

    MapPaginationDTO dto = new MapPaginationDTO();

    List<Map<String, String>> truncate = updatePagination(dto, offset, max, list);

    dto.setData(truncate);

    return dto;
}

From source file:com.formkiq.core.dao.SystemDaoImpl.java

License:Apache License

@SuppressWarnings({ "unchecked", "resource" })
@Override//from   ww w .  java2  s .co  m
public List<SystemPropertyDTO> getProperties(final User user, final String key) {

    String sql = "select p.key as key, p.value as value, " + "p.user_id as \"user.uuid\","
            + "u.email as \"user.email\"" + " from system_properties p "
            + " left join users u on u.user_id=p.user_id";

    if (user != null || StringUtils.hasText(key)) {
        sql += " where ";
    }

    if (user != null) {
        sql += " p.user_id=:user";
    }

    if (StringUtils.hasText(key)) {
        sql += user != null ? " and " : " ";
        sql += "key=:key";
    }

    sql += " order by p.key ";

    Session session = getEntityManager().unwrap(Session.class);

    SQLQuery q = session.createSQLQuery(sql).addScalar("key", StringType.INSTANCE)
            .addScalar("value", StringType.INSTANCE).addScalar("user.email", StringType.INSTANCE)
            .addScalar("user.uuid", PostgresUUIDType.INSTANCE);

    if (user != null) {
        q.setParameter("user", user.getUserid(), PostgresUUIDType.INSTANCE);
    }

    if (StringUtils.hasText(key)) {
        q.setParameter("key", key);
    }

    List<Map<String, Object>> maplist = q.setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE)
            .list();

    List<SystemPropertyDTO> list = transformMapListToObject(maplist, SystemPropertyDTO.class);

    return list;
}

From source file:com.formkiq.core.dao.UserDaoImpl.java

License:Apache License

@SuppressWarnings({ "unchecked", "resource" })
@Override/*from w ww . j a v  a 2 s. co  m*/
public UserNotificationListDTO findNotifications(final User user, final String token) {

    int offset = Strings.getOffset(token);
    int max = Strings.getMaxResults(token, DEFAULT_MAX_RESULTS);

    StringBuilder sql = new StringBuilder(
            "select user_notifications_id as uuid, " + "data->'workflow'->>'label1' as \"workflow.label1\", "
                    + "data->'workflow'->>'label2' as \"workflow.label2\", "
                    + "data->'workflow'->>'label3' as \"workflow.label3\", " + "method as method, "
                    + "inserted_date as inserteddate " + "from user_notifications " + "where user_id=:user "
                    + "order by inserted_date, method desc ");

    sql.append(" OFFSET " + offset + " FETCH FIRST " + (max + 1) + " ROWS ONLY");

    Session session = getEntityManager().unwrap(Session.class);

    List<Map<String, Object>> list = session.createSQLQuery(sql.toString())
            .addScalar("uuid", StringType.INSTANCE).addScalar("workflow.label1", StringType.INSTANCE)
            .addScalar("workflow.label2", StringType.INSTANCE).addScalar("workflow.label3", StringType.INSTANCE)
            .addScalar("method", EnumCustomType.transform(NotificationMethod.class))
            .addScalar("inserteddate", TimestampType.INSTANCE)
            .setParameter("user", user.getUserid(), PostgresUUIDType.INSTANCE)
            .setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE).list();

    UserNotificationListDTO dto = new UserNotificationListDTO();

    List<UserNotificationDTO> unlist = transformMapListToObject(list, UserNotificationDTO.class);

    List<UserNotificationDTO> tr = updatePagination(dto, offset, max, unlist);

    dto.setNotifications(tr);

    return dto;
}

From source file:com.impetus.client.rdbms.HibernateClient.java

License:Apache License

/**
 * Find./*  w ww .ja  va  2s.c o m*/
 * 
 * @param nativeQuery
 *            the native fquery
 * @param relations
 *            the relations
 * @param m
 *            the m
 * @return the list
 */
public List find(String nativeQuery, List<String> relations, EntityMetadata m) {
    List entities = new ArrayList();

    s = getStatelessSession();

    SQLQuery q = s.createSQLQuery(nativeQuery);
    q.setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE);

    List result = q.list();

    try {
        MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata()
                .getMetamodel(m.getPersistenceUnit());

        EntityType entityType = metaModel.entity(m.getEntityClazz());

        List<AbstractManagedType> subManagedType = ((AbstractManagedType) entityType).getSubManagedType();
        for (Object o : result) {
            Map<String, Object> relationValue = null;
            Object entity = null;
            EntityMetadata subEntityMetadata = null;
            if (!subManagedType.isEmpty()) {
                for (AbstractManagedType subEntity : subManagedType) {
                    String discColumn = subEntity.getDiscriminatorColumn();
                    String disColValue = subEntity.getDiscriminatorValue();
                    Object value = ((Map<String, Object>) o).get(discColumn);
                    if (value != null && value.toString().equals(disColValue)) {
                        subEntityMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata,
                                subEntity.getJavaType());
                        break;
                    }
                }
                entity = instantiateEntity(subEntityMetadata.getEntityClazz(), entity);
                relationValue = HibernateUtils.getTranslatedObject(kunderaMetadata, entity,
                        (Map<String, Object>) o, m);

            } else {
                entity = instantiateEntity(m.getEntityClazz(), entity);
                relationValue = HibernateUtils.getTranslatedObject(kunderaMetadata, entity,
                        (Map<String, Object>) o, m);
            }

            if (relationValue != null && !relationValue.isEmpty()) {
                entity = new EnhanceEntity(entity, PropertyAccessorHelper.getId(entity, m), relationValue);
            }
            entities.add(entity);
        }
        return entities;
    } catch (Exception e) {
        if (e.getMessage().equals("Can not be translated into entity.")) {
            return result;
        }
        throw new EntityReaderException(e);
    }
}

From source file:com.openwords.database.DatabaseHandler.java

License:Open Source License

public static List<Map<String, Object>> Query(String sql, Session s) {
    Query q = s.createSQLQuery(sql).setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE);
    @SuppressWarnings("unchecked")
    List<Map<String, Object>> r = q.list();
    return r;/*from  w  ww .j  ava2 s .  co m*/
}