org.eclipse.osbp.xtext.datainterchange.common/src/org/eclipse/osbp/xtext/datainterchange/common/CriteriaGenerator.java

package org.eclipse.osbp.xtext.datainterchange.common;

import java.util.List;
import java.util.Map;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaBuilder.In;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.Root;
import javax.persistence.criteria.Subquery;

@SuppressWarnings({ "unchecked", "rawtypes" })
public abstract class CriteriaGenerator {
	//TODO follow this :
	// https://en.wikibooks.org/wiki/Java_Persistence/Criteria
	// https://blog.oio.de/2013/06/07/jpa-2-0-criteria-api-join-how-to/
	// https://blog.oio.de/2010/10/29/jpa-2-0-criteria-api-how-to/#metamodel
	
	//https://www.objectdb.com/java/jpa/query/jpql/structure
	//Example Criterias
	//	select * from STATE_PROVINCE;
	//	select * from STATE_PROVINCE where REGION_ID in (select ID from REGION where SALES_COUNTRY = 'USA');
	//	select ID from REGION where SALES_COUNTRY = 'USA';
	
	
	
	/**
	 * Return the appropriate expression for the criteria builder select statement
	 * @param builder the criteria builder
	 * @return the created expression 
	 */
	public static Expression<Object> getExpression(CriteriaBuilder builder, Object rawValue){
		if(builder != null && rawValue != null){
			if(rawValue instanceof java.sql.Date){
				return builder.literal(rawValue);
			}
		}
		// TODO Franck extension for all expression types, view link bellow
		// https://www.objectdb.com/java/jpa/query/jpql/expression
		return builder.nullLiteral(null);
	}
	
	public static Expression generateQueryExpression(CriteriaBuilder builder, String query){
		if(query != null && !query.isEmpty()){
			//TODO add logic here
		}
		return null;
	}
	
	public static Join generateJoinQuery(CriteriaBuilder builder, Class c1, String a1, Class c2, String a2){
		
		return null;
	}
	
	public static Expression generateQueryExpression(CriteriaBuilder builder, Class root, WhereClausel where){
		String query = null;
		if(query != null && !query.isEmpty()){
			//TODO add logic here			
		}
		return null;
	}

	public static Expression generateDeleteQueryExpression(CriteriaBuilder builder, String from, String where, String groupby, String having, String orderby){
		String query = null;
		if(query != null && !query.isEmpty()){
			//TODO add logic here
		}
		return null;
	}
	
	public static Expression generateUpdateQueryExpression(CriteriaBuilder builder, String from, String set, String where){
		String query = null;
		if(query != null && !query.isEmpty()){
			//TODO add logic here
		}
		return null;
	}
	
	public static CriteriaQuery generateCriteriaQueryInClause(CriteriaBuilder criteriaBuilder, Class rootclass, String column, List<String> values){
		//TODO replace with the current expression
		if(rootclass != null){
			CriteriaQuery criteriaQuery =  criteriaBuilder.createQuery(rootclass);
			Root root = criteriaQuery.from(rootclass);
			In<String> inClause = criteriaBuilder.in(root.get(column));
			for (String title : values) {
				inClause.value(title);
			}
			criteriaQuery.select(root).where(inClause);
			return criteriaQuery;
		}	
		return null;
	}
	
	public static CriteriaQuery generateCriteriaQueryIn(CriteriaBuilder criteriaBuilder, Class rootclass, String column, List<String> values){
		if(rootclass != null){
			CriteriaQuery criteriaQuery =  criteriaBuilder.createQuery(rootclass);
			Root root = criteriaQuery.from(rootclass);
			criteriaQuery.select(root)
			.where(root.get(column).in(values));
			return criteriaQuery;
		}
		return null;
	}
	
	public static CriteriaQuery generateCriteriaQuery(CriteriaBuilder criteriaBuilder, Class rootclass, WhereClausel filter){ //List<String> values){
		if(rootclass != null){
			CriteriaQuery criteriaQuery =  criteriaBuilder.createQuery(rootclass);
			Root root = criteriaQuery.from(rootclass);
			
			if(root != null && filter.hasOperator()){

				switch (filter.getOperator()) {
				case EQUALS: 
					criteriaQuery.select(root).where(root.get(filter.getColumn())); break;
				case NOTEQUALS: 
					criteriaQuery.select(root).where(root.get(filter.getColumn())); break;
				case ISNULL: 
					criteriaQuery.select(root).where(root.get(filter.getColumn()).isNull()); break;
				case ISNOTNULL: 
					criteriaQuery.select(root).where(root.get(filter.getColumn()).isNotNull()); break;
				case ISIN: 
					criteriaQuery.select(root).where(root.get(filter.getColumn()).in(filter.getValues())); break;   //TODO check subquery
				case ISNOTIN: 
					break;
				case ISLIKE: //the value is the search key
					criteriaQuery.select(root).where(criteriaBuilder.like(root.get(filter.getColumn()), "%" + filter.getValue() + "%")); break;  //TODO Test
					
				default:
					criteriaQuery.select(root).where(root.get(filter.getColumn())); break;
				}
			}
			else{
				criteriaQuery.select(root);
			}
			return criteriaQuery;
		}
		return null;
	}
	
