outfox.dict.contest.dao.ContestDAO.java Source code

Introduction

Here is the source code for outfox.dict.contest.dao.ContestDAO.java

Source

/**
 * @(#)ContestDAO.java, 2016-3-1. 
 * 
 * Copyright 2016 Yodao, Inc. All rights reserved.
 * YODAO PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package outfox.dict.contest.dao;

import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import outfox.dict.contest.data.*;
import outfox.dict.contest.front.data.RequestParams;

/**
 *
 * @author wangning
 *
 */
@Repository
public class ContestDAO {

    @Autowired
    private SessionFactory sessionFactory;

    @Transactional
    public int user(UserEntity user) {
        sessionFactory.getCurrentSession().save(user);
        return user.getId();
    }

    @Transactional
    public int signup(SingerEntity singerEntity) {
        sessionFactory.getCurrentSession().save(singerEntity);
        return singerEntity.getId();
    }

    @SuppressWarnings("unchecked")
    @Transactional
    public SingerEntity getSingerInfo(int id) {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(SingerEntity.class);
        c.add(Restrictions.eq("id", id));
        List<SingerEntity> list = c.list();
        if (list != null) {
            return list.get(0);
        }
        return null;
    }

    @Transactional
    public int updateSingerInfo(SingerEntity singerEntity) {
        sessionFactory.getCurrentSession().saveOrUpdate(singerEntity);
        return singerEntity.getId();
    }

    @SuppressWarnings("unchecked")
    @Transactional
    public List<AreaEntity> listContestAreas(int period) {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(AreaEntity.class);
        c.add(Restrictions.eq("period", period));
        c.add(Restrictions.eq("status", DataStatus.PUBLISH));
        c.addOrder(Order.asc("sequence"));
        return c.list();
    }

    @SuppressWarnings("unchecked")
    @Transactional
    public LotteryUserEntity getLotteryUserInfo(int period, String userId) {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(LotteryUserEntity.class);
        c.add(Restrictions.eq("period", period));
        c.add(Restrictions.eq("userId", userId));
        List<LotteryUserEntity> lotteryList = c.list();
        if (lotteryList != null && lotteryList.size() > 0) {
            return lotteryList.get(0);
        }
        return null;
    }

    @Transactional
    public void addLotteryUserInfo(LotteryUserEntity lotteryUser) {
        sessionFactory.getCurrentSession().saveOrUpdate(lotteryUser);
    }

    @Transactional
    public void updateLotteryUserInfo(LotteryUserEntity lotteryUser) {
        sessionFactory.getCurrentSession().saveOrUpdate(lotteryUser);
    }

    @SuppressWarnings("unchecked")
    @Transactional
    public List<AwardEntity> getAwardList(int period) {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(AwardEntity.class);
        c.add(Restrictions.eq("period", period));
        // ?0??
        c.add(Restrictions.or(Restrictions.gt("remainNum", 0), Restrictions.eq("remainNum", -1)));
        c.addOrder(Order.asc("id"));
        return c.list();
    }

    @Transactional
    public void updateAwardInfo(AwardEntity award) {
        sessionFactory.getCurrentSession().saveOrUpdate(award);
    }

    @Transactional
    public void addWinAwardRecord(WinAwardEntity winAwardRecord) {
        sessionFactory.getCurrentSession().save(winAwardRecord);
    }

    @SuppressWarnings("unchecked")
    @Transactional
    public WinAwardEntity getWinAwardRecord(int period, String userId) {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(WinAwardEntity.class);
        c.add(Restrictions.eq("period", period));
        c.add(Restrictions.eq("userId", userId));
        c.add(Restrictions.eq("used", false));
        c.add(Restrictions.eq("awardType", 2)); // ????
        List<WinAwardEntity> winAwardList = c.list();
        if (winAwardList != null && winAwardList.size() > 0) {
            return winAwardList.get(0);
        }
        return null;
    }

    @SuppressWarnings("unchecked")
    @Transactional
    public List<WinAwardEntity> getWinAwardList(int period, int itemNum) {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(WinAwardEntity.class);
        c.add(Restrictions.eq("period", period));
        c.add(Restrictions.ne("awardType", 0));
        c.addOrder(Order.desc("id"));
        c.setMaxResults(itemNum);
        return c.list();
    }

    @Transactional
    public void updateWinAwardRecord(WinAwardEntity winAwardRecord) {
        sessionFactory.getCurrentSession().saveOrUpdate(winAwardRecord);
    }

