How to handle KeyboardEvent in different browsers

    

How to handle KeyboardEvent in different browsers (IE, Chrome, Safari and Firefox)

KeyboardEvent.keyCode - This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

The value of keypress event is different between browsers. IE and Google Chrome set the KeyboardEvent.charCode value. Gecko sets 0 if the pressed key is a printable key, otherwise it sets the same keyCode as a keydown or keyup event.

Google Chrome and Safari have implemented KeyboardEvent.keyIdentifier, which was defined in a draft specification but not the final spec.


Google Chrome, Chromium and Safari must decide the value from the input character. If the inputting character can be inputted with the US keyboard layout, they use the keyCode value on the US keyboard layout.

This example works in Angular 6 and Typescript 2.9.2

/**
     * Allow key codes for special events
     * Del - IE Key in Numeric keypad
     * Decimal - IE Key in Numeric keypad
     * Subtract - IE Key in Numeric keypad
     * Left, Right - IE Keys
     */

specialKeys: Array<string> = ['Backspace', 'Tab', 'End', 'Home', 'Delete', 'Del', '-', 'Decimal', 'ArrowLeft', 'ArrowRight', 'Left', 'Right', 'Subtract'];

//event.key is not working with Safari 5.x so we had to go with keyCode
specialKeyCodes: Array<any> = [9, 35, 36, 37, 39, 46, 48, 48, 50, 51, 52, 53, 54, 55, 56, 57, 190];

@HostListener('keydown', ['$event'])
  onKeyDown(event: KeyboardEvent) {
   

    if ((specialKeys.indexOf(event.key) !== -1) || (specialKeyCodes.indexOf(event.keyCode) !== -1)) {
      // some action......
    }
    //......

}

Generic DAO

Generic DAO Interface

import java.io.Serializable;

import java.lang.reflect.Type;

import java.util.Collection;

import java.util.List;

public interface GenericDao<T, PK extends Serializable> {

public void setClazz(final Class<T> clazzToSet);

public T findById(PK id);

public List<T> findAll();

public void persist(T persistenceObject); 

public PK save(T persistenceObject);

public Collection<PK> saveAll(Collection<T> persistenceObject);

public void saveOrUpdate(T persistenceObject);

public void saveOrUpdateBulk(Collection<T> persistenceObject);

public boolean delete(PK id);

public boolean deleteAll(Collection<T> persistenceObject);

public List<T> getNamedQuery(String queryName);

public List<T> getNamedQueryAndNamedParam(String queryName,

String paramName, Object value);

public List<T> getNamedQueryAndNamedParam(String queryName,

String[] paramNames, Object[] values);

public List<T> getNamedQueryPrimaryKeys(String queryName,

String[] paramNames, Object[] values);

public List<T> getNamedQueryWithParamTypes(String queryName,

String[] paramNames, Object[] values, Type[] types);

public List<T> getNamedQueryWithParamTypes(String queryName, Object[] values, Type[] types);

public List getNamedQueryWithParamTypesAndReturn(String queryName, String[] paramNames, Object[] values, Type[] types);

public List<T> getNamedQueryWithEntitiesAndNamedParam(String queryName,

String entity, Object entityValue, String[] paramNames, Object[] paramValues);

public List<String> getNamedQueryWithEntitiesAndNamedParamReturnString(String queryName,

String entity, Object entityValue, String[] paramNames,

Object[] paramValues);

public List<T> getNamedQueryWithTwoEntitiesAndNamedParam(String queryName,

String entity, Object entityValue, String entity2, Object entityValue2, String[] paramNames,

Object[] paramValues);

public List<String> getNamedQueryWithParams(String queryName, String[] paramNames, Object[] paramValues);

public int getNamedQueryWithParamsWithNoReturn(String queryName, String[] paramNames, Object[] paramValues);

public int getNamedQueryWithParamTypesForUpdates(String queryName, 

String[] paramNames, Object[] values, Type[] types);

public int insertWithPartition(String queryName, 

String[] paramNames, Object[] values, Type[] types);

}

GenericHibernateDao

import java.io.Serializable;

import java.lang.reflect.Type;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import org.hibernate.Hibernate;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.StatelessSession;

import org.hibernate.Transaction;

import org.hibernate.type.IntegerType;

import org.hibernate.type.CharacterArrayType;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Scope;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

@Repository

@Scope("prototype")

