/** {@inheritDoc} */
public long totalLeafDoneStoryPoints(Project project) {
Criteria projectCrit = getCurrentSession().createCriteria(Story.class);
Criteria iterationCrit = getCurrentSession().createCriteria(Story.class);
this.attachLeafFilters(projectCrit, iterationCrit, project);
projectCrit.setProjection(Projections.projectionList().add(Projections.sum("storyPoints")));
iterationCrit.setProjection(Projections.projectionList().add(Projections.sum("storyPoints")));
projectCrit.add(Restrictions.eq("state", StoryState.DONE));
iterationCrit.add(Restrictions.eq("state", StoryState.DONE));
return sum((Long) projectCrit.uniqueResult(), (Long) iterationCrit.uniqueResult());
}
@Override
public UserAct getActById(int logId) {
Session session = HibernateUtil.currentSession();
Criteria c = session.createCriteria(UserAct.class);
c.add(Restrictions.eq("logId", logId));
return (UserAct) c.uniqueResult();
}
@Override
public VerifyPO get(long uid, int type) {
Criteria c = createCriteria();
c.add(Restrictions.eq("uid", uid));
c.add(Restrictions.eq("type", type));
return (VerifyPO) c.uniqueResult();
}
public static Group findByOrgAndName(Organisation org, String name, Session session) {
Criteria crit = session.createCriteria(Group.class);
crit.setCacheable(true);
crit.add(Restrictions.eq("organisation", org));
crit.add(Restrictions.eq("name", name));
return (Group) crit.uniqueResult();
}
/**
* 查询一个对象的属性值在数据库中是不是唯一
*
* @param entity 实体对象
* @param propertyNames 属性的名称，可多个 如："prop1,prop2"
* @return 针对 编辑 对象保存时 如果和其它 对象 属性名称相同 抛出异常问题 重写此方法
*/
public boolean isUnique(Object entity, String propertyNames) {
Class<?> clazz = getTrueClass(entity);
Criteria criteria = createCriteria(clazz).setProjection(Projections.rowCount());
String[] nameList = propertyNames.split(",");
try {
boolean isQuery = false;
for (String name : nameList) {
Object obj = PropertyUtils.getProperty(entity, name);
if (obj != null) {
criteria.add(Restrictions.eq(name, obj));
isQuery = true;
} else {
isQuery = false;
}
}
if (!isQuery) {
return true;
}
String idName = getIdName(clazz);
Serializable id = getId(clazz, entity);
if (id != null) {
criteria.add(Restrictions.not(Restrictions.eq(idName, id)));
}
} catch (Exception e) {
ReflectionUtils.handleReflectionException(e);
}
this.getSession().evict(entity);
return (Integer) criteria.uniqueResult() == 0;
}
@Override
public Long getTotal(CommentBo bo) {
Criteria criteria = createRowCountsCriteria(Comment.class);
initCriteria(criteria, bo);
criteria.addOrder(Order.desc("createdDatetime"));
return (Long) criteria.uniqueResult();
}
public StorageDevice findDeviceById(final Integer datacenterId, final String managementIp) {
Criteria criteria =
createCriteria(Restrictions.eq("datacenter.id", datacenterId))
.add(Restrictions.eq("managementIp", managementIp));
Object obj = criteria.uniqueResult();
return (StorageDevice) obj;
}
// TODO add fromData-toDate
public IncomeBalance findAccountPeriod(Account account, Date date) {
Criteria criteria = sessionFactory.getCurrentSession().createCriteria(IncomeBalance.class);
criteria.add(Restrictions.eq("account", account));
criteria.add(
Restrictions.and(Restrictions.ge("startDate", date), Restrictions.le("endDate", date)));
return (IncomeBalance) criteria.uniqueResult();
}
public BudgetItem getBudgetItem(Date date, Account account) {
Criteria criteria = sessionFactory.getCurrentSession().createCriteria(BudgetItem.class);
criteria.add(Restrictions.eq("account", account));
criteria.add(
Restrictions.and(Restrictions.le("startDate", date), Restrictions.ge("endDate", date)));
return (BudgetItem) criteria.uniqueResult();
}
public DmFolder getByName(String folderName, String accountId, String folderIdParent) {
DmFolder folderParent = null;
if ((folderIdParent != null) && (!folderIdParent.isEmpty())) {
folderParent = new DmFolder();
folderParent.setId(folderIdParent);
}
DmAccount accountOwner = null;
if (folderParent == null) {
if ((accountId != null) && (!accountId.isEmpty())) {
accountOwner = new DmAccount();
accountOwner.setId(accountId);
}
}
Criteria crit = getSession().createCriteria(DmFolder.class);
crit.add(Restrictions.eq("name", folderName).ignoreCase());
if (accountOwner != null) {
crit.add(Restrictions.eq("owner", accountOwner));
}
if (folderParent != null) {
crit.add(Restrictions.eq("parent", folderParent));
} else {
crit.add(Restrictions.isNull("parent"));
}
return (DmFolder) crit.uniqueResult();
}
public PriceBlockHeaderVO getpriceBlck(int blckId) {
/**
* Requires - Modifies - Effects -
*
* @throws -
*/
Criteria objCriteria = null;
Session objSession = null;
PriceBlockHeaderVO objPriceBlockHeaderVO = null;
try {
logger.info("GETTING PRICE BLOCK FOR BLOCK ID");
objSession = HibernateUtil.getSession();
objCriteria =
objSession
.createCriteria(PriceBlockHeaderVO.class)
.add(Restrictions.eq("priceBlockIdentifier", new Integer(blckId)));
objPriceBlockHeaderVO = (PriceBlockHeaderVO) objCriteria.uniqueResult();
logger.info("GOT PRICE BLOCK FOR BLOCK");
} catch (HibernateException e) {
logger.error("HIBERNATE EXCEPTION DURING GET PRICE BLOCK FOR BLOCK", e);
e.printStackTrace();
} finally {
if (objSession != null) {
objSession.close();
}
}
return objPriceBlockHeaderVO;
}
@Override
public Long getTotalCount(Reply model) {
Criteria criteria = getCurrentSession().createCriteria(Reply.class);
criteria.createAlias("potential", "potential", CriteriaSpecification.LEFT_JOIN);
criteria.createAlias(
"potentialStuStatus", "potentialStuStatus", CriteriaSpecification.LEFT_JOIN);
criteria.createAlias("user", "user", CriteriaSpecification.LEFT_JOIN);
if (model != null && model.getPotential().getPotentialId() != null) {
criteria.add(Restrictions.eq("potential.potentialId", model.getPotential().getPotentialId()));
}
if (model != null
&& model.getPotentialStuStatus() != null
&& model.getPotentialStuStatus().getPotentialStuStatusId() != null) {
criteria.add(
Restrictions.eq(
"potentialStuStatus.potentialStuStatusId",
model.getPotentialStuStatus().getPotentialStuStatusId()));
}
if (model != null && model.getReplyDate() != null) {
criteria.add(Restrictions.eq("replyDate", model.getReplyDate()));
}
if (model != null && model.getNextReplyDate() != null) {
criteria.add(Restrictions.eq("nextReplyDate", model.getNextReplyDate()));
}
criteria.setProjection(Projections.rowCount());
return new Long(criteria.uniqueResult().toString());
}
// sets the order item to a particular book present in the book database
public boolean setOrderItem(int id, int productId) {
Boolean flag = false;
try {
Session session = HibernateUtil.getSessionFactory().openSession();
Criteria cr1 = session.createCriteria(Book.class);
cr1.add(Restrictions.eq("productId", id));
Object result1 = cr1.uniqueResult();
if (result1 != null) {
Book book = (Book) result1;
Session session1 = HibernateUtil.getSessionFactory().openSession();
Transaction tx1 = session1.beginTransaction();
OrderItem oi1 = (OrderItem) session1.get(OrderItem.class, productId);
oi1.setBook(book);
session1.update(oi1);
tx1.commit();
close();
flag = true;
}
} catch (Exception e) {
e.printStackTrace();
}
return flag;
}
public AccountEntity findByUsername(String username) {
Criteria criteria = this.getSession().createCriteria(AccountEntity.class);
criteria.add(Restrictions.eq("username", username));
return (AccountEntity) criteria.uniqueResult();
}
public static User getUserDatas(Integer id) {
Criteria criteria = getSession().createCriteria(User.class);
criteria.add(Restrictions.eq("userId", id));
User user = (User) criteria.uniqueResult();
closeSession();
return user;
}
public IncomeReceiptItem getIncomeReceiptItemByAccountAndReceipt(
Account acc, IncomeReceipt receipt) {
Criteria criteria = sessionFactory.getCurrentSession().createCriteria(IncomeReceiptItem.class);
criteria.add(Restrictions.eq("account", acc));
criteria.add(Restrictions.eq("receipt", receipt));
return (IncomeReceiptItem) criteria.uniqueResult();
}
public StoragePool findPoolById(final Integer deviceId, final String poolId) {
Criteria criteria =
createCriteria(Restrictions.eq("device.id", deviceId))
.add(Restrictions.eq("idStorage", poolId));
Object obj = criteria.uniqueResult();
return (StoragePool) obj;
}
public ExpenseBalance getExpenseBalanceByAccountAndPeriod(Account account, FiscalPeriod period) {
Criteria criteria = sessionFactory.getCurrentSession().createCriteria(ExpenseBalance.class);
criteria.add(Restrictions.eq("account", account));
criteria.add(Restrictions.eq("period", period));
// criteria.add(Restrictions.eq("status", BalanceStatus.ACTIVE));
return (ExpenseBalance) criteria.uniqueResult();
}
public StorageDevice getDeviceById(final Integer datacenterId, final Integer deviceId) {
Criteria criteria =
createCriteria(Restrictions.eq("datacenter.id", datacenterId))
.add(Restrictions.eq("id", deviceId));
Object obj = criteria.uniqueResult();
return (StorageDevice) obj;
}
@Override
public void DeletebyCodigo(Long codigo) {
Criteria crit = createEntityCriteria();
crit.add(Restrictions.eq("codigo", codigo));
Contacto contacto = (Contacto) crit.uniqueResult();
delete(contacto);
}
public Application getByIdWithCourses(Long id) {
Criteria c = createCriteria();
c.add(Restrictions.idEq(id));
c.setFetchMode("courses", FetchMode.JOIN);
return (Application) c.uniqueResult();
}
@Override
public Contrat getContratById(Long uidContrat) {
final Criteria crit = createCriteria(Contrat.class);
crit.add(Restrictions.eq("id", uidContrat));
crit.add(Restrictions.eq("isVisible", true));
return (Contrat) crit.uniqueResult();
}
@Override
@SuppressWarnings({"unchecked"})
public Set<Pair<String, Class>> findEntityTypes(Number revision)
throws IllegalStateException, IllegalArgumentException {
checkNotNull(revision, "Entity revision");
checkPositive(revision, "Entity revision");
checkSession();
final Session session = auditReaderImplementor.getSession();
final SessionImplementor sessionImplementor = auditReaderImplementor.getSessionImplementor();
final Set<Number> revisions = new HashSet<Number>(1);
revisions.add(revision);
final Criteria query =
verCfg.getRevisionInfoQueryCreator().getRevisionsQuery(session, revisions);
final Object revisionInfo = query.uniqueResult();
if (revisionInfo != null) {
// If revision exists.
final Set<String> entityNames =
verCfg.getModifiedEntityNamesReader().getModifiedEntityNames(revisionInfo);
if (entityNames != null) {
// Generate result that contains entity names and corresponding Java classes.
final Set<Pair<String, Class>> result = new HashSet<Pair<String, Class>>();
for (String entityName : entityNames) {
result.add(
Pair.make(
entityName, EntityTools.getEntityClass(sessionImplementor, session, entityName)));
}
return result;
}
}
return Collections.EMPTY_SET;
}
@Override
public Notice findById(int noticeId) throws OperationalException {
Session session = null;
Notice notice = null;
try {
session = parkingSessionFactory.getSessionFactory().openSession();
session.beginTransaction();
Criteria criteria = session.createCriteria(Notice.class);
criteria.add(Restrictions.eq(NOTICEID, noticeId));
criteria.add(Restrictions.ne(STATUS, NoticeStatus.DELETED.name()));
criteria.setMaxResults(1);
notice = (Notice) criteria.uniqueResult();
return notice;
} catch (Exception e) {
LOGGER.error("findById: Exception ", e);
throw new OperationalException(
HttpConstants.INTERNAL_SERVER_ERROR,
ResponseConstants.ERROR_FETCHING_FROM_DB,
HttpStatus.INTERNAL_SERVER_ERROR);
} finally {
if (session != null) {
session.close();
}
}
}
public Consulta pesquisarConsultaPorId(long id) throws Exception {
Consulta c = new Consulta();
Criteria cr = session.createCriteria(Consulta.class).add(Restrictions.eq("idConsulta", id));
c = (Consulta) cr.uniqueResult();
closeSession();
return c;
}
@Override
public long standbyCount() throws OperationalException {
Session session = null;
long count = 0;
try {
session = parkingSessionFactory.getSessionFactory().openSession();
Criteria criteria = session.createCriteria(Notice.class);
User user = (User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
String role = user.getRole();
criteria.add(Restrictions.eq("author", user));
criteria.add(Restrictions.ne(STATUS, NoticeStatus.DELETED.name()));
criteria.setProjection(Projections.rowCount());
count = (long) criteria.uniqueResult();
} catch (Exception e) {
LOGGER.error("unreadCount: error in unreadCount notfication", e);
throw new OperationalException(
HttpConstants.INTERNAL_SERVER_ERROR,
ResponseConstants.ERROR_FETCHING_FROM_DB,
HttpStatus.INTERNAL_SERVER_ERROR);
} finally {
if (session != null) {
session.close();
}
}
return count;
}
public User getDetail(String login, Session session) {
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.eq("login", login));
User user = (User) criteria.uniqueResult();
return user;
}
public Filme buscaFilme(Integer codigo) {
Filme filme = null;
try {
sessao = HibernateUtil.getSessionFactory().getCurrentSession();
transacao = sessao.beginTransaction();
Criteria filtro = sessao.createCriteria(Filme.class);
filtro.add(Restrictions.eq("filme", codigo));
filme = (Filme) filtro.uniqueResult();
transacao.commit();
} catch (Throwable e) {
if (transacao.isActive()) {
transacao.rollback();
}
} finally {
try {
if (sessao.isOpen()) {
sessao.close();
}
} catch (Throwable e) {
System.out.println("Erro ao fechar operação de busca. Mensagem: " + e.getMessage());
}
}
return filme;
}
/**
* 使用检索标准对象查询记录数
*
* @param detachedCriteria
* @return
*/
@SuppressWarnings("rawtypes")
public long count(DetachedCriteria detachedCriteria) {
Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
long totalCount = 0;
try {
// Get orders
Field field = CriteriaImpl.class.getDeclaredField("orderEntries");
field.setAccessible(true);
List orderEntrys = (List) field.get(criteria);
// Remove orders
field.set(criteria, new ArrayList());
// Get count
criteria.setProjection(Projections.rowCount());
totalCount = Long.valueOf(criteria.uniqueResult().toString());
// Clean count
criteria.setProjection(null);
// Restore orders
field.set(criteria, orderEntrys);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return totalCount;
}
/**
* 判断对象某些属性的值在数据库中不存在重复.
*
* @param entityClass 类型
* @param entity 指定的实体
* @param names 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"
* @return 包含重复的内容返回true，否则返回false
*/
public boolean isGenericNotUnique(Class entityClass, Object entity, String names) {
Assert.hasText(names);
Criteria criteria = getEntityCriteria(entityClass).setProjection(Projections.rowCount());
String[] nameList = names.split(",");
try {
// 循环加入
for (String name : nameList) {
criteria.add(Restrictions.eq(name, PropertyUtils.getProperty(entity, name)));
}
// 以下代码为了如果是update的情况,排除entity自身.
// 通过Hibernate的MetaData接口取得主键名
String idPropertyName =
getSessionFactory().getClassMetadata(entity.getClass()).getIdentifierPropertyName();
if (idPropertyName != null) {
// 通过反射取得entity的主键值
Object id = PropertyUtils.getProperty(entity, idPropertyName);
// 如果id!=null,说明对象已存在,该操作为update,加入排除自身的判断
if (id != null) criteria.add(Restrictions.not(Restrictions.eq(idPropertyName, id)));
}
} catch (IllegalAccessException e) {
logger.error("Error when reflection on entity", e);
return false;
} catch (InvocationTargetException e) {
logger.error("Error when reflection on entity", e);
return false;
} catch (NoSuchMethodException e) {
logger.error("Error when reflection on entity", e);
return false;
}
return (Integer) criteria.uniqueResult() > 0;
}
