/**
 * 
 */
package org.gcube.portlets.user.td.gwtservice.server;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.ResourceBundle;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
import org.gcube.common.portal.PortalContext;
import org.gcube.common.scope.api.ScopeProvider;
import org.gcube.data.analysis.tabulardata.service.tabular.TabularResource;
import org.gcube.portlets.user.td.gwtservice.server.file.CSVFileUploadSession;
import org.gcube.portlets.user.td.gwtservice.server.file.CodelistMappingFileUploadSession;
import org.gcube.portlets.user.td.gwtservice.server.trservice.TRTasksManager;
import org.gcube.portlets.user.td.gwtservice.server.util.ServiceCredentials;
import org.gcube.portlets.user.td.gwtservice.shared.Constants;
import org.gcube.portlets.user.td.gwtservice.shared.chart.ChartTopRatingSession;
import org.gcube.portlets.user.td.gwtservice.shared.codelisthelper.CodelistMappingSession;
import org.gcube.portlets.user.td.gwtservice.shared.csv.CSVExportSession;
import org.gcube.portlets.user.td.gwtservice.shared.csv.CSVImportSession;
import org.gcube.portlets.user.td.gwtservice.shared.exception.TDGWTServiceException;
import org.gcube.portlets.user.td.gwtservice.shared.extract.ExtractCodelistSession;
import org.gcube.portlets.user.td.gwtservice.shared.file.FileUploadMonitor;
import org.gcube.portlets.user.td.gwtservice.shared.geometry.GeometryCreatePointSession;
import org.gcube.portlets.user.td.gwtservice.shared.geospatial.GeospatialCreateCoordinatesSession;
import org.gcube.portlets.user.td.gwtservice.shared.geospatial.GeospatialDownscaleCSquareSession;
import org.gcube.portlets.user.td.gwtservice.shared.history.RollBackSession;
import org.gcube.portlets.user.td.gwtservice.shared.i18n.InfoLocale;
import org.gcube.portlets.user.td.gwtservice.shared.json.JSONExportSession;
import org.gcube.portlets.user.td.gwtservice.shared.map.MapCreationSession;
import org.gcube.portlets.user.td.gwtservice.shared.rule.ApplyAndDetachColumnRulesSession;
import org.gcube.portlets.user.td.gwtservice.shared.rule.ApplyTableRuleSession;
import org.gcube.portlets.user.td.gwtservice.shared.rule.DetachColumnRulesSession;
import org.gcube.portlets.user.td.gwtservice.shared.rule.DetachTableRulesSession;
import org.gcube.portlets.user.td.gwtservice.shared.sdmx.SDMXExportSession;
import org.gcube.portlets.user.td.gwtservice.shared.sdmx.SDMXImportSession;
import org.gcube.portlets.user.td.gwtservice.shared.sdmx.SDMXTemplateExportSession;
import org.gcube.portlets.user.td.gwtservice.shared.source.SDMXRegistrySource;
import org.gcube.portlets.user.td.gwtservice.shared.statistical.DataMinerOperationSession;
import org.gcube.portlets.user.td.gwtservice.shared.task.TaskResubmitSession;
import org.gcube.portlets.user.td.gwtservice.shared.task.TaskResumeSession;
import org.gcube.portlets.user.td.gwtservice.shared.task.TaskWrapper;
import org.gcube.portlets.user.td.gwtservice.shared.template.TemplateApplySession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.TabResource;
import org.gcube.portlets.user.td.gwtservice.shared.tr.batch.ReplaceBatchColumnSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.clone.CloneTabularResourceSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.column.AddColumnSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.column.ChangeColumnsPositionSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.column.DeleteColumnSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.column.FilterColumnSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.column.LabelColumnSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.column.MergeColumnSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.column.ReplaceColumnByExpressionSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.column.ReplaceColumnSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.column.SplitColumnSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.column.type.ChangeColumnTypeSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.groupby.GroupBySession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.groupby.TimeAggregationSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.normalization.DenormalizationSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.normalization.NormalizationSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.open.TDOpenSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.replacebyexternal.ReplaceByExternalSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.resources.SaveResourceSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.rows.DeleteRowsSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.rows.DuplicatesSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.rows.EditRowSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.table.ChangeTableTypeSession;
import org.gcube.portlets.user.td.gwtservice.shared.tr.type.Agencies;
import org.gcube.portlets.user.td.gwtservice.shared.tr.type.Codelist;
import org.gcube.portlets.user.td.gwtservice.shared.tr.type.Dataset;
import org.gcube.portlets.user.td.gwtservice.shared.tr.union.UnionSession;
import org.gcube.portlets.user.td.widgetcommonevent.shared.TRId;
import org.gcube.vomanagement.usermanagement.impl.LiferayGroupManager;
import org.gcube.vomanagement.usermanagement.model.GCubeGroup;
import org.gcube.vomanagement.usermanagement.model.GCubeUser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 * @author Giancarlo Panichi
 *
 * 
 */
public class SessionUtil {

	private static Logger logger = LoggerFactory.getLogger(SessionUtil.class);

	public static ServiceCredentials getServiceCredentials(HttpServletRequest httpServletRequest)
			throws TDGWTServiceException {
		return getServiceCredentials(httpServletRequest, null);
	}

	public static ServiceCredentials getServiceCredentials(HttpServletRequest httpServletRequest, String scopeGroupId)
			throws TDGWTServiceException {

		ServiceCredentials sCredentials = null;
		String userName = null;
		String scope = null;
		String token = null;
		String groupId = null;
		String groupName = null;

		if (Constants.DEBUG_MODE) {
			logger.info("No credential found in session, use test user!");	
			userName = Constants.DEFAULT_USER;
			scope = Constants.DEFAULT_SCOPE;
			token = Constants.DEFAULT_TOKEN;

			logger.info("Set SecurityToken: " + token);
			SecurityTokenProvider.instance.set(token);
			logger.info("Set ScopeProvider: " + scope);
			ScopeProvider.instance.set(scope);

			sCredentials = new ServiceCredentials(userName, scope, token);
			
			InfoLocale infoLocale = getInfoLocale(httpServletRequest, sCredentials);
			Locale locale = new Locale(infoLocale.getLanguage());
			
			ResourceBundle.getBundle(TDGWTServiceMessagesConstants.TDGWTServiceMessages,
					locale);

			
		} else {
			logger.info("Retrieving credential in session!");
			PortalContext pContext = PortalContext.getConfiguration();
			boolean hasScopeGroupId = false;

			if (scopeGroupId != null && !scopeGroupId.isEmpty()) {
				hasScopeGroupId = true;

			} else {
				hasScopeGroupId = false;
			}

			if (hasScopeGroupId) {
				scope = pContext.getCurrentScope(scopeGroupId);
			} else {
				scope = pContext.getCurrentScope(httpServletRequest);
			}

			if (scope == null || scope.isEmpty()) {
				String error = "Error retrieving scope: " + scope;
				logger.error(error);
				throw new TDGWTServiceException(error);
			}

			GCubeUser gCubeUser = pContext.getCurrentUser(httpServletRequest);

			if (gCubeUser == null) {
				String error = "Error retrieving gCubeUser in scope " + scope + ": " + gCubeUser;
				logger.error(error);
				throw new TDGWTServiceException(error);
			}

			userName = gCubeUser.getUsername();

			if (userName == null || userName.isEmpty()) {
				String error = "Error retrieving username in scope " + scope + ": " + userName;
				logger.error(error);
				throw new TDGWTServiceException(error);
			}

			token = pContext.getCurrentUserToken(scope, userName);

			if (token == null || token.isEmpty()) {
				String error = "Error retrieving token for " + userName + " in " + scope + ": " + token;
				logger.error(error);
				throw new TDGWTServiceException(error);
			}

			String name = gCubeUser.getFirstName();
			String lastName = gCubeUser.getLastName();
			String fullName = gCubeUser.getFullname();

			String userAvatarURL = gCubeUser.getUserAvatarURL();

			String email = gCubeUser.getEmail();

			if (hasScopeGroupId) {
				logger.info("Set SecurityToken: " + token);
				SecurityTokenProvider.instance.set(token);
				logger.info("Set ScopeProvider: " + scope);
				ScopeProvider.instance.set(scope);

				groupId = scopeGroupId;

				long gId;

				try {
					gId = Long.parseLong(scopeGroupId);
				} catch (Throwable e) {
					String error = "Error retrieving groupId: " + scopeGroupId;
					logger.error(error, e);
					throw new TDGWTServiceException(error);
				}

				GCubeGroup group;
				try {
					group = new LiferayGroupManager().getGroup(gId);
				} catch (Throwable e) {
					String error = "Error retrieving group: " + groupName;
					logger.error(error);
					throw new TDGWTServiceException(error);
				}

				groupName = group.getGroupName();

			} else {

				groupId = String.valueOf(pContext.getCurrentGroupId(httpServletRequest));

				groupName = pContext.getCurrentGroupName(httpServletRequest);

			}

			sCredentials = new ServiceCredentials(userName, fullName, name, lastName, email, scope, groupId, groupName,
					userAvatarURL, token);
		}

		logger.debug("ServiceCredentials: " + sCredentials);

		return sCredentials;
	}