public class GenericHibernateDao<T, PK extends Serializable> implements GenericDao<T, PK> {

private Class<T> clazz;

private static final Logger log = LoggerFactory.getLogger(GenericHibernateDao.class);

@Autowired

private SessionFactory sessionFactory;

public void setClazz(final Class<T> clazzToSet) {

this.clazz = clazzToSet;

}

//@Autowired

public void setSessionFactory(final SessionFactory sessionFactory) {

this.sessionFactory = sessionFactory;

}

protected Session getSession() {

return sessionFactory.getCurrentSession();

}

protected StatelessSession getStatelessSession() {

    return sessionFactory.openStatelessSession();

}

protected Session getOpenSession() {

return sessionFactory.openSession();

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public T findById(PK id) {

Object obj = null;

obj = getSession().get(clazz, id);

return (T) obj;

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public List<T> findAll() {

String queryString = "from " + clazz.getName();

Query query = getSession().createQuery(queryString);

//query.setCacheable(true);

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

return list;

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public PK save(T persistenceObject) {

Serializable save = getSession().save(persistenceObject);

return (PK) save;

}

public void persist(T persistenceObject) {

Session session = sessionFactory.openSession();

session.beginTransaction();

session.persist(persistenceObject);

session.getTransaction().commit();

}

@SuppressWarnings({ "unchecked", "rawtypes" })

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public Collection<PK> saveAll(Collection<T> persistenceObject) {

List<Serializable> serializableList = new ArrayList();

for (Iterator<T> iterator = persistenceObject.iterator(); iterator

.hasNext();) {

T o = iterator.next();

Serializable returnObject = getSession().save(o);

serializableList.add(returnObject);

}

return (Collection<PK>) serializableList;

}

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public void saveOrUpdate(T persistenceObject) {

getSession().saveOrUpdate(persistenceObject);

}

public void saveOrUpdateBulk(Collection<T> persistenceObject) {

Session session = getOpenSession();

Transaction tx = session.beginTransaction();

try {

int i = 0;

for (Iterator<T> iterator = persistenceObject.iterator(); iterator.hasNext();) {

//System.out.println(i);

i++;

session.saveOrUpdate(iterator.next());

if (i % 1000 == 0) {

session.flush();

session.clear();

}

}

tx.commit();

}catch (Exception e) {

    if (tx!=null) tx.rollback();

    log.error("ERROR ON saveOrUpdateBulk ", e);

} finally {

session.close();

}

}

/*public void saveOrUpdateBulkPartition(String partitionQueryName, Collection<T> persistenceObject) {

Session session = getOpenSession();

Transaction tx = session.beginTransaction();

try {

int i = 0;

for (Iterator<T> iterator = persistenceObject.iterator(); iterator.hasNext();) {

//System.out.println(i);

i++;

session.saveOrUpdate(iterator.next());

if (i % 1000 == 0) {

session.flush();

session.clear();

}

}

tx.commit();

}catch (Exception e) {

    if (tx!=null) tx.rollback();

    log.error("ERROR ON saveOrUpdateBulk ", e);

} finally {

session.close();

}

}

*/

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public boolean delete(PK id) {

Object findById = findById(id);

if (findById != null) {

getSession().delete(findById);

return true;

}

return false;

}

@Transactional

public boolean deleteAll(Collection<T> persistenceObject) {

Session session = getOpenSession();

Transaction tx = session.beginTransaction();

int i = 0;

for (Iterator<T> iterator = persistenceObject.iterator(); iterator.hasNext();) {

i++;

session.delete(iterator.next());

if (i % 100 == 0) {

session.flush();

session.clear();

}

}

tx.commit();

session.close();

return true;

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public List<T> getNamedQuery(String queryName) {

Query query = getSession().getNamedQuery(queryName);

//query.setCacheable(true);

List<T> results = query.list();

return results;

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public List<T> getNamedQueryAndNamedParam(String queryName, String paramName, Object value) {

Query query = getSession().getNamedQuery(queryName).setString(paramName, value.toString());

//query.setCacheable(true);

List<T> results = query.list();

return results;

}

// This uses open session because if there is a huge amount of data then it cannot be handle normally 

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public List<T> getNamedQueryWithEntitiesAndNamedParam(String queryName, String entity, Object entityValue, String[] paramNames, Object[] paramValues) {

Session session = getOpenSession();

Transaction beginTransaction = session.beginTransaction();

Query namedQuery = session.getNamedQuery(queryName);

namedQuery.setEntity(entity, entityValue);

for (int i = 0; i < paramNames.length; i++) {

String intValue = paramValues[i].toString();

namedQuery.setParameter(paramNames[i], Integer.parseInt(intValue));

}

List<T> results = namedQuery.list();

beginTransaction.commit();

session.flush();

return results;

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public List<String> getNamedQueryWithEntitiesAndNamedParamReturnString(String queryName, String entity, Object entityValue, String[] paramNames, Object[] paramValues) {

Query namedQuery = getSession().getNamedQuery(queryName);

namedQuery.setEntity(entity, entityValue);

for (int i = 0; i < paramNames.length; i++) {

String intValue = paramValues[i].toString();

namedQuery.setParameter(paramNames[i], Integer.parseInt(intValue));

}

//namedQuery.setCacheable(true);

        List<String> results = namedQuery.list();

        return results;

}

// This uses open session because if there is a huge amount of data then it cannot be handle normally  

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public List<T> getNamedQueryWithTwoEntitiesAndNamedParam(String queryName,

String entity, Object entityValue, String entity2, Object entityValue2, String[] paramNames,

Object[] paramValues) {

Session session = getOpenSession();

Transaction beginTransaction = session.beginTransaction();

Query namedQuery = session.getNamedQuery(queryName);

namedQuery.setEntity(entity, entityValue);

namedQuery.setEntity(entity2, entityValue2);

for (int i = 0; i < paramNames.length; i++) {

String intValue = paramValues[i].toString();

namedQuery.setParameter(paramNames[i], Integer.parseInt(intValue));

}

List<T> results = namedQuery.list();

beginTransaction.commit();

session.flush();

return results;

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public List<T> getNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values) {

Query namedQuery = getSession().getNamedQuery(queryName);

for (int i = 0; i < paramNames.length; i++) {

String intValue = values[i].toString();

namedQuery.setParameter(paramNames[i], Integer.parseInt(intValue));

}

//namedQuery.setCacheable(true);

List<T> results = namedQuery.list();

return results;

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public List<T> getNamedQueryPrimaryKeys(String queryName, String[] paramNames, Object[] values) {

Query namedQuery = getSession().getNamedQuery(queryName);

for (int i = 0; i < paramNames.length; i++) {

String intValue = values[i].toString();

//namedQuery.setParameter(paramNames[i], Integer.parseInt(intValue));

namedQuery.setInteger(paramNames[i], Integer.parseInt(intValue));

}

//namedQuery.setCacheable(true);

List<T> results = namedQuery.list();

return results;

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public int getNamedQueryWithParamsWithNoReturn(String queryName, String[] paramNames, Object[] values) {

Query namedQuery = getSession().getNamedQuery(queryName);

for (int i = 0; i < paramNames.length; i++) {

String intValue = values[i].toString();

namedQuery.setParameter(i, Integer.parseInt(intValue));

}

//namedQuery.setCacheable(true);

int executeUpdate = namedQuery.executeUpdate();

return executeUpdate;

}

@SuppressWarnings("unchecked")

// @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public int getNamedQueryWithParamTypesForUpdates(String queryName, String[] paramNames, Object[] values, Type[] types) {

Query namedQuery = getSession().getNamedQuery(queryName);

//namedQuery.setEntity(entity, entityValue);

for (int i = 0; i < paramNames.length; i++) {

if (types[i].equals(Integer.class)) {

Integer value = (Integer) values[i];

namedQuery.setInteger(i, value);

} else if (types[i].equals(String.class)) {

namedQuery.setString(i, (String) values[i]);

} else if (types[i].equals(Date.class)) {

    namedQuery.setParameter(paramNames[i],  (Date) values[i]);

}

}

int results = namedQuery.executeUpdate();

return results;

}

@Transactional

public int insertWithPartition(String queryName, String[] paramNames, Object[] values, Type[] types) {

Query namedQuery = getSession().getNamedQuery(queryName);

for (int i = 0; i < paramNames.length; i++) {

//System.out.println(values[i]);

if (types[i].equals(Integer.class) && values[i] != null) {

Integer value = (Integer) values[i];

namedQuery.setInteger(i, value);

} else if (types[i].equals(String.class) ) {

namedQuery.setString(i, (String) values[i]);

} else if (types[i].equals(Date.class) && values[i] != null) {

    namedQuery.setParameter(i,  (Date) values[i]);

} else if (types[i].equals(Character[].class) && values[i] != null) {

//namedQuery.setParameter(i,  charArray, CharacterArrayType.INSTANCE );

//namedQuery.setText(i,  values[i]);

} else if(values[i] == null){

//namedQuery.setParameter(paramNames[i],  values[i] );

namedQuery.setParameter(i,  values[i], IntegerType.INSTANCE );

}

}

int results = namedQuery.executeUpdate();

return results;

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public List<T> getNamedQueryWithParamTypes(String queryName, String[] paramNames, Object[] values, Type[] types) {

Query namedQuery = getSession().getNamedQuery(queryName);

for (int i = 0; i < paramNames.length; i++) {

if (types[i].equals(Integer.class)) {

Integer value = (Integer) values[i];

namedQuery.setParameter(paramNames[i], value);

} else if (types[i].equals(String.class)) {

namedQuery.setParameter(paramNames[i], (String) values[i]);

} else if (types[i].equals(Date.class)) {

    namedQuery.setParameter(paramNames[i],  (Date) values[i]);

}

}

//namedQuery.setCacheable(true);

List<T> results = namedQuery.list();

return results;

}

@Transactional

public List<T> getNamedQueryWithParamTypes(String queryName, Object[] values, Type[] types) {

Query namedQuery = getSession().getNamedQuery(queryName);

for (int i = 0; i < values.length; i++) {

if (types[i].equals(Integer.class)) {

Integer value = (Integer) values[i];

namedQuery.setParameter(i, value);

} else if (types[i].equals(String.class)) {

namedQuery.setParameter(i, (String) values[i]);

} else if (types[i].equals(Date.class)) {

    namedQuery.setParameter(i,  (Date) values[i]);

}

}

//namedQuery.setCacheable(true);

List<T> results = namedQuery.list();

return results;

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public List getNamedQueryWithParamTypesAndReturn(String queryName, String[] paramNames, Object[] values, Type[] types) {

Query namedQuery = getSession().getNamedQuery(queryName);

for (int i = 0; i < paramNames.length; i++) {

if (types[i].equals(Integer.class)) {

Integer value = (Integer) values[i];

namedQuery.setParameter(paramNames[i], value);

} else if (types[i].equals(String.class)) {

namedQuery.setParameter(paramNames[i], (String) values[i]);

} else if (types[i].equals(Date.class)) {

    namedQuery.setParameter(paramNames[i],  (Date) values[i]);

}

}

//namedQuery.setCacheable(true);

List result = namedQuery.list();

return result;

}

@SuppressWarnings("unchecked")

//@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)

@Transactional

public List<String> getNamedQueryWithParams(String queryName, String[] paramNames, Object[] paramValues){

    Query namedQuery = getSession().getNamedQuery(queryName);

    for (int i = 0; i < paramNames.length; i++) {

            String intValue = paramValues[i].toString();

            namedQuery.setParameter(paramNames[i], Integer.parseInt(intValue));

        }

    //namedQuery.setCacheable(true);

        List<String> results = namedQuery.list();

        return results;

   

}

}

Datasoure Configurations in Spring

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

<property name="driverClassName" value="com.mysql.jdbc.Driver" />

<property name="url" value="${JDBC_CONNECTION_STRING}" />

<property name="username" value="${DATASOURCE_USER_NAME}" />

<property name="password" value="${DATASOURCE_USER_PASSWORD}" />

</bean>

<bean id="sessionFactory"

class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">

<property name="dataSource" ref="dataSource" />

<property name="packagesToScan" value="com.x.model" />

<property name="hibernateProperties">

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</prop>

<prop key="hibernate.show_sql">${HIBERNATE_SHOW_SQL}</prop>

<prop key="hibernate.hbm2ddl.auto">false</prop>

<prop key="hibernate.format_sql">true</prop>

<prop key="hibernate.auto_close_session">true</prop>

<!-- below line may be important for some apps for the releasing to work properly -->

            <prop key="hibernate.connection.release_mode">after_transaction</prop>

</props>

</property>

<property name="mappingResources">

<list>

<value>named-queries.xml</value>

</list>

</property>

</bean>

<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"

p:sessionFactory-ref="sessionFactory" p:dataSource-ref="dataSource">

</bean>

<tx:annotation-driven transaction-manager="transactionManager" />

<bean id="clientDao" class="com.xxxxxxxxxxdao.GenericHibernateDao">

<property name="clazz" value="com.ls.nix.client.model.Client" />

</bean>

<hibernate-mapping>

<!-- Named queries for Client -->

<query name="Client.findAllByNotNullSalesForceId">

<![CDATA[SELECT c FROM Client c LEFT JOIN FETCH  c.clientStatus AS clientStatus]]>

</query>

</hibernate-mapping>

How do you call it

  @Autowired

    @Qualifier(value = "clientDao")

    private GenericDao<Client, Integer> clientDao;