    @Transactional
    public void addContactInfo(ContactEntity contactInfo) {
        sessionFactory.getCurrentSession().save(contactInfo);
    }

    @SuppressWarnings("unchecked")
    @Transactional
    public List<SponsorEntity> getSponsorList() {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(SponsorEntity.class);
        c.add(Restrictions.eq("status", true));
        return c.list();
    }

    @Transactional
    public void saveOpRecord(SponsorOpEntity operateRecord) {
        sessionFactory.getCurrentSession().save(operateRecord);
    }

    @Transactional
    public void addSingerInfoForCityContest(SceneContestEntity sceneContest) {
        sessionFactory.getCurrentSession().save(sceneContest);
    }

    @Transactional
    public void updateSingerInfoForCityContest(SceneContestEntity sceneContest) {
        sessionFactory.getCurrentSession().saveOrUpdate(sceneContest);
    }

    @Transactional
    @SuppressWarnings("unchecked")
    public List<SceneContestEntity> getSingersForCityContest(RequestParams params) {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(SceneContestEntity.class);
        String area = params.getArea();
        if (StringUtils.isNotBlank(area)) {
            c.add(Restrictions.eq("areaName", params.getArea()));
        }
        c.add(Restrictions.ge("round", params.getRound()));
        c.add(Restrictions.eq("period", params.getPeriod()));
        c.add(Restrictions.eq("stage", params.getStage()));
        c.add(Restrictions.eq("status", true));
        return c.list();
    }

    @Transactional
    public void riseInRankForCityContest(RequestParams params) {
        String hqlUpdate = "update sceneContest set round = :round where id = :id";
        Query q = sessionFactory.getCurrentSession().createSQLQuery(hqlUpdate)
                .setInteger("round", params.getRound()).setInteger("id", params.getId());
        q.executeUpdate();
    }

    @Transactional
    @SuppressWarnings("unchecked")
    public SwitchScreenEntity getScreenState(String type) {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(SwitchScreenEntity.class);
        c.add(Restrictions.eq("type", type));
        List<SwitchScreenEntity> list = c.list();
        if (list != null) {
            return list.get(0);
        }
        return null;
    }

    @Transactional
    public void updateScreenState(RequestParams params) {
        String hqlUpdate = "update switchScreen set singerIds = :singerIds, " + "state = :state, "
                + "round = :round " + "where type = :type";
        Query q = sessionFactory.getCurrentSession().createSQLQuery(hqlUpdate)
                .setString("singerIds", params.getSingerIds()).setInteger("state", params.getState())
                .setInteger("round", params.getRound()).setString("type", params.getType());
        q.executeUpdate();
    }

    @Transactional
    @SuppressWarnings("unchecked")
    public List<SceneContestEntity> getSingersInfoForCityContest(List<Integer> idList) {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(SceneContestEntity.class);
        c.add(Restrictions.in("id", idList));
        return c.list();
    }

    /**
     * ?
     * @param item
     * @param itemNum
     * @return
     */
    @SuppressWarnings("unchecked")
    @Transactional
    public List<CommentEntity> listComment(String item, int itemNum) {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(CommentEntity.class);
        c.add(Restrictions.eq("item", item));
        c.add(Restrictions.eq("status", 1));
        c.addOrder(Order.desc("id"));
        c.setMaxResults(itemNum);
        return c.list();
    }

    @Transactional
    public void addComment(CommentEntity commentInfo) {
        sessionFactory.getCurrentSession().save(commentInfo);
    }

    /**
     * ?topK
     * @param itemNum
     * @return
     */
    @SuppressWarnings("unchecked")
    @Transactional
    public List<CommentEntity> listTopKComment(int itemNum) {
        Criteria c = sessionFactory.getCurrentSession().createCriteria(CommentEntity.class)
                .add(Restrictions.eq("status", 0)).addOrder(Order.desc("id")).addOrder(Order.desc("time"))
                .setMaxResults(itemNum);
        return c.list();
    }

    /**
     * 
     * @param id
     */
    @Transactional
    public void auditCommentForInner(int id, int auditStatus) {
        String hqlUpdate = "update comment set status = :status where id = :id";
        Query q = sessionFactory.getCurrentSession().createSQLQuery(hqlUpdate).setInteger("status", auditStatus)
                .setInteger("id", id);
        q.executeUpdate();
    }
}