	//

	public static InfoLocale getInfoLocale(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials) {
		InfoLocale infoLocale = null;
		String scope = serviceCredentials.getScope();
		HttpSession session = httpRequest.getSession();

		@SuppressWarnings("unchecked")
		HashMap<String, InfoLocale> infoLocaleMap = (HashMap<String, InfoLocale>) session
				.getAttribute(SessionConstants.INFO_LOCALE_MAP);

		if (infoLocaleMap != null) {
			if (infoLocaleMap.containsKey(scope)) {
				infoLocale = infoLocaleMap.get(scope);
			} else {
				infoLocale = new InfoLocale("en");
				infoLocaleMap.put(scope, infoLocale);
			}
		} else {
			infoLocale = new InfoLocale("en");
			infoLocaleMap = new HashMap<>();
			infoLocaleMap.put(scope, infoLocale);
			session.setAttribute(SessionConstants.INFO_LOCALE_MAP, infoLocaleMap);
		}
		return infoLocale;
	}

	public static void setInfoLocale(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			InfoLocale infoLocale) {
		HttpSession httpSession = httpRequest.getSession();
		String scope = serviceCredentials.getScope();
		@SuppressWarnings("unchecked")
		HashMap<String, InfoLocale> infoLocaleMap = (HashMap<String, InfoLocale>) httpSession
				.getAttribute(SessionConstants.INFO_LOCALE_MAP);
		if (infoLocaleMap != null) {
			infoLocaleMap.put(scope, infoLocale);
		} else {
			infoLocale = new InfoLocale("en");
			infoLocaleMap = new HashMap<>();
			infoLocaleMap.put(scope, infoLocale);
			httpSession.setAttribute(SessionConstants.INFO_LOCALE_MAP, infoLocaleMap);

		}

	}

