| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 org.apache.openmeetings.data.basic; |
| |
| import java.util.Collection; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import javax.persistence.EntityManager; |
| import javax.persistence.NoResultException; |
| import javax.persistence.PersistenceContext; |
| import javax.persistence.TypedQuery; |
| |
| import org.apache.openmeetings.OpenmeetingsVariables; |
| import org.apache.openmeetings.data.basic.dao.ConfigurationDao; |
| import org.apache.openmeetings.data.beans.basic.SearchResult; |
| import org.apache.openmeetings.persistence.beans.lang.FieldLanguage; |
| import org.apache.openmeetings.persistence.beans.lang.Fieldlanguagesvalues; |
| import org.apache.openmeetings.persistence.beans.lang.Fieldvalues; |
| import org.red5.logging.Red5LoggerFactory; |
| import org.slf4j.Logger; |
| import org.springframework.beans.factory.annotation.Autowired; |
| import org.springframework.transaction.annotation.Transactional; |
| |
| /** |
| * |
| * @author sebastianwagner |
| * |
| */ |
| @Transactional |
| public class FieldManager { |
| |
| private static final Logger log = Red5LoggerFactory.getLogger( |
| FieldManager.class, OpenmeetingsVariables.webAppRootKey); |
| |
| @PersistenceContext |
| private EntityManager em; |
| |
| @Autowired |
| private FieldLanguageDao fieldLanguageDaoImpl; |
| |
| @Autowired |
| private FieldLanguagesValuesDao fieldLanguagesValuesDAO; |
| |
| @Autowired |
| private ConfigurationDao configurationDaoImpl; |
| |
| // Reflect the Reverse Order!! |
| public Fieldlanguagesvalues getFieldByIdAndLanguageByNavi( |
| Long fieldvalues_id, Long language_id) { |
| try { |
| if (fieldvalues_id == null) { |
| return null; |
| } |
| |
| TypedQuery<Fieldlanguagesvalues> query = em |
| .createQuery("select f from Fieldlanguagesvalues f WHERE f.language_id = :language_id AND f.fieldvalues_id = :fieldvalues_id", Fieldlanguagesvalues.class); |
| query.setParameter("fieldvalues_id", fieldvalues_id); |
| query.setParameter("language_id", language_id); |
| Fieldlanguagesvalues flv = null; |
| try { |
| flv = performReplace(query.getSingleResult()); |
| } catch (NoResultException ex) { |
| } |
| |
| FieldLanguage fieldLanguage = fieldLanguageDaoImpl |
| .getFieldLanguageById(language_id); |
| |
| log.debug("Getting FieldById for Language " |
| + fieldLanguage.getName()); |
| |
| // Check for Right To Left Languages |
| if (fieldLanguage.getRtl()) { |
| |
| log.debug("Language requieres RTL"); |
| |
| Fieldlanguagesvalues remote = flv; |
| Fieldlanguagesvalues toAdd = new Fieldlanguagesvalues(); |
| toAdd.setFieldlanguagesvalues_id(remote |
| .getFieldlanguagesvalues_id()); |
| toAdd.setFieldvalues_id(remote.getFieldvalues_id()); |
| toAdd.setLanguage_id(remote.getLanguage_id()); |
| |
| String[] splitted = remote.getValue().split(" "); |
| String reverseOrder = ""; |
| for (int i = splitted.length - 1; i >= 0; i--) { |
| reverseOrder += splitted[i]; |
| if (splitted.length != 1) { |
| reverseOrder += " "; |
| } |
| } |
| toAdd.setValue(reverseOrder); |
| |
| return toAdd; |
| } else { |
| log.debug("Language doesnt requiere RTL"); |
| |
| return flv; |
| } |
| |
| } catch (Exception ex2) { |
| log.error("[getFieldByIdAndLanguage]: ", ex2); |
| } |
| return null; |
| } |
| |
| public String getString(Long fieldvalues_id, Long language_id) { |
| String result = null; |
| Fieldlanguagesvalues flv = getFieldByIdAndLanguage(fieldvalues_id, language_id); |
| if (flv != null) { |
| result = performReplace(flv).getValue(); |
| } |
| return result; |
| } |
| |
| public Fieldlanguagesvalues getFieldByIdAndLanguage(Long fieldvalues_id, |
| Long language_id) { |
| try { |
| |
| String hql = "select f from Fieldlanguagesvalues as f " |
| + "WHERE f.language_id = :language_id " |
| + "AND f.fieldvalues_id = :fieldvalues_id"; |
| |
| Fieldlanguagesvalues flv = null; |
| |
| TypedQuery<Fieldlanguagesvalues> query = em.createQuery(hql, Fieldlanguagesvalues.class); |
| |
| query.setParameter("fieldvalues_id", fieldvalues_id); |
| query.setParameter("language_id", language_id); |
| List<Fieldlanguagesvalues> fList = query.getResultList(); |
| |
| if (fList.size() > 0) { |
| flv = fList.get(0); //replace should not be performed here to enable string editing via admin |
| } |
| |
| return flv; |
| } catch (Exception ex2) { |
| log.error("[getFieldByIdAndLanguage]: ", ex2); |
| } |
| return null; |
| } |
| |
| public Long deleteFieldlanguagesvaluesById(Long fieldlanguagesvalues_id) { |
| try { |
| Fieldlanguagesvalues flv = this |
| .getFieldlanguagesvaluesById(fieldlanguagesvalues_id); |
| if (flv == null) { |
| return new Long(-27); |
| } |
| |
| flv = em.find(Fieldlanguagesvalues.class, fieldlanguagesvalues_id); |
| |
| return new Long(-28); |
| } catch (Exception ex2) { |
| log.error("[getFieldByIdAndLanguage]: ", ex2); |
| } |
| return new Long(-1); |
| } |
| |
| public List<Fieldlanguagesvalues> getAllFieldsByLanguage(Long language_id) { |
| try { |
| |
| TypedQuery<Fieldlanguagesvalues> query = em |
| .createQuery("select f from Fieldlanguagesvalues f WHERE f.language_id = :language_id ", Fieldlanguagesvalues.class); |
| query.setParameter("language_id", language_id); |
| List<Fieldlanguagesvalues> returnList = performReplace(query.getResultList()); |
| |
| return returnList; |
| } catch (Exception ex2) { |
| log.error("[getConfKey]: " + ex2); |
| } |
| return null; |
| } |
| |
| public List<Map<String, Object>> getLabelsByLanguage(Long language_id, |
| int start, int max) { |
| try { |
| |
| String sql = "select f.fieldvalues.fieldvalues_id, f.value from Fieldlanguagesvalues as f " |
| + "WHERE f.language_id = :language_id "; |
| |
| TypedQuery<Object> query = em.createQuery(sql, Object.class); |
| query.setParameter("language_id", language_id); |
| query.setFirstResult(start); |
| query.setMaxResults(max); |
| |
| String appName = configurationDaoImpl.getAppName(); |
| List<Map<String, Object>> returnList = new LinkedList<Map<String, Object>>(); |
| for (Object fl : query.getResultList()) { |
| Map<String, Object> map = new HashMap<String, Object>(); |
| Object[] row = (Object[])fl; |
| map.put("id", row[0]); |
| map.put("value", performReplace((String)row[1], appName)); |
| returnList.add(map); |
| } |
| FieldLanguage fieldLanguage = fieldLanguageDaoImpl |
| .getFieldLanguageById(language_id); |
| |
| log.debug("Getting Labels for Language " + fieldLanguage.getName()); |
| |
| // Check for Right To Left Languages |
| if (fieldLanguage.getRtl()) { |
| log.debug("Language requieres RTL!"); |
| |
| List<Map<String, Object>> returnRtlList = new LinkedList<Map<String, Object>>(); |
| |
| for (Iterator<Map<String, Object>> iter = returnList.iterator(); iter |
| .hasNext();) { |
| Map<String, Object> remote = iter.next(); |
| |
| Map<String, Object> toAdd = new HashMap<String, Object>(); |
| toAdd.put("id", remote.get("id")); |
| |
| String value = remote.get("value").toString(); |
| |
| String[] splitted = value.split(" "); |
| String reverseOrder = ""; |
| for (int i = splitted.length - 1; i >= 0; i--) { |
| reverseOrder += splitted[i]; |
| if (splitted.length != 1) { |
| reverseOrder += " "; |
| } |
| } |
| log.debug("reverseOrder " + reverseOrder); |
| toAdd.put("value", value); |
| |
| returnRtlList.add(toAdd); |
| } |
| |
| return returnRtlList; |
| } else { |
| log.debug("Language doesnt requiere RTL!"); |
| |
| return returnList; |
| |
| } |
| |
| } catch (Exception ex2) { |
| log.error("[getLabelsByLanguage]: ", ex2); |
| ex2.printStackTrace(); |
| } |
| return null; |
| } |
| |
| public List<Fieldlanguagesvalues> getAllFieldsByLanguage(Long language_id, |
| int start, int max) { |
| try { |
| |
| String sql = "select f from Fieldlanguagesvalues f WHERE f.language_id = :language_id " |
| + "AND f.fieldvalues_id >= :start AND f.fieldvalues_id < :max"; |
| |
| TypedQuery<Fieldlanguagesvalues> query = em.createQuery(sql, Fieldlanguagesvalues.class); |
| query.setParameter("language_id", language_id); |
| query.setParameter("start", start); |
| query.setParameter("max", start + max); |
| |
| List<Fieldlanguagesvalues> returnList = performReplace(query.getResultList()); |
| FieldLanguage fieldLanguage = fieldLanguageDaoImpl |
| .getFieldLanguageById(language_id); |
| |
| log.debug("GEtting all fields by language : " |
| + fieldLanguage.getName()); |
| |
| // Check for Right To Left Languages |
| if (fieldLanguage.getRtl()) { |
| log.debug("language : " + fieldLanguage.getName() |
| + " requieres RTL"); |
| |
| List<Fieldlanguagesvalues> returnRtlList = new LinkedList<Fieldlanguagesvalues>(); |
| |
| for (Iterator<Fieldlanguagesvalues> iter = returnList |
| .iterator(); iter.hasNext();) { |
| Fieldlanguagesvalues remote = iter.next(); |
| Fieldlanguagesvalues toAdd = new Fieldlanguagesvalues(); |
| toAdd.setFieldlanguagesvalues_id(remote |
| .getFieldlanguagesvalues_id()); |
| toAdd.setFieldvalues_id(remote.getFieldvalues_id()); |
| toAdd.setLanguage_id(remote.getLanguage_id()); |
| |
| String[] splitted = remote.getValue().split(" "); |
| String reverseOrder = ""; |
| for (int i = splitted.length - 1; i >= 0; i--) { |
| reverseOrder += splitted[i]; |
| if (splitted.length != 1) { |
| reverseOrder += " "; |
| } |
| } |
| toAdd.setValue(reverseOrder); |
| |
| returnRtlList.add(toAdd); |
| } |
| |
| return returnRtlList; |
| } else { |
| log.debug("language : " + fieldLanguage.getName() |
| + " requieres NO RTL"); |
| |
| return returnList; |
| |
| } |
| |
| } catch (Exception ex2) { |
| log.error("[getConfKey]: ", ex2); |
| } |
| return null; |
| } |
| |
| public Long addFieldValueByFieldAndLanguage(Fieldvalues fv, |
| Long language_id, String fieldvalue) { |
| try { |
| |
| Fieldlanguagesvalues flv = new Fieldlanguagesvalues(); |
| flv.setStarttime(new Date()); |
| flv.setValue(fieldvalue); |
| flv.setLanguage_id(language_id); |
| flv.setFieldvalues(fv); |
| flv.setDeleted(false); |
| |
| flv = em.merge(flv); |
| Long fieldlanguagesvaluesId = flv.getFieldlanguagesvalues_id(); |
| |
| return fieldlanguagesvaluesId; |
| } catch (Exception ex2) { |
| log.error("[getConfKey]: ", ex2); |
| } |
| return null; |
| } |
| |
| public void updateFieldValueByFieldAndLanguage(Fieldlanguagesvalues flv) { |
| try { |
| |
| if (flv.getFieldlanguagesvalues_id() == null) { |
| em.persist(flv); |
| } else { |
| if (!em.contains(flv)) { |
| em.merge(flv); |
| } |
| } |
| |
| } catch (Exception ex2) { |
| log.error("[updateFieldValueByFieldAndLanguage]: ", ex2); |
| } |
| |
| } |
| |
| public Fieldvalues addFieldById(String fieldName, Long fieldvalues_id) { |
| try { |
| Fieldvalues fl = new Fieldvalues(); |
| fl.setFieldvalues_id(fieldvalues_id); |
| fl.setStarttime(new Date()); |
| fl.setName(fieldName); |
| fl.setDeleted(false); |
| |
| return em.merge(fl); |
| } catch (Exception ex2) { |
| log.error("[getConfKey]: ", ex2); |
| } |
| return null; |
| } |
| |
| public List<Fieldlanguagesvalues> getMixedFieldValuesList(Long language_id) { |
| // all Fieldlanguagesvalues in current Language |
| TypedQuery<Fieldlanguagesvalues> q = em.createNamedQuery("allFieldLanguageValues", Fieldlanguagesvalues.class); |
| q.setParameter("language_id", language_id); |
| return q.getResultList(); |
| } |
| |
| public List<Fieldlanguagesvalues> getUntranslatedFieldValuesList(Long language_id) { |
| // all FieldValuesIds in current Language |
| TypedQuery<Long> q0 = em.createNamedQuery("allFieldValuesIds", Long.class); |
| q0.setParameter("language_id", language_id); |
| List<Long> translatedIds = q0.getResultList(); |
| |
| // all not translated values from english |
| TypedQuery<Fieldlanguagesvalues> q1 = em.createNamedQuery("allNotTranslatedValues", Fieldlanguagesvalues.class); |
| q1.setParameter("id_list", translatedIds); |
| |
| return q1.getResultList(); |
| } |
| |
| public Fieldvalues getFieldvaluesById(Long fieldvalues_id, Long language_id) { |
| try { |
| // log.error("Long fieldvalues_id, Long language_id "+fieldvalues_id+" || "+language_id); |
| Fieldvalues fv = this.getFieldvaluesById(fieldvalues_id); |
| fv.setFieldlanguagesvalue(this.getFieldByIdAndLanguage( |
| fieldvalues_id, language_id)); |
| return fv; |
| } catch (Exception e) { |
| log.error("[getFieldvaluesById] ", e); |
| } |
| return null; |
| } |
| |
| /** |
| * update given Field and its Label by IDs |
| * |
| * @param fieldvalues_id |
| * @param name |
| * @param fieldlanguagesvalues_id |
| * @param value |
| * @return |
| */ |
| public Long updateLabel(Long fieldvalues_id, String name, |
| Long fieldlanguagesvalues_id, String value) { |
| try { |
| Fieldvalues fv = this.getFieldvaluesById(fieldvalues_id); |
| if (fv == null) { |
| return new Long(-24); |
| } else { |
| fv.setName(name); |
| fv.setUpdatetime(new Date()); |
| this.updateField(fv); |
| } |
| Fieldlanguagesvalues flv = this |
| .getFieldlanguagesvaluesById(fieldlanguagesvalues_id); |
| if (flv == null) { |
| return new Long(-25); |
| } else { |
| flv.setUpdatetime(new Date()); |
| flv.setValue(value); |
| this.updateFieldLanguagesLabel(flv); |
| } |
| return fieldvalues_id; |
| } catch (Exception ex2) { |
| log.error("[updateFieldLanguagesLabel]: ", ex2); |
| } |
| return new Long(-1); |
| } |
| |
| public Long addAndUpdateLabel(Long fieldvalues_id, String name, |
| String value, Long language_id) { |
| try { |
| Fieldvalues fv = this.getFieldvaluesById(fieldvalues_id); |
| if (fv == null) { |
| return new Long(-24); |
| } else { |
| fv.setName(name); |
| fv.setUpdatetime(new Date()); |
| this.updateField(fv); |
| } |
| this.addFieldValueByFieldAndLanguage(fv, language_id, |
| value); |
| return fieldvalues_id; |
| } catch (Exception ex2) { |
| log.error("[updateFieldLanguagesLabel]: ", ex2); |
| } |
| return new Long(-1); |
| } |
| |
| public long getNextFieldvaluesId() { |
| return fieldLanguagesValuesDAO.count() + 1; |
| } |
| |
| public Long addFieldAndLabel(String name, String value, Long language_id) { |
| try { |
| Fieldvalues fv = addFieldById(name, getNextFieldvaluesId()); |
| if (fv.getFieldvalues_id() > 0) { |
| this.addFieldValueByFieldAndLanguage(fv, |
| language_id, value); |
| return fv.getFieldvalues_id(); |
| } else { |
| return -1L; |
| } |
| } catch (Exception ex2) { |
| log.error("[updateFieldLanguagesLabel]: ", ex2); |
| } |
| return -1L; |
| } |
| |
| public SearchResult<Fieldvalues> getFieldsByLanguage(int start, int max, String orderby, |
| boolean asc, Long language_id, String search) { |
| try { |
| SearchResult<Fieldvalues> sresult = new SearchResult<Fieldvalues>(); |
| sresult.setObjectName(Fieldlanguagesvalues.class.getName()); |
| sresult.setRecords(this.selectMaxFromFieldsValues(search)); |
| sresult.setResult(this.getMixedFieldValuesList(start, max, orderby, |
| asc, language_id, search)); |
| return sresult; |
| } catch (Exception ex2) { |
| log.error("[getFieldsByLanguage]: ", ex2); |
| } |
| return null; |
| } |
| |
| private Long selectMaxFromFieldsValues(String search) throws Exception { |
| String queryLanguage = "select count(c.fieldvalues_id) from Fieldvalues c where c.deleted = false"; |
| if (search.length()>0) { |
| queryLanguage += " AND (c.name LIKE :searchStr " + |
| "OR c.fieldvalues_id = :fieldvalues_id)"; |
| } |
| TypedQuery<Long> query = em |
| .createQuery(queryLanguage, Long.class); |
| if (search.length()>0) { |
| query.setParameter("searchStr", "%"+search+"%"); |
| long idNumber = 0; |
| try { |
| idNumber = Long.parseLong(search); |
| } catch (NumberFormatException nfe) { |
| } |
| query.setParameter("fieldvalues_id", idNumber); |
| } |
| return query.getResultList().get(0); |
| } |
| |
| private List<Fieldvalues> getMixedFieldValuesList(int start, int max, |
| String orderby, boolean asc, Long language_id, String search) throws Exception { |
| List<Fieldvalues> fvList = this.getFieldsValues(start, max, orderby, asc, search); |
| for (Fieldvalues fv : fvList) { |
| fv.setFieldlanguagesvalue(this.getFieldByIdAndLanguage( |
| fv.getFieldvalues_id(), language_id)); |
| } |
| return fvList; |
| } |
| |
| private List<Fieldvalues> getFieldsValues(int start, int max, |
| String orderby, boolean asc, String search) throws Exception { |
| String queryLanguage = "select c from Fieldvalues c where c.deleted = false"; |
| if (search.length()>0) { |
| queryLanguage += " AND (c.name LIKE :searchStr " + |
| "OR c.fieldvalues_id = :fieldvalues_id)"; |
| } |
| if (asc) { |
| queryLanguage += " ORDER BY "+orderby+ " ASC"; |
| } else { |
| queryLanguage += " ORDER BY "+orderby + "DESC"; |
| } |
| TypedQuery<Fieldvalues> q = em |
| .createQuery(queryLanguage, Fieldvalues.class); |
| if (search.length()>0) { |
| q.setParameter("searchStr", "%"+search+"%"); |
| long idNumber = 0; |
| try { |
| idNumber = Long.parseLong(search); |
| } catch (NumberFormatException nfe) { |
| } |
| q.setParameter("fieldvalues_id", idNumber); |
| } |
| q.setFirstResult(start); |
| q.setMaxResults(max); |
| return q.getResultList(); |
| } |
| |
| public Fieldvalues getFieldvaluesById(Long fieldvalues_id) { |
| String hql = "select f from Fieldvalues f WHERE f.fieldvalues_id = :fieldvalues_id "; |
| TypedQuery<Fieldvalues> query = em.createQuery(hql, Fieldvalues.class); |
| query.setParameter("fieldvalues_id", fieldvalues_id); |
| Fieldvalues fv = null; |
| try { |
| fv = query.getSingleResult(); |
| } catch (NoResultException ex) { |
| } |
| return fv; |
| } |
| |
| private Fieldlanguagesvalues getFieldlanguagesvaluesById( |
| Long fieldlanguagesvalues_id) throws Exception { |
| return performReplace(fieldLanguagesValuesDAO.get(fieldlanguagesvalues_id)); |
| } |
| |
| private Fieldlanguagesvalues performReplace(Fieldlanguagesvalues f) { |
| String appName = configurationDaoImpl.getAppName(); |
| return performReplace(f, appName); |
| } |
| |
| private String performReplace(String val, String appName) { |
| return val == null ? val : val.replaceAll("\\$APP_NAME", appName); |
| } |
| |
| private Fieldlanguagesvalues performReplace(Fieldlanguagesvalues f, String appName) { |
| Fieldlanguagesvalues r = new Fieldlanguagesvalues(); |
| r.setDeleted(f.getDeleted()); |
| r.setFieldlanguagesvalues_id(f.getFieldlanguagesvalues_id()); |
| r.setFieldvalues_id(f.getFieldvalues_id()); |
| r.setLanguage_id(f.getLanguage_id()); |
| r.setStarttime(f.getStarttime()); |
| r.setUpdatetime(f.getUpdatetime()); |
| r.setValue(performReplace(f.getValue(), appName)); |
| return r; |
| } |
| |
| private <T extends Collection<Fieldlanguagesvalues>> T performReplace(T flv) { |
| String appName = configurationDaoImpl.getAppName(); |
| |
| for (Fieldlanguagesvalues f : flv) { |
| performReplace(f, appName); |
| } |
| return flv; |
| } |
| |
| private void updateField(Fieldvalues fv) throws Exception { |
| if (fv.getFieldvalues_id() == null) { |
| em.persist(fv); |
| } else { |
| if (!em.contains(fv)) { |
| em.merge(fv); |
| } |
| } |
| } |
| |
| private void updateFieldLanguagesLabel(Fieldlanguagesvalues flv) |
| throws Exception { |
| if (flv.getFieldlanguagesvalues_id() == null) { |
| em.persist(flv); |
| } else { |
| if (!em.contains(flv)) { |
| em.merge(flv); |
| } |
| } |
| } |
| |
| } |