AppBean.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: AppBean.java
 * Description: Singleton for storing global variables and performing operations 
 * at global application level (eg. generating session id's).
 */

/**
 * @file AppBean.java
 *
 * @brief Singleton for storing global variables
 */

/**
 * @package cz.vutbr.fit.knot.annotations.app
 * 
 * @brief Global objects and constants
 */
package cz.vutbr.fit.knot.annotations.app;

import cz.vutbr.fit.knot.annotations.comet.AnnotServerModule;
import cz.vutbr.fit.knot.annotations.comet.EditorSession;
import cz.vutbr.fit.knot.annotations.comet.ResponseCreator;
import cz.vutbr.fit.knot.annotations.comet.SessionCleaner;
import cz.vutbr.fit.knot.annotations.comet.documentLock.LockMaster;
import cz.vutbr.fit.knot.annotations.entity.ServerSetting;
import cz.vutbr.fit.knot.annotations.entity.User;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SECAPIConn;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SECAPIInterface;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SecApiReqTypeDef;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SuggestionManager;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Singleton for storing global variables and performing operations at global 
 * application level (eg. generating session id's).
 * 
 * @brief Singleton for storing global variables
 * @author idytrych
 */
public class AppBean {

  /** Instance of AppBean */
  private static AppBean instance = null;

  /** Persistence manager */
  private static PersistM persistenceManager = null;
  /** Response creator (single instance for whole application) */
  private static ResponseCreator responseCreator = null;
  /** Next id for session */
  private static long idGen = 0;
  /** Next temporary id for suggested annotation */
  private static long tmpIdGen = 0;

  /** List of active sessions */
  private static ArrayList<EditorSession> sessions;
  /** Map with user authentication data for external authentication */
  private static Map<String,Map<String,String>> extAuthData;
  /** Instance of SessionsCleaner */
  private static SessionCleaner sessionCleaner = null;
  /** Counters of how many instances of document is opened. */
  private static HashMap<Integer, Integer> documentUsageMap = new HashMap<Integer,Integer>();
  /** HashMap for id of last used text modification on document. <documentID, lastModificationID> */
  private static HashMap<Integer, Integer> documentLastModificationIDMap = new HashMap<Integer, Integer>();
  /** HashMap for last 3 used text modification on document. <documentID, lastModifications> */
  private static HashMap<Integer, LastTextModifications> documentAppliedModificationsMap = new HashMap<Integer, LastTextModifications>();
  /** Instance of SEC API Interface */
  private static SECAPIInterface secApiInterface = null;
  /** Instance of LockMaster */
  private static LockMaster lockMaster = null;
  /* HashMap for locking document URIs while trying to search in database */
  public static HashMap<String,ReentrantLock> documentURILocker = new HashMap<String,ReentrantLock>();
  
  /** Server URI */
  private static String serverUri = Constants.SERVER_URI;
  /** Was server URI loaded? */
  private static boolean serverUriLoaded = false;
  /** SEC API SERVER URI */
  private static String secApiServerUri = null;
  /** URI prefix for images from controlled vocabulary */
  private static String KBImagePrefix = null;
  /** List of requested type definitions for SEC API */
  private static ArrayList<SecApiReqTypeDef> reqTypeDefinitions = null;
  /** List of available type definitions for SEC API */
  private static ArrayList<SecApiReqTypeDef> avTypeDefinitions = null;
  /** List of desired type definitions for SEC API */
  private static ArrayList<SecApiReqTypeDef> desTypeDefinitions = null;
  /** List of unnecessary type definitions for SEC API */
  private static ArrayList<SecApiReqTypeDef> unTypeDefinitions = null;
  /** List of unnecessary attribute definitions for SEC API */
  private static ArrayList<SecApiReqTypeDef> unAtDefinitions = null;
  /** List of requested type definitions for SEC API entity autocomplete */
  private static ArrayList<SecApiReqTypeDef> reqTypeDefinitionsEA = null;
  /** List of desired type definitions for SEC API entity autocomplete */
  private static ArrayList<SecApiReqTypeDef> desTypeDefinitionsEA = null;
  /** List of unnecessary type definitions for SEC API entity autocomplete */
  private static ArrayList<SecApiReqTypeDef> unTypeDefinitionsEA = null;
  /** List of unnecessary attribute definitions for SEC API entity autocomplete */
  private static ArrayList<SecApiReqTypeDef> unAtDefinitionsEA = null;
  /** Should be usage of getAlternativesFor logged (for measurement purposes)? */
  private static Boolean logGetAlternativesFor = null;
  
  /** 
   * Constructor - Creates a new instance of AppBean, response creator 
   * and persistence manager
   */
  private AppBean() {
    if (persistenceManager == null) {
      persistenceManager = new PersistM();
    }
    Object[] paramsP = {"name", Constants.SERVER_URI_SETTING_NAME};
    @SuppressWarnings("unchecked")
    List<ServerSetting> settingsList = persistenceManager.queryDB("ServerSetting.findByName", paramsP);
    if (settingsList != null && !settingsList.isEmpty()) {
      if (!settingsList.get(0).getSettingValue().isEmpty()) {
        serverUri = settingsList.get(0).getSettingValue();
      }
    }
    serverUriLoaded = true;
    if (responseCreator == null) {
      responseCreator = new ResponseCreator();
    }
    if (sessions == null) {
      sessions = new ArrayList<EditorSession>();
    }
    if (extAuthData == null) {
      extAuthData = new HashMap<String, Map<String,String>>();
    }
    if (sessionCleaner == null) {
      sessionCleaner = new SessionCleaner();
    }
    if(lockMaster == null){
      lockMaster = new LockMaster();
    }
    if (secApiInterface == null) {
      if (Constants.USE_REMOTE_SEC_API || SECAPIInterface.isSecCommandEmpty()) {
        SECAPIConn sac = new SECAPIConn(getSecApiServerUri());
        SuggestionManager.initReqTypesFromRemote(sac, null);
      } else {
        secApiInterface = new SECAPIInterface();
        secApiInterface.init();
        SuggestionManager.initReqTypes();
      }
    }
  }
  
  /**
   * Gets instance of AppBean
   * 
   * @return Returns instance of AppBean
   */
  public static AppBean getInstance() {
    if (instance == null) {
      instance = new AppBean();
    }
    return instance;
  }

  /**
   * Gets instance of SessionsCleaner
   * 
   * @return Returns instance of SessionsCleaner
   */
  public static SessionCleaner getSessionsCleaner(){
    if (sessionCleaner == null) {
      sessionCleaner = new SessionCleaner();
    }
    
    return sessionCleaner;
  }
  
  /**
   * Gets instance of persistence manager
   * 
   * @return Returns instance of persistence manager
   */
  public static PersistM getPersistenceManager() {
    if (persistenceManager == null) {
      persistenceManager = new PersistM();
    }
    return persistenceManager;
  }

  /**
   * Gets instance of response creator
   * 
   * @return Returns instance of response creator
   */
  public static ResponseCreator getResponseCreator() {
    if (responseCreator == null) {
      responseCreator = new ResponseCreator();
    }
    return responseCreator;
  }

  /**
   * Adds server module to list of active modules in response creator
   * 
   * @param module Server module
   */
  public static void addModule(AnnotServerModule module) {
    if (responseCreator == null) {
      responseCreator = new ResponseCreator();
    }
    responseCreator.addModule(module);
  }

  /**
   * Generate session id
   * 
   * @return New generated session id
   */
  public static synchronized long getNextSessId() {
    return idGen++;
  }

  /**
   * Generate temporary id for suggested annotation
   * 
   * @return New generated temporary id for suggested annotation
   */
  public static synchronized long getNextTmpId() {
    return tmpIdGen++;
  }

  /**
   * Gets list of client sessions
   *
   * @return List of sessions
   */
  public static ArrayList<EditorSession> getSessions() {
    if (sessions == null) {
      sessions = new ArrayList<EditorSession>();
    }
    return sessions;
  }
  
  /**
   * Gets global LockMaster instance
   *
   * @return Global LockMaster instance
   */
  public static LockMaster getLockMaster(){
    if(lockMaster == null){
      lockMaster = new LockMaster();
    }
    return lockMaster;
  }
  
  /**
   * Refreshes users in client sessions
   * 
   * @param user Optional parameter with updated user
   */
  public static void refreshUsersInSessions(User user) {
    if (sessions == null) {
      sessions = new ArrayList<EditorSession>();
      return;
    }
    
    synchronized(sessions){
      if (user != null) {  // if only given users data will be refreshed
        for (Iterator<EditorSession> sesIt = sessions.iterator(); sesIt.hasNext();) {
          EditorSession editorSession = sesIt.next();
          if (editorSession.getUser() != null 
              && editorSession.getUser().getId() != null 
              && editorSession.getUser().getId() == user.getId()) {
            editorSession.refreshUser();
          }
        }
      } else {  // if all users data will be refreshed
        for (Iterator<EditorSession> sesIt = sessions.iterator(); sesIt.hasNext();) {
          EditorSession editorSession = sesIt.next();
          editorSession.refreshUser();
        }
      }
    }
  }  // refreshUsersInSessions()

  /**
   * Adds client session to the list of sessions
   *
   * @param es Session to be added
   */
  public static void addSession(EditorSession es) {
    if (sessions == null) {
      sessions = new ArrayList<EditorSession>();
    }
    
    synchronized(sessions){
      sessions.add(es);
    }
  }

  /**
   * Removes client session from the list of sessions
   *
   * @param es Session to be removed
   */
  public static void removeSession(EditorSession es) {
    if (sessions == null) {
      sessions = new ArrayList<EditorSession>();
    }
    
    synchronized(sessions){
      sessions.remove(es);
    }
  }

  /**
   * Removes client session from the list of sessions
   *
   * @param id Id of session to be removed
   */
  public static void removeSession(long id) {
    if (sessions == null) {
      sessions = new ArrayList<EditorSession>();
    }
    
    synchronized(sessions){
      EditorSession cmp = new EditorSession(id);
      sessions.remove(cmp);
    }
  }

  /**
   * Gets requested session
   *
   * @param id Id of requested session
   * @return If session exists, returns requested session, else returns null.
   */
  public static EditorSession getSession(long id) {
    if (sessions == null) {
      sessions = new ArrayList<EditorSession>();
    }
    
    synchronized(sessions){
      EditorSession cmp = new EditorSession(id);
      int index = sessions.indexOf(cmp);
      if (index < 0)
        return null;
      return sessions.get(index);
    }
  }

  /**
   * Checks whether session with given id exists
   *
   * @param id Id of checked session
   * @return If session exists, returns true, false otherwise
   */
  public static boolean sessionExists(long id) {
    if (sessions == null) {
      sessions = new ArrayList<EditorSession>();
    }
    synchronized(sessions){
      EditorSession cmp = new EditorSession(id);
      return sessions.contains(cmp);
    }
  }
  
  /**
   * Removes authentication data of given user from the global map
   * 
   * @param system System from which user come
   * @param login Login of the user
   */
  public static void removeExtAuthData(String system, String login) {
    if (extAuthData == null) {
      extAuthData = new HashMap<String, Map<String,String>>();
      return;
    }
    Map<String,String> sysAuthData = extAuthData.get(system);
    if (sysAuthData != null) {
      extAuthData.remove(login);
    }
  }
  
  /**
   * Sets authentication data of given user in the global map
   * 
   * @param system System from which user come
   * @param login Login of the user
   * @param data String with authentication data for the user
   */
  public static void setExtAuthData(String system, String login, String data) {
    if (extAuthData == null) {
      extAuthData = new HashMap<String, Map<String,String>>();
    }
    Map<String,String> sysAuthData = extAuthData.get(system);
    if (sysAuthData == null) {
      sysAuthData = new HashMap<String, String>();
      extAuthData.put(system, sysAuthData);
    }
    sysAuthData.put(login, data);
  }
  
  /**
   * Gets authentication data for given user
   * 
   * @param system System from which user come
   * @param login Login of the user
   * @return Returns authentication data for the user or null, if no data for 
   *         this user available
   */
  public static String getExtAuthData(String system, String login) {
    if (extAuthData == null) {
      extAuthData = new HashMap<String, Map<String,String>>();
      return null;
    }
    Map<String,String> sysAuthData = extAuthData.get(system);
    if (sysAuthData == null) {
      return null;
    }
    return sysAuthData.get(login);
  }
  
  /**
   * Gets instance of SEC API interface
   * 
   * @return Returns instance of SEC API interface
   */
  public static SECAPIInterface getSecApiInterface() {
    if (secApiInterface == null) {
      secApiInterface = new SECAPIInterface();
      secApiInterface.init();
      SuggestionManager.initReqTypes();
    }
    return secApiInterface;
  }
  
  /**
   * Checks whether SEC API interface is available
   * 
   * @return If SEC API interface is available, returns true, false otherwise
   */
  public static boolean isSecApiInterfaceAvailable() {
    if (secApiInterface == null) {
      return false;
    }
    return true;
  }

  /**
   * Sets instance of SEC API interface
   * 
   * @param secApiInterface Instance of SEC API interface
   */
  public static void setSecApiInterface(SECAPIInterface secApiInterface) {
    AppBean.secApiInterface = secApiInterface;
  }

  /**
   * Gets number of opened document instances
   * 
   * @param documentId ID of document
   * @return Number of opened document instances
   */
  public static synchronized int getDocumentUsage(Integer documentId){
    if(documentUsageMap.get(documentId) != null){
      return documentUsageMap.get(documentId);
    }
    return 0;
  }
  
  /**
   * Increments number of opened document instances
   * 
   * @param documentId ID of document
   */
  public static synchronized void incrementDocumentUsage(Integer documentId){
    Integer value = documentUsageMap.get(documentId);
    if (value != null) {
      // Increment number of instances of existing document
        documentUsageMap.put(documentId, value + 1);
    } else {  // Document is opened for the first time
        documentUsageMap.put(documentId, 1);
    }
  }

  /**
   * Decrement number of opened document instances
   * 
   * @param documentId ID of document
   */
  public static synchronized void decrementDocumentUsage(Integer documentId){
    Integer value = documentUsageMap.get(documentId);
    if (value != null) {
      if (value > 1) {
        documentUsageMap.put(documentId, value - 1);
      } else {
        documentUsageMap.remove(documentId);
      }
    }
  }
  
  /**
   * Gets ID of the last text modification set applied on a document.
   * 
   * @param documentId ID of the document
   * @return modification set ID, -1 on error
   */
  public static synchronized int getLastDocModification(int documentId){
    if(documentLastModificationIDMap != null && !documentLastModificationIDMap.isEmpty()){
      return documentLastModificationIDMap.get(documentId);
    }
    return -1;
  }
  
  /**
   * Increments ID of the last text modification set applied on a document.
   * 
   * @param documentId ID of the document
   * @return On success returns incremented ID, null otherwise
   */
  public static synchronized Integer incrementLastDocModification(int documentId){
    if(documentLastModificationIDMap != null && !documentLastModificationIDMap.isEmpty()){
      Integer modID = documentLastModificationIDMap.get(documentId);
      if(modID != null){
        ++modID;
        documentLastModificationIDMap.put(documentId, modID);
        return modID;
      }
    }
    return null;
  }
  
  /**
   * Initializes ID of the last text modification set applied on a document.
   * 
   * @param documentId ID of the document
   */
  public static synchronized void initLastDocModification(int documentId){
    if(documentLastModificationIDMap == null){
       documentLastModificationIDMap = new HashMap<Integer, Integer>();
    }
    documentLastModificationIDMap.put(documentId, 0);
  }
  
  /**
   * Adds last applied set of modifications to hashmap
   * 
   * @param documentID ID of the document
   * @param modificationID modification set ID
   * @param modificationSet modification set
   */
  public static synchronized void addDocModificationSet(int documentID, int modificationID, 
          ArrayList<TextModification> modificationSet)
  {
    if(documentAppliedModificationsMap == null){
      documentAppliedModificationsMap = new HashMap<Integer, LastTextModifications>();
    }
    LastTextModifications lastMods = documentAppliedModificationsMap.get(documentID);
    if(lastMods != null){
      lastMods.addNextModificationSet(modificationID, modificationSet);
    }
    else{
      LastTextModifications newLastMod = new LastTextModifications(documentID, modificationID, modificationSet);
      documentAppliedModificationsMap.put(documentID, newLastMod);
    }
  }
  
  /**
   * Removes all applied sets of modifications from hashmap
   * 
   * @param documentID Document ID for modification sets removal
   */
  public static synchronized void removePossibleModificationSets(int documentID){
    if(documentAppliedModificationsMap != null){
      documentAppliedModificationsMap.remove(documentID);
    }
  }
  
  /**
   * Checks whetever last modification sets of the document indetified by
   * documentID contains passed modification setID.
   * 
   * @param documentID Document ID 
   * @param setID Checked modification set ID
   * @return true if contains otherwise false
   */
  public static synchronized boolean lastModificationSetsContains(int documentID, int setID){
    if(documentAppliedModificationsMap != null){
      LastTextModifications lastMods = documentAppliedModificationsMap.get(documentID);
      if(lastMods != null && lastMods.containsSet(setID)){
        return true;
      }
    }
    return false;
  }
  
  /**
   * Checks whetever the modification sets applied after modification
   * identified by the passed setID of the document indetified by
   * documentID contains conflicts with passed modification set.
   * 
   * @param documentID Document ID 
   * @param setID ID of the set preceding the checked sets
   * @param modifications Checked modification set
   * @return true if there are conflicts otherwise false
   */
  public static synchronized boolean hasModificationSetsConflicts(int documentID,
          int setID, ArrayList<TextModification> modifications)
  {
    if(documentAppliedModificationsMap != null){
      LastTextModifications lastMods = documentAppliedModificationsMap.get(documentID);
      if(lastMods != null){
        return lastMods.hasModificationSetsConflicts(setID, modifications);
      }
    }
    return false;
  }

  /**
   * Gets server URI
   * 
   * @return Returns server URI
   */
  public static String getServerUri() {
    if (!serverUriLoaded) {
      Object[] paramsP = {"name", Constants.SERVER_URI_SETTING_NAME};
      @SuppressWarnings("unchecked")
      List<ServerSetting> settingsList = getPersistenceManager().queryDB("ServerSetting.findByName", paramsP);
      if (settingsList != null && !settingsList.isEmpty()) {
        if (!settingsList.get(0).getSettingValue().isEmpty()) {
          serverUri = settingsList.get(0).getSettingValue();
        }
      }
      serverUriLoaded = true;
    }
    return serverUri;
  }

  /**
   * Sets server URI
   * 
   * @param serverUri New server URI
   */
  public static void setServerUri(String serverUri) {
    AppBean.serverUri = serverUri;
  }
  
  /**
   * Gets base URI
   * 
   * @return Returns base URI
   */
  public static String getBaseUri() {
    return getServerUri() + "/" + Constants.URI_C;
  }
  
  /**
   * Gets beginning of URI of annotation
   * 
   * @return Returns beginning of URI of annotation
   */
  public static String getBaseAnnotUri() {
    return getServerUri() + "/" + Constants.URI_C + Constants.ANNOT_URI_SUFFIX;
  }
  
  /**
   * Gets beginning of URI of suggestion
   * 
   * @return Returns beginning of URI of suggestion
   */
  public static String getBaseSugUri() {
    return getServerUri() + "/" + Constants.URI_C + Constants.SUG_URI_SUFFIX;
  }
  
  /**
   * Gets beginning of URI of annotation type
   * 
   * @return Returns beginning of URI of annotation type
   */
  public static String getBaseTypeUri() {
    return getServerUri() + "/" + Constants.URI_C + Constants.TYPE_URI_SUFFIX;
  }
  
  /**
   * Gets beginning of URI of annotated copy of document
   * 
   * @return Returns beginning of URI of annotated copy of document
   */
  public static String getBaseDocumentUri() {
    return getServerUri() + "/" + Constants.URI_C + Constants.DOC_URI_SUFFIX;
  }
  
  /**
   * Gets beginning of URI of stored document
   * 
   * @return Returns beginning of URI of stored document
   */
  public static String getBaseStoredDocumentUri() {
    return getServerUri() + "/" + Constants.URI_C + Constants.S_DOC_URI_SUFFIX;
  }
  
  /**
   * Gets beginning of URI of annotation author (person)
   * 
   * @return Returns beginning of URI of annotation author (person)
   */
  public static String getBaseAuthorUri() {
    return getServerUri() + "/" + Constants.URI_C + Constants.AUTHOR_URI_SUFFIX;
  }
  
  /**
   * Gets beginning of URI of user (person)
   * 
   * @return Returns beginning of URI of user (person)
   */
  public static String getBaseUserUri() {
    return getServerUri() + "/" + Constants.URI_C + Constants.USER_URI_SUFFIX;
  }
  
  /**
   * Gets beginning of URI of user (person) for protocol version 2
   * 
   * @return Returns beginning of URI of user (person) for protocol version 2
   */
  public static String getBaseUserUriV2() {
    return getServerUri() + "/" + Constants.URI_C + Constants.USER_URI_SUFFIX_V2;
  }

  /**
   * Gets beginning of URI of user group
   * 
   * @return Returns beginning of URI of user group
   */
  public static String getBaseGroupUri() {
    return getServerUri() + "/" + Constants.URI_C + Constants.GROUP_URI_SUFFIX;
  }
  
  /**
   * Gets base URI for ontology upload
   * 
   * @return Returns base URI for ontology upload
   */
  public static String getBaseOntoUploadUri() {
    return getServerUri() + "/" + Constants.URI_C + Constants.ONTO_UPLOAD_URI_SUFFIX;
  }

  /**
   * Gets address of the SEC API server for annotation suggestions
   * 
   * @return Returns address of the SEC API server for annotation suggestions
   */
  public static String getSecApiServerUri() {
    if (secApiServerUri == null) {  // load on first request
      Object[] paramsP = {"name", Constants.SEC_API_SERVER_URI_SETTING_NAME};
      @SuppressWarnings("unchecked")
      List<ServerSetting> settingsList = getPersistenceManager().queryDB("ServerSetting.findByName", paramsP);
      if (settingsList != null && !settingsList.isEmpty()) {
        if (!settingsList.get(0).getSettingValue().isEmpty()) {
          secApiServerUri = settingsList.get(0).getSettingValue();
        } else {
          secApiServerUri = Constants.SEC_API_SERVER_URI;
        }
      } else {
        secApiServerUri = Constants.SEC_API_SERVER_URI;
      }
    }
    return secApiServerUri;
  }  // getSecApiServerUri()
  
  /**
   * Gets beginning of URI of subscription
   * 
   * @return Returns beginning of URI of subscription
   */
  public static String getBaseSubscriptionUri() {
    return getServerUri() + "/" + Constants.URI_C + Constants.SUBSCR_URI_SUFFIX;
  }
  
  /**
   * Ensures reload of some URIs loaded from DB
   */
  public static void resetURIs() {
    KBImagePrefix = null;
    secApiServerUri = null;
    logGetAlternativesFor = null;
  }
  
  /**
   * Sets address of the SEC API server for annotation suggestions
   * 
   * @param secApiServerUri Address of the SEC server for annotation suggestions
   */
  public static void setSecApiServerUri(String secApiServerUri) {
    AppBean.secApiServerUri = secApiServerUri;
  }
  
  /**
   * Gets URI prefix for images from controlled vocabulary
   * 
   * @return Returns URI prefix for images from controlled vocabulary
   */
  public static String getKBImagePrefix() {
    if (KBImagePrefix == null) {  // load on first request
      Object[] paramsP = {"name", Constants.KB_IMG_PREFIX_SETTING_NAME};
      @SuppressWarnings("unchecked")
      List<ServerSetting> settingsList = getPersistenceManager().queryDB("ServerSetting.findByName", paramsP);
      if (settingsList != null && !settingsList.isEmpty()) {
        if (!settingsList.get(0).getSettingValue().isEmpty()) {
          KBImagePrefix = settingsList.get(0).getSettingValue();
        } else {
          KBImagePrefix = Constants.KB_IMAGE_PREFIX;
        }
      } else {
        KBImagePrefix = Constants.KB_IMAGE_PREFIX;
      }
    }
    return KBImagePrefix;
  }
  
  /**
   * Gets whethershould be usage of getAlternativesFor logged
   * 
   * @return Returns whether should be usage of getAlternativesFor logged
   */
  public static Boolean getLogGetAlternativesFor() {
    if (logGetAlternativesFor == null) {  // load on first request
      Object[] paramsP = {"name", Constants.LOG_GET_ALTERNATIVES_SETTINGS};
      @SuppressWarnings("unchecked")
      List<ServerSetting> settingsList = getPersistenceManager().queryDB("ServerSetting.findByName", paramsP);
      if (settingsList != null && !settingsList.isEmpty()) {
        if (!settingsList.get(0).getSettingValue().isEmpty()) {
          String settingsStr = settingsList.get(0).getSettingValue();
          if (Boolean.parseBoolean(settingsStr) || "1".equals(settingsStr)) {
            logGetAlternativesFor = true;
          } else {
            logGetAlternativesFor = false;
          }
        } else {
          logGetAlternativesFor = false;
        }
      } else {
        logGetAlternativesFor = false;
      }
    }
    return logGetAlternativesFor;
  }

  /**
   * Sets URI prefix for images from controlled vocabulary
   * 
   * @param KBImagePrefix URI prefix for images from controlled vocabulary
   */
  public static void setKBImagePrefix(String KBImagePrefix) {
    AppBean.KBImagePrefix = KBImagePrefix;
  }

  /**
   * Gets list of requested type definitions for SEC API
   * 
   * @return Returns list of requested type definitions for SEC API
   */
  public static ArrayList<SecApiReqTypeDef> getReqTypeDefinitions() {
    return reqTypeDefinitions;
  }

  /**
   * Sets list of requested type definitions for SEC API
   * 
   * @param reqTypeDefinitions List of requested type definitions for SEC API
   */
  public static void setReqTypeDefinitions(ArrayList<SecApiReqTypeDef> reqTypeDefinitions) {
    AppBean.reqTypeDefinitions = reqTypeDefinitions;
  }

  /**
   * Gets list of desired type definitions for SEC API
   * 
   * @return Returns list of desired type definitions for SEC API
   */
  public static ArrayList<SecApiReqTypeDef> getDesTypeDefinitions() {
    return desTypeDefinitions;
  }
  
  /**
   * Sets list of desired type definitions for SEC API
   * 
   * @param desTypeDefinitions List of desired type definitions for SEC API
   */
  public static void setDesTypeDefinitions(ArrayList<SecApiReqTypeDef> desTypeDefinitions) {
    AppBean.desTypeDefinitions = desTypeDefinitions;
  }

  /**
   * Gets list of unnecessary type definitions for SEC API
   * 
   * @return Returns list of unnecessary type definitions for SEC API
   */
  public static ArrayList<SecApiReqTypeDef> getUnTypeDefinitions() {
    return unTypeDefinitions;
  }
  
  /**
   * Sets list of unnecessary type definitions for SEC API
   * 
   * @param unTypeDefinitions List of unnecessary type definitions for SEC API
   */
  public static void setUnTypeDefinitions(ArrayList<SecApiReqTypeDef> unTypeDefinitions) {
    AppBean.unTypeDefinitions = unTypeDefinitions;
  }

  /**
   * Gets list of available type definitions for SEC API
   * 
   * @return Returns list of available type definitions for SEC API
   */
  public static ArrayList<SecApiReqTypeDef> getAvTypeDefinitions() {
    return avTypeDefinitions;
  }
  
  /**
   * Sets list of available type definitions for SEC API
   * 
   * @param avTypeDefinitions List of available type definitions for SEC API
   */
  public static void setAvTypeDefinitions(ArrayList<SecApiReqTypeDef> avTypeDefinitions) {
    AppBean.avTypeDefinitions = avTypeDefinitions;
  }

  /**
   * Gets list of unnecessary attribute definitions for SEC API
   * 
   * @return Returns list of unnecessary attribute definitions for SEC API
   */
  public static ArrayList<SecApiReqTypeDef> getUnAtDefinitions() {
    return unAtDefinitions;
  }

  /**
   * Sets list of unnecessary attribute definitions for SEC API
   * 
   * @param unAtDefinitions List of unnecessary attribute definitions for SEC API
   */
  public static void setUnAtDefinitions(ArrayList<SecApiReqTypeDef> unAtDefinitions) {
    AppBean.unAtDefinitions = unAtDefinitions;
  }

  
  /**
   * Gets list of desired type definitions for SEC API entity autocomplete
   * 
   * @return Returns list of desired type definitions for SEC API entity autocomplete
   */
  public static ArrayList<SecApiReqTypeDef> getDesTypeDefinitionsEA() {
    return desTypeDefinitionsEA;
  }

  /**
   * Sets list of desired type definitions for SEC API entity autocomplete
   * 
   * @param desTypeDefinitionsEA List of desired type definitions for SEC API entity autocomplete
   */
  public static void setDesTypeDefinitionsEA(ArrayList<SecApiReqTypeDef> desTypeDefinitionsEA) {
    AppBean.desTypeDefinitionsEA = desTypeDefinitionsEA;
  }

  /**
   * Gets list of requested type definitions for SEC API entity autocomplete
   * 
   * @return Returns list of requested type definitions for SEC API entity autocomplete
   */
  public static ArrayList<SecApiReqTypeDef> getReqTypeDefinitionsEA() {
    return reqTypeDefinitionsEA;
  }

  /**
   * Sets list of requested type definitions for SEC API entity autocomplete
   * 
   * @param reqTypeDefinitionsEA List of requested type definitions for SEC API entity autocomplete
   */
  public static void setReqTypeDefinitionsEA(ArrayList<SecApiReqTypeDef> reqTypeDefinitionsEA) {
    AppBean.reqTypeDefinitionsEA = reqTypeDefinitionsEA;
  }

  /**
   * Gets list of unnecessary attribute definitions for SEC API entity autocomplete
   * 
   * @return Returns list of unnecessary attribute definitions for SEC API entity autocomplete
   */
  public static ArrayList<SecApiReqTypeDef> getUnAtDefinitionsEA() {
    return unAtDefinitionsEA;
  }

  /**
   * Sets list of unnecessary attribute definitions for SEC API entity autocomplete
   * 
   * @param unAtDefinitionsEA List of unnecessary attribute definitions for SEC API entity autocomplete
   */
  public static void setUnAtDefinitionsEA(ArrayList<SecApiReqTypeDef> unAtDefinitionsEA) {
    AppBean.unAtDefinitionsEA = unAtDefinitionsEA;
  }
  
  /**
   * Gets list of unnecessary type definitions for SEC API entity autocomplete
   * 
   * @return Returns list of unnecessary type definitions for SEC API
   */
  public static ArrayList<SecApiReqTypeDef> getUnTypeDefinitionsEA() {
    return unTypeDefinitionsEA;
  }

  /**
   * Sets list of unnecessary type definitions for SEC API entity autocomplete
   * 
   * @param unTypeDefinitionsEA List of unnecessary type definitions for SEC API
   */
  public static void setUnTypeDefinitionsEA(ArrayList<SecApiReqTypeDef> unTypeDefinitionsEA) {
    AppBean.unTypeDefinitionsEA = unTypeDefinitionsEA;
  }
  
}  // class AppBean