	/**
	 * Set in session the Tabular Resource List retrieved from service only for
	 * caching
	 * 
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service credentials
	 * @param trs
	 *            list of tabular resource
	 */
	public static void setTabularResources(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			List<TabularResource> trs) {
		SessionOp<List<TabularResource>> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SCOPE_TO_TABULAR_RESOURCE_LIST_MAP, trs);
	}

	public static TRId getTRId(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials) {
		SessionOp<TRId> sessionOp = new SessionOp<>();
		TRId trId = sessionOp.get(httpRequest, serviceCredentials, SessionConstants.SCOPE_TO_CURRENT_TRID_MAP);
		return trId;
	}

	public static void setTRId(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials, TRId trId) {
		SessionOp<TRId> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SCOPE_TO_CURRENT_TRID_MAP, trId);
	}

	public static TabResource getTabResource(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials) {
		SessionOp<TabResource> sessionOp = new SessionOp<>();
		TabResource tabResource = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_CURRENT_TABULAR_RESOURCE_MAP);
		return tabResource;

	}

	public static void setTabResource(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TabResource tabResource) {
		SessionOp<TabResource> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SCOPE_TO_CURRENT_TABULAR_RESOURCE_MAP,
				tabResource);
	}

	public static ArrayList<TabResource> getCurrentTabularResourcesOpen(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<ArrayList<TabResource>> sessionOp = new SessionOp<>();
		ArrayList<TabResource> currentTROpen = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_CURRENT_TABULAR_RESOURCES_OPEN_MAP);
		return currentTROpen;
	}

	public static void setCurrentTabularResourcesOpen(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, ArrayList<TabResource> currentTROpen) {
		SessionOp<ArrayList<TabResource>> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SCOPE_TO_CURRENT_TABULAR_RESOURCES_OPEN_MAP,
				currentTROpen);
	}

	public static void addToCurrentTabularResourcesOpen(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, TabResource tabResource) {
		if (tabResource.getTrId() != null && tabResource.getTrId().getId() != null
				&& !tabResource.getTrId().getId().isEmpty()) {

			HttpSession httpSession = httpRequest.getSession();

			@SuppressWarnings("unchecked")
			HashMap<String, ArrayList<TabResource>> scopeToTabResourceOpenMap = (HashMap<String, ArrayList<TabResource>>) httpSession
					.getAttribute(SessionConstants.SCOPE_TO_CURRENT_TABULAR_RESOURCES_OPEN_MAP);

			if (scopeToTabResourceOpenMap == null) {
				scopeToTabResourceOpenMap = new HashMap<>();
				ArrayList<TabResource> openList = new ArrayList<>();
				openList.add(tabResource);
				scopeToTabResourceOpenMap.put(serviceCredentials.getScope(), openList);
				httpSession.setAttribute(SessionConstants.SCOPE_TO_CURRENT_TABULAR_RESOURCES_OPEN_MAP,
						scopeToTabResourceOpenMap);
			} else {
				ArrayList<TabResource> openList = scopeToTabResourceOpenMap.get(serviceCredentials.getScope());

				if (openList != null) {
					for (TabResource tr : openList) {
						if (tr.getTrId().getId().compareTo(tabResource.getTrId().getId()) == 0) {
							openList.remove(tr);
							break;
						}
					}
					openList.add(tabResource);
				} else {
					openList = new ArrayList<>();
					openList.add(tabResource);
				}
				scopeToTabResourceOpenMap.put(serviceCredentials.getScope(), openList);
			}

		} else {
			logger.error("Tabular Resource has invalid id");
		}

	}

	public static void removeFromCurrentTabularResourcesOpen(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, TRId trId) {

		if (trId != null && trId.getId() != null & !trId.getId().isEmpty()) {
			HttpSession httpSession = httpRequest.getSession();

			@SuppressWarnings("unchecked")
			HashMap<String, ArrayList<TabResource>> scopeToTabResourceOpenMap = (HashMap<String, ArrayList<TabResource>>) httpSession
					.getAttribute(SessionConstants.SCOPE_TO_CURRENT_TABULAR_RESOURCES_OPEN_MAP);

			if (scopeToTabResourceOpenMap == null) {
				scopeToTabResourceOpenMap = new HashMap<>();
				ArrayList<TabResource> openList = new ArrayList<>();
				scopeToTabResourceOpenMap.put(serviceCredentials.getScope(), openList);
				httpSession.setAttribute(SessionConstants.SCOPE_TO_CURRENT_TABULAR_RESOURCES_OPEN_MAP,
						scopeToTabResourceOpenMap);
				logger.debug("No open tr list in session");
			} else {
				ArrayList<TabResource> openList = scopeToTabResourceOpenMap.get(serviceCredentials.getScope());
				if (openList != null) {
					for (TabResource tr : openList) {
						if (tr.getTrId().getId().compareTo(trId.getId()) == 0) {
							openList.remove(tr);
							break;
						}
					}

				} else {
					openList = new ArrayList<>();
				}
				scopeToTabResourceOpenMap.put(serviceCredentials.getScope(), openList);
			}

		} else {
			logger.error("TRId request has invalid id");
		}
	}

	public static void removeAllFromCurrentTabularResourcesOpen(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<ArrayList<TabResource>> sessionOp = new SessionOp<>();
		sessionOp.remove(httpRequest, serviceCredentials, SessionConstants.SCOPE_TO_CURRENT_TABULAR_RESOURCES_OPEN_MAP);
	}

	public static TabResource getFirstFromCurrentTabularResourcesOpen(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<ArrayList<TabResource>> sessionOp = new SessionOp<>();
		ArrayList<TabResource> openList = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_CURRENT_TABULAR_RESOURCES_OPEN_MAP);

		if (openList == null || openList.isEmpty()) {
			logger.info("No open tr in session");
			return null;
		} else {
			return openList.get(0);
		}

	}

	public static TabResource getFromCurrentTabularResourcesOpen(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, TRId trId) {
		SessionOp<ArrayList<TabResource>> sessionOp = new SessionOp<>();
		ArrayList<TabResource> openList = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_CURRENT_TABULAR_RESOURCES_OPEN_MAP);
		if (openList == null || openList.isEmpty()) {
			logger.info("No open tr in session");
		} else {
			logger.debug("Current Tabular Open In session: " + serviceCredentials.getScope() + ", trList: " + openList);
			for (TabResource tabResource : openList) {
				if (tabResource != null && tabResource.getTrId() != null
						&& tabResource.getTrId().getId().compareTo(trId.getId()) == 0) {
					return tabResource;
				}
			}
			logger.info("No tabular resource open in session with: " + trId);

		}
		return null;
	}

	public static void setTDOpenSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TDOpenSession tdOpenSession) {
		SessionOp<TDOpenSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.TDOPEN_SESSION, tdOpenSession);
	}

	public static TabResource getSDMXImportTabResource(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<TabResource> sessionOp = new SessionOp<>();
		TabResource tabResource = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SDMX_IMPORT_TABULAR_RESOURCE);
		return tabResource;
	}

	public static void setSDMXImportTabResource(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TabResource tabResource) {
		SessionOp<TabResource> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SDMX_IMPORT_TABULAR_RESOURCE, tabResource);

	}

	public static TabResource getCSVImportTabResource(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<TabResource> sessionOp = new SessionOp<>();
		TabResource tabResource = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CSV_IMPORT_TABULAR_RESOURCE);
		return tabResource;
	}

	public static void setCSVImportTabResource(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TabResource tabResource) {
		SessionOp<TabResource> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CSV_IMPORT_TABULAR_RESOURCE, tabResource);
	}

	public static void setSDMXImportSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			SDMXImportSession sdmxImportSession) {
		SessionOp<SDMXImportSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SDMX_IMPORT_SESSION, sdmxImportSession);
	}

	public static SDMXImportSession getSDMXImportSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {

		SessionOp<SDMXImportSession> sessionOp = new SessionOp<>();
		SDMXImportSession sdmxImportSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SDMX_IMPORT_SESSION);
		return sdmxImportSession;

	}

	public static void setCSVImportSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			CSVImportSession csvImportSession) {
		SessionOp<CSVImportSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CSV_IMPORT_SESSION, csvImportSession);
	}

	public static CSVImportSession getCSVImportSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<CSVImportSession> sessionOp = new SessionOp<>();
		CSVImportSession csvImportSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CSV_IMPORT_SESSION);
		return csvImportSession;
	}

	public static void setCSVExportSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			CSVExportSession csvExportSession) {
		SessionOp<CSVExportSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CSV_EXPORT_SESSION, csvExportSession);
	}

	public static CSVExportSession getCSVExportSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<CSVExportSession> sessionOp = new SessionOp<>();
		CSVExportSession csvExportSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CSV_EXPORT_SESSION);
		return csvExportSession;

	}

	public static void setInternalSDMXRegistryURLSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			String defaultSDMXRegistryUrl) {
		SessionOp<String> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SDMX_INTERNAL_REGISTRY_URL, defaultSDMXRegistryUrl);
	}

	public static String getInternalSDMXRegistryURLSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<String> sessionOp = new SessionOp<>();
		String defaultSDMXRegistryURL = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SDMX_INTERNAL_REGISTRY_URL);
		return defaultSDMXRegistryURL;
	}

	
	
	public static void setSDMXExportSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			SDMXExportSession sdmxExportSession) {
		SessionOp<SDMXExportSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SDMX_EXPORT_SESSION, sdmxExportSession);
	}

	public static SDMXExportSession getSDMXExportSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<SDMXExportSession> sessionOp = new SessionOp<>();
		SDMXExportSession sdmxExportSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SDMX_EXPORT_SESSION);
		return sdmxExportSession;
	}

	public static void setSDMXTemplateExportSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, SDMXTemplateExportSession sdmxTemplateExportSession) {
		SessionOp<SDMXTemplateExportSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SDMX_TEMPLATE_EXPORT_SESSION,
				sdmxTemplateExportSession);
	}

	public static SDMXTemplateExportSession getSDMXTemplateExportSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<SDMXTemplateExportSession> sessionOp = new SessionOp<>();
		SDMXTemplateExportSession sdmxTemplateExportSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SDMX_TEMPLATE_EXPORT_SESSION);
		return sdmxTemplateExportSession;
	}

	public static void setJSONExportSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			JSONExportSession jsonExportSession) {
		SessionOp<JSONExportSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.JSON_EXPORT_SESSION, jsonExportSession);

	}

	public static JSONExportSession getJSONExportSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<JSONExportSession> sessionOp = new SessionOp<>();
		JSONExportSession jsonExportSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.JSON_EXPORT_SESSION);
		return jsonExportSession;

	}

	//
	public static void setCSVFileUploadSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			CSVFileUploadSession csvFileUploadSession) {
		SessionOp<CSVFileUploadSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CSV_IMPORT_FILE_UPLOAD_SESSION,
				csvFileUploadSession);

	}

	public static CSVFileUploadSession getCSVFileUploadSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<CSVFileUploadSession> sessionOp = new SessionOp<>();
		CSVFileUploadSession csvFileUploadSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CSV_IMPORT_FILE_UPLOAD_SESSION);
		return csvFileUploadSession;
	}

	//
	public static void setCodelistMappingFileUploadSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, CodelistMappingFileUploadSession codelistMappingFileUploadSession) {
		SessionOp<CodelistMappingFileUploadSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CODELIST_MAPPING_FILE_UPLOAD_SESSION,
				codelistMappingFileUploadSession);
	}

	public static CodelistMappingFileUploadSession getCodelistMappingFileUploadSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<CodelistMappingFileUploadSession> sessionOp = new SessionOp<>();
		CodelistMappingFileUploadSession codelistMappingFileUploadSession = sessionOp.get(httpRequest,
				serviceCredentials, SessionConstants.CODELIST_MAPPING_FILE_UPLOAD_SESSION);
		return codelistMappingFileUploadSession;

	}

	//
	public static ArrayList<Codelist> retrieveCodelists(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws Exception {
		logger.info("SessionUtil retrieveCodelists");
		ScopeProvider.instance.set(serviceCredentials.getScope());
		SDMXClient client = getSdmxClient(httpRequest, serviceCredentials);
		return client.getAllCodelists();
	}

	public static ArrayList<Dataset> retrieveDatasets(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws Exception {
		logger.info("SessionUtil retrieveDatasets");
		ScopeProvider.instance.set(serviceCredentials.getScope());
		SDMXClient client = getSdmxClient(httpRequest, serviceCredentials);
		return client.getAllDatasets();
	}

	public static ArrayList<Agencies> retrieveAgencies(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws Exception {
		logger.info("SessionUtil retrieveAgencies");
		ScopeProvider.instance.set(serviceCredentials.getScope());
		SDMXClient client = getSdmxClient(httpRequest, serviceCredentials);
		return client.getAllAgencies();
	}

	//
	public static void setSDMXRegistrySource(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			SDMXRegistrySource sdmxRegistrySource) {
		ScopeProvider.instance.set(serviceCredentials.getScope());
		SessionOp<SDMXRegistrySource> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SDMX_REGISTRY_SOURCE, sdmxRegistrySource);

	}

	public static SDMXRegistrySource getSDMXRegistrySource(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<SDMXRegistrySource> sessionOp = new SessionOp<>();
		SDMXRegistrySource sdmxRegistrySource = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SDMX_REGISTRY_SOURCE);
		return sdmxRegistrySource;

	}

	//
	public static SDMXClient getSDMXClientInSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {
		SessionOp<SDMXClient> sessionOp = new SessionOp<>();
		SDMXClient sdmxClient = sessionOp.get(httpRequest, serviceCredentials, SessionConstants.SDMX_CLIENT_ATTRIBUTE);
		return sdmxClient;
	}

	public static void setSDMXClientInSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			SDMXClient sdmxClient) {
		SessionOp<SDMXClient> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SDMX_CLIENT_ATTRIBUTE, sdmxClient);
	}

	//
	public static SDMXClient getSdmxClient(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials) {
		// HttpSession httpSession = httpRequest.getSession();
		SDMXClient sdmxClient = getSDMXClientInSession(httpRequest, serviceCredentials);
		SDMXRegistrySource sdmxRegistrySource = getSDMXRegistrySource(httpRequest, serviceCredentials);
		if (sdmxRegistrySource == null) {
			logger.error("SDMXRegistrySource was not acquired");
		} else {
			String url = sdmxRegistrySource.getUrl();
			if (url == null || url.isEmpty()) {
				if (sdmxClient == null) {
					sdmxClient = new SDMXClient();
				} else {
					if (sdmxClient.getType().compareTo(SDMXClient.TYPE.ANOTHER) == 0) {
						sdmxClient = new SDMXClient();
					}
				}
			} else {
				if (sdmxClient == null) {
					sdmxClient = new SDMXClient(url);
				} else {
					if (sdmxClient.getType().compareTo(SDMXClient.TYPE.INTERNAL) == 0) {
						sdmxClient = new SDMXClient(url);
					} else {
						if (sdmxClient.getUrl().compareTo(url) != 0) {
							sdmxClient = new SDMXClient(url);
						}
					}
				}
			}
			setSDMXClientInSession(httpRequest, serviceCredentials, sdmxClient);

		}

		return sdmxClient;
	}

	//
	public static void setCSVExportEnd(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			Boolean end) {
		SessionOp<Boolean> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CSV_EXPORT_END, end);

	}

	public static Boolean getCSVExportEnd(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials) {
		SessionOp<Boolean> sessionOp = new SessionOp<>();
		Boolean end = sessionOp.get(httpRequest, serviceCredentials, SessionConstants.CSV_EXPORT_END);
		if (end == null) {
			end = false;
		}
		return end;
	}

	//
	public static void setJSONExportEnd(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			Boolean end) {
		SessionOp<Boolean> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.JSON_EXPORT_END, end);

	}

	public static Boolean getJSONExportEnd(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials) {
		SessionOp<Boolean> sessionOp = new SessionOp<>();
		Boolean end = sessionOp.get(httpRequest, serviceCredentials, SessionConstants.JSON_EXPORT_END);
		if (end == null) {
			end = false;
		}
		return end;
	}

	//
	public static TRTasksManager getTRTasksManager(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<TRTasksManager> sessionOp = new SessionOp<>();
		TRTasksManager tasksManager = sessionOp.get(httpRequest, serviceCredentials, SessionConstants.TR_TASK_MANAGER,
				TRTasksManager.class);

		return tasksManager;

	}

	public static void setTRTasksManager(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TRTasksManager trTasksManager) {
		SessionOp<TRTasksManager> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.TR_TASK_MANAGER, trTasksManager);
	}

	//
	public static ChangeColumnTypeSession getChangeColumnTypeSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ChangeColumnTypeSession> sessionOp = new SessionOp<>();
		ChangeColumnTypeSession changeColumnTypeSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CHANGE_COLUMN_TYPE_SESSION, ChangeColumnTypeSession.class);

		return changeColumnTypeSession;

	}

	public static void setChangeColumnTypeSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			ChangeColumnTypeSession changeColumnTypeSession) {
		SessionOp<ChangeColumnTypeSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CHANGE_COLUMN_TYPE_SESSION,
				changeColumnTypeSession);
	}

	//
	public static LabelColumnSession getLabelColumnSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<LabelColumnSession> sessionOp = new SessionOp<>();
		LabelColumnSession labelColumnSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CHANGE_THE_COLUMN_LABEL_SESSION, LabelColumnSession.class);

		return labelColumnSession;
	}

	//
	public static void setLabelColumnSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			LabelColumnSession labelColumnSession) {
		SessionOp<LabelColumnSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CHANGE_THE_COLUMN_LABEL_SESSION,
				labelColumnSession);
	}

	//
	public static AddColumnSession getAddColumnSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<AddColumnSession> sessionOp = new SessionOp<>();
		AddColumnSession addColumnSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.ADD_COLUMN_SESSION, AddColumnSession.class);

		return addColumnSession;
	}

	public static void setAddColumnSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			AddColumnSession addColumnSession) {
		SessionOp<AddColumnSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.ADD_COLUMN_SESSION, addColumnSession);
	}

	//
	public static DeleteColumnSession getDeleteColumnSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<DeleteColumnSession> sessionOp = new SessionOp<>();
		DeleteColumnSession deleteColumnSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.DELETE_COLUMN_SESSION, DeleteColumnSession.class);

		return deleteColumnSession;

	}

	public static void setDeleteColumnSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			DeleteColumnSession deleteColumnSession) {
		SessionOp<DeleteColumnSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.DELETE_COLUMN_SESSION, deleteColumnSession);
	}

	//
	public static FilterColumnSession getFilterColumnSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<FilterColumnSession> sessionOp = new SessionOp<>();
		FilterColumnSession filterColumnSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.FILTER_COLUMN_SESSION, FilterColumnSession.class);
		return filterColumnSession;

	}

	public static void setFilterColumnSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			FilterColumnSession filterColumnSession) {
		SessionOp<FilterColumnSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.FILTER_COLUMN_SESSION, filterColumnSession);

	}

	//
	public static ReplaceColumnByExpressionSession getReplaceColumnByExpressionSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ReplaceColumnByExpressionSession> sessionOp = new SessionOp<>();
		ReplaceColumnByExpressionSession replaceColumnByExpressionSession = sessionOp.get(httpRequest,
				serviceCredentials, SessionConstants.REPLACE_COLUMN_BY_EXPRESSION_SESSION,
				ReplaceColumnByExpressionSession.class);
		return replaceColumnByExpressionSession;
	}

	public static void setReplaceColumnByExpressionSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, ReplaceColumnByExpressionSession replaceColumnByExpressionSession) {
		SessionOp<ReplaceColumnByExpressionSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.REPLACE_COLUMN_BY_EXPRESSION_SESSION,
				replaceColumnByExpressionSession);
	}

	//
	public static ApplyAndDetachColumnRulesSession getRulesOnColumnApplyAndDetachSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ApplyAndDetachColumnRulesSession> sessionOp = new SessionOp<>();
		ApplyAndDetachColumnRulesSession applyColumnRulesSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.RULES_ON_COLUMN_APPLY_AND_DETACH_SESSION, ApplyAndDetachColumnRulesSession.class);
		return applyColumnRulesSession;
	}

	public static void setRulesOnColumnApplyAndDetachSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, ApplyAndDetachColumnRulesSession applyColumnRulesSession) {
		SessionOp<ApplyAndDetachColumnRulesSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.RULES_ON_COLUMN_APPLY_AND_DETACH_SESSION,
				applyColumnRulesSession);
	}

	//
	public static ApplyTableRuleSession getApplyTableRuleSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ApplyTableRuleSession> sessionOp = new SessionOp<>();
		ApplyTableRuleSession applyTableRuleSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.RULES_ON_TABLE_APPLY_SESSION, ApplyTableRuleSession.class);
		return applyTableRuleSession;
	}

	public static void setApplyTableRuleSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			ApplyTableRuleSession applyTableRuleSession) {
		SessionOp<ApplyTableRuleSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.RULES_ON_TABLE_APPLY_SESSION,
				applyTableRuleSession);
	}

	//
	public static DetachColumnRulesSession getDetachColumnRulesSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<DetachColumnRulesSession> sessionOp = new SessionOp<>();
		DetachColumnRulesSession detachColumnRulesSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.RULES_ON_COLUMN_DETACH_SESSION, DetachColumnRulesSession.class);
		return detachColumnRulesSession;
	}

	public static void setDetachColumnRulesSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, DetachColumnRulesSession detachColumnRulesSession) {
		SessionOp<DetachColumnRulesSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.RULES_ON_COLUMN_DETACH_SESSION,
				detachColumnRulesSession);
	}

	//
	public static DetachTableRulesSession getDetachTableRulesSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<DetachTableRulesSession> sessionOp = new SessionOp<>();
		DetachTableRulesSession detachTableRulesSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.RULES_ON_TABLE_DETACH_SESSION, DetachTableRulesSession.class);
		return detachTableRulesSession;
	}

	public static void setDetachTableRulesSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			DetachTableRulesSession detachTableRulesSession) {
		SessionOp<DetachTableRulesSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.RULES_ON_TABLE_DETACH_SESSION,
				detachTableRulesSession);
	}

	//
	public static TaskResubmitSession getTaskResubmitSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<TaskResubmitSession> sessionOp = new SessionOp<>();
		TaskResubmitSession taskResubmitSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.TASK_RESUBMIT_SESSION, TaskResubmitSession.class);
		return taskResubmitSession;
	}

	public static void setTaskResubmitSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TaskResubmitSession taskResubmitSession) {
		SessionOp<TaskResubmitSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.TASK_RESUBMIT_SESSION, taskResubmitSession);
	}

	//
	public static TaskResumeSession getTaskResumeSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<TaskResumeSession> sessionOp = new SessionOp<>();
		TaskResumeSession taskResumeSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.TASK_RESUME_SESSION, TaskResumeSession.class);
		return taskResumeSession;

	}

	public static void setTaskResumeSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TaskResumeSession taskResumeSession) {
		SessionOp<TaskResumeSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.TASK_RESUME_SESSION, taskResumeSession);
	}

	//
	public static EditRowSession getEditRowSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<EditRowSession> sessionOp = new SessionOp<>();
		EditRowSession editRowSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.EDIT_ROW_SESSION, EditRowSession.class);
		return editRowSession;
	}

	public static void setEditRowSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			EditRowSession editRowSession) {
		SessionOp<EditRowSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.EDIT_ROW_SESSION, editRowSession);
	}

	//
	public static ReplaceColumnSession getReplaceColumnSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ReplaceColumnSession> sessionOp = new SessionOp<>();
		ReplaceColumnSession replaceColumnSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.REPLACE_COLUMN_SESSION, ReplaceColumnSession.class);
		return replaceColumnSession;
	}

	public static void setReplaceColumnSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			ReplaceColumnSession replaceColumnSession) {
		SessionOp<ReplaceColumnSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.REPLACE_COLUMN_SESSION, replaceColumnSession);
	}

	//
	public static ReplaceBatchColumnSession getReplaceBatchColumnSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ReplaceBatchColumnSession> sessionOp = new SessionOp<>();
		ReplaceBatchColumnSession replaceBatchColumnSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.REPLACE_BATCH_COLUMN_SESSION, ReplaceBatchColumnSession.class);
		return replaceBatchColumnSession;
	}

	public static void setReplaceBatchColumnSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, ReplaceBatchColumnSession replaceBatchColumnSession) {
		SessionOp<ReplaceBatchColumnSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.REPLACE_BATCH_COLUMN_SESSION,
				replaceBatchColumnSession);
	}

	//
	public static ChangeTableTypeSession getChangeTableTypeSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ChangeTableTypeSession> sessionOp = new SessionOp<>();
		ChangeTableTypeSession changeTableTypeSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CHANGE_TABLE_TYPE_SESSION, ChangeTableTypeSession.class);
		return changeTableTypeSession;
	}

	public static void setChangeTableTypeSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			ChangeTableTypeSession changeTableTypeSession) {
		SessionOp<ChangeTableTypeSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CHANGE_TABLE_TYPE_SESSION,
				changeTableTypeSession);
	}

	//
	public static CloneTabularResourceSession getCloneTabularResourceSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<CloneTabularResourceSession> sessionOp = new SessionOp<>();
		CloneTabularResourceSession cloneTabularResourceSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CLONE_TABULAR_RESOURCE_SESSION, CloneTabularResourceSession.class);
		return cloneTabularResourceSession;
	}

	public static void setCloneTabularResourceSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, CloneTabularResourceSession cloneTabularResourceSession) {
		SessionOp<CloneTabularResourceSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CLONE_TABULAR_RESOURCE_SESSION,
				cloneTabularResourceSession);
	}

	//
	public static DeleteRowsSession getDeleteRowsSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<DeleteRowsSession> sessionOp = new SessionOp<>();
		DeleteRowsSession deleteRowsSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.DELETE_ROWS_SESSION, DeleteRowsSession.class);
		return deleteRowsSession;
	}

	public static void setDeleteRowsSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			DeleteRowsSession deleteRowsSession) {
		SessionOp<DeleteRowsSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.DELETE_ROWS_SESSION, deleteRowsSession);
	}

	//
	public static TemplateApplySession getTemplateApplySession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<TemplateApplySession> sessionOp = new SessionOp<>();
		TemplateApplySession templateApplySession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.TEMPLATE_APPLY_SESSION, TemplateApplySession.class);
		return templateApplySession;
	}

	public static void setTemplateApplySession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TemplateApplySession templateApplySession) {
		SessionOp<TemplateApplySession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.TEMPLATE_APPLY_SESSION, templateApplySession);
	}

	//
	public static DuplicatesSession getDuplicatesSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<DuplicatesSession> sessionOp = new SessionOp<>();
		DuplicatesSession duplicatesSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.DUPLICATES_ROWS_SESSION, DuplicatesSession.class);
		return duplicatesSession;

	}

	public static void setDuplicatesSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			DuplicatesSession duplicatesSession) {
		SessionOp<DuplicatesSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.DUPLICATES_ROWS_SESSION, duplicatesSession);
	}

	//
	public static ArrayList<TabResource> getCodelistsPagingLoaded(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ArrayList<TabResource>> sessionOp = new SessionOp<>();
		ArrayList<TabResource> ltr = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CODELISTS_PAGING_LOADED);
		return ltr;
	}

	public static void setCodelistsPagingLoaded(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			ArrayList<TabResource> listCodelists) {
		SessionOp<ArrayList<TabResource>> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CODELISTS_PAGING_LOADED, listCodelists);
	}

	//
	public static ArrayList<TabResource> getCodelistsPagingLoadedFilteredCopy(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ArrayList<TabResource>> sessionOp = new SessionOp<>();
		ArrayList<TabResource> ltrFilteredCopy = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CODELISTS_PAGING_LOADED_FILTERED_COPY);
		return ltrFilteredCopy;
	}

	public static void setCodelistsPagingLoadedFilteredCopy(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, ArrayList<TabResource> listCodelistsFilteredCopy) {
		SessionOp<ArrayList<TabResource>> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CODELISTS_PAGING_LOADED_FILTERED_COPY,
				listCodelistsFilteredCopy);
	}

	//
	public static String getCodelistsPagingLoadedFilter(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<String> sessionOp = new SessionOp<>();
		String filter = sessionOp.get(httpRequest, serviceCredentials, SessionConstants.CODELISTS_PAGING_LOADED_FILTER);
		return filter;

	}

	public static void setCodelistsPagingLoadedFilter(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, String filter) {
		SessionOp<String> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CODELISTS_PAGING_LOADED_FILTER, filter);
	}

	//
	public static RollBackSession getRollBackSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<RollBackSession> sessionOp = new SessionOp<>();
		RollBackSession rollBackSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.ROLLBACK_SESSION, RollBackSession.class);
		return rollBackSession;
	}

	public static void setRollBackSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			RollBackSession rollBackSession) {
		SessionOp<RollBackSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.ROLLBACK_SESSION, rollBackSession);
	}

	//
	public static ExtractCodelistSession getExtractCodelistSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ExtractCodelistSession> sessionOp = new SessionOp<>();
		ExtractCodelistSession extractCodelistSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.EXTRACT_CODELIST_SESSION, ExtractCodelistSession.class);
		return extractCodelistSession;
	}

	public static void setExtractCodelistSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			ExtractCodelistSession extractCodelistSession) {
		SessionOp<ExtractCodelistSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.EXTRACT_CODELIST_SESSION,
				extractCodelistSession);
	}

	//
	public static SplitColumnSession getSplitColumnSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<SplitColumnSession> sessionOp = new SessionOp<>();
		SplitColumnSession splitColumnSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SPLIT_COLUMN_SESSION, SplitColumnSession.class);
		return splitColumnSession;
	}

	public static void setSplitColumnSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			SplitColumnSession splitColumnSession) {
		SessionOp<SplitColumnSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SPLIT_COLUMN_SESSION, splitColumnSession);
	}

	//
	public static MergeColumnSession getMergeColumnSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<MergeColumnSession> sessionOp = new SessionOp<>();
		MergeColumnSession mergeColumnSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.MERGE_COLUMN_SESSION, MergeColumnSession.class);
		return mergeColumnSession;
	}

	public static void setMergeColumnSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			MergeColumnSession mergeColumnSession) {
		SessionOp<MergeColumnSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.MERGE_COLUMN_SESSION, mergeColumnSession);
	}

	//
	public static GroupBySession getGroupBySession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<GroupBySession> sessionOp = new SessionOp<>();
		GroupBySession groupBySession = sessionOp.get(httpRequest, serviceCredentials, SessionConstants.GROUPBY_SESSION,
				GroupBySession.class);
		return groupBySession;

	}

	public static void setGroupBySession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			GroupBySession groupBySession) {
		SessionOp<GroupBySession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.GROUPBY_SESSION, groupBySession);
	}

	//
	public static TimeAggregationSession getTimeAggregationSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<TimeAggregationSession> sessionOp = new SessionOp<>();
		TimeAggregationSession timeAggregationSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.TIME_AGGREGATION_SESSION, TimeAggregationSession.class);
		return timeAggregationSession;
	}

	public static void setTimeAggregationSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TimeAggregationSession timeAggregationSession) {
		SessionOp<TimeAggregationSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.TIME_AGGREGATION_SESSION,
				timeAggregationSession);
	}

	//
	public static CodelistMappingSession getCodelistMappingSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<CodelistMappingSession> sessionOp = new SessionOp<>();
		CodelistMappingSession codelistMappingSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CODELIST_MAPPING_SESSION);
		return codelistMappingSession;
	}

	public static void setCodelistMappingSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			CodelistMappingSession codelistMappingSession) {
		SessionOp<CodelistMappingSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CODELIST_MAPPING_SESSION,
				codelistMappingSession);
	}

	//
	public static NormalizationSession getNormalizationSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<NormalizationSession> sessionOp = new SessionOp<>();
		NormalizationSession normalizationSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.NORMALIZATION_SESSION, NormalizationSession.class);
		return normalizationSession;

	}

	public static void setNormalizationSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			NormalizationSession normalizationSession) {
		SessionOp<NormalizationSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.NORMALIZATION_SESSION, normalizationSession);
	}

	//
	public static DenormalizationSession getDenormalizationSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<DenormalizationSession> sessionOp = new SessionOp<>();
		DenormalizationSession denormalizationSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.DENORMALIZATION_SESSION, DenormalizationSession.class);
		return denormalizationSession;
	}

	public static void setDenormalizationSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			DenormalizationSession denormalizationSession) {
		SessionOp<DenormalizationSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.DENORMALIZATION_SESSION,
				denormalizationSession);
	}

	//
	public static UnionSession getUnionSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials)
			throws TDGWTServiceException {
		SessionOp<UnionSession> sessionOp = new SessionOp<>();
		UnionSession unionSession = sessionOp.get(httpRequest, serviceCredentials, SessionConstants.UNION_SESSION,
				UnionSession.class);
		return unionSession;
	}

	public static void setUnionSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			UnionSession unionSession) {
		SessionOp<UnionSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.UNION_SESSION, unionSession);
	}

	//
	public static ChangeColumnsPositionSession getChangeColumnsPositionSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ChangeColumnsPositionSession> sessionOp = new SessionOp<>();
		ChangeColumnsPositionSession changeColumnsPositionSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CHANGE_COLUMNS_POSITION_SESSION, ChangeColumnsPositionSession.class);
		return changeColumnsPositionSession;
	}

	public static void setChangeColumnsPositionSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, ChangeColumnsPositionSession changeColumnsPositionSession) {
		SessionOp<ChangeColumnsPositionSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CHANGE_COLUMNS_POSITION_SESSION,
				changeColumnsPositionSession);
	}

	//
	public static ReplaceByExternalSession getReplaceByExternalSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ReplaceByExternalSession> sessionOp = new SessionOp<>();
		ReplaceByExternalSession replaceByExternalSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.REPLACE_BY_EXTERNAL_SESSION, ReplaceByExternalSession.class);
		return replaceByExternalSession;
	}

	public static void setReplaceByExternalSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, ReplaceByExternalSession replaceByExternalSession) {
		SessionOp<ReplaceByExternalSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.REPLACE_BY_EXTERNAL_SESSION,
				replaceByExternalSession);
	}

	//
	public static DataMinerOperationSession getDataMinerOperationSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<DataMinerOperationSession> sessionOp = new SessionOp<>();
		DataMinerOperationSession dataMinerOperationSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.DATAMINER_OPERATION_SESSION, DataMinerOperationSession.class);
		return dataMinerOperationSession;
	}

	public static void setDataMinerOperationSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, DataMinerOperationSession dataMinerOperationSession) {
		SessionOp<DataMinerOperationSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.DATAMINER_OPERATION_SESSION,
				dataMinerOperationSession);
	}

	//
	public static MapCreationSession getMapCreationSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<MapCreationSession> sessionOp = new SessionOp<>();
		MapCreationSession mapCreationSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.MAP_CREATION_SESSION, MapCreationSession.class);
		return mapCreationSession;
	}

	public static void setMapCreationSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			MapCreationSession mapCreationSession) {
		SessionOp<MapCreationSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.MAP_CREATION_SESSION, mapCreationSession);
	}

	//
	public static ChartTopRatingSession getChartTopRatingSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<ChartTopRatingSession> sessionOp = new SessionOp<>();
		ChartTopRatingSession chartTopRatingSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.CHART_TOPRATING_SESSION, ChartTopRatingSession.class);
		return chartTopRatingSession;
	}

	public static void setChartTopRatingSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			ChartTopRatingSession chartTopRatingSession) {
		SessionOp<ChartTopRatingSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.CHART_TOPRATING_SESSION, chartTopRatingSession);
	}

	// Geospatial
	public static GeospatialCreateCoordinatesSession getGeospatialCreateCoordinatesSession(
			HttpServletRequest httpRequest, ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<GeospatialCreateCoordinatesSession> sessionOp = new SessionOp<>();
		GeospatialCreateCoordinatesSession geospatialCreateCoordinatesSession = sessionOp.get(httpRequest,
				serviceCredentials, SessionConstants.GEOSPATIAL_CREATE_COORDINATES_SESSION,
				GeospatialCreateCoordinatesSession.class);
		return geospatialCreateCoordinatesSession;
	}

	public static void setGeospatialCreateCoordinatesSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials,
			GeospatialCreateCoordinatesSession geospatialCreateCoordinateSession) {
		SessionOp<GeospatialCreateCoordinatesSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.GEOSPATIAL_CREATE_COORDINATES_SESSION,
				geospatialCreateCoordinateSession);
	}

	//
	public static GeospatialDownscaleCSquareSession getGeospatialDownscaleCSquareSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<GeospatialDownscaleCSquareSession> sessionOp = new SessionOp<>();
		GeospatialDownscaleCSquareSession geospatialDownscaleCSquareSession = sessionOp.get(httpRequest,
				serviceCredentials, SessionConstants.GEOSPATIAL_DOWNSCALE_CSQUARE_SESSION,
				GeospatialDownscaleCSquareSession.class);
		return geospatialDownscaleCSquareSession;
	}

	public static void setGeospatialDownscaleCSquareSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials,
			GeospatialDownscaleCSquareSession geospatialDownscaleCSquareSession) {
		SessionOp<GeospatialDownscaleCSquareSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.GEOSPATIAL_DOWNSCALE_CSQUARE_SESSION,
				geospatialDownscaleCSquareSession);
	}

	// Geometry
	public static GeometryCreatePointSession getGeometryCreatePointSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<GeometryCreatePointSession> sessionOp = new SessionOp<>();
		GeometryCreatePointSession geometryCreatePointSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.GEOMETRY_CREATE_POINT_SESSION, GeometryCreatePointSession.class);
		return geometryCreatePointSession;
	}

	public static void setGeometryCreatePointSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, GeometryCreatePointSession geometryCreatePointSession) {
		SessionOp<GeometryCreatePointSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.GEOMETRY_CREATE_POINT_SESSION,
				geometryCreatePointSession);
	}

	//
	/**
	 * Retrieve task started
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service Credentials
	 * @param taskId
	 *            Task id
	 * @return Task Wrapper
	 */
	public static TaskWrapper getStartedTask(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			String taskId) {

		TaskWrapper taskWrapper = null;

		if (taskId == null || taskId.isEmpty()) {
			logger.error("TaskId is not valid: " + taskId);
		} else {
			SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
			HashMap<String, TaskWrapper> tasksStarted = sessionOp.get(httpRequest, serviceCredentials,
					SessionConstants.SCOPE_TO_OPERATIONS_TASKS_STARTED_MAP);
			if (tasksStarted == null) {
				logger.debug("Task with id=" + taskId + " was not acquired");
			} else {
				taskWrapper = tasksStarted.get(taskId);
				if (taskWrapper == null) {
					logger.debug("Task with id=" + taskId + " was not acquired");
				}
			}
		}
		return taskWrapper;

	}

	/**
	 * Remove Task Started
	 * 
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service credendials
	 * @param taskWrapper
	 *            Task wrapper
	 */
	public static void removeStartedTask(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TaskWrapper taskWrapper) {

		if (taskWrapper == null) {
			logger.error("TaskWrapper is null");
			return;
		}

		if (taskWrapper.getTask() == null || taskWrapper.getTask().getId() == null
				|| taskWrapper.getTask().getId().getValue() == null
				|| taskWrapper.getTask().getId().getValue().isEmpty()) {
			logger.error("TaskWrapper contains invalid Task: " + taskWrapper);
			return;
		}

		SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
		HashMap<String, TaskWrapper> tasksStarted = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_OPERATIONS_TASKS_STARTED_MAP);
		if (tasksStarted == null) {
			logger.debug("Started tasks was not acquired: " + taskWrapper);
		} else {
			if (tasksStarted.containsKey(taskWrapper.getTask().getId().getValue())) {
				tasksStarted.remove(taskWrapper.getTask().getId().getValue());
				logger.debug("Remove task: " + taskWrapper);
			} else {
				logger.debug("Started tasks was not acquired: " + taskWrapper);
			}
		}
	}

	/**
	 * Add Task Started
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service Credentials
	 * @param taskWrapper
	 *            Task wrapper
	 */
	public static void setStartedTask(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TaskWrapper taskWrapper) {

		if (taskWrapper == null) {
			logger.error("TaskWrapper is null");
			return;
		}

		if (taskWrapper.getTask() == null || taskWrapper.getTask().getId() == null
				|| taskWrapper.getTask().getId().getValue() == null
				|| taskWrapper.getTask().getId().getValue().isEmpty()) {
			logger.error("TaskWrapper contains invalid Task: " + taskWrapper);
			return;
		}

		SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
		HashMap<String, TaskWrapper> tasksStarted = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_OPERATIONS_TASKS_STARTED_MAP);

		if (tasksStarted == null) {
			tasksStarted = new HashMap<String, TaskWrapper>();
			tasksStarted.put(taskWrapper.getTask().getId().getValue(), taskWrapper);
			sessionOp = new SessionOp<>();
			sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SCOPE_TO_OPERATIONS_TASKS_STARTED_MAP,
					tasksStarted);
		} else {
			tasksStarted.put(taskWrapper.getTask().getId().getValue(), taskWrapper);
		}
	}

	//
	/**
	 * Retrieve Aborted Task Map
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service credentials
	 * @return Map from operation to task wrapper in scope
	 */
	public static HashMap<String, TaskWrapper> getAbortedTaskMap(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {

		SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
		HashMap<String, TaskWrapper> tasksAborted = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_OPERATIONS_TASKS_ABORTED_MAP);

		return tasksAborted;
	}

	/**
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service Credentials
	 * @param taskWrapper
	 *            Task wrapper
	 */
	public static void setAbortedTasks(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TaskWrapper taskWrapper) {

		if (taskWrapper == null || taskWrapper.getTask() == null) {
			logger.error("TaskWrapper is null");
			return;
		}

		if (taskWrapper.getTask().getId() == null || taskWrapper.getTask().getId().getValue() == null
				|| taskWrapper.getTask().getId().getValue().isEmpty()) {
			logger.error("TaskWrapper contains invalid Task: " + taskWrapper);
			return;
		}

		SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
		HashMap<String, TaskWrapper> tasksAborted = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_OPERATIONS_TASKS_ABORTED_MAP);

		if (tasksAborted == null) {
			tasksAborted = new HashMap<String, TaskWrapper>();
			tasksAborted.put(taskWrapper.getTask().getId().getValue(), taskWrapper);
			sessionOp = new SessionOp<>();
			sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SCOPE_TO_OPERATIONS_TASKS_ABORTED_MAP,
					tasksAborted);
		} else {
			tasksAborted.put(taskWrapper.getTask().getId().getValue(), taskWrapper);
		}

	}

	//
	/**
	 * Retrieve Hidden Task Map
	 * 
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service credentials
	 * @return Map
	 */
	public static HashMap<String, TaskWrapper> getHiddenTaskMap(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {

		SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
		HashMap<String, TaskWrapper> tasksHidden = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_OPERATIONS_TASKS_HIDDEN_MAP);
		return tasksHidden;

	}

	/**
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service credentials
	 * @param taskWrapper
	 *            Task wrapper
	 */
	public static void setHiddenTask(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TaskWrapper taskWrapper) {

		if (taskWrapper == null) {
			logger.error("TaskWrapper is null");
			return;
		}

		if (taskWrapper.getTask() == null || taskWrapper.getTask().getId() == null
				|| taskWrapper.getTask().getId().getValue() == null
				|| taskWrapper.getTask().getId().getValue().isEmpty()) {
			logger.error("TaskWrapper contains invalid Task: " + taskWrapper);
			return;
		}

		SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
		HashMap<String, TaskWrapper> tasksHidden = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_OPERATIONS_TASKS_HIDDEN_MAP);

		if (tasksHidden == null) {
			tasksHidden = new HashMap<String, TaskWrapper>();
			tasksHidden.put(taskWrapper.getTask().getId().getValue(), taskWrapper);
			sessionOp = new SessionOp<>();
			sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SCOPE_TO_OPERATIONS_TASKS_HIDDEN_MAP,
					tasksHidden);
		} else {
			tasksHidden.put(taskWrapper.getTask().getId().getValue(), taskWrapper);
		}
	}

	/**
	 * Retrieve Tasks In Background
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service credentials
	 * @return Tasks in background
	 */
	public static HashMap<String, TaskWrapper> getTaskInBackgroundMap(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {

		SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
		HashMap<String, TaskWrapper> tasksInBackground = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_OPERATIONS_TASKS_IN_BACKGROUND_MAP);
		return tasksInBackground;
	}

	/**
	 * Add Task In Background
	 * 
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service credentials
	 * @param taskWrapper
	 *            Task wrapper
	 */
	public static void setTaskInBackground(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TaskWrapper taskWrapper) {

		if (taskWrapper == null) {
			logger.error("TaskWrapper is null");
			return;
		}

		if (taskWrapper.getTask() == null || taskWrapper.getTask().getId() == null
				|| taskWrapper.getTask().getId().getValue() == null
				|| taskWrapper.getTask().getId().getValue().isEmpty()) {
			logger.error("TaskWrapper contains invalid Task: " + taskWrapper);
			return;
		}

		SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
		HashMap<String, TaskWrapper> tasksInBackground = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_OPERATIONS_TASKS_IN_BACKGROUND_MAP);

		if (tasksInBackground == null) {
			tasksInBackground = new HashMap<String, TaskWrapper>();
			tasksInBackground.put(taskWrapper.getTask().getId().getValue(), taskWrapper);
			sessionOp = new SessionOp<>();
			sessionOp.set(httpRequest, serviceCredentials, SessionConstants.SCOPE_TO_OPERATIONS_TASKS_IN_BACKGROUND_MAP,
					tasksInBackground);
		} else {
			tasksInBackground.put(taskWrapper.getTask().getId().getValue(), taskWrapper);
		}

	}

	/**
	 * Remove Task from Tasks In Background
	 * 
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service credentials
	 * @param taskWrapper
	 *            Task wrapper
	 */
	public static void removeTaskInBackground(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			TaskWrapper taskWrapper) {

		if (taskWrapper == null) {
			logger.error("TaskWrapper is null");
			return;
		}

		if (taskWrapper.getTask() == null || taskWrapper.getTask().getId() == null
				|| taskWrapper.getTask().getId().getValue() == null
				|| taskWrapper.getTask().getId().getValue().isEmpty()) {
			logger.error("TaskWrapper contains invalid Task: " + taskWrapper);
			return;
		}

		SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
		HashMap<String, TaskWrapper> tasksInBackground = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_OPERATIONS_TASKS_IN_BACKGROUND_MAP);
		if (tasksInBackground == null) {
			logger.debug("Tasks In Background was not acquired: " + taskWrapper);
		} else {
			if (tasksInBackground.containsKey(taskWrapper.getTask().getId().getValue())) {
				tasksInBackground.remove(taskWrapper.getTask().getId().getValue());
				logger.debug("Remove Task In Background: " + taskWrapper);
			} else {
				logger.debug("Task In Background was not acquired: " + taskWrapper);
			}
		}

	}

	/**
	 * Remove All Background Tasks in the scope
	 * 
	 * @param httpRequest
	 *            Requet
	 * @param serviceCredentials
	 *            Service credentials
	 */
	public static void removeAllTasksInBackground(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) {

		SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
		sessionOp.remove(httpRequest, serviceCredentials, SessionConstants.SCOPE_TO_OPERATIONS_TASKS_IN_BACKGROUND_MAP);

	}

	/**
	 * Remove Task on specific tabular resource from Tasks In Background
	 * 
	 * 
	 * @param httpRequest
	 *            Request
	 * @param serviceCredentials
	 *            Service credentials
	 * @param trId
	 *            TR id
	 */
	public static void removeTaskInBackgroundOnTRId(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials, TRId trId) {

		if (trId == null) {
			logger.error("TRId is null");
			return;
		}

		if (trId.getId() == null || trId.getId().isEmpty()) {
			logger.error("TRId contains Id invalid: " + trId);
			return;
		}

		SessionOp<HashMap<String, TaskWrapper>> sessionOp = new SessionOp<>();
		HashMap<String, TaskWrapper> tasksInBackground = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.SCOPE_TO_OPERATIONS_TASKS_IN_BACKGROUND_MAP);

		if (tasksInBackground == null) {
			logger.debug("No Background task for TRId: " + trId);
		} else {
			ArrayList<String> removableKeys = new ArrayList<String>();
			for (String key : tasksInBackground.keySet()) {
				TaskWrapper taskWrapper = tasksInBackground.get(key);
				if (taskWrapper.getTrId() != null && taskWrapper.getTrId().getId() != null
						&& taskWrapper.getTrId().getId().compareTo(trId.getId()) == 0) {
					removableKeys.add(key);
				}
			}

			for (String key : removableKeys) {
				tasksInBackground.remove(key);
			}

		}

	}

	//
	public static FileUploadMonitor getFileUploadMonitor(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<FileUploadMonitor> sessionOp = new SessionOp<>();
		FileUploadMonitor fileUploadMonitor = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.FILE_UPLOAD_MONITOR, FileUploadMonitor.class);
		return fileUploadMonitor;
	}

	public static void setFileUploadMonitor(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			FileUploadMonitor fileUploadMonitor) {
		SessionOp<FileUploadMonitor> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.FILE_UPLOAD_MONITOR, fileUploadMonitor);
	}

	//
	public static SaveResourceSession getSaveResourceSession(HttpServletRequest httpRequest,
			ServiceCredentials serviceCredentials) throws TDGWTServiceException {
		SessionOp<SaveResourceSession> sessionOp = new SessionOp<>();
		SaveResourceSession saveResourceSession = sessionOp.get(httpRequest, serviceCredentials,
				SessionConstants.RESOURCE_SAVE_SESSION, SaveResourceSession.class);
		return saveResourceSession;
	}

	public static void setSaveResourceSession(HttpServletRequest httpRequest, ServiceCredentials serviceCredentials,
			SaveResourceSession saveResourceSession) {
		SessionOp<SaveResourceSession> sessionOp = new SessionOp<>();
		sessionOp.set(httpRequest, serviceCredentials, SessionConstants.RESOURCE_SAVE_SESSION, saveResourceSession);

	}

}