@SuppressWarnings({"unchecked", "rawtypes"})
@Override
public List<Lista> getByQuery(Map<String, Object> m) throws DataException {
Criteria crit = this.getSession().createCriteria(Lista.class);
/** Extraemos el mapa de parametros. */
Iterator it = m.entrySet().iterator();
while (it.hasNext()) {
Map.Entry e = (Map.Entry) it.next();
if (e.getKey().equals("descripcion"))
crit.add(
Restrictions.sqlRestriction("trim(ucase(descripcion)) like '%" + e.getValue() + "%'"));
if (e.getKey().equals("borrado"))
crit.add(Restrictions.sqlRestriction("borrado=" + e.getValue()));
if (e.getKey().equals("idUsuario"))
crit.add(Restrictions.sqlRestriction("idUsuario=" + e.getValue()));
}
// reemplazar por la linea de arriba las dos siguientes si se requiere ordenacion
// Si en vez de Criteria es un SQLQuery echa un vistazo a la clase del proyecto compras-rest
// ProveedorMercanciaDAOImpl
Criteria criteriaConOrder = asignarOrdenacionACriteria(crit);
List<Lista> list = criteriaConOrder.list();
return list;
}
@GlobalDBOpenCloseAndUserPrivilages
public Map getUserTypeSize(
Session session,
HttpServletRequest request,
HttpServletResponse response,
String LoggedInRegion,
String LoggedInUser) {
Map resultMap = new HashMap();
String isAccountModule = "No";
Map financialYearMap = new LinkedHashMap();
financialYearMap.put("0", "--Select--");
UserViewModel userObj = (UserViewModel) request.getSession(false).getAttribute("userDetails");
Criteria rcCriteria = session.createCriteria(Useroperatingrights.class);
rcCriteria.add(Restrictions.sqlRestriction("userid = '" + userObj.getUserid() + "'"));
rcCriteria.add(Restrictions.sqlRestriction("accessright is true"));
rcCriteria.addOrder(Order.asc("usertypeid"));
List rcList = rcCriteria.list();
resultMap.put("typesize", rcList.size());
Criteria fyearsCriteria = session.createCriteria(Accountingyear.class);
List fyearsList = fyearsCriteria.list();
if (fyearsList.size() > 0) {
for (int i = 0; i < fyearsList.size(); i++) {
Accountingyear accountingyearObj = (Accountingyear) fyearsList.get(i);
financialYearMap.put(
accountingyearObj.getId(),
(accountingyearObj.getStartyear() + "-" + accountingyearObj.getEndyear()));
}
}
resultMap.put("financialYearMap", financialYearMap);
if (rcList.size() == 1) {
Useroperatingrights useroperatingrightsObj = (Useroperatingrights) rcList.get(0);
Criteria privileageCriteria = session.createCriteria(Menuprivilages.class);
privileageCriteria.add(
Restrictions.sqlRestriction("usertype = " + useroperatingrightsObj.getUsertypeid()));
privileageCriteria.add(Restrictions.sqlRestriction("accessright is true"));
List privileageList = privileageCriteria.list();
if (privileageList.size() > 0) {
for (int j = 0; j < privileageList.size(); j++) {
Menuprivilages menuprivilagesObj = (Menuprivilages) privileageList.get(j);
//
// System.out.println("menuprivilagesObj.getMenumaster().getGrouptype()==" +
// menuprivilagesObj.getMenumaster().getGrouptype());
if (menuprivilagesObj.getMenumaster().getGrouptype() == null) {
} else if (menuprivilagesObj.getMenumaster().getGrouptype() == 'A') {
isAccountModule = "Yes";
break;
}
}
}
}
resultMap.put("isAccountModule", isAccountModule);
return resultMap;
}
@GlobalDBOpenCloseAndUserPrivilages
public Map loadRegionDetails(
Session session,
HttpServletRequest request,
HttpServletResponse response,
String LoggedInRegion,
String LoggedInUser) {
Map resultMap = new HashMap();
Map regionMap = new LinkedHashMap();
regionMap.put("0", "----Select One----");
String regionid = "";
String regionname = "";
try {
Criteria rgnCrit = session.createCriteria(Regionmaster.class);
rgnCrit.add(Restrictions.sqlRestriction("defaultregion is true"));
rgnCrit.addOrder(Order.asc("regionname"));
List<Regionmaster> rgnList = rgnCrit.list();
resultMap = new TreeMap();
for (Regionmaster lbobj : rgnList) {
regionid = lbobj.getId();
regionname = lbobj.getRegionname();
regionMap.put(regionid, regionname);
}
resultMap.put("regionlist", regionMap);
} catch (Exception e) {
e.printStackTrace();
}
return resultMap;
}
public Criterion transform(IRestriction source) {
if (source instanceof SqlRestriction) {
SqlRestriction sqlRestriction = (SqlRestriction) source;
return Restrictions.sqlRestriction(sqlRestriction.getSql());
}
return null;
}
/** {@inheritDoc} */
@Override
public Criterion getCriterion() {
return Restrictions.sqlRestriction(
" {alias}.ifserviceid NOT IN (SELECT DISTINCT ifservices.id FROM ifservices, ipinterface, node WHERE ifservices.ipinterfaceid = ipinterface.id AND ipinterface.nodeid = node.nodeid AND node.foreignSource=?)",
getValue(),
StringType.INSTANCE);
}
@GlobalDBOpenCloseAndUserPrivilages
public Map getUsertypesforModify1(
Session session,
HttpServletRequest request,
HttpServletResponse response,
String LoggedInRegion,
String LoggedInUser,
String usertypeid) {
Map resultMap = new HashMap();
Map usertypeMap = new LinkedHashMap();
usertypeMap.put("0", "--Select--");
try {
Criteria usertypeCrit = session.createCriteria(Usertype.class);
usertypeCrit.add(Restrictions.sqlRestriction("parentcode=" + Integer.parseInt(usertypeid)));
usertypeCrit.addOrder(Order.asc("id"));
List<Usertype> usertypeList = usertypeCrit.list();
resultMap = new TreeMap();
for (Usertype lbobj : usertypeList) {
usertypeMap.put(lbobj.getId(), lbobj.getUsertypename());
}
resultMap.put("usertypes", usertypeMap);
} catch (Exception e) {
e.printStackTrace();
}
return resultMap;
}
/**
* This method is for getting all Presenter
*
* @param requestParamters
* @return Presenter List
*/
public ArrayList getAllPresenter(HttpServletRequest req) {
log.log(Level.INFO, "PresenterMaintanence --> getAllPresenter");
ArrayList arrActivity = new ArrayList();
Session session = null;
int month = Calendar.getInstance().get(Calendar.MONTH) + 1;
int year = Calendar.getInstance().get(Calendar.YEAR);
User userObj = (User) req.getSession().getAttribute("currUserObj");
try {
session = HibernateFactory.openSession();
Criteria crit = session.createCriteria(Presenter.class);
crit.add(Restrictions.sqlRestriction("MONTH(START_DATE)=?", month, Hibernate.INTEGER));
crit.add(Restrictions.sqlRestriction("YEAR(START_DATE)=?", year, Hibernate.INTEGER));
crit.add(Restrictions.eq("status", true));
if (userObj.isBuLevel() && userObj.getBuCode() != 0) {
crit.add(Restrictions.eq("buCode", userObj.getBuCode()));
}
if (userObj.isDistrictLevel()) {
crit.add(Restrictions.eq("distCode", userObj.getDistrict()));
}
if (userObj.isBranchLevel()) {
crit.add(Restrictions.eq("branchCode", userObj.getBranchCode()));
}
if (userObj.isCityLevel()) {
crit.add(Restrictions.eq("cityCode", userObj.getCityCode()));
}
if (userObj.isSscLevel()) {
crit.add(Restrictions.eq("sscCode", userObj.getSscCode()));
}
if (userObj.isOfficeLevel()) {
crit.add(Restrictions.eq("officeCode", userObj.getOfficeCode()));
}
arrActivity = (ArrayList) crit.list();
} catch (Exception e) {
log.log(Level.SEVERE, e.getMessage());
e.printStackTrace();
} finally {
HibernateFactory.close(session);
}
return arrActivity;
}
/*
* (non-Javadoc)
* @see cn.trymore.core.dao.DAOGeneric#getListByCriteria(org.hibernate.criterion.DetachedCriteria, boolean)
*/
@SuppressWarnings("unchecked")
public List<T> getListByCriteria(final DetachedCriteria criteria, final boolean dataFilter)
throws DAOException {
if (dataFilter && UtilString.isNotEmpty(this.getQueryFilter())) {
criteria.add(Restrictions.sqlRestriction(this.getQueryFilter()));
this.setQueryFilter(null);
}
return (List<T>) getHibernateTemplate().findByCriteria(criteria);
}
@SuppressWarnings("unchecked")
@Override
public List<NoticeModel> getNotices(String userId, String beginDate, String endDate, String type)
throws ServiceException {
// TODO Auto-generated method stub
DetachedCriteria criteria = DetachedCriteria.forClass(NoticeModel.class);
if (StringUtils.isNotEmpty(userId) && (!userId.equals("1"))) {
criteria.add(Restrictions.like("teacherAttendIds", userId, MatchMode.ANYWHERE));
}
if (StringUtils.isNotEmpty(beginDate))
criteria.add(Restrictions.sqlRestriction("postTime >= '" + beginDate + " 00:00:00'"));
if (StringUtils.isNotEmpty(endDate))
criteria.add(Restrictions.sqlRestriction("postTime <= '" + endDate + " 23:59:59'"));
if (StringUtils.isNotEmpty(type)) criteria.add(Restrictions.eq("type", type));
criteria.add(Restrictions.eq("status", NoticeModel.EStatus.Published.getValue()));
criteria.addOrder(Order.desc("postTime"));
return noticeDAO.getListByCriteria(criteria);
}
@GlobalDBOpenCloseAndUserPrivilages
public Map getAssignedMenus(
Session session,
HttpServletRequest request,
HttpServletResponse response,
String LoggedInRegion,
String LoggedInUser,
String usertypes) {
Map resultMap = new HashMap();
Map menuMap = new LinkedHashMap();
try {
Criteria menuCrit = session.createCriteria(Menuprivilages.class);
menuCrit.add(Restrictions.sqlRestriction("usertype=" + Integer.parseInt(usertypes)));
menuCrit.add(Restrictions.sqlRestriction("accessright is true"));
List menuList = menuCrit.list();
if (menuList.size() > 0) {
for (int i = 0; i < menuList.size(); i++) {
Menuprivilages menuObj = (Menuprivilages) menuList.get(i);
Criteria criteria = session.createCriteria(Menumaster.class);
criteria.add(Restrictions.ne("parentcode", 0));
criteria.add(Restrictions.eq("code", menuObj.getMenumaster().getCode()));
criteria.add(Restrictions.ne("methodname", ""));
// criteria.add(Restrictions.sqlRestriction("code=" +
// menuObj.getMenumaster().getCode()+" and parentcode!=0"));
List menulist = criteria.list();
if (menulist.size() > 0) {
menuMap.put(
"accessright" + menuObj.getMenumaster().getCode(),
"accessright" + menuObj.getMenumaster().getCode());
}
}
resultMap.put("menuMap", menuMap);
} else {
resultMap.put("ERROR", "Not Assigned");
}
} catch (Exception e) {
}
return resultMap;
}
public void insertParent(Session session, int menuId, int usertypes) {
Transaction transaction = null;
try {
Criteria menuCrit = session.createCriteria(Menumaster.class);
menuCrit.add(Restrictions.sqlRestriction("code=" + menuId));
List menuList = menuCrit.list();
if (menuList.size() > 0) {
Menumaster menuObj = (Menumaster) menuList.get(0);
Criteria menuCrit1 = session.createCriteria(Menuprivilages.class);
menuCrit1.add(Restrictions.sqlRestriction("usertype=" + usertypes));
menuCrit1.add(Restrictions.sqlRestriction("menumaster=" + menuObj.getParentcode()));
List menuList1 = menuCrit1.list();
if (menuList1.size() <= 0) {
transaction = session.beginTransaction();
Usertype typeobj = new Usertype();
typeobj.setId(usertypes);
Menumaster menuMasterObj = new Menumaster();
menuMasterObj.setCode(menuObj.getParentcode());
Menuprivilages menuObj2 = new Menuprivilages();
menuObj2.setId(String.valueOf(getSequenceNumber(session)));
menuObj2.setUsertype(typeobj);
menuObj2.setMenumaster(menuMasterObj);
menuObj2.setAccessright(Boolean.TRUE);
session.save(menuObj2);
transaction.commit();
this.insertParent(session, menuObj.getParentcode(), usertypes);
}
}
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
}
public void testQueryView() {
User entity = new User();
entity.setStatus("NONEOCT");
GeneralCriteria criteria = new GeneralCriteria(UserVO.class);
criteria.setDataOnly(false);
criteria.addOrder(Order.desc("activeTime"));
if (entity != null) {
if (entity.getUsername() != null) {
criteria.add(Restrictions.eq("username", entity.getUsername()));
}
if (entity.getPassword() != null) {
criteria.add(Restrictions.eq("bindIP", entity.getBindIP()));
}
if (entity.getStatus() != null) {
if (entity.getStatus().equals("NORMAL")) { // 正常
criteria.add(Restrictions.eq("status", "NORMAL"));
} else if (entity.getStatus().equals("EXPIRED")) { // 过期
criteria.add(Restrictions.gt("expiredTime", new Date()));
} else if (entity.getStatus().equals("NONEOCT")) { // 无流量
criteria.add(
Restrictions.sqlRestriction("maxOctets*1024*1024>sumInputOctets+sumOutputOctets"));
}
}
}
GeneralCriteriaResult<UserVO> result = criteria.executeQuery();
GeneralCriteriaQuery query = criteria.getCriteriaQuery();
System.out.println("结果数:" + result.getTotal());
Calendar c = Calendar.getInstance();
c.clear();
c.set(2012, 6, 1);
Date start = c.getTime();
c.add(Calendar.MONTH, 12);
Date end = c.getTime();
DecimalFormat df = new DecimalFormat(".00");
for (UserVO vo : result.getData()) {
System.out.println(vo.getId() + ",username:"******",sumoct:");
User u = (User) query.get(User.class, vo.getId());
// UserFeeCycle cycle = new UserFeeCycle();
// cycle.setStart(start);
// cycle.setEnd(end);
// double ratio = vo.getActualFee()/(vo.getMaxOctets()*1024);
// cycle.setCostFee(Double.valueOf(df.format(((cycle.getInputOct()+cycle.getOutputOct())*1.05/1024)*ratio)));
// cycle.setUser(u);
// query.save(cycle);
}
}
public void updateParent(Session session, int menuId, int usertypes) {
Transaction transaction = null;
try {
Criteria menuCrit3 = session.createCriteria(Menuprivilages.class);
menuCrit3.add(Restrictions.sqlRestriction("usertype=" + usertypes));
menuCrit3.add(Restrictions.sqlRestriction("menumaster=" + menuId));
List menuList3 = menuCrit3.list();
if (menuList3.size() > 0) {
transaction = session.beginTransaction();
Menuprivilages menuObj3 = (Menuprivilages) menuList3.get(0);
menuObj3.setAccessright(Boolean.TRUE);
session.update(menuObj3);
transaction.commit();
this.updateParent(session, menuObj3.getMenumaster().getParentcode(), usertypes);
}
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
}
@Override
public List<Participation> getParticipationsWithNoSubmissionToTaskOrdered(Task task) {
return getSession()
.createCriteria(Participation.class)
.add(Restrictions.eq("lecture", task.getTaskGroup().getLecture()))
.add(
Restrictions.sqlRestriction(
"{alias}.id not in (SELECT submitters_id FROM submissions, submissions_participations where submissions.submissionid=submissions_participations.submissions_submissionid and taskid="
+ task.getTaskid()
+ ")"))
.createCriteria("user")
.addOrder(Order.asc("lastName"))
.addOrder(Order.asc("firstName"))
.list();
}
@SuppressWarnings("unchecked")
@Override
public List<CourseProductItemModel> getProductsByCourse(String course) {
// TODO Auto-generated method stub
DetachedCriteria criteria = DetachedCriteria.forClass(CourseProductItemModel.class);
criteria.add(Restrictions.sqlRestriction("course_name=?", course, Hibernate.STRING));
try {
List<CourseProductItemModel> list = courseProductConfigDAO.getListByCriteria(criteria);
courseProductConfigDAO.saveOrUpdate(list, false);
return courseProductConfigDAO.getListByCriteria(criteria);
} catch (DAOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}
/*
* (non-Javadoc)
* @see cn.trymore.core.dao.DAOGeneric#findPageByCriteria(org.hibernate.criterion.DetachedCriteria, int, int, boolean)
*/
@SuppressWarnings({"unchecked"})
public PaginationSupport<T> findPageByCriteria(
final DetachedCriteria criteria,
final int pageSize,
final int startIndex,
final boolean dataFilter)
throws DAOException {
if (dataFilter && UtilString.isNotEmpty(this.getQueryFilter())) {
criteria.add(Restrictions.sqlRestriction(this.getQueryFilter()));
this.setQueryFilter(null);
}
return (PaginationSupport<T>)
getHibernateTemplate()
.execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria execCriteria = criteria.getExecutableCriteria(session);
int rowCount =
((Integer)
execCriteria.setProjection(Projections.rowCount()).uniqueResult())
.intValue();
execCriteria.setProjection(null);
execCriteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
// execCriteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
execCriteria.setFirstResult(startIndex);
if (pageSize > 0) {
execCriteria.setMaxResults(pageSize);
} else {
execCriteria.setMaxResults(rowCount);
}
List<T> items = execCriteria.list();
return rowCount > 0
? new PaginationSupport<T>(
items, rowCount, startIndex, pageSize > 0 ? pageSize : rowCount)
: null;
}
});
}
public void sql(String sql, Object objects, Type type) {
Restrictions.sqlRestriction(sql, objects, type);
}
public void sql(String sql) {
Restrictions.sqlRestriction(sql);
}
@Override
public Iterator<Item> findByMetadataQuery(
Context context,
List<List<MetadataField>> listFieldList,
List<String> query_op,
List<String> query_val,
List<UUID> collectionUuids,
String regexClause,
int offset,
int limit)
throws SQLException {
Criteria criteria = createCriteria(context, Item.class, "item");
criteria.setFirstResult(offset);
criteria.setMaxResults(limit);
if (!collectionUuids.isEmpty()) {
DetachedCriteria dcollCriteria = DetachedCriteria.forClass(Collection.class, "coll");
dcollCriteria.setProjection(Projections.property("coll.id"));
dcollCriteria.add(Restrictions.eqProperty("coll.id", "item.owningCollection"));
dcollCriteria.add(Restrictions.in("coll.id", collectionUuids));
criteria.add(Subqueries.exists(dcollCriteria));
}
int index = Math.min(listFieldList.size(), Math.min(query_op.size(), query_val.size()));
StringBuilder sb = new StringBuilder();
for (int i = 0; i < index; i++) {
OP op = OP.valueOf(query_op.get(i));
if (op == null) {
log.warn("Skipping Invalid Operator: " + query_op.get(i));
continue;
}
if (op == OP.matches || op == OP.doesnt_match) {
if (regexClause.isEmpty()) {
log.warn("Skipping Unsupported Regex Operator: " + query_op.get(i));
continue;
}
}
DetachedCriteria subcriteria = DetachedCriteria.forClass(MetadataValue.class, "mv");
subcriteria.add(Property.forName("mv.dSpaceObject").eqProperty("item.id"));
subcriteria.setProjection(Projections.property("mv.dSpaceObject"));
if (!listFieldList.get(i).isEmpty()) {
subcriteria.add(Restrictions.in("metadataField", listFieldList.get(i)));
}
sb.append(op.name() + " ");
if (op == OP.equals || op == OP.not_equals) {
subcriteria.add(Property.forName("mv.value").eq(query_val.get(i)));
sb.append(query_val.get(i));
} else if (op == OP.like || op == OP.not_like) {
subcriteria.add(Property.forName("mv.value").like(query_val.get(i)));
sb.append(query_val.get(i));
} else if (op == OP.contains || op == OP.doesnt_contain) {
subcriteria.add(Property.forName("mv.value").like("%" + query_val.get(i) + "%"));
sb.append(query_val.get(i));
} else if (op == OP.matches || op == OP.doesnt_match) {
subcriteria.add(
Restrictions.sqlRestriction(regexClause, query_val.get(i), StandardBasicTypes.STRING));
sb.append(query_val.get(i));
}
if (op == OP.exists
|| op == OP.equals
|| op == OP.like
|| op == OP.contains
|| op == OP.matches) {
criteria.add(Subqueries.exists(subcriteria));
} else {
criteria.add(Subqueries.notExists(subcriteria));
}
}
log.debug(String.format("Running custom query with %d filters", index));
return list(criteria).iterator();
}
/**
* See Interface for functional description.
*
* @see UserAccountDaoInterface #retrieveUserAccounts(java.util.Map, int, int, String,
* ListSorting)
*/
@Override
public List<UserAccount> retrieveUserAccounts(
final Map<String, Object> criterias,
final int offset,
final int maxResults,
final String orderBy,
final ListSorting sorting)
throws SqlDatabaseSystemException {
final DetachedCriteria detachedCriteria = DetachedCriteria.forClass(UserAccount.class, "user");
final Map<String, Object> clonedCriterias = new HashMap<String, Object>(criterias);
// ids
final Set<String> userAccountIds =
mergeSets(
(Set<String>) clonedCriterias.remove(Constants.DC_IDENTIFIER_URI),
(Set<String>) clonedCriterias.remove(Constants.FILTER_PATH_ID));
if (userAccountIds != null && !userAccountIds.isEmpty()) {
detachedCriteria.add(Restrictions.in("id", userAccountIds.toArray()));
}
// active flag
final String active = (String) clonedCriterias.remove(Constants.FILTER_ACTIVE);
final String active1 = (String) clonedCriterias.remove(Constants.FILTER_PATH_ACTIVE);
if (active != null) {
detachedCriteria.add(Restrictions.eq("active", Boolean.valueOf(active)));
} else if (active1 != null) {
detachedCriteria.add(Restrictions.eq("active", Boolean.valueOf(active1)));
}
for (final Entry<String, Object[]> stringEntry : criteriaMap.entrySet()) {
if (stringEntry.getKey().equals(Constants.FILTER_ORGANIZATIONAL_UNIT)
|| stringEntry.getKey().equals(Constants.FILTER_PATH_ORGANIZATIONAL_UNIT)) {
continue;
}
final Object criteriaValue = clonedCriterias.remove(stringEntry.getKey());
if (criteriaValue != null) {
final Object[] parts = stringEntry.getValue();
if (parts[0].equals(COMPARE_EQ)) {
detachedCriteria.add(Restrictions.eq((String) parts[1], criteriaValue));
} else {
detachedCriteria.add(Restrictions.like((String) parts[1], criteriaValue));
}
}
}
// organizational units
final String organizationalUnit1 =
(String) clonedCriterias.remove(Constants.FILTER_ORGANIZATIONAL_UNIT);
final String organizationalUnit2 =
(String) clonedCriterias.remove(Constants.FILTER_PATH_ORGANIZATIONAL_UNIT);
final String organizationalUnit =
organizationalUnit1 != null ? organizationalUnit1 : organizationalUnit2;
if (organizationalUnit != null) {
final String ouAttributeName =
EscidocConfiguration.getInstance()
.get(EscidocConfiguration.ESCIDOC_CORE_AA_OU_ATTRIBUTE_NAME);
if (ouAttributeName == null || ouAttributeName.length() == 0) {
throw new SqlDatabaseSystemException("ou-attribute-name not found in configuration");
}
detachedCriteria.add(
Restrictions.sqlRestriction(
"this_.id in ("
+ "select ua.id from aa.user_account ua, "
+ "aa.user_attribute atts "
+ "where ua.id = atts.user_id "
+ "and atts.name = '"
+ ouAttributeName
+ "' and atts.value = ?)",
organizationalUnit,
Hibernate.STRING));
// detachedCriteria.add(Restrictions.like("ous", StringUtility
// .concatenateToString("%", organizationalUnit, "|||%")));
}
if (orderBy != null) {
if (sorting == ListSorting.ASCENDING) {
detachedCriteria.addOrder(Order.asc(propertiesNamesMap.get(orderBy)));
} else if (sorting == ListSorting.DESCENDING) {
detachedCriteria.addOrder(Order.desc(propertiesNamesMap.get(orderBy)));
}
}
if (clonedCriterias.isEmpty()) {
final List<UserAccount> result;
try {
result = getHibernateTemplate().findByCriteria(detachedCriteria, offset, maxResults);
} catch (final DataAccessException e) {
throw new SqlDatabaseSystemException(e);
}
return result;
} else {
// unsupported filter criteria has been found, therefore the result
// list must be empty.
return new ArrayList<UserAccount>(0);
}
}
/**
* This method is for search Presenter
*
* @param requestParameters Servlet Request Parameter
* @return Presenter List
*/
public ArrayList searchPresenter(HttpServletRequest req) {
log.log(Level.INFO, "PresenterMaintenance --> search presenter ");
ArrayList arrPresenter = new ArrayList();
String presenterName = req.getParameter(NAME_PARAM);
String category = req.getParameter("presenter_category");
String month = req.getParameter(MONTH_PARAM);
String year = req.getParameter(YEAR_PARAM);
String bu = req.getParameter(BU_PARAM);
String district = req.getParameter(DISTRICT_PARAM);
String city = req.getParameter(CITY_PARAM);
String ssc = req.getParameter(SSC_PARAM);
String office = req.getParameter("office");
String branchCode = req.getParameter("branchCode");
Session session = HibernateFactory.openSession();
try {
Criteria crit = session.createCriteria(Presenter.class);
if (presenterName != null && presenterName.length() > 0)
crit.add(Restrictions.like("presenterName", presenterName, MatchMode.ANYWHERE));
if (category != null && Integer.parseInt(category) != 0)
crit.add(Restrictions.eq("category", Integer.parseInt(category)));
if (month != null)
crit.add(
Restrictions.sqlRestriction(
"MONTH(START_DATE)=?", Integer.parseInt(month), Hibernate.INTEGER));
if (year != null)
crit.add(
Restrictions.sqlRestriction(
"YEAR(START_DATE)=?", Integer.parseInt(year), Hibernate.INTEGER));
if (bu != null && Integer.parseInt(bu) != 0)
crit.add(Restrictions.eq("buCode", Integer.parseInt(bu)));
if (district != null && Integer.parseInt(district) != 0)
crit.add(Restrictions.eq("distCode", Integer.parseInt(district)));
if (branchCode != null && Integer.parseInt(branchCode) != 0)
crit.add(Restrictions.eq("branchCode", Integer.parseInt(branchCode)));
if (city != null && Integer.parseInt(city) != 0)
crit.add(Restrictions.eq("cityCode", Integer.parseInt(city)));
if (office != null && Integer.parseInt(office) != 0)
crit.add(Restrictions.eq("officeCode", Integer.parseInt(office)));
if (ssc != null && Integer.parseInt(ssc) != 0)
crit.add(Restrictions.eq("sscCode", Integer.parseInt(ssc)));
crit.add(Restrictions.eq("status", true));
List l = crit.list();
Iterator it = l.iterator();
while (it.hasNext()) {
Presenter presenter = (Presenter) it.next();
arrPresenter.add(presenter);
}
} catch (Exception e) {
log.log(Level.SEVERE, e.getMessage());
e.printStackTrace();
}
try {
HibernateFactory.close(session);
} catch (Exception e) {
log.log(Level.SEVERE, e.getMessage());
e.printStackTrace();
}
return arrPresenter;
}
@GlobalDBOpenCloseAndUserPrivilages
public Map saveMenuAssign(
Session session,
HttpServletRequest request,
HttpServletResponse response,
String LoggedInRegion,
String LoggedInUser,
String usertypes,
String menucodes) {
Map resultMap = new HashMap();
String[] strArray = null;
String delimiter = "-";
Transaction transaction = null;
try {
Criteria menuCrit = session.createCriteria(Menuprivilages.class);
menuCrit.add(Restrictions.sqlRestriction("usertype=" + Integer.parseInt(usertypes)));
List menuList = menuCrit.list();
if (menuList.size() > 0) {
for (int i = 0; i < menuList.size(); i++) {
Menuprivilages menuObj = (Menuprivilages) menuList.get(i);
transaction = session.beginTransaction();
menuObj.setAccessright(Boolean.FALSE);
session.update(menuObj);
transaction.commit();
}
if (!menucodes.equalsIgnoreCase("") && menucodes != null) {
strArray = menucodes.split(java.util.regex.Pattern.quote(delimiter));
for (String menuId : strArray) {
Criteria menuCrit1 = session.createCriteria(Menuprivilages.class);
menuCrit1.add(Restrictions.sqlRestriction("usertype=" + Integer.parseInt(usertypes)));
menuCrit1.add(Restrictions.sqlRestriction("menumaster=" + Integer.parseInt(menuId)));
List menuList1 = menuCrit1.list();
if (menuList1.size() > 0) {
transaction = session.beginTransaction();
Menuprivilages menuObj = (Menuprivilages) menuList1.get(0);
menuObj.setAccessright(Boolean.TRUE);
session.update(menuObj);
transaction.commit();
this.updateParent(
session, menuObj.getMenumaster().getParentcode(), menuObj.getUsertype().getId());
} else {
transaction = session.beginTransaction();
Usertype typeobj = new Usertype();
typeobj.setId(Integer.parseInt(usertypes));
Menumaster menuMasterObj = new Menumaster();
menuMasterObj.setCode(Integer.parseInt(menuId));
Menuprivilages menuObj = new Menuprivilages();
menuObj.setId(String.valueOf(getSequenceNumber(session)));
menuObj.setUsertype(typeobj);
menuObj.setMenumaster(menuMasterObj);
menuObj.setAccessright(Boolean.TRUE);
session.saveOrUpdate(menuObj);
transaction.commit();
this.insertParent(session, Integer.parseInt(menuId), Integer.parseInt(usertypes));
}
}
}
} else {
Criteria criteria = session.createCriteria(Menumaster.class);
// criteria.add(Restrictions.ne("parentcode", 0));
criteria.addOrder(Order.asc("menuorder"));
List menumasterlist = criteria.list();
if (menumasterlist.size() > 0) {
for (int i = 0; i < menumasterlist.size(); i++) {
Menumaster menuMasterObj = (Menumaster) menumasterlist.get(i);
transaction = session.beginTransaction();
Usertype typeobj = new Usertype();
typeobj.setId(Integer.parseInt(usertypes));
Menuprivilages menuObj = new Menuprivilages();
menuObj.setId(String.valueOf(getSequenceNumber(session)));
menuObj.setUsertype(typeobj);
menuObj.setMenumaster(menuMasterObj);
menuObj.setAccessright(Boolean.FALSE);
session.save(menuObj);
transaction.commit();
}
}
if (!menucodes.equalsIgnoreCase("") && menucodes != null) {
strArray = menucodes.split(java.util.regex.Pattern.quote(delimiter));
for (String menuId : strArray) {
Criteria menuCrit1 = session.createCriteria(Menuprivilages.class);
menuCrit1.add(Restrictions.sqlRestriction("usertype=" + Integer.parseInt(usertypes)));
menuCrit1.add(Restrictions.sqlRestriction("menumaster=" + Integer.parseInt(menuId)));
List menuList1 = menuCrit1.list();
if (menuList1.size() > 0) {
transaction = session.beginTransaction();
Menuprivilages menuObj = (Menuprivilages) menuList1.get(0);
menuObj.setAccessright(Boolean.TRUE);
session.update(menuObj);
transaction.commit();
this.updateParent(
session, menuObj.getMenumaster().getParentcode(), menuObj.getUsertype().getId());
} else {
transaction = session.beginTransaction();
Usertype typeobj = new Usertype();
typeobj.setId(Integer.parseInt(usertypes));
Menumaster menuMasterObj = new Menumaster();
menuMasterObj.setCode(Integer.parseInt(menuId));
Menuprivilages menuObj = new Menuprivilages();
menuObj.setId(String.valueOf(getSequenceNumber(session)));
menuObj.setUsertype(typeobj);
menuObj.setMenumaster(menuMasterObj);
menuObj.setAccessright(Boolean.TRUE);
session.save(menuObj);
transaction.commit();
this.insertParent(session, Integer.parseInt(menuId), Integer.parseInt(usertypes));
}
}
}
}
resultMap.put("success", "Successfully Menus Assigned");
} catch (Exception e) {
e.printStackTrace();
if (transaction != null) {
transaction.rollback();
}
resultMap.put("ERROR", "Menus Assigning Faild");
}
return resultMap;
}
public EntityFilter sql(String sql) {
criterias.add(Restrictions.sqlRestriction(sql));
return this;
}
private Criterion parseExpression(Expression expression) {
ExpressionTypes type = expression.getType();
String propertyName = expression.getTargetPropertyName();
Object value = expression.getValue();
Class<?> clazz;
if (log.isTraceEnabled()) {
log.trace(
String.format(
"Parsing expression of type '%s' for propety '%s', value=%s",
type.name(), propertyName, value));
}
switch (type) {
case EQUAL:
return org.hibernate.criterion.Restrictions.eq(propertyName, value);
case GREATER:
return org.hibernate.criterion.Restrictions.gt(propertyName, value);
case GREATER_OR_EQUAL:
return org.hibernate.criterion.Restrictions.ge(propertyName, value);
case LESS:
return org.hibernate.criterion.Restrictions.lt(propertyName, value);
case LESS_OR_EQUAL:
return org.hibernate.criterion.Restrictions.le(propertyName, value);
case LIKE:
String sval = (String) value;
if (sval.contains("%") || sval.contains("_")) {
return org.hibernate.criterion.Restrictions.ilike(propertyName, sval);
} else {
return org.hibernate.criterion.Restrictions.ilike(propertyName, sval, MatchMode.ANYWHERE);
}
case LIKE_END:
return org.hibernate.criterion.Restrictions.ilike(
propertyName, (String) value, MatchMode.END);
case LIKE_START:
return org.hibernate.criterion.Restrictions.ilike(
propertyName, (String) value, MatchMode.START);
case LIKE_EXACT:
return org.hibernate.criterion.Restrictions.ilike(
propertyName, (String) value, MatchMode.EXACT);
case BETWEEN:
return org.hibernate.criterion.Restrictions.between(
propertyName, ((Object[]) value)[0], ((Object[]) value)[1]);
case IN:
clazz = value.getClass();
if (clazz.isArray()) {
return org.hibernate.criterion.Restrictions.in(propertyName, (Object[]) value);
} else if (Collection.class.isAssignableFrom(clazz)) {
return org.hibernate.criterion.Restrictions.in(propertyName, (Collection<?>) value);
} else {
throw new IllegalStateException(
"Object for 'IN' criteria must be array or collection, but it is "
+ (clazz == null ? "(null)" : "'" + clazz.getName() + "'"));
}
case IS_NULL:
return org.hibernate.criterion.Restrictions.isNull(propertyName);
case IS_NOT_NULL:
return org.hibernate.criterion.Restrictions.isNotNull(propertyName);
case NOT_EQUAL:
return org.hibernate.criterion.Restrictions.ne(propertyName, value);
case EXISTS:
return Subqueries.exists(subquery((SubqueryExpression) expression));
case NOT_EXISTS:
return Subqueries.notExists(subquery((SubqueryExpression) expression));
case EQUAL_PROPERTY:
if (!(value instanceof CharSequence)) {
throw new IllegalStateException(
"Value for 'EQUAL_PROPERTY' criteria must be CharSequence, but it is "
+ (value == null ? "(null)" : "'" + value.getClass().getName() + "'"));
}
return org.hibernate.criterion.Restrictions.eqProperty(propertyName, value.toString());
case GREATER_PROPERTY:
return org.hibernate.criterion.Restrictions.gtProperty(propertyName, value.toString());
case LESS_PROPERTY:
return org.hibernate.criterion.Restrictions.ltProperty(propertyName, value.toString());
case GREATER_EQUAL_PROPERTY:
return org.hibernate.criterion.Restrictions.geProperty(propertyName, value.toString());
case LESS_EQUAL_PROPERTY:
return org.hibernate.criterion.Restrictions.leProperty(propertyName, value.toString());
case SQL_RESTICTION:
return org.hibernate.criterion.Restrictions.sqlRestriction(value.toString());
default:
throw new IllegalStateException(
String.format("Unknown query expression '%s'", type.name()));
}
}