com.formkiq.core.dao.UserDaoImpl.java Source code

Java tutorial

Introduction

Here is the source code for com.formkiq.core.dao.UserDaoImpl.java

Source

/*
 * Copyright (C) 2016 FormKiQ Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.formkiq.core.dao;

import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;

import javax.persistence.Query;

import org.hibernate.Session;
import org.hibernate.transform.AliasToBeanResultTransformer;
import org.hibernate.transform.AliasToEntityMapResultTransformer;
import org.hibernate.type.IntegerType;
import org.hibernate.type.PostgresUUIDType;
import org.hibernate.type.StringType;
import org.hibernate.type.TimestampType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.formkiq.core.domain.User;
import com.formkiq.core.domain.UserNotification;
import com.formkiq.core.domain.UserSetting;
import com.formkiq.core.domain.type.FolderDTO;
import com.formkiq.core.domain.type.FolderStatus;
import com.formkiq.core.domain.type.UserDTO;
import com.formkiq.core.domain.type.UserListDTO;
import com.formkiq.core.domain.type.UserNotificationDTO;
import com.formkiq.core.domain.type.UserNotificationListDTO;
import com.formkiq.core.domain.type.UserRole;
import com.formkiq.core.domain.type.UserSettings;
import com.formkiq.core.domain.type.UserStatus;
import com.formkiq.core.form.dto.NotificationMethod;
import com.formkiq.core.form.dto.Workflow;
import com.formkiq.core.util.DateService;
import com.formkiq.core.util.Strings;

/**
 * UserDao hibernate implemenation.
 *
 */
@Repository
public class UserDaoImpl extends AbstractDaoImpl implements UserDao {

    /** DateService. */
    @Autowired
    private DateService dateservice;

    /** FolderDao. */
    @Autowired
    private FolderDao folderDao;

    /** Jackson2ObjectMapperBuilder. */
    @Autowired
    private Jackson2ObjectMapperBuilder jsonMapper;

    @SuppressWarnings("unchecked")
    @Override
    public void deleteNotification(final User user, final String uuid) {

        String jql = "select u from UserNotification u where u.userid=:user " + "and u.usernotificationid=:uuid";

        Collection<UserNotification> list = getEntityManager().createQuery(jql)
                .setParameter("user", user.getUserid()).setParameter("uuid", UUID.fromString(uuid)).getResultList();

        for (UserNotification un : list) {
            getEntityManager().remove(un);
        }
    }

    @SuppressWarnings("resource")
    @Override
    public void deleteUser(final User user) {

        String d0 = "update users set status=:status, updated_date=:date " + " where user_id=:user";

        String d1 = "update folders_access " + "set status=:status, updated_date=:date " + "where user_id=:user";

        Date now = this.dateservice.now();
        Session session = getEntityManager().unwrap(Session.class);

        session.createSQLQuery(d1).setParameter("status", UserStatus.DELETED.name()).setParameter("date", now)
                .setParameter("user", user.getUserid(), PostgresUUIDType.INSTANCE).executeUpdate();

        session.createSQLQuery(d0).setParameter("status", UserStatus.DELETED.name()).setParameter("date", now)
                .setParameter("user", user.getUserid(), PostgresUUIDType.INSTANCE).executeUpdate();
    }

    @SuppressWarnings("resource")
    @Override
    public void deleteUserAccessToken(final String email) {
        String sql = "delete from oauth_access_token where " + " user_name=:user";

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

        session.createSQLQuery(sql).setParameter("user", email).executeUpdate();
    }

    @Override
    public void deleteUserSetting(final UserSetting us) {
        getEntityManager().remove(us);
    }

