# GalleryRequestRouter.java

    /*
     * Copyright (C) 2000 - 2024 Silverpeas
     *
     * This program is free software: you can redistribute it and/or modify
     * it under the terms of the GNU Affero General Public License as
     * published by the Free Software Foundation, either version 3 of the
     * License, or (at your option) any later version.
     *
     * As a special exception to the terms and conditions of version 3.0 of
     * the GPL, you may redistribute this Program in connection with Free/Libre
     * Open Source Software ("FLOSS") applications as described in Silverpeas's
     * FLOSS exception. You should have received a copy of the text describing
     * the FLOSS exception, and it is also available here:
     * "http://www.silverpeas.org/docs/core/legal/floss_exception.html"
     *
     * This program is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     * GNU Affero General Public License for more details.
     *
     * You should have received a copy of the GNU Affero General Public License
     * along with this program. If not, see <https://www.gnu.org/licenses/>.
     */
    package org.silverpeas.components.gallery.servlets;

    import org.silverpeas.components.gallery.ParameterNames;
    import org.silverpeas.components.gallery.constant.MediaResolution;
    import org.silverpeas.components.gallery.constant.MediaType;
    import org.silverpeas.components.gallery.control.GallerySessionController;
    import org.silverpeas.components.gallery.delegate.AbstractMediaDataDelegate;
    import org.silverpeas.components.gallery.delegate.MediaDataCreateDelegate;
    import org.silverpeas.components.gallery.delegate.MediaDataUpdateDelegate;
    import org.silverpeas.components.gallery.model.AlbumDetail;
    import org.silverpeas.components.gallery.model.Media;
    import org.silverpeas.components.gallery.model.MetaData;
    import org.silverpeas.components.gallery.model.Order;
    import org.silverpeas.components.gallery.model.OrderRow;
    import org.silverpeas.components.gallery.web.MediaSort;
    import org.silverpeas.core.admin.user.model.SilverpeasRole;
    import org.silverpeas.core.util.file.FileItem;
    import org.silverpeas.kernel.cache.model.SimpleCache;
    import org.silverpeas.core.contribution.content.form.DataRecord;
    import org.silverpeas.core.contribution.content.form.Field;
    import org.silverpeas.core.contribution.content.form.Form;
    import org.silverpeas.core.contribution.content.form.FormException;
    import org.silverpeas.core.contribution.content.form.PagesContext;
    import org.silverpeas.core.contribution.content.form.RecordSet;
    import org.silverpeas.core.contribution.content.form.RecordTemplate;
    import org.silverpeas.core.contribution.content.form.form.XmlSearchForm;
    import org.silverpeas.core.contribution.template.publication.PublicationTemplate;
    import org.silverpeas.core.contribution.template.publication.PublicationTemplateException;
    import org.silverpeas.core.contribution.template.publication.PublicationTemplateImpl;
    import org.silverpeas.core.importexport.report.ExportReport;
    import org.silverpeas.core.index.indexing.model.FieldDescription;
    import org.silverpeas.core.index.search.model.QueryDescription;
    import org.silverpeas.core.node.model.NodeDetail;
    import org.silverpeas.core.util.DateUtil;
    import org.silverpeas.kernel.util.StringUtil;
    import org.silverpeas.core.util.URLUtil;
    import org.silverpeas.core.util.file.FileUploadUtil;
    import org.silverpeas.kernel.logging.SilverLogger;
    import org.silverpeas.core.web.http.HttpRequest;
    import org.silverpeas.core.web.mvc.controller.ComponentContext;
    import org.silverpeas.core.web.mvc.controller.MainSessionController;
    import org.silverpeas.core.web.mvc.route.ComponentRequestRouter;
    import org.silverpeas.core.web.mvc.util.AccessForbiddenException;
    import org.silverpeas.core.webapi.pdc.PdcClassificationEntity;

    import jakarta.servlet.http.HttpServletRequest;
    import java.text.ParseException;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Date;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Optional;
    import java.util.UUID;

    import static org.silverpeas.core.cache.service.CacheAccessorProvider.getSessionCacheAccessor;
    import static org.silverpeas.core.persistence.jdbc.sql.JdbcSqlQuery.isSqlDefined;
    import static org.silverpeas.core.util.JSONCodec.encodeObject;

    public class GalleryRequestRouter extends ComponentRequestRouter<GallerySessionController> {
      private static final long serialVersionUID = 1L;

      private static final String ORDER_VIEW_PAGIN_FUNC = "OrderViewPagin";
      private static final String ORDER_VIEW_LIST_FUNC = "OrderViewList";
      private static final String BASKET_VIEW_FUNC = "BasketView";
      private static final String VIEW_SEARCH_RESULTS_FUNC = "ViewSearchResults";
      private static final String VIEW_NOT_VISIBLE_FUNC = "ViewNotVisible";
      private static final String MEDIA_VIEW_FUNC = "MediaView";
      private static final String GO_TO_CURRENT_ALBUM_FUNC = "GoToCurrentAlbum";
      private static final String ORDER_ID = "OrderId";
      private static final String MEDIA_TYPE_ALERT_ATTR = "MediaTypeAlert";
      private static final String MEDIA_ID = "MediaId";
      private static final String IS_VIEW_LIST = "IsViewList";
      private static final String SELECTED_IDS = "SelectedIds";
      private static final String IS_VIEW_METADATA = "IsViewMetadata";
      private static final String MEDIA_RESOLUTION = "MediaResolution";
      private static final String CURRENT_ALBUM = "CurrentAlbum";
      private static final String CURRENT_PAGE_INDEX = "CurrentPageIndex";
      private static final String NB_MEDIA_PER_PAGE = "NbMediaPerPage";
      private static final String IS_BASKET = "IsBasket";
      private static final String IS_ORDER = "IsOrder";
      private static final String IS_PRIVATE_SEARCH = "IsPrivateSearch";
      private static final String IS_USE_PDC = "IsUsePdc";
      private static final String MEDIA_LIST = "MediaList";
      private static final String ALBUMS = "Albums";
      private static final String ALBUM_ID = "albumId";
      private static final String ALBUM_ID_FIRST_LETTER_UPPERCASE = "AlbumId";
      private static final String SEARCH_KEY_WORD = "SearchKeyWord";
      private static final String MEDIA_PREFIX = "media";
      private static final String UTF_8 = "UTF-8";
      private static final String DESCRIPTION = "Description";

      /**
       * This method has to be implemented in the component request rooter class. returns the session
       * control bean name to be put in the request object ex : for almanach, returns "almanach"
       */
      @Override
      public String getSessionControlBeanName() {
        return "Gallery";
      }

      @Override
      public GallerySessionController createComponentSessionController(
          MainSessionController mainSessionCtrl, ComponentContext componentContext) {
        return new GallerySessionController(mainSessionCtrl, componentContext);
      }

      @Override
      public String getDestination(String function, GallerySessionController gallerySC,
          HttpRequest request) {
        String destination = "";
        String rootDest = "/gallery/jsp/";
        request.setAttribute("gallerySC", gallerySC);

        // Set common parameters
        SilverpeasRole highestUserRole = gallerySC.getHighestSilverpeasUserRole();
        String userId = gallerySC.getUserId();

        request.setAttribute("Profile", highestUserRole.getName());
        request.setAttribute("highestUserRole", highestUserRole);
        request.setAttribute("UserId", userId);
        request.setAttribute("IsGuest", gallerySC.isGuest());
        request.setAttribute("IsAnonymous", gallerySC.isAnonymous());
        request.setAttribute("IsExportEnable", gallerySC.isExportEnable());
        request.setAttribute("Sort", gallerySC.getSort());

        try {
          if (function.startsWith("Main")) {
            // récupération des albums de 1er niveau
            gallerySC.setIndexOfCurrentPage("0");

            AlbumDetail root = gallerySC.goToAlbum("0");
            request.setAttribute("root", root);
            request.setAttribute(ALBUMS, gallerySC.addNbMedia(root.getChildrenAlbumsDetails()));
            // chercher les dernièrs médias
            Collection<Media> mediaCollection = gallerySC.getLastRegisteredMedia();
            request.setAttribute(MEDIA_LIST, mediaCollection);
            request.setAttribute(IS_USE_PDC, gallerySC.isUsePdc());
            request.setAttribute(IS_PRIVATE_SEARCH, gallerySC.isPrivateSearch());
            request.setAttribute(IS_BASKET, gallerySC.isBasket());
            request.setAttribute(IS_ORDER, gallerySC.isOrder());
            destination = rootDest + "welcome.jsp";
          } else if ("ManageComponentSubscriptions".equals(function)) {
            destination = gallerySC.manageComponentSubscriptions();
          } else if ("ManageAlbumSubscriptions".equals(function)) {
            destination = gallerySC.manageAlbumSubscriptions();
          } else if ("ViewAlbum".equals(function)) {
            if (StringUtil.isDefined(request.getParameter("deselectAll"))) {
              deselectAll(gallerySC);
            }
            // récupération de l'Id de l'album en cours
            String albumId = request.getParameter("Id");
            gallerySC.goToAlbum(albumId);
            gallerySC.setIndexOfCurrentPage("0");
            // Slideshow requirements
            request.setAttribute(ALBUM_ID, albumId);
            request.setAttribute("wait", gallerySC.getSlideshowWait());
            // retour à l'album courant
            destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
          } else if ("Pagination".equals(function)) {
            processSelection(request, gallerySC);

            // traitement de la pagination : passage des paramètres
            String index = request.getParameter("Index");
            if (index != null && !index.isEmpty()) {
              gallerySC.setIndexOfCurrentPage(index);
            }
            String nbItemsPerPage = request.getParameter("NbItemsPerPage");
            if (StringUtil.isInteger(nbItemsPerPage)) {
              gallerySC.setNbMediasPerPage(Integer.parseInt(nbItemsPerPage));
            }
            destination = returnToAlbum(request, gallerySC);

          } else if (GO_TO_CURRENT_ALBUM_FUNC.equals(function)) {
            // mise à blanc de l'index de pagination si on arrive de la recherche
            if (gallerySC.isSearchResult() || gallerySC.isViewNotVisible()) {
              gallerySC.setIndexOfCurrentPage("0");
            }
            // mise à blanc de la liste des médias (pour les mots clé et pour les médias non visibles)
            gallerySC.setRestrictedListMedia(new ArrayList<>());
            gallerySC.setSearchResult(false);
            gallerySC.setViewNotVisible(false);

            // récupération de l'album en cours
            String currentAlbumId = gallerySC.getCurrentAlbumId();
            if ("0".equals(currentAlbumId)) {
              // on est à la racine, on retourne à l'accueil
              destination = getDestination("Main", gallerySC, request);
            } else {
              // on est dans un album, on y retourne
              AlbumDetail currentAlbum = gallerySC.goToAlbum();
              request.setAttribute(NB_MEDIA_PER_PAGE, gallerySC.getNbMediaPerPage());
              request.setAttribute(CURRENT_PAGE_INDEX, gallerySC.getIndexOfCurrentPage());
              request.setAttribute(CURRENT_ALBUM, currentAlbum);
              request.setAttribute(ALBUM_ID, currentAlbum.getId());
              request.setAttribute(ALBUMS,
                  gallerySC.addNbMedia(currentAlbum.getChildrenAlbumsDetails()));
              request.setAttribute("Path", gallerySC.getPath(currentAlbum.getNodePK()));
              request.setAttribute(MEDIA_RESOLUTION, gallerySC.getDisplayedMediaResolution());
              request.setAttribute("DragAndDropEnable", gallerySC.isDragAndDropEnabled());
              request.setAttribute(IS_VIEW_METADATA, gallerySC.isViewMetadata());
              request.setAttribute(IS_VIEW_LIST, gallerySC.isViewList());
              request.setAttribute(SELECTED_IDS, gallerySC.getListSelected());
              request.setAttribute(IS_USE_PDC, gallerySC.isUsePdc());
              request.setAttribute(IS_BASKET, gallerySC.isBasket());
              request.setAttribute(IS_ORDER, gallerySC.isOrder());
              request.setAttribute(IS_PRIVATE_SEARCH, gallerySC.isPrivateSearch());

              destination = rootDest + "viewAlbum.jsp";
            }
          } else if ("NewAlbum".equals(function)) {
            // passage de l'album courant : null car en création
            request.setAttribute(CURRENT_ALBUM, null);
            request.setAttribute("Path", gallerySC.getPath());
            // appel jsp
            destination = rootDest + "albumManager.jsp";
          } else if ("CreateAlbum".equals(function)) {
            // check user rights
            if (!gallerySC.isAlbumAdmin(highestUserRole, null, userId)) {
              throw new AccessForbiddenException("Gallery creation forbidden");
            }

            // récupération des paramètres de l'album
            String name = request.getParameter("Name");
            String description = request.getParameter(DESCRIPTION);
            // création de l'album
            NodeDetail node =
                new NodeDetail("unknown", name, description, 0, "unknown");
            AlbumDetail album = new AlbumDetail(node);
            gallerySC.createAlbum(album);
            // retour à l'album courant
            destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
          } else if ("EditAlbum".equals(function)) {
            // récupération des paramètres
            String albumId = request.getParameter("Id");

            // check user rights
            if (!gallerySC.isAlbumAdmin(highestUserRole, albumId, userId)) {
              throw new AccessForbiddenException("Gallery edition forbidden");
            }

            // récupération de l'album courant
            AlbumDetail currentAlbum = gallerySC.getAlbum(albumId);
            // passage des paramètres
            request.setAttribute(CURRENT_ALBUM, currentAlbum);
            request.setAttribute("Path", gallerySC.getPath());
            destination = rootDest + "albumManager.jsp";
          } else if ("UpdateAlbum".equals(function)) {
            String albumId = request.getParameter("Id");

            // check user rights
            if (!gallerySC.isAlbumAdmin(highestUserRole, albumId, userId)) {
              throw new AccessForbiddenException("Gallery update forbidden");
            }

            // Retrieve album name and description
            String name = request.getParameter("Name");
            String description = request.getParameter(DESCRIPTION);

            // Retrieve current album
            AlbumDetail album = gallerySC.getAlbum(albumId);
            // set new value
            album.setName(name);
            album.setDescription(description);

            gallerySC.updateAlbum(album);
            // retour à l'album courant
            destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
          } else if ("DeleteAlbum".equals(function)) {
            // Retrieve album identifier to delete
            String albumId = request.getParameter("Id");

            // check user rights
            if (!gallerySC.isAlbumAdmin(highestUserRole, albumId, userId)) {
              throw new AccessForbiddenException("Gallery deletion forbidden");
            }

            gallerySC.deleteAlbum(albumId);
            // retour à l'album courant
            destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
          } else if ("AddMedia".equals(function)) {
            // check user rights
            if (!gallerySC.isMediaAdmin(highestUserRole, null, userId)) {
              throw new AccessForbiddenException("Media adding forbidden");
            }
            MediaType mediaType = MediaType.from(request.getParameter("type"));

            // passage des paramètres
            request.setAttribute("Media", mediaType.newInstance());
            request.setAttribute("Repertoire", "");
            request.setAttribute("Path", gallerySC.getPath());
            request.setAttribute("GetLanguage", gallerySC.getLanguage());
            request.setAttribute("UserName", gallerySC.getUserDetail(userId).getDisplayedName());
            request.setAttribute("NbComments", 0);
            request.setAttribute(IS_USE_PDC, gallerySC.isUsePdc());
            request.setAttribute("XMLFormName", gallerySC.getXMLFormName());
            request.setAttribute("ShowCommentsTab", gallerySC.areCommentsEnabled());
            request.setAttribute(IS_BASKET, gallerySC.isBasket());
            request.setAttribute(IS_ORDER, gallerySC.isOrder());
            request.setAttribute(IS_VIEW_METADATA, gallerySC.isViewMetadata());

            // prepare XML form data
            PublicationTemplate template = gallerySC.getTemplate();
            if (template != null) {
              RecordSet recordSet = template.getRecordSet();
              request.setAttribute("Form", template.getUpdateForm());
              request.setAttribute("Data", recordSet.getEmptyRecord());
            }

            destination = rootDest + MEDIA_PREFIX + mediaType + "Edit.jsp";
          } else if ("CreateMedia".equals(function)) {

            if (!StringUtil.isDefined(request.getCharacterEncoding())) {
              request.setCharacterEncoding(UTF_8);
            }

            // check user rights
            if (!gallerySC.isMediaAdmin(highestUserRole, null, userId)) {
              throw new AccessForbiddenException("Media creation forbidden");
            }

            final String mediaId = createMediaData(request, gallerySC);

            // Reload the album
            gallerySC.loadCurrentAlbum();

            // preview of the new media
            request.setAttribute(MEDIA_ID, mediaId);
            destination = getDestination(MEDIA_VIEW_FUNC, gallerySC, request);
          } else if ("UpdateMedia".equals(function) || "UpdateInformation".equals(function)) {
            boolean isUpdateMediaFromAlbumCase =
                StringUtil.getBooleanValue(request.getParameter("isUpdateMediaFromAlbumCase"));
            if (!StringUtil.isDefined(request.getCharacterEncoding())) {
              request.setCharacterEncoding(UTF_8);
            }
            List<FileItem> parameters = request.getFileItems();
            String mediaId = FileUploadUtil
                .getParameter(parameters, MEDIA_ID, null, request.getCharacterEncoding());
            updateMediaData(mediaId, request, gallerySC);
            if (isUpdateMediaFromAlbumCase) {
              // Reload and clean the current album
              gallerySC.loadCurrentAlbum();
              deselectAll(gallerySC);
              // Back to the current album
              destination = returnToAlbum(request, gallerySC);
            } else {
              // Back to the view of the updated media
              request.setAttribute(MEDIA_ID, mediaId);
              destination = getDestination(MEDIA_VIEW_FUNC, gallerySC, request);
            }
          } else if ("DeleteMedia".equals(function)) {
            // Retrieve media identifier to delete
            String mediaId = request.getParameter(MEDIA_ID);

            // check user rights
            if (!gallerySC.isMediaAdmin(highestUserRole, mediaId, userId)) {
              throw new AccessForbiddenException("Media deletion forbidden");
            }
            gallerySC.deleteMedia(mediaId);

            // retour à l'album courant
            destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
          } else if (MEDIA_VIEW_FUNC.equals(function)) {
            // mise à blanc de la liste restreinte des médias (pour les médias non visibles)
            gallerySC.setRestrictedListMedia(new ArrayList<>());
            // remise à blanc des médias sélectionnés
            deselectAll(gallerySC);
            // récupération des paramètres
            String mediaId = request.getParameter(MEDIA_ID);
            if (mediaId == null || mediaId.isEmpty() || "null".equals(mediaId)) {
              mediaId = (String) request.getAttribute(MEDIA_ID);
            }
            request.setAttribute(IS_PRIVATE_SEARCH, gallerySC.isPrivateSearch());
            destination = processMedia(gallerySC, request, rootDest, highestUserRole, mediaId);
          } else if ("PreviousMedia".equals(function)) {
            Media media = gallerySC.getPrevious();
            request.setAttribute(MEDIA_ID, media.getId());
            destination = getDestination(MEDIA_VIEW_FUNC, gallerySC, request);
          } else if ("NextMedia".equals(function)) {
            Media media = gallerySC.getNext();
            request.setAttribute(MEDIA_ID, media.getId());
            destination = getDestination(MEDIA_VIEW_FUNC, gallerySC, request);
          } else if (function.startsWith("searchResult")) {
            // traitement des recherches
            String id = request.getParameter("Id");
            String type = request.getParameter("Type");
            destination = processMediaType(gallerySC, request, id, type);
          } else if ("AccessPath".equals(function)) {

            // visualisation des emplacements
            request.setAttribute("Path", gallerySC.getPath());
            // récupération du média
            String mediaId = request.getParameter(MEDIA_ID);
            if (mediaId == null || mediaId.isEmpty()) {
              mediaId = request.getParameter("PubId");
            }
            if (mediaId == null || mediaId.isEmpty()) {
              mediaId = (String) request.getAttribute(MEDIA_ID);
            }

            // check user rights
            if (!gallerySC.isMediaAdmin(highestUserRole, mediaId, userId)) {
              throw new AccessForbiddenException("Gallery access forbidden");
            }

            Media media = gallerySC.getMedia(mediaId);

            // passage des paramètres
            putMediaCommonParameters(request, gallerySC, media, highestUserRole);

            request.setAttribute("PathList", gallerySC.getAlbumIdsOf(mediaId));
            request.setAttribute(ALBUMS, gallerySC.getAllAlbums());

            destination = rootDest + "albumsOfMedia.jsp";
          } else if ("SelectPath".equals(function)) {
            // modification de la liste des emplacements du média
            String[] albums = request.getParameterValues("albumChoice");
            String mediaId = request.getParameter(MEDIA_ID);

            // check user rights
            if (!gallerySC.isMediaAdmin(highestUserRole, mediaId, userId)) {
              throw new AccessForbiddenException("Media access forbidden");
            }

            gallerySC.setMediaToAlbums(mediaId, albums);
            destination = getDestination(MEDIA_VIEW_FUNC, gallerySC, request);
          } else if ("AskMedia".equals(function)) {
            // demande de médias auprès du gestionnaire de la médiathèque
            destination = rootDest + "askMedia.jsp";
          } else if ("SendAsk".equals(function)) {
            // envoie d'une notification au gestionnaire
            String description = request.getParameter(DESCRIPTION);
            gallerySC.sendAskMedia(description);
            destination = rootDest + "closeWindow.jsp";
          } else if ("ChoiceSize".equals(function)) {
            // traitement du choix des tailles
            String choix = request.getParameter("Choice");
            // mettre à jour la taille avec le choix
            gallerySC.setDisplayedMediaResolution(MediaResolution.fromNameOrLabel(choix));
            // retourner au début de la liste des médias
            gallerySC.initIndex();
            // retour en fonction d'où on vient
            destination = returnToAlbum(request, gallerySC);

          } else if ("SortBy".equals(function)) {
            // traitement du tri selon l'écran en cours
            MediaSort sort = MediaSort.from(request.getParameter("Sort"));
            if ((!gallerySC.isSearchResult() && !gallerySC.isViewNotVisible())) {
              gallerySC.setSort(sort);
            } else {
              gallerySC.setSortSearch(sort);
            }
            destination = returnToAlbum(request, gallerySC);
          } else if ("EditSelectedMedia".equals(function)) {
            // traitement par lot
            String albumId = request.getParameter(ALBUM_ID_FIRST_LETTER_UPPERCASE);

            // check user rights
            if (!highestUserRole.isGreaterThanOrEquals(SilverpeasRole.PUBLISHER)) {
              throw new AccessForbiddenException("Media edition forbidden");
            }

            String searchKeyWord = request.getParameter(SEARCH_KEY_WORD);

            processSelection(request, gallerySC);

            // liste des médias sélectionnés
            if (!gallerySC.getListSelected().isEmpty()) {
              if (gallerySC.getListSelected().size() == 1) {
                // One media is being to be edited, the user is redirected to the edit page of the media
                request.setAttribute("MediaIdFromAlbum", gallerySC.getListSelected().iterator().next());
                destination = getDestination("EditInformation", gallerySC, request);
              } else {
                // passage des paramètres globaux
                request.setAttribute("SelectedMediaIds", gallerySC.getListSelected());
                request.setAttribute(ALBUM_ID_FIRST_LETTER_UPPERCASE, albumId);
                request.setAttribute(SEARCH_KEY_WORD, searchKeyWord);
                request.setAttribute("Path", gallerySC.getPath());
                request.setAttribute("GetLanguage", gallerySC.getLanguage());

                // passage des paramètres pour le formulaire
                PublicationTemplate template = gallerySC.getTemplate();
                if (template != null) {
                  RecordSet recordSet = template.getRecordSet();
                  request.setAttribute("Form", template.getUpdateForm());
                  request.setAttribute("Data", recordSet.getEmptyRecord());
                }

                destination = rootDest + "selectedMediaManager.jsp";
              }
            } else {
              destination = returnToAlbum(request, gallerySC);
            }
          } else if ("UpdateSelectedMedia".equals(function)) {
            // récupération des médias modifiés
            Collection<String> mediaIds = gallerySC.getListSelected();

            // mise à jour des médias
            if (!StringUtil.isDefined(request.getCharacterEncoding())) {
              request.setCharacterEncoding(UTF_8);
            }
            updateSelectedMedia(request, gallerySC, mediaIds, request.getCharacterEncoding());

            // tout désélectionner
            deselectAll(gallerySC);
            destination = returnToAlbum(request, gallerySC);

          } else if ("UpdateSelectedPaths".equals(function)) {
            // récupération des médias modifiés
            Collection<String> mediaIds = gallerySC.getListSelected();

            // mise à jour des emplacements des médias
            String[] albums = request.getParameterValues("albumChoice");

            for (String mediaId : mediaIds) {
              if (gallerySC.isMediaAdmin(highestUserRole, mediaId, userId)) {
                // ajouter les nouveaux emplacements sur les anciens
                gallerySC.addMediaToAlbums(mediaId, albums);
              }
            }
            deselectAll(gallerySC);

            destination = returnToAlbum(request, gallerySC);
          } else if ("DeleteSelectedMedia".equals(function)) {
            processSelection(request, gallerySC);

            // liste des médias sélectionnés
            if (!gallerySC.getListSelected().isEmpty()) {
              // récupération des médias à supprimer
              Collection<String> mediaIds = gallerySC.getListSelected();

              // suppression des médias
              deleteSelectedMedia(gallerySC, mediaIds);

              deselectAll(gallerySC);

              // retour à l'album en cours
              destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
            }
          } else if ("CategorizeSelectedMedia".equals(function)) {
            processSelection(request, gallerySC);

            // liste des médias sélectionnés
            if (!gallerySC.getListSelected().isEmpty()) {
              final List<String> selectedIds = (List<String>) gallerySC.getListSelected();

              // get silverObjectIds according to selected mediaIds
              final List<String> silverObjectIds = new ArrayList<>();
              for (final String selectedId : selectedIds) {
                silverObjectIds.add(Integer.toString(gallerySC.getSilverObjectId(selectedId)));
              }

              request.setAttribute("ObjectIds", silverObjectIds);
              request.setAttribute("ComponentId", gallerySC.getComponentId());
              destination = "/RpdcClassify/jsp/ToAddPositions";
            } else {
              destination = rootDest + "closeWindow.jsp";
            }
          } else if ("AddAlbumForSelectedMedia".equals(function)) {
            // placement par lot
            String albumId = request.getParameter(ALBUM_ID_FIRST_LETTER_UPPERCASE);
            // check user rights
            if (!highestUserRole.isGreaterThanOrEquals(SilverpeasRole.PUBLISHER)) {
              throw new AccessForbiddenException("Media adding into gallery forbidden");
            }
            processSelection(request, gallerySC);
            // liste des médias sélectionnés
            if (!gallerySC.getListSelected().isEmpty()) {
              // passage des paramètres globaux
              request.setAttribute(ALBUM_ID_FIRST_LETTER_UPPERCASE, albumId);
              request.setAttribute("Path", gallerySC.getPath());
              request.setAttribute(ALBUMS, gallerySC.getAllAlbums());

              destination = rootDest + "pathsManager.jsp";
            } else {
              destination = returnToAlbum(request, gallerySC);
            }
          } else if ("EditInformation".equals(function)) {
            // récupération des paramètres
            String mediaId = request.getParameter(MEDIA_ID);
            if (StringUtil.isNotDefined(mediaId)) {
              // Firstly, verifying that the user tries to modify a media from album
              mediaId = (String) request.getAttribute("MediaIdFromAlbum");
              if (StringUtil.isDefined(mediaId)) {
                request.setAttribute("isUpdateMediaFromAlbumCase", true);
              }
            }
            // récupération du média
            Media media = gallerySC.getMedia(mediaId);

            // passage des paramètres
            putMediaCommonParameters(request, gallerySC, media, highestUserRole);

            request.setAttribute(IS_VIEW_METADATA, gallerySC.isViewMetadata());

            request.setAttribute("Repertoire", media.getWorkspaceSubFolderName());

            // récupération du formulaire et affichage
            PublicationTemplate template = gallerySC.getTemplate();
            if (template != null) {
              RecordSet recordSet = template.getRecordSet();
              DataRecord data = recordSet.getRecord(mediaId);
              if (data == null) {
                data = recordSet.getEmptyRecord();
                data.setId(mediaId);
              }
              request.setAttribute("Form", template.getUpdateForm());
              request.setAttribute("Data", data);
            }

            // appel jsp
            destination = rootDest + MEDIA_PREFIX + media.getType().name() + "Edit.jsp";
          } else if ("AllSelected".equals(function)) {
            // sélectionne (ou désélectionne) tous les médias de l'album (ou de la liste restreinte
            // dans le cas de la recherche)
            boolean select = !gallerySC.getSelect();
            gallerySC.setSelect(select);

            Collection<Media> media;

            // Returning to the form
            if (!gallerySC.isSearchResult() && !gallerySC.isViewNotVisible()) {
              // Returning to the album
              media = gallerySC.goToAlbum().getMedia();

              if (select) {
                gallerySC.getListSelected().addAll(extractIds(media));
              } else {
                gallerySC.getListSelected().removeAll(extractIds(media));
              }

              destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);

            } else {
              // Returning to search result or to not visible list
              if (gallerySC.isViewNotVisible()) {
                media = gallerySC.getNotVisible();

                if (select) {
                  gallerySC.getListSelected().addAll(extractIds(media));
                } else {
                  gallerySC.getListSelected().removeAll(extractIds(media));
                }

                gallerySC.setRestrictedListMedia(media);
                destination = getDestination(VIEW_NOT_VISIBLE_FUNC, gallerySC, request);
              } else {
                media = gallerySC.getSearchResultListMedia();

                if (select) {
                  gallerySC.getListSelected().addAll(extractIds(media));
                } else {
                  gallerySC.getListSelected().removeAll(extractIds(media));
                }

                destination = getDestination(VIEW_SEARCH_RESULTS_FUNC, gallerySC, request);

              }
            }
          } else if ("SearchAdvanced".equals(function)) {
            // recherche avancée
            request.setAttribute("MetaDataKeys", gallerySC.getMetaDataKeys());

            // récupérer le contexte
            QueryDescription query = gallerySC.getQuery();

            // passage des paramètres pour garder le contexte
            String keyWord = query.getQuery();
            request.setAttribute("KeyWord", keyWord);

            // contexte de recherche du PDC
            request.setAttribute("PDCSearchContext", gallerySC.getPDCSearchContext());

            // pour les formulaires
            PublicationTemplate template = gallerySC.getTemplate();
            if (template != null) {
              // get previous search
              DataRecord data = gallerySC.getXMLSearchContext();
              if (data == null) {
                RecordSet recordSet = template.getRecordSet();
                data = recordSet.getEmptyRecord();
              }
              request.setAttribute("Form", template.getSearchForm());
              request.setAttribute("Data", data);
            }

            destination = rootDest + "searchAdvanced.jsp";
          } else if ("ClearSearch".equals(function)) {
            gallerySC.clearSearchContext();

            destination = getDestination("SearchAdvanced", gallerySC, request);
          } else if ("LastResult".equals(function)) {
            // Reset pagination index
            gallerySC.setIndexOfCurrentPage("0");

            destination = getDestination(VIEW_SEARCH_RESULTS_FUNC, gallerySC, request);
          } else if (SEARCH_KEY_WORD.equals(function)) {
            // traitement de la recherche par mot clé
            // et de la recherche dédiée
            // récupération du mot clé et de la liste des médias concernés s'il existe
            String searchKeyWord = request.getParameter(SEARCH_KEY_WORD);
            if (searchKeyWord == null) {
              searchKeyWord = (String) request.getAttribute(SEARCH_KEY_WORD);
            }
            if (!isDefined(searchKeyWord)) {
              searchKeyWord = gallerySC.getSearchKeyWord();
            }

            // Reset search if keyword has changed
            if (!gallerySC.getSearchKeyWord().equals(searchKeyWord)) {
              gallerySC.setSearchResultListMedia(new ArrayList<>());
              gallerySC.setSearchKeyWord(searchKeyWord);
              // reset pagination index
              gallerySC.setIndexOfCurrentPage("0");
            }

            // mise à jour du tag pour les retours
            gallerySC.setViewNotVisible(false);
            gallerySC.setSearchResult(true);

            QueryDescription query = new QueryDescription(searchKeyWord);

            if (StringUtil.isDefined(query.getQuery())) {
              gallerySC.setSearchResultListMedia(gallerySC.search(query));
            }

            destination = getDestination(VIEW_SEARCH_RESULTS_FUNC, gallerySC, request);
          } else if ("PaginationSearch".equals(function)) {
            processSelection(request, gallerySC);

            // traitement de la pagination : passage des paramètres
            String index = request.getParameter("Index");
            if (index != null && !index.isEmpty()) {
              gallerySC.setIndexOfCurrentPage(index);
            }

            destination = getDestination(VIEW_SEARCH_RESULTS_FUNC, gallerySC, request);
          } else if (VIEW_SEARCH_RESULTS_FUNC.equals(function)) {
            Collection<Media> media = gallerySC.getSearchResultListMedia();
            // passage des paramètres
            setDefaultRequestAttributes(gallerySC, media, gallerySC.getSearchKeyWord(), request);

            // mise à jour du tag pour les retours
            gallerySC.setSearchResult(true);
            gallerySC.setViewNotVisible(false);
            request.setAttribute(VIEW_NOT_VISIBLE_FUNC, gallerySC.isViewNotVisible());

            // appel jsp
            destination = rootDest + "viewRestrictedMediaList.jsp";
          } else if ("Search".equals(function)) {
            if (!StringUtil.isDefined(request.getCharacterEncoding())) {
              request.setCharacterEncoding(UTF_8);
            }
            List<FileItem> items = request.getFileItems();
            QueryDescription query = new QueryDescription();
            // Ajout de la requête classique
            String word = FileUploadUtil
                .getParameter(items, SEARCH_KEY_WORD, null, request.getCharacterEncoding());
            query.setQuery(word);
            gallerySC.setSearchKeyWord(word);

            // Ajout des éléments de recherche sur form XML
            PublicationTemplateImpl template = (PublicationTemplateImpl) gallerySC.getTemplate();
            if (template != null) {
              String templateFileName = template.getFileName();
              String templateName = templateFileName.substring(0, templateFileName.lastIndexOf('.'));

              RecordTemplate searchTemplate = template.getSearchTemplate();
              if (searchTemplate != null) {
                DataRecord data = searchTemplate.getEmptyRecord();

                PagesContext context = new PagesContext("XMLSearchForm", "2", gallerySC.getLanguage(),
                    gallerySC.getUserId());
                context.setEncoding(UTF_8);
                XmlSearchForm searchForm = (XmlSearchForm) template.getSearchForm();
                searchForm.update(items, data, context);

                // store XML search data in session
                gallerySC.setXMLSearchContext(data);

                for (final String fieldName : searchTemplate.getFieldNames()) {
                  Field field = data.getField(fieldName);
                  String fieldValue = field.getStringValue();
                  if (fieldValue != null && !fieldValue.trim().isEmpty()) {
                    String fieldQuery = fieldValue.trim().replaceAll("##", " AND "); // case à cocher multiple
                    query.addFieldQuery(
                        new FieldDescription(templateName + "$$" + fieldName, fieldQuery, null));
                  }
                }
              }
            }

            // Add IPTC search elements
            List<MetaData> iptcFields = gallerySC.getMetaDataKeys();
            // Loop for each XML fields
            for (final MetaData iptcField : iptcFields) {
              // recuperation valeur dans request
              String property = iptcField.getProperty();

              // ajouter à l'objet query
              if (!iptcField.isDate()) {
                String value =
                    FileUploadUtil.getParameter(items, property, null, request.getCharacterEncoding());
                if (StringUtil.isDefined(value)) {
                  query.addFieldQuery(new FieldDescription("IPTC_" + property, value, null));
                }
              } else {
                // cas particulier des champs de type date
                // récupère les deux champs
                String dateBeginStr = FileUploadUtil
                    .getParameter(items, property + "_Begin", null, request.getCharacterEncoding());
                String dateEndStr = FileUploadUtil
                    .getParameter(items, property + "_End", null, request.getCharacterEncoding());

                Date dateBegin = null;
                Date dateEnd = null;

                if (StringUtil.isDefined(dateBeginStr)) {
                  dateBegin = DateUtil.stringToDate(dateBeginStr, gallerySC.getLanguage());
                }

                if (StringUtil.isDefined(dateEndStr)) {
                  dateEnd = DateUtil.stringToDate(dateEndStr, gallerySC.getLanguage());
                }

                if (dateBegin != null || dateEnd != null) {
                  query.addFieldQuery(new FieldDescription("IPTC_" + property,
                      dateBegin, dateEnd, null));
                }

              }
            }

            // Ajout élément PDC
            String axisValues = request.getParameter("AxisValueCouples");
            query.setTaxonomyPosition(axisValues);

            // Lancement de la recherche
            gallerySC.search(query);

            destination = getDestination(VIEW_SEARCH_RESULTS_FUNC, gallerySC, request);
          } else if (VIEW_NOT_VISIBLE_FUNC.equals(function)) {
            // traitement de la liste des médias plus visibles
            // récupération de la liste des médias plus visibles, ou création de cette liste si elle est
            // vide
            Collection<Media> media = gallerySC.getRestrictedListMedia();
            if (media.isEmpty()) {
              media = gallerySC.getNotVisible();
            }

            // mise à jour du tag pour les médias non visibles
            gallerySC.setSearchResult(false);
            gallerySC.setViewNotVisible(true);
            request.setAttribute(VIEW_NOT_VISIBLE_FUNC, gallerySC.isViewNotVisible());

            // passage des paramètres
            setDefaultRequestAttributes(gallerySC, media, "", request);

            destination = rootDest + "viewRestrictedMediaList.jsp";
          } else if (function.startsWith("portlet")) {
            // récupération des albums de 1er niveau
            gallerySC.setIndexOfCurrentPage("0");
            request.setAttribute("root", gallerySC.goToAlbum("0"));
            // chercher les derniers médias
            Collection<Media> mediaList = gallerySC.getLastRegisteredMedia();
            request.setAttribute(MEDIA_LIST, mediaList);
            destination = rootDest + "portlet.jsp";
          } else if ("copy".equals(function)) {
            String objectType = request.getParameter("Object");
            String objectId = request.getParameter("Id");
            if (StringUtil.isDefined(objectType) && "Node".equalsIgnoreCase(objectType)) {
              gallerySC.copyAlbum(objectId);
            } else {
              gallerySC.copyMedia(objectId);
            }
            destination =
                URLUtil.getURL(URLUtil.CMP_CLIPBOARD, null, null) +
                    "Idle.jsp?message=REFRESHCLIPBOARD";
          } else if ("CopySelectedMedia".equals(function)) {
            processSelection(request, gallerySC);
            // check list of selected media
            if (!gallerySC.getListSelected().isEmpty()) {
              // retrieve media to copy
              Collection<String> mediaIds = gallerySC.getListSelected();
              // copy media
              gallerySC.copySelectedMedia(mediaIds);
              deselectAll(gallerySC);
            }
            // Get back to current album view
            destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
          } else if ("cut".startsWith(function)) {
            String objectType = request.getParameter("Object");
            String objectId = request.getParameter("Id");
            if (StringUtil.isDefined(objectType) && "Node".equalsIgnoreCase(objectType)) {
              gallerySC.cutAlbum(objectId);
            } else {
              gallerySC.cutMedia(objectId);
            }
            destination =
                URLUtil.getURL(URLUtil.CMP_CLIPBOARD, null, null) +
                    "Idle.jsp?message=REFRESHCLIPBOARD";
          } else if ("CutSelectedMedia".equals(function)) {
            processSelection(request, gallerySC);

            if (!gallerySC.getListSelected().isEmpty()) {
              Collection<String> mediaIds = gallerySC.getListSelected();
              gallerySC.cutSelectedMedia(mediaIds);
              deselectAll(gallerySC);
            }
            // Get back to current album view
            destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
          } else if (function.startsWith("paste")) {
            gallerySC.paste();
            gallerySC.loadCurrentAlbum();
            destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
          } else if (function.startsWith("Basket")) {
            // Manage basket functions
            switch (function) {
              case BASKET_VIEW_FUNC:
                // Basket view
                request.setAttribute(MEDIA_LIST, gallerySC.getBasketMedias());
                request.setAttribute(NB_MEDIA_PER_PAGE, gallerySC.getNbMediaPerPage());
                request.setAttribute(SELECTED_IDS, gallerySC.getListSelected());
                request.setAttribute(IS_ORDER, gallerySC.isOrder());
                request.setAttribute(MEDIA_TYPE_ALERT_ATTR, request.getAttribute(MEDIA_TYPE_ALERT_ATTR));

                destination = rootDest + "basket.jsp";
                break;
              case "BasketDelete":
                gallerySC.clearBasket();
                destination = getDestination(BASKET_VIEW_FUNC, gallerySC, request);
                break;
              case "BasketDeleteMedia": {
                // Delete media from basket
                String mediaId = request.getParameter(MEDIA_ID);
                gallerySC.deletePhotoFromBasket(mediaId);

                destination = getDestination(BASKET_VIEW_FUNC, gallerySC, request);
                break;
              }
              case "BasketDeleteSelectedMedia":
                // delete selected medias from basket
                processSelection(request, gallerySC);
                if (!gallerySC.getListSelected().isEmpty()) {
                  gallerySC.deleteSelectedPhotosFromBasket();
                }
                destination = getDestination(BASKET_VIEW_FUNC, gallerySC, request);
                break;
              case "BasketAddMediaList":
                // Add selected photo media inside basket
                processSelection(request, gallerySC);
                if (!gallerySC.getListSelected().isEmpty()) {
                  if (!gallerySC.addToBasket()) {
                    request.setAttribute(MEDIA_TYPE_ALERT_ATTR, true);
                  }
                  destination = getDestination(BASKET_VIEW_FUNC, gallerySC, request);
                } else {
                  destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
                }
                break;
              case "BasketAddMedia": {
                // Add this media inside basket
                String mediaId = request.getParameter(MEDIA_ID);
                gallerySC.addMediaToBasket(mediaId);
                destination = getDestination(BASKET_VIEW_FUNC, gallerySC, request);
                break;
              }
              case "BasketPagination":
                processSelection(request, gallerySC);

                // retour au panier
                destination = getDestination(BASKET_VIEW_FUNC, gallerySC, request);
                break;
            }
          } else if (function.startsWith("Order")) {
            switch (function) {
              case "OrderAdd": {
                // Retrieve order form
                PublicationTemplate template = gallerySC.getOrderTemplate();
                if (template != null) {
                  RecordSet recordSet = template.getRecordSet();
                  request.setAttribute("Form", template.getUpdateForm());
                  request.setAttribute("Data", recordSet.getEmptyRecord());
                }

                // retrieve convention
                String charteUrl = gallerySC.getCharteUrl();
                request.setAttribute("CharteUrl", charteUrl);

                destination = rootDest + "basketForm.jsp";
                break;
              }
              case "OrderCreate": {
                // create order from basket
                String orderId = gallerySC.addOrder();

                // mise à jour des données du formulaire
                if (!StringUtil.isDefined(request.getCharacterEncoding())) {
                  request.setCharacterEncoding(UTF_8);
                }
                List<FileItem> items = request.getFileItems();

                PublicationTemplate template = gallerySC.getOrderTemplate();
                if (template != null) {
                  RecordSet set = template.getRecordSet();
                  Form form = template.getUpdateForm();
                  DataRecord data = set.getRecord(orderId);
                  if (data == null) {
                    data = set.getEmptyRecord();
                    data.setId(orderId);
                  }

                  PagesContext context = new PagesContext("myForm", "0", gallerySC.getLanguage(), false,
                      gallerySC.getComponentId(), gallerySC.getUserId());
                  context.setEncoding(UTF_8);
                  context.setObjectId(orderId);

                  // mise à jour des données saisies
                  form.update(items, data, context);
                  set.save(data);
                }

                // notify gallery manager
                gallerySC.sendAskOrder(orderId);

                // view order list destination
                destination = getDestination(ORDER_VIEW_LIST_FUNC, gallerySC, request);
                break;
              }
              case "OrderUpdate": {
                String orderId = request.getParameter(ORDER_ID);
                // update order
                updateOrder(request, gallerySC, orderId, userId);
                // notify reader user
                gallerySC.sendAskOrderUser(orderId);
                destination = getDestination(ORDER_VIEW_LIST_FUNC, gallerySC, request);
                break;
              }
              case ORDER_VIEW_LIST_FUNC:
                Collection<Order> orders;
                if (highestUserRole == SilverpeasRole.ADMIN) {
                  // if manager retrieve all orders
                  orders = gallerySC.getAllOrders();
                } else {
                  // else if retrieve only user orders
                  orders = gallerySC.getOrdersByUser();
                }
                request.setAttribute("NbOrdersProcess", getNbOrdersProcess(orders));
                request.setAttribute("Orders", orders);
                destination = rootDest + "orders.jsp";
                break;
              case "OrderView": {
                String orderId = request.getParameter(ORDER_ID);
                if (orderId == null || orderId.isEmpty() || "null".equals(orderId)) {
                  orderId = (String) request.getAttribute(ORDER_ID);
                }

                if (highestUserRole == SilverpeasRole.ADMIN || gallerySC.isAccessAuthorized(orderId)) {
                  gallerySC.setCurrentOrderId(orderId);

                  destination = getDestination(ORDER_VIEW_PAGIN_FUNC, gallerySC, request);
                } else {
                  destination = "/admin/jsp/accessForbidden.jsp";
                }
                break;
              }
              case ORDER_VIEW_PAGIN_FUNC: {
                String orderId = gallerySC.getCurrentOrderId();
                request.setAttribute("Order", gallerySC.getOrder(orderId));
                request.setAttribute(NB_MEDIA_PER_PAGE, gallerySC.getNbMediaPerPage());

                PublicationTemplate template = gallerySC.getOrderTemplate();
                if (template != null) {
                  RecordSet recordSet = template.getRecordSet();
                  DataRecord data = recordSet.getRecord(orderId);
                  if (data != null) {
                    request.setAttribute("XMLForm", template.getViewForm());
                    request.setAttribute("XMLData", data);
                  }
                }
                destination = rootDest + "order.jsp";
                break;
              }
              case "OrderPagination":
                // retour à la demande
                destination = getDestination(ORDER_VIEW_PAGIN_FUNC, gallerySC, request);
                break;
              case "OrderDownloadMedia":
                final SimpleCache cache = getSessionCacheAccessor().getCache();
                destination = Optional.ofNullable(request.getParameter("downloadId"))
                    .filter(StringUtil::isDefined)
                    .map(d -> Optional.ofNullable(cache.remove(d, String.class))
                        .filter(StringUtil::isDefined)
                        .map(u -> u.replace(URLUtil.getApplicationURL(), StringUtil.EMPTY))
                        .orElseGet(() -> getDestination(ORDER_VIEW_PAGIN_FUNC, gallerySC, request)))
                    .orElseGet(() -> {
                      final String mediaId = request.getParameter(MEDIA_ID);
                      final String orderId = request.getParameter(ORDER_ID);
                      return Optional.of(gallerySC.getUrl(orderId, mediaId))
                          .filter(StringUtil::isDefined)
                          .map(u -> {
                            gallerySC.updateOrderRow(orderId, mediaId);
                            final String downloadUrlKey = UUID.randomUUID().toString();
                            cache.put(downloadUrlKey, u);
                            return sendJson(encodeObject(o -> o.put("downloadId", downloadUrlKey)));
                          }).orElseGet(() -> {
                            final String errorMessage = gallerySC.getString("gallery.alreadyDownloaded");
                            return sendJson(encodeObject(o -> o.put("errorMessage", errorMessage)));
                          });
                    });
                break;
            }
          } else if (function.startsWith("Export")) {
            if ("ExportAlbum".equals(function)) {
              String albumId = request.getParameter(ALBUM_ID);
              String format = request.getParameter("format");
              ExportReport exportRpt =
                  gallerySC.exportAlbum(albumId, MediaResolution.fromNameOrLabel(format));
              request.setAttribute("ExportReport", exportRpt);
              destination = rootDest +"downloadZip.jsp";
            } else if ("ExportSelection".equals(function)) {
              String format = request.getParameter("format");
              ExportReport exportRpt =
                  gallerySC.exportSelection(MediaResolution.fromNameOrLabel(format));
              request.setAttribute("ExportReport", exportRpt);
              gallerySC.clearBasket();
              destination = rootDest +"downloadZip.jsp";
            }
          } else {
            destination = rootDest + function;
          }
        } catch (AccessForbiddenException afe) {
          SilverLogger.getLogger(this).warn(afe);
          destination = "/admin/jsp/accessForbidden.jsp";
        } catch (Exception e) {
          request.setAttribute("jakarta.servlet.jsp.jspException", e);
          destination = "/admin/jsp/errorpageMain.jsp";
        }

        return destination;
      }

      private void setDefaultRequestAttributes(GallerySessionController gallerySC,
          Collection<Media> media, String searchKeyWords, HttpRequest request) {
        request.setAttribute(MEDIA_LIST, media);
        request.setAttribute(NB_MEDIA_PER_PAGE, gallerySC.getNbMediaPerPage());
        request.setAttribute(CURRENT_PAGE_INDEX, gallerySC.getIndexOfCurrentPage());
        request.setAttribute(MEDIA_RESOLUTION, gallerySC.getDisplayedMediaResolution());
        request.setAttribute(IS_VIEW_METADATA, gallerySC.isViewMetadata());
        request.setAttribute(IS_VIEW_LIST, gallerySC.isViewList());
        request.setAttribute(SELECTED_IDS, gallerySC.getListSelected());
        request.setAttribute(IS_BASKET, gallerySC.isBasket());
        request.setAttribute(SEARCH_KEY_WORD, searchKeyWords);
      }

      private String processMediaType(final GallerySessionController gallerySC,
          final HttpRequest request, final String id, final String type) {
        String destination;
        try {
          MediaType mediaType = MediaType.from(type);
          if (mediaType != MediaType.Unknown) {
            // traitement des médias
            request.setAttribute(MEDIA_ID, id);
            destination = getDestination(MEDIA_VIEW_FUNC, gallerySC, request);
          } else if ("Node".equals(type)) {
            // traitement des nœuds = les albums
            destination = getDestination("ViewAlbum", gallerySC, request);
          } else {
            destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
          }
        } catch (Exception e) {
          SilverLogger.getLogger(this).warn(e);
          destination = getDocumentNotFoundDestination(gallerySC, request);
        }
        return destination;
      }

      private String processMedia(final GallerySessionController gallerySC, final HttpRequest request,
          final String rootDest, final SilverpeasRole highestUserRole, final String mediaId) {
        String destination;
        try {
          Media media = gallerySC.getMedia(mediaId);

          request.setAttribute(SEARCH_KEY_WORD, request.getParameter(SEARCH_KEY_WORD));
          request.setAttribute("Rang", gallerySC.getRang());
          request.setAttribute("NbMedia", gallerySC.goToAlbum().getMedia().size());
          request.setAttribute(IS_VIEW_METADATA, gallerySC.isViewMetadata());
          request.setAttribute("IsWatermark", gallerySC.isMakeWatermark());
          request.setAttribute("ImageResolutionPreview", gallerySC.getImageResolutionPreview(media));

          boolean linkDownload = isLinkDownloadable(gallerySC, highestUserRole, media);
          request.setAttribute("ViewLinkDownload", linkDownload);

          putMediaCommonParameters(request, gallerySC, media, highestUserRole);

          // Prepare XML form data
          putXMLDisplayerIntoRequest(media, request, gallerySC);
          // Slideshow requirements
          request.setAttribute(ALBUM_ID, gallerySC.getCurrentAlbumId());
          request.setAttribute("wait", gallerySC.getSlideshowWait());
          // Add this following line for backward compatibility TODO create migration script in
          // order to insert each media inside content manager
          request.setAttribute("SilverObjetId", gallerySC.getSilverObjectId(mediaId));
          // appel jsp
          destination = rootDest + MEDIA_PREFIX + media.getType().toString() + "View.jsp";
        } catch (Exception e) {
          SilverLogger.getLogger(this).warn(e);
          destination = getDocumentNotFoundDestination(gallerySC, request);
        }
        return destination;
      }

      private boolean isLinkDownloadable(final GallerySessionController gallerySC,
          final SilverpeasRole highestUserRole, final Media media) {
        if (gallerySC.getHighestSilverpeasUserRole().isGreaterThanOrEquals(SilverpeasRole.PUBLISHER)) {
          return true;
        }
        return (SilverpeasRole.PRIVILEGED_USER == highestUserRole && media.isDownloadable()) ||
            (SilverpeasRole.WRITER == highestUserRole &&
                media.getCreatorId().equals(gallerySC.getUserId()));
      }

      private Integer getNbOrdersProcess(Collection<Order> orders) {
        int nb = 0;
        for (final Order order : orders) {
          if (isSqlDefined(order.getProcessUserId())) {
            nb++;
          }
        }
        return nb;
      }

      private String createMediaData(HttpRequest request, GallerySessionController gallerySC)
          throws ParseException, PublicationTemplateException {

        final List<FileItem> parameters = request.getFileItems();
        MediaType mediaType = MediaType.from(request.getParameter("type"));
        final MediaDataCreateDelegate delegate =
            new MediaDataCreateDelegate(mediaType, gallerySC.getLanguage(),
                gallerySC.getCurrentAlbumId(), parameters);

        // 1. Getting the header data
        setHeaderData(delegate.getHeaderData(), request);

        String positions = request.getParameter("Positions");
        if (StringUtil.isDefined(positions)) {
          PdcClassificationEntity withClassification = PdcClassificationEntity.fromJSON(positions);
          delegate.getHeaderData().setPdcPositions(withClassification.getPdcPositions());
        }

        // 2. Getting form data
        PublicationTemplate template = gallerySC.getTemplate();
        if (template != null) {
          delegate.setForm(template.getRecordSet(), template.getUpdateForm());
        }

        // Persisting the media in database & on file system
        return gallerySC.createMedia(delegate);
      }

      private void setHeaderData(AbstractMediaDataDelegate.HeaderData headerData,
          HttpRequest request) throws ParseException {
        headerData
            .setHomepageUrl(request.getParameter(ParameterNames.StreamingHomepageUrl));
        headerData.setTitle(request.getParameter(ParameterNames.MediaTitle));
        headerData.setDescription(request.getParameter(ParameterNames.MediaDescription));
        headerData.setAuthor(request.getParameter(ParameterNames.MediaAuthor));
        headerData.setKeyWord(request.getParameter(ParameterNames.MediaKeyWord));
        headerData
            .setBeginVisibilityDate(request.getParameter(ParameterNames.MediaBeginVisibilityDate));
        headerData
            .setEndVisibilityDate(request.getParameter(ParameterNames.MediaEndVisibilityDate));
        headerData
            .setDownloadAuthorized(request.getParameter(ParameterNames.MediaDownloadAuthorized));
        headerData
            .setBeginDownloadDate(request.getParameter(ParameterNames.MediaBeginDownloadDate));
        headerData
            .setEndDownloadDate(request.getParameter(ParameterNames.MediaEndDownloadDate));
      }

      private void updateOrder(HttpServletRequest request, GallerySessionController gallerySC,
          String orderId, String userId) {
        // rechercher la demande
        Order order = gallerySC.getOrder(orderId);

        // mettre à jour la date et l'utilisateur
        order.setProcessUserId(userId);

        // mettre à jour les lignes
        List<OrderRow> rows = order.getRows();
        for (final OrderRow orderRow : rows) {
          String mediaId = orderRow.getMediaId();
          String download = request.getParameter("DownloadType" + mediaId);
          orderRow.setDownloadDecision(download);
        }
        order.setRows(rows);
        gallerySC.updateOrder(order);

      }

      private void updateSelectedMedia(HttpRequest request, GallerySessionController gallerySC,
          Collection<String> mediaIds, String encoding)
          throws ParseException, PublicationTemplateException {

        // Getting all HTTP parameters
        final List<FileItem> parameters = new ArrayList<>(request.getFileItems());

        final MediaDataUpdateDelegate delegate =
            new MediaDataUpdateDelegate(MediaType.Photo, gallerySC.getLanguage(),
                gallerySC.getCurrentAlbumId(), parameters);

        // Setting header data
        delegate.getHeaderData()
            .setTitle(FileUploadUtil.getParameter(parameters, "Media$Title", null, encoding));
        delegate.getHeaderData().setDescription(
            FileUploadUtil.getParameter(parameters, "Media$Description", null, encoding));
        delegate.getHeaderData()
            .setAuthor(FileUploadUtil.getParameter(parameters, "Media$Author", null, encoding));
        delegate.getHeaderData()
            .setKeyWord(FileUploadUtil.getParameter(parameters, "Media$KeyWord", null, encoding));
        delegate.getHeaderData().setBeginVisibilityDate(
            FileUploadUtil.getParameter(parameters, "Media$BeginVisibilityDate", null, encoding));
        delegate.getHeaderData().setEndVisibilityDate(
            FileUploadUtil.getParameter(parameters, "Media$EndVisibilityDate", null, encoding));
        delegate.getHeaderData().setDownloadAuthorized(
            FileUploadUtil.getParameter(parameters, "Media$DownloadAuthorized", null, encoding));
        delegate.getHeaderData().setBeginDownloadDate(
            FileUploadUtil.getParameter(parameters, "Media$BeginDownloadDate", null, encoding));
        delegate.getHeaderData().setEndDownloadDate(
            FileUploadUtil.getParameter(parameters, "Media$EndDownloadDate", null, encoding));

        // Setting form
        PublicationTemplate template = gallerySC.getTemplate();
        if (template != null) {
          delegate.setForm(template.getRecordSet(), template.getUpdateForm());
        }

        // Process data
        gallerySC.updateMediaByUser(mediaIds, delegate);

        // Reload media of current album
        gallerySC.loadCurrentAlbum();
      }

      private void deleteSelectedMedia(GallerySessionController gallerySC,
          Collection<String> mediaIds) {
        // suppression des médias sélectionnés : traitement par lot
        gallerySC.deleteMedia(mediaIds);
      }

      private boolean isDefined(String param) {
        return (param != null && !param.trim().isEmpty());
      }

      private void putXMLDisplayerIntoRequest(Media media, HttpServletRequest request,
          GallerySessionController gallerySC) throws PublicationTemplateException, FormException {
        String mediaId = media.getId();
        PublicationTemplate template = gallerySC.getTemplate();
        if (template != null) {
          RecordSet recordSet = template.getRecordSet();
          DataRecord data = recordSet.getRecord(mediaId);
          if (data != null) {
            request.setAttribute("XMLForm", template.getViewForm());
            request.setAttribute("XMLData", data);
          }
        }
      }

      private void updateMediaData(String mediaId, HttpRequest request,
          GallerySessionController gallerySC) throws ParseException, PublicationTemplateException {

        final MediaDataUpdateDelegate delegate =
            new MediaDataUpdateDelegate(MediaType.Photo, gallerySC.getLanguage(),
                gallerySC.getCurrentAlbumId(), request.getFileItems(), false);

        // 1. Récupération des données de l'entête
        setHeaderData(delegate.getHeaderData(), request);

        // 2. Récupération des données du formulaire
        PublicationTemplate template = gallerySC.getTemplate();
        if (template != null) {
          delegate.setForm(template.getRecordSet(), template.getUpdateForm());
        }

        // Enregistrement des informations des médias
        gallerySC.updateMediaByUser(mediaId, delegate);

        // mise à jour de l'album courant
        Collection<String> albumIds = gallerySC.getAlbumIdsOf(mediaId);
        // regarder si l'album courant est dans la liste des albums
        boolean inAlbum = false;
        boolean first = true;
        String firstAlbumId = "0";
        for (final String albumId : albumIds) {
          if (first) {
            firstAlbumId = albumId;
            first = false;
          }
          if (albumId.equals(gallerySC.getCurrentAlbumId())) {
            inAlbum = true;
          }
        }
        if (!inAlbum) {
          gallerySC.setCurrentAlbumId(firstAlbumId);
        }
      }

      private void putMediaCommonParameters(HttpServletRequest request,
          GallerySessionController gallerySC, Media media, SilverpeasRole userRole) {
        request.setAttribute("Media", media);
        int nbComments = 0;
        try {
          nbComments = gallerySC.getAllComments(media).size();
        } catch (Exception e) {
          SilverLogger.getLogger(this).error(e);
        }
        request.setAttribute("NbComments", nbComments);
        request.setAttribute("Path", gallerySC.getPath());
        request.setAttribute(IS_USE_PDC, gallerySC.isUsePdc());
        request.setAttribute("XMLFormName", gallerySC.getXMLFormName());
        request.setAttribute(IS_BASKET, gallerySC.isBasket());
        request.setAttribute(IS_ORDER, gallerySC.isOrder());

        boolean allowedToUpdateMedia = userRole.isGreaterThanOrEquals(SilverpeasRole.PUBLISHER) ||
            (userRole == SilverpeasRole.WRITER && media.getCreatorId().equals(gallerySC.getUserId()));
        request.setAttribute("UpdateMediaAllowed", allowedToUpdateMedia);

        request.setAttribute("ShowCommentsTab", gallerySC.areCommentsEnabled());
      }

      /**
       * update gallery session controller list of selected elements
       * @param request the incoming request
       * @param gallerySC the session controller of the Gallery application
       */
      private void processSelection(HttpServletRequest request, GallerySessionController gallerySC) {
        String selectedIds = request.getParameter(SELECTED_IDS);
        String notSelectedIds = request.getParameter("NotSelectedIds");
        Collection<String> memSelected = gallerySC.getListSelected();

        if (StringUtil.isDefined(selectedIds)) {
          for (String selectedId : selectedIds.split(",")) {
            if (!memSelected.contains(selectedId)) {
              memSelected.add(selectedId);
            }
          }
        }

        if (StringUtil.isDefined(notSelectedIds)) {
          for (String notSelectedId : notSelectedIds.split(",")) {
            memSelected.remove(notSelectedId);
          }
        }
      }

      private List<String> extractIds(Collection<Media> col) {
        List<String> ids = new ArrayList<>();
        if (col != null) {
          Iterator<Media> it = col.iterator();
          Media media;
          while (it.hasNext()) {
            media = it.next();
            if (media != null) {
              ids.add(media.getId());
            }
          }
        }
        return ids;
      }

      private String returnToAlbum(HttpRequest request, GallerySessionController gallerySC) {
        String destination;
        // retour d'où on vient
        if (!gallerySC.isSearchResult() && !gallerySC.isViewNotVisible()) {
          // retour à l'album en cours
          destination = getDestination(GO_TO_CURRENT_ALBUM_FUNC, gallerySC, request);
        } else {
          // retour aux résultats de recherche ou à la liste des médias non visibles
          if (gallerySC.isViewNotVisible()) {
            destination = getDestination(VIEW_NOT_VISIBLE_FUNC, gallerySC, request);
          } else {
            destination = getDestination(VIEW_SEARCH_RESULTS_FUNC, gallerySC, request);
          }
        }
        return destination;
      }

      private void deselectAll(GallerySessionController gallerySC) {
        gallerySC.setSelect(false);
        gallerySC.clearListSelected();
      }

      private String getDocumentNotFoundDestination(GallerySessionController gallery,
          HttpServletRequest request) {
        request.setAttribute("ComponentId", gallery.getComponentId());
        return "/admin/jsp/documentNotFound.jsp";
      }

    }