	public static Subquery generateSubQuery(CriteriaBuilder criteriaBuilder, Class rootclass, WhereClausel filter){
		if(rootclass != null){
			Subquery subQuery =  criteriaBuilder.createQuery(rootclass).subquery(rootclass);
			Root root = subQuery.from(rootclass);
			
			if(filter != null && filter.hasOperator()){
				switch (filter.getOperator()) {
				case EQUALS: 
					if(filter.hasColumn() && filter.hasValue()){
						subQuery.select(root).where(root.get(filter.getColumn())); break;					
					}
				case NOTEQUALS:
					if(filter.hasColumn() && filter.hasValue()){
						subQuery.select(root).where(root.get(filter.getColumn())); break;						
					}
				case ISNULL: 
					subQuery.select(root).where(root.get(filter.getColumn()).isNull()); break;
				case ISNOTNULL: 
					subQuery.select(root).where(root.get(filter.getColumn()).isNotNull()); break;
				case ISIN: 
					subQuery.select(root).where(root.get(filter.getColumn()).in(filter.getValues())); break;
				case ISNOTIN: 
					break;
				case ISLIKE:
					if(filter.hasColumn() && filter.hasValue()){						
						subQuery.select(root).where(criteriaBuilder.like(root.get(filter.getColumn()), "%" + filter.getValue() + "%")); break;  //TODO Test
					}
				default:
					subQuery.select(root).where(root.get(filter.getColumn())); break;
				}
			}
			subQuery.select(root).distinct(true).where(criteriaBuilder.equal(root.get(filter.getColumn()), filter.getValue()));
			
			//how to use the subquery
//			criteriaQuery.select(emp).where(criteriaBuilder.in(emp.get("department")).value(subquery));
			
		}
		return null;
	}
	
	public static void generateJoinExpression(){
		
	}
	
	public class WhereClausel {
		private String column;
		private List<String> columns;

		private Operator operator;
		
		private String value;
		private Object rawValue;
		private Object values;

		private boolean hasColumn;
		private boolean hasColumns;
		private boolean hasOperator;
		private boolean hasValue;
		
		private boolean isDistinct;
		
		
		public WhereClausel(String column){
			setColumn(column);
		}
		
		public WhereClausel(String value, String column, Operator operator){
			setValue(value);
			setColumn(column);
			setOperator(operator);
		}
		
		public WhereClausel(Object value, String column, Operator operator){
			setRawValue(value);
			setColumn(column);
			setOperator(operator);
		}
		
		public WhereClausel(Map<String, Object> columnsAndvalues, List<Operator> operators){
			
		}
		
		public boolean hasColumn() {
			return hasColumn;
		}

		public void setHasColumn(boolean hasColumn) {
			this.hasColumn = hasColumn;
		}

		public boolean hasColumns() {
			return hasColumns;
		}

		public void setHasColumns(boolean hasColumns) {
			this.hasColumns = hasColumns;
		}
		
		public String getColumn() {
			return column;
		}

		public void setColumn(String column) {
			if(column != null && !column.isEmpty()){			
				this.column = column;
				setHasColumn(true);
			}
			setHasColumn(false);
		}

		public Object getRawValue() {
			return rawValue;
		}

		public void setRawValue(Object rawValue) {
			this.rawValue = rawValue;
		}
		
		public List<String> getColumns() {
			return columns;
		}

		public void setColumns(List<String> columns) {
			if(columns != null && !columns.isEmpty()){
				this.columns = columns;
				setHasOperator(true);
			}
			setHasOperator(false);
		}
		
		public void addColumns(List<String> columns) {
			this.columns = columns;
		}
		
		public Operator getOperator() {
			return operator;
		}

		public void setOperator(Operator operator) {
			if(operator != null){
				this.operator = operator;
				setHasOperator(true);
			}
			setHasOperator(false);
		}
		
//		public String getSearchKey() {
//			return searchKey;
//		}

//		public void setSearchKey(String searchkey) {
//			if(searchkey != null && !searchkey.isEmpty()){
//				this.searchKey = searchKey;
//				setHasSearchKey(true);
//			}
//			setHasSearchKey(false);
//		}
	//
//		public boolean hasSearchKey() {
//			return hasSearchKey;
//		}
	//
//		public void setHasSearchKey(boolean hasSearchKey) {
//			this.hasSearchKey = hasSearchKey;
//		}
		
		public String getValue() {
			return value;
		}

		public void setValue(String value) {
			if(value != null && !value.isEmpty()){
				this.value = value;
				setHasValue(true);	
			}
			setHasValue(false);
		}

		public Object getValues() {
			return values;
		}

		public void setValues(Object values) {
			this.values = values;
		}
		
		public boolean hasOperator() {
			return hasOperator;
		}
		public void setHasOperator(boolean hasOperator) {
			this.hasOperator = hasOperator;
		}
		public boolean hasValue() {
			return hasValue;
		}
		public void setHasValue(boolean hasValue) {
			this.hasValue = hasValue;
		}
		public boolean isDistinct() {
			return isDistinct;
		}
		public void setDistinct(boolean isDistinct) {
			this.isDistinct = isDistinct;
		}
	}

	public enum Operator {
		EQUALS,
		NOTEQUALS,
		GREATERTHAN,
		GREATERTHANOREQUALTO,
		LESSTHAN,
		LESSTHANOREQUALTO,
		ISNULL,
		ISNOTNULL,
		ISIN,
		ISNOTIN,
		ISLIKE;
	}

	
}