    @SuppressWarnings({ "unchecked", "resource" })
    @Override
    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;
    }

    @Override
    public User findUser(final String email) {

        String jql = "select u from User u where u.email=:email ";

        Query query = getEntityManager().createQuery(jql).setParameter("email",
                email.toLowerCase(Locale.getDefault()));

        return (User) getSingleResult(query);
    }

    @Override
    public User findUser(final UUID userid) {
        return getEntityManager().find(User.class, userid);
    }

    @Override
    public User findUserByLoginToken(final String clientid, final String loginToken) {

        String jql = "select u from User u " + "where u.clientid=:clientid and u.loginToken=:loginToken";

        Query query = getEntityManager().createQuery(jql).setParameter("clientid", clientid)
                .setParameter("loginToken", loginToken);

        return (User) getSingleResult(query);
    }

    @SuppressWarnings("resource")
    @Override
    public UserDTO findUserDTO(final String email) {

        String sql = "select u.user_id as userid, u.email as email, " + " u.password as password, "
                + " u.status as status, u.role as role, " + " u.lastlogin_date as lastlogin, "
                + " u.last_user_agent as lastuseragent, " + " u.login_token as logintoken " + " from Users u"
                + " where u.email=:email";

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

        UserDTO dto = (UserDTO) session.createSQLQuery(sql).addScalar("userid", StringType.INSTANCE)
                .addScalar("email", StringType.INSTANCE).addScalar("password", StringType.INSTANCE)
                .addScalar("status", StringType.INSTANCE).addScalar("role", StringType.INSTANCE)
                .addScalar("lastlogin", TimestampType.INSTANCE).addScalar("lastuseragent", StringType.INSTANCE)
                .addScalar("logintoken", StringType.INSTANCE).setParameter("email", email)
                .setResultTransformer(new AliasToBeanResultTransformer(UserDTO.class)).uniqueResult();

        if (dto != null) {

            List<FolderDTO> folders = this.folderDao.findFoldersDTO(email, FolderStatus.ACTIVE);
            dto.setFolders(folders);

            UUID userid = dto.getUUID();
            Collection<UserSetting> settings = findUserSettings(userid);

            Map<String, String> map = new HashMap<>();
            for (UserSetting us : settings) {
                map.put(us.getSetting().name(), us.getValue());
            }
            dto.setSettings(map);
        }

        return dto;
    }

    @SuppressWarnings({ "unchecked", "resource" })
    @Override
    public UserListDTO findUsers(final String token, final String text) {

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

        StringBuilder sql = new StringBuilder("select u.user_id as userid, " + " u.email as email, "
                + " u.status as status, " + " u.role as role, " + " u.lastlogin_date as lastlogin, "
                + " u.last_user_agent as lastuseragent " + " from Users u ");

        if (StringUtils.hasText(text)) {
            sql.append("where u.email like :text ");
        }

        sql.append("order by u.email");

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

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

        org.hibernate.Query query = session.createSQLQuery(sql.toString()).addScalar("userid", StringType.INSTANCE)
                .addScalar("email", StringType.INSTANCE).addScalar("status", StringType.INSTANCE)
                .addScalar("role", StringType.INSTANCE).addScalar("lastlogin", TimestampType.INSTANCE)
                .addScalar("lastuseragent", StringType.INSTANCE)
                .setResultTransformer(new AliasToBeanResultTransformer(UserDTO.class));

        if (StringUtils.hasText(text)) {
            query.setParameter("text", "%" + text + "%");
        }

        List<UserDTO> list = query.list();

        UserListDTO dto = new UserListDTO();

        List<UserDTO> truncated = updatePagination(dto, offset, max, list);
        dto.setUsers(truncated);

        return dto;
    }

    @Override
    public UserSetting findUserSetting(final User user, final UserSettings setting) {

        String jql = "select us from UserSetting us " + " where us.userid=:user and us.setting=:setting";

        Query query = getEntityManager().createQuery(jql).setParameter("user", user.getUserid())
                .setParameter("setting", setting);

        return (UserSetting) getSingleResult(query);
    }

    @Override
    public Collection<UserSetting> findUserSettings(final User user) {
        return findUserSettings(user.getUserid());
    }

    /**
     * Find User Settings.
     * @param user {@link UUID}
     * @return {@link Collection}
     */
    @SuppressWarnings("unchecked")
    private Collection<UserSetting> findUserSettings(final UUID user) {
        String jql = "select us from UserSetting us " + " where us.userid=:user";

        return getEntityManager().createQuery(jql).setParameter("user", user).getResultList();
    }

    @SuppressWarnings("resource")
    @Override
    public int getAdminUserCount() {
        String sql = "select count(*) as count from users where role=:role";
        Session session = getEntityManager().unwrap(Session.class);

        Integer count = (Integer) session.createSQLQuery(sql).addScalar("count", IntegerType.INSTANCE)
                .setParameter("role", UserRole.ROLE_ADMIN.name()).uniqueResult();
        return count.intValue();
    }

    @Override
    public User saveUser(final User user) {

        Date now = this.dateservice.now();
        user.setUpdatedDate(now);
        user.setEmail(user.getEmail().toLowerCase(Locale.getDefault()));

        if (StringUtils.isEmpty(user.getUserid())) {

            user.setUserid(UUID.randomUUID());
            user.setInsertedDate(now);
            getEntityManager().persist(user);

        } else {

            getEntityManager().merge(user);
        }

        return user;
    }

    @Override
    public UserNotification saveUserNotification(final User user, final String folder, final Workflow workflow,
            final NotificationMethod method) {

        UUID id = UUID.randomUUID();
        Date now = this.dateservice.now();

        FolderDTO fdto = new FolderDTO();
        fdto.setUUID(UUID.fromString(folder));

        UserNotificationDTO dto = new UserNotificationDTO();
        dto.setFolder(fdto);

        dto.setInserteddate(now);
        dto.setUUID(id.toString());
        dto.setMethod(method);
        dto.setWorkflow(workflow);

        try {

            String text = this.jsonMapper.build().writeValueAsString(dto);
            UserNotification un = new UserNotification();

            un.setUsernotificationid(id);
            un.setData(text);
            un.setMethod(method);
            un.setUserid(user.getUserid());
            un.setInsertedDate(now);

            getEntityManager().persist(un);

            return un;

        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public UserSetting saveUserSetting(final UserSetting setting) {

        if (setting.getUsersettingid() == null) {

            setting.setUsersettingid(UUID.randomUUID());
            getEntityManager().persist(setting);
            return setting;
        }

        return getEntityManager().merge(setting);
    }

    @SuppressWarnings("resource")
    @Override
    public void updateLastLogin(final String email, final Date date) {
        String sql = "update users set lastlogin_date=:date where email=:email";
        Session session = getEntityManager().unwrap(Session.class);

        session.createSQLQuery(sql).setParameter("date", date).setParameter("email", email).executeUpdate();
    }

    @SuppressWarnings("resource")
    @Override
    public void updateLastUserAgent(final String email, final String useragent) {

        String sql = "update users set last_user_agent=:agent " + "where email=:email";
        Session session = getEntityManager().unwrap(Session.class);

        session.createSQLQuery(sql).setParameter("agent", useragent).setParameter("email", email).executeUpdate();
    }
}