diff --git a/sources/Re3gistry2/src/main/resources/localizations/LocalizationBundle_en.properties b/sources/Re3gistry2/src/main/resources/localizations/LocalizationBundle_en.properties
index c669d79c..fc483605 100644
--- a/sources/Re3gistry2/src/main/resources/localizations/LocalizationBundle_en.properties
+++ b/sources/Re3gistry2/src/main/resources/localizations/LocalizationBundle_en.properties
@@ -577,7 +577,8 @@ bulkimport.error.itemreference=Some items linking to references could not be ins
 
 bulk.import.success=The bulk import has been complete with success.
 bulk.import.error=The bulk import has been complete with the following errors: 
-bulk.import.error.emptyfile=The bulk import cannot be complete because the file does not contain any item. 
+bulk.import.error.emptyfile=The bulk import cannot be complete because the file does not contain any item.
+bulk.import.error.emptyrequired=The bulk cannot be complete because the file does not contain data on required field: {fields} on line: {line}. 
 bulk.import.error.file=The bulk import has been complete with errors. The file could not be processed because of a wrong format.
 bulk.import.error.header.localid=The header of the file does not contain the "LocalID" column.
 bulk.import.error.header.language=The header of the file does not contain the "Language" column.
diff --git a/sources/Re3gistry2/src/main/webapp/jsp/ajaxServices/browseLoader.jsp b/sources/Re3gistry2/src/main/webapp/jsp/ajaxServices/browseLoader.jsp
index 61f05778..9e92874a 100644
--- a/sources/Re3gistry2/src/main/webapp/jsp/ajaxServices/browseLoader.jsp
+++ b/sources/Re3gistry2/src/main/webapp/jsp/ajaxServices/browseLoader.jsp
@@ -656,21 +656,28 @@
                                     </div>
                                 </div>
                             </div>
-                            <div class="modal-footer">
+                            <div id="browseLoaderModalFooter" class="modal-footer">
                                 <div class="col-sm-6">
                                     <button type="reset" class="btn btn-danger width100"><i class="fas fa-sync-alt"></i> ${localization.getString("reset")}</button>                                    
                                 </div>
                                 <div class="col-sm-6">
-                                    <button type="submit" class="btn btn-primary width100">
+                                    <button id="btnStartBulkImport" type="submit" class="btn btn-primary width100">
                                         <i class="fas fa-upload"></i> ${localization.getString("label.start.bulkimport")}
                                     </button>
-                                </div>
+                                    <script>
+            $(document).on('click', '#btnStartBulkImport', function (e) {
+                $('#bufferLoader').html('<div class="lds-ellipsis"><div></div><div></div><div></div><div></div></div>');
+            });
+        </script>
+                                    
+                                </div> 
+
                             </div>
+                                                                        <div id="bufferLoader"></div>
                         </div>
                     </form>
                 </div>
-            </div>
-
+            </div>                                                        
             <% } else { %>
             <div class="col-sm-6"></div>
             <%}%>
diff --git a/sources/Re3gistry2/src/main/webapp/jsp/registryManagerDataExport.jsp b/sources/Re3gistry2/src/main/webapp/jsp/registryManagerDataExport.jsp
index 66832437..117b9daa 100644
--- a/sources/Re3gistry2/src/main/webapp/jsp/registryManagerDataExport.jsp
+++ b/sources/Re3gistry2/src/main/webapp/jsp/registryManagerDataExport.jsp
@@ -75,6 +75,7 @@
 <!DOCTYPE html>
 <html lang="${localization.getString("property.localeid")}" role="document">
     <%@include file="includes/head.inc.jsp" %>
+    <link rel="stylesheet" href="res/css/css-loader.css">
     <body>
         <%@include file="includes/header.inc.jsp"%>
 
@@ -129,7 +130,7 @@
                     <h5 class="card-title"></h5>
                     <p class="card-text">${localization.getString("label.solrdescription")}</p>
                     <% if (SolrHandler.checkSolrCompleteIndexinglRunning()) { %>
-                    <p class="card-text mt-3 alert alert-warning">${localization.getString("label.solrrunning")}</p>
+                    <div class="card-text mt-3 alert alert-warning"><p>${localization.getString("label.solrrunning")}</p> <div class="lds-ellipsis"><div></div><div></div><div></div><div></div></div> </div>
                     <% } else {%>
                     <a id="startSolrIndexing" class="btn btn-primary btn-md<%=buttonDisabled%>" href="?<%=BaseConstants.KEY_REQUEST_STARTINDEX%>=<%=BaseConstants.KEY_BOOLEAN_STRING_TRUE%>" role="button">${localization.getString("label.solrstartindexing")}</a>
                     <script>
@@ -157,8 +158,9 @@
                 <div class="card-body">
                     <h5 class="card-title"></h5>
                     <p class="card-text">${localization.getString("label.cachingdescription")}</p>
-                    <% if (CacheHelper.checkCacheCompleteRunning()) { %>
-                    <p class="card-text mt-3 alert alert-warning">${localization.getString("label.cacheallrunning")}</p>
+                    <% if (CacheHelper.checkCacheCompleteRunning()) {                
+                    %>
+                    <div class="card-text mt-3 alert alert-warning"><p>${localization.getString("label.cacheallrunning")}</p> <div class="lds-ellipsis"><div></div><div></div><div></div><div></div></div> </div>
                     <% } else {%>
                     <div class="row">
                         <div class="col-sm-4">
diff --git a/sources/Re3gistry2/src/main/webapp/res/css/css-loader.css b/sources/Re3gistry2/src/main/webapp/res/css/css-loader.css
new file mode 100644
index 00000000..69307d03
--- /dev/null
+++ b/sources/Re3gistry2/src/main/webapp/res/css/css-loader.css
@@ -0,0 +1,64 @@
+/*
+Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+Click nbfs://nbhost/SystemFileSystem/Templates/JSP_Servlet/CascadeStyleSheet.css to edit this template
+*/
+/* 
+    Created on : 08-sep-2023, 9:45:16
+    Author     : ubarrigon
+*/
+.lds-ellipsis {
+  display: flex;
+  position: relative;
+  width: 80px;
+  height: 80px;
+  margin: 0 auto;
+}
+.lds-ellipsis div {
+  position: absolute;
+  top: 33px;
+  width: 13px;
+  height: 13px;
+  border-radius: 50%;
+  background: #ccc;
+  animation-timing-function: cubic-bezier(0, 1, 1, 0);
+}
+.lds-ellipsis div:nth-child(1) {
+  left: 8px;
+  animation: lds-ellipsis1 0.6s infinite;
+}
+.lds-ellipsis div:nth-child(2) {
+  left: 8px;
+  animation: lds-ellipsis2 0.6s infinite;
+}
+.lds-ellipsis div:nth-child(3) {
+  left: 32px;
+  animation: lds-ellipsis2 0.6s infinite;
+}
+.lds-ellipsis div:nth-child(4) {
+  left: 56px;
+  animation: lds-ellipsis3 0.6s infinite;
+}
+@keyframes lds-ellipsis1 {
+  0% {
+    transform: scale(0);
+  }
+  100% {
+    transform: scale(1);
+  }
+}
+@keyframes lds-ellipsis3 {
+  0% {
+    transform: scale(1);
+  }
+  100% {
+    transform: scale(0);
+  }
+}
+@keyframes lds-ellipsis2 {
+  0% {
+    transform: translate(0, 0);
+  }
+  100% {
+    transform: translate(24px, 0);
+  }
+}
diff --git a/sources/Re3gistry2JavaAPI/src/main/java/eu/europa/ec/re3gistry2/javaapi/handler/RegBulkImportHandler.java b/sources/Re3gistry2JavaAPI/src/main/java/eu/europa/ec/re3gistry2/javaapi/handler/RegBulkImportHandler.java
index 7be2b5c9..35f2b95a 100644
--- a/sources/Re3gistry2JavaAPI/src/main/java/eu/europa/ec/re3gistry2/javaapi/handler/RegBulkImportHandler.java
+++ b/sources/Re3gistry2JavaAPI/src/main/java/eu/europa/ec/re3gistry2/javaapi/handler/RegBulkImportHandler.java
@@ -25,14 +25,20 @@
 
 import eu.europa.ec.re3gistry2.base.utility.BaseConstants;
 import eu.europa.ec.re3gistry2.base.utility.Configuration;
+import eu.europa.ec.re3gistry2.base.utility.InputSanitizerHelper;
 import eu.europa.ec.re3gistry2.base.utility.MailManager;
 import eu.europa.ec.re3gistry2.base.utility.PersistenceFactory;
+import eu.europa.ec.re3gistry2.base.utility.exceptions.ExceptionConstants;
+import eu.europa.ec.re3gistry2.base.utility.exceptions.UnauthorizedUserException;
 import eu.europa.ec.re3gistry2.crudimplementation.RegActionManager;
 import eu.europa.ec.re3gistry2.crudimplementation.RegFieldManager;
 import eu.europa.ec.re3gistry2.crudimplementation.RegFieldmappingManager;
+import eu.europa.ec.re3gistry2.crudimplementation.RegGroupManager;
 import eu.europa.ec.re3gistry2.crudimplementation.RegItemManager;
+import eu.europa.ec.re3gistry2.crudimplementation.RegItemRegGroupRegRoleMappingManager;
 import eu.europa.ec.re3gistry2.crudimplementation.RegItemclassManager;
 import eu.europa.ec.re3gistry2.crudimplementation.RegItemproposedManager;
+import eu.europa.ec.re3gistry2.crudimplementation.RegItemproposedRegGroupRegRoleMappingManager;
 import eu.europa.ec.re3gistry2.crudimplementation.RegLanguagecodeManager;
 import eu.europa.ec.re3gistry2.crudimplementation.RegLocalizationManager;
 import eu.europa.ec.re3gistry2.crudimplementation.RegLocalizationproposedManager;
@@ -45,9 +51,12 @@
 import eu.europa.ec.re3gistry2.model.RegAction;
 import eu.europa.ec.re3gistry2.model.RegField;
 import eu.europa.ec.re3gistry2.model.RegFieldmapping;
+import eu.europa.ec.re3gistry2.model.RegGroup;
 import eu.europa.ec.re3gistry2.model.RegItem;
+import eu.europa.ec.re3gistry2.model.RegItemRegGroupRegRoleMapping;
 import eu.europa.ec.re3gistry2.model.RegItemclass;
 import eu.europa.ec.re3gistry2.model.RegItemproposed;
+import eu.europa.ec.re3gistry2.model.RegItemproposedRegGroupRegRoleMapping;
 import eu.europa.ec.re3gistry2.model.RegLanguagecode;
 import eu.europa.ec.re3gistry2.model.RegLocalization;
 import eu.europa.ec.re3gistry2.model.RegLocalizationproposed;
@@ -58,6 +67,7 @@
 import eu.europa.ec.re3gistry2.model.RegUser;
 import eu.europa.ec.re3gistry2.model.uuidhandlers.RegActionUuidHelper;
 import eu.europa.ec.re3gistry2.model.uuidhandlers.RegItemUuidHelper;
+import eu.europa.ec.re3gistry2.model.uuidhandlers.RegItemproposedRegGroupRegRoleMappingUuidHelper;
 import eu.europa.ec.re3gistry2.model.uuidhandlers.RegItemproposedUuidHelper;
 import eu.europa.ec.re3gistry2.model.uuidhandlers.RegLocalizationproposedUuidHelper;
 import eu.europa.ec.re3gistry2.model.uuidhandlers.RegRelationproposedUuidHelper;
@@ -65,17 +75,23 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.StringWriter;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.ResourceBundle;
+import java.util.Set;
 import javax.mail.internet.InternetAddress;
 import javax.persistence.EntityManager;
+import javax.persistence.NoResultException;
 import javax.servlet.ServletOutputStream;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
@@ -84,6 +100,14 @@
 import org.apache.commons.fileupload.disk.DiskFileItemFactory;
 import org.apache.commons.fileupload.servlet.ServletFileUpload;
 import org.apache.commons.io.IOUtils;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.message.BasicNameValuePair;
 import org.apache.logging.log4j.Logger;
 
 public class RegBulkImportHandler {
@@ -100,6 +124,9 @@ public class RegBulkImportHandler {
     private final HttpServletRequest request;
     private final ResourceBundle systemLocalization;
 
+    // Synchronization object
+    private static final Object sync = new Object();
+    
     private final String BR_HTML = "<br/>";
     private final String SUBSTITUTE_LOCALID = "{localid}";
     private final String SUBSTITUTE_LINE = "{line}";
@@ -219,24 +246,47 @@ public void processFile(HttpServletRequest request, RegItem regItem, RegUser reg
                 LOGGER.info("###");
                 LOGGER.info("### ANALIZE FILE ###");
                 HashMap<String, ArrayList<FieldsBulkImport>> itemsBulkImport = analyzeFile(headerListSplitted, additionLines, regItem);
-                checkRequired(additionLines, regItem);
+                
                 LOGGER.info("### THE FILE HAS BEEN ANALIZED ###");
                 LOGGER.info("###");
                 LOGGER.info("### START STORING ITEMS ###");
                 try {
-                    if (itemsBulkImport != null && !itemsBulkImport.isEmpty()) {
-                        storeItems(itemsBulkImport, regItem, regUser);
-                        LOGGER.info("### END STORING ITEMS WITH SUCCESS ###");
-                        LOGGER.info("###");
-                        if (!operationResult.isEmpty()) {
-                            operationResult = "<b>" + systemLocalization.getString("bulk.import.success") + "</b>" + BR_HTML + systemLocalization.getString("bulk.import.error.solveerrors") + BR_HTML + operationResult;
-                        } else {
-                            operationResult = "<b>" + systemLocalization.getString("bulk.import.success") + "</b>";
+                    ArrayList<String> emptyFields = new ArrayList();
+                    if(itemsBulkImport != null && !itemsBulkImport.isEmpty()) {
+                        try {
+                            //Code for when the action is bulk edit
+                            RegItemManager regItemManager = new RegItemManager(entityManager);
+                            Map.Entry<String, ArrayList<FieldsBulkImport>> any = itemsBulkImport.entrySet().iterator().next();
+                            RegItemclass regItemclassChild = getItemClassChildren(regItem);
+                            RegItem regItemExistentAlready = regItemManager.getByLocalidAndRegItemClass(any.getKey(), regItemclassChild);    
+                        }catch(Exception e){
+                            emptyFields = checkRequired(additionLines, regItem);
                         }
-                        request.setAttribute(BaseConstants.KEY_REQUEST_BULK_SUCCESS, operationResult);
+                        
+                        if(!emptyFields.isEmpty()){
+                            operationResult = "<b>" + systemLocalization.getString("bulk.import.error.emptyrequired")
+                                .replace("{fields}", "<b>" + emptyFields.get(0) + "</b>")
+                                .replace("{line}", "<b>" + emptyFields.get(1) + "</b>")
+                                + "</b>" + BR_HTML + operationResult;
+                            request.setAttribute(BaseConstants.KEY_REQUEST_BULK_ERROR, operationResult);
+                            subject = systemLocalization.getString(BaseConstants.KEY_EMAIL_SUBJECT_BULKIMPORT_ERROR);
+                            body = systemLocalization.getString(BaseConstants.KEY_EMAIL_BODY_BULKIMPORT_ERROR);
+                        }
+                        else{
+                            storeItems(itemsBulkImport, regItem, regUser, request, additionLines);
+                            LOGGER.info("### END STORING ITEMS WITH SUCCESS ###");
+                            LOGGER.info("###");
+                            if (!operationResult.isEmpty()) {
+                                operationResult = "<b>" + systemLocalization.getString("bulk.import.success") + "</b>" + BR_HTML + systemLocalization.getString("bulk.import.error.solveerrors") + BR_HTML + operationResult;
+                            } else {
+                                operationResult = "<b>" + systemLocalization.getString("bulk.import.success") + "</b>";
+                            }
+                            request.setAttribute(BaseConstants.KEY_REQUEST_BULK_SUCCESS, operationResult);
 
-                        subject = systemLocalization.getString(BaseConstants.KEY_EMAIL_SUBJECT_BULKIMPORT_SUCCESS);
-                        body = systemLocalization.getString(BaseConstants.KEY_EMAIL_BODY_BULKIMPORT_SUCCESS);
+                            subject = systemLocalization.getString(BaseConstants.KEY_EMAIL_SUBJECT_BULKIMPORT_SUCCESS);
+                            body = systemLocalization.getString(BaseConstants.KEY_EMAIL_BODY_BULKIMPORT_SUCCESS);
+                        }
+                        
                     }
                 } catch (Exception ex) {
 //                    operationResult = "<b>" + systemLocalization.getString("bulk.import.error.emptyfile") + "</b>" + BR_HTML + operationResult;
@@ -274,20 +324,42 @@ public void processFile(HttpServletRequest request, RegItem regItem, RegUser reg
         MailManager.sendMail(recipient, subject, body);
     }
     
-    private boolean checkRequired(List<String> additionLines, RegItem regItem){
+    private boolean isEdit(RegItem regItem){
+        
+        return false;
+    }
+    
+    private ArrayList<String> checkRequired(List<String> additionLines, RegItem regItem){
         RegFieldmappingManager regFieldmappingManager = new RegFieldmappingManager(entityManager);
         List<RegFieldmapping> regFieldMappingList = new ArrayList<>();
+        ArrayList<String> emptyFields = new ArrayList();
         try{
           RegItemclass regItemclassChild = getItemClassChildren(regItem);  
           regFieldMappingList = regFieldmappingManager.getAll(regItemclassChild);
-          
+          regFieldMappingList.remove(2);
           
           for(int i = 0; i < additionLines.size();i++){
               String[] addLineSplitted = additionLines.get(i).split("\\|", -1);
               List<String> linesListSplitted = new ArrayList<>(Arrays.asList(addLineSplitted));
-              for(int j = 0; j < regFieldMappingList.size(); j++){
-                  if(regFieldMappingList.get(j).getRequired()==true && linesListSplitted.get(i).equalsIgnoreCase("")){
-                      System.out.println("Cascaste");
+              if(linesListSplitted.get(0).equalsIgnoreCase("")){
+                  emptyFields.add("LocalId");
+                  emptyFields.add(Integer.toString(i+1));
+                  return emptyFields;
+              }
+              
+              if(linesListSplitted.get(1).equalsIgnoreCase("")){
+                  emptyFields.add("Language");
+                  emptyFields.add(Integer.toString(i+1));
+                  return emptyFields;
+              }
+              
+              linesListSplitted.remove(1);
+              linesListSplitted.remove(0);
+              for(int j = 0; j < linesListSplitted.size(); j++){
+                  if(regFieldMappingList.get(j).getRequired()==true && linesListSplitted.get(j).equalsIgnoreCase("")){
+                      emptyFields.add(regFieldMappingList.get(j).getRegField().getLocalid());
+                      emptyFields.add(Integer.toString(i+1));
+                      return emptyFields;
                   }
               }
           }
@@ -295,7 +367,7 @@ private boolean checkRequired(List<String> additionLines, RegItem regItem){
             e.printStackTrace();
         }
         
-        return false;
+        return emptyFields;
     }
 
     private String[] readFileFromServletFileUpload(HttpServletRequest request) throws IOException, FileUploadException {
@@ -796,18 +868,23 @@ private void fillMapWithFiledsAndCollectionMapWithFieldsCollection(List<String>
                     }
                 }
             }
+                else{
+                    if (object instanceof RegField) {
+                        RegField field = (RegField) object;
+                    
+                        hashMap.put(field, value);
+                }
+            }
         }
     }
 
-    private void storeItems(HashMap<String, ArrayList<FieldsBulkImport>> itemsBulkImport, RegItem regItemContainer, RegUser regUser) throws Exception {
+    private void storeItems(HashMap<String, ArrayList<FieldsBulkImport>> itemsBulkImport, RegItem regItemContainer, RegUser regUser, HttpServletRequest request, ArrayList<String> additionLines) throws Exception {
         RegItemclass regItemclassChild = getItemClassChildren(regItemContainer);
 
         if (regItemclassChild != null) {
-            RegAction regAction = addRegActionForAllProposedItemsCSV(regUser, regItemContainer, regItemclassChild);
+            RegAction regAction = new RegAction();
             if (regAction != null) {
-
-                storeProposedItems(itemsBulkImport, regItemContainer, regUser, regItemclassChild, regAction);
-
+                storeProposedItems(itemsBulkImport, regItemContainer, regUser, regItemclassChild, regAction, request, additionLines);
                 try {
                     if (!entityManager.getTransaction().isActive()) {
                         entityManager.getTransaction().begin();
@@ -826,38 +903,388 @@ private void storeItems(HashMap<String, ArrayList<FieldsBulkImport>> itemsBulkIm
         }
     }
 
-    private void storeProposedItems(HashMap<String, ArrayList<FieldsBulkImport>> itemsBulkImport, RegItem regItemContainer, RegUser regUser, RegItemclass regItemclassChild, RegAction regAction) throws Exception {
-        for (Map.Entry<String, ArrayList<FieldsBulkImport>> items : itemsBulkImport.entrySet()) {
-            String localId = items.getKey();
+    
+    public void handleBulkRegItemproposedSave(RegUser regUser, Map requestParameters) throws Exception {
 
-            RegItemproposed regItemproposed = createItemProposed(regItemContainer, regItemclassChild, localId, regUser, regAction);
-//            createRegItemProposedRegGroupRegRoleMapping(regItemproposed, regUser);
-            ArrayList<FieldsBulkImport> array = items.getValue();
+        
+        String regItemUuid = (String) requestParameters.get("form_item-uuid");
+        
+        // Getting the RegItem on which the proposal is done
+        RegItem regItem = null;
+        try {
+            RegItemManager regItemManager = new RegItemManager(entityManager);
+            regItem = regItemManager.get(regItemUuid);
+        } catch (NoResultException e) {
+        }
 
-            RegLanguagecodeManager regLanguagecodeManager = new RegLanguagecodeManager(entityManager);
-            RegLanguagecode masterLanguage = regLanguagecodeManager.getMasterLanguage();
+        // Init managers
+        RegItemproposedManager regItemproposedManager = new RegItemproposedManager(entityManager);
 
-            ArrayList<FieldsBulkImport> fieldsBulkImportListLocal = new ArrayList<>();
-            for (FieldsBulkImport fieldsBulkImport : array) {
+        // Check if the RegItemproposed is already available
+        try {
+            RegItemproposed regItemproposed = regItemproposedManager.getByRegItemReference(regItem);
+
+            // Checking the ownership
+            if (!regItemproposed.getRegUser().getUuid().equals(regUser.getUuid())) {
+                // If the user is not the owner of the current RegItemproposed, deny the update
+                throw new UnauthorizedUserException(ExceptionConstants.KEY_EXCEPTION_UNAUTHORIZED_USER_OWNER);
+            }
 
-                RegLanguagecode fieldLanguage = fieldsBulkImport.getLanguage();
+            // The writing operation on the Database are synchronized
+            /* ## Start Synchronized ## */
+            synchronized (sync) {
+                // Update the RegItemproposed
+                if (!entityManager.getTransaction().isActive()) {
+                    entityManager.getTransaction().begin();
+                }
+                updateRegItemproposed(regItemproposed, requestParameters);
+                entityManager.getTransaction().commit();
+            }
+            /* ## End Synchronized ## */
+
+        } catch (NoResultException e) {
+            // If the RegItemproposed is not available, creating it
+
+            // The writing operation on the Database are synchronized
+            /* ## Start Synchronized ## */
+            synchronized (sync) {
+                if (!entityManager.getTransaction().isActive()) {
+                    entityManager.getTransaction().begin();
+                }
+                // Copy the RegItem to the RegItemproposed
+                RegItemproposed regItemproposed = copyRegItemToRegItemproposed(regItem, regUser);
 
-                if (fieldLanguage.equals(masterLanguage)) {
-                    storeItemFromBulk(fieldsBulkImport, regItemContainer, regItemclassChild, regItemproposed, localId, array, fieldLanguage, masterLanguage);
+                // Copy all the regRelations
+                copyRegRelationsToRegRelationproposeds(regItem, regItemproposed);
+
+                // Copy groups relations
+                copyRegItemRegGroupRegRoleMappingToRegItemproposedRegGroupRegRoleMapping(regItem, regItemproposed);
+
+                // Register Federation export
+                String registerFederationExportTmp = (String) requestParameters.get("registerFederationExport");
+                // !!! Sanitizing input
+                String registerFederationExport;
+                boolean registerFederationExportBol;
+
+                if (registerFederationExportTmp != null) {
+                    registerFederationExport = InputSanitizerHelper.sanitizeInput(registerFederationExportTmp);
+                    registerFederationExportBol = (registerFederationExport != null && registerFederationExport.equals(BaseConstants.KEY_BOOLEAN_STRING_TRUE));
                 } else {
-                    fieldsBulkImportListLocal.add(fieldsBulkImport);
+                    registerFederationExportBol = false;
+                }
+
+                if (regItemproposed != null) {
+                    regItemproposed.setRorExport(registerFederationExportBol);
                 }
+
+                // Update the RegFields
+                updateFields(regItemproposed, requestParameters);
+                entityManager.getTransaction().commit();
             }
-            if (!fieldsBulkImportListLocal.isEmpty()) {
-                for (FieldsBulkImport fieldsBulkImport : fieldsBulkImportListLocal) {
-                    RegLanguagecode fieldLanguage = fieldsBulkImport.getLanguage();
-                    storeItemFromBulk(fieldsBulkImport, regItemContainer, regItemclassChild, regItemproposed, localId, array, fieldLanguage, masterLanguage);
+            /* ## End Synchronized ## */
+        } catch (Exception e) {
+            LOGGER.error(e);
+        } finally {
+            if (entityManager != null) {
+                entityManager.close();
+            }
+        }
+    }
+    
+    // Copy all the RegItemRegGroupRegRoleMapping related to the item passed by parameter
+    // to RegItemproposedRegGroupRegRoleMapping
+    private void copyRegItemRegGroupRegRoleMappingToRegItemproposedRegGroupRegRoleMapping(RegItem regItem, RegItemproposed regItemproposed) throws Exception {
+
+        RegItemRegGroupRegRoleMappingManager regItemRegGroupRegRoleMappingManager = new RegItemRegGroupRegRoleMappingManager(entityManager);
+        RegItemproposedRegGroupRegRoleMappingManager regItemproposedRegGroupRegRoleMappingManager = new RegItemproposedRegGroupRegRoleMappingManager(entityManager);
+
+        // Getting all the RegItemRegGroupRegRoleMapping related to that RegItem
+        List<RegItemRegGroupRegRoleMapping> regItemRegGroupRegRoleMappings = regItemRegGroupRegRoleMappingManager.getAll(regItem);
+
+        for (RegItemRegGroupRegRoleMapping tmpRegItemRegGroupRegRoleMapping : regItemRegGroupRegRoleMappings) {
+
+            RegItemproposedRegGroupRegRoleMapping regItemproposedRegGroupRegRoleMapping = new RegItemproposedRegGroupRegRoleMapping();
+            String newUuid = RegItemproposedRegGroupRegRoleMappingUuidHelper.getUuid(regItemproposed.getUuid(), tmpRegItemRegGroupRegRoleMapping.getRegGroup().getUuid(), tmpRegItemRegGroupRegRoleMapping.getRegRole().getUuid());
+
+            regItemproposedRegGroupRegRoleMapping.setUuid(newUuid);
+            regItemproposedRegGroupRegRoleMapping.setRegItemRegGroupRegRoleMappingReference(tmpRegItemRegGroupRegRoleMapping);
+            regItemproposedRegGroupRegRoleMapping.setInsertdate(new Date());
+            regItemproposedRegGroupRegRoleMapping.setRegGroup(tmpRegItemRegGroupRegRoleMapping.getRegGroup());
+            regItemproposedRegGroupRegRoleMapping.setRegItemproposed(regItemproposed);
+            regItemproposedRegGroupRegRoleMapping.setRegRole(tmpRegItemRegGroupRegRoleMapping.getRegRole());
+
+            regItemproposedRegGroupRegRoleMappingManager.add(regItemproposedRegGroupRegRoleMapping);
+        }
+    }
+    
+    // Copy all the RegRelation related to the item passed by parameter and all the
+    // RegLocalization to RegRelationproposed and RegLocalizationproposed
+    private void copyRegRelationsToRegRelationproposeds(RegItem regItem, RegItemproposed regItemproposed) throws Exception {
+
+        RegRelationManager regRelationManager = new RegRelationManager(entityManager);
+        RegLocalizationManager regLocalizationManager = new RegLocalizationManager(entityManager);
+        RegRelationproposedManager regRelationproposedManager = new RegRelationproposedManager(entityManager);
+        RegLocalizationproposedManager regLocalizationproposedManager = new RegLocalizationproposedManager(entityManager);
+
+        // Getting all the relations related to that object
+        List<RegRelation> regRelations = regRelationManager.getAllBySubject(regItem);
+
+        // Copying RegRelations to RegRelationProposeds
+        HashMap<String, RegRelationproposed> tempHashmap = new HashMap();
+
+        for (RegRelation regRelation : regRelations) {
+
+            RegRelationproposed regRelationproposed = new RegRelationproposed();
+            String regRelationproposedUuid = RegRelationproposedUuidHelper.getUuid(regItemproposed, null, regRelation.getRegRelationpredicate(), null, regRelation.getRegItemObject());
+
+            regRelationproposed.setUuid(regRelationproposedUuid);
+            regRelationproposed.setRegItemSubject(null);
+            regRelationproposed.setRegItemproposedSubject(regItemproposed);
+            regRelationproposed.setRegItemObject(regRelation.getRegItemObject());
+            regRelationproposed.setRegItemproposedObject(null);
+            regRelationproposed.setRegRelationReference(regRelation);
+            regRelationproposed.setRegRelationpredicate(regRelation.getRegRelationpredicate());
+            regRelationproposed.setInsertdate(new Date());
+
+            regRelationproposedManager.add(regRelationproposed);
+
+            tempHashmap.put(regRelation.getUuid(), regRelationproposed);
+        }
+
+        // Replicating the relevant Reglocalizationproposeds pointing to the 
+        //  RegRelationproposed copyied above
+        // Getting all the localization with a reference to a reg relation 
+        // related to the current RegItem
+        List<RegLocalization> regLocalizations = regLocalizationManager.getAllWithRelationReference(regItem);
+        for (RegLocalization regLocalization : regLocalizations) {
+            // Creating the regLocalizationproposed for the regRelationreference
+            RegLocalizationproposed regLocalizationproposed = new RegLocalizationproposed();
+            String newUuid = RegLocalizationproposedUuidHelper.getUuid(regLocalization.getFieldValueIndex(), regLocalization.getRegLanguagecode(), regItemproposed, regLocalization.getRegField());
+            regLocalizationproposed.setUuid(newUuid);
+            regLocalizationproposed.setFieldValueIndex(regLocalization.getFieldValueIndex());
+            regLocalizationproposed.setHref(regLocalization.getHref());
+            regLocalizationproposed.setRegField(regLocalization.getRegField());
+            regLocalizationproposed.setRegItemproposed(regItemproposed);
+            regLocalizationproposed.setRegLanguagecode(regLocalization.getRegLanguagecode());
+            regLocalizationproposed.setRegLocalizationReference(regLocalization);
+            regLocalizationproposed.setRegRelationproposedReference(tempHashmap.get(regLocalization.getRegRelationReference().getUuid()));
+            regLocalizationproposed.setValue(regLocalization.getValue());
+            regLocalizationproposed.setInsertdate(new Date());
+            regLocalizationproposed.setRegAction(regItemproposed.getRegAction());
+
+            regLocalizationproposedManager.add(regLocalizationproposed);
+        }
+    }
+    
+    /* -- Supporting methods -- */
+    // Create the new RegItemproposed
+    private RegItemproposed copyRegItemToRegItemproposed(RegItem regItem, RegUser regUser) throws Exception {
+        if (regItem != null) {
+            // Init managers
+            RegItemproposedManager regItemproposedManager = new RegItemproposedManager(entityManager);
+            RegStatusManager regStatusManager = new RegStatusManager(entityManager);
+            RegRelationpredicateManager regRelationpredicateManager = new RegRelationpredicateManager(entityManager);
+
+            // Getting the eventual collection relation
+            RegRelationManager regRelationManager = new RegRelationManager(entityManager);
+            RegRelationpredicate regRelationpredicateRegistry = regRelationpredicateManager.get(BaseConstants.KEY_PREDICATE_REGISTRY);
+            RegRelationpredicate regRelationpredicateRegister = regRelationpredicateManager.get(BaseConstants.KEY_PREDICATE_REGISTER);
+            RegRelationpredicate regRelationpredicateCollection = regRelationpredicateManager.get(BaseConstants.KEY_PREDICATE_COLLECTION);
+            List<RegRelation> regRelationCollections = regRelationManager.getAll(regItem, regRelationpredicateCollection);
+            RegRelation regRelationCollection = null;
+            if (!regRelationCollections.isEmpty()) {
+                // Every items can have just one relation of type collection
+                regRelationCollection = regRelationCollections.get(0);
+            }
+
+            // Setting the register
+            RegItem regItemRegister;
+            if (!regItem.getRegItemclass().getRegItemclasstype().getLocalid().equals(BaseConstants.KEY_ITEMCLASS_TYPE_REGISTER)) {
+                List<RegRelation> regRelationRegisters = regRelationManager.getAll(regItem, regRelationpredicateRegister);
+                try {
+                    regItemRegister = regRelationRegisters.get(0).getRegItemObject();
+                } catch (Exception e2) {
+                    regItemRegister = null;
                 }
+            } else {
+                regItemRegister = regItem;
+            }
 
+            // Setting the registry
+            RegItem regItemRegistry;
+            if (!regItem.getRegItemclass().getRegItemclasstype().getLocalid().equals(BaseConstants.KEY_ITEMCLASS_TYPE_REGISTRY)) {
+                List<RegRelation> regRelationRegistries = regRelationManager.getAll(regItem, regRelationpredicateRegistry);
+                try {
+                    regItemRegistry = regRelationRegistries.get(0).getRegItemObject();
+
+                } catch (Exception e2) {
+                    regItemRegistry = null;
+                }
+            } else {
+                regItemRegistry = regItem;
             }
 
+            // Getting the reg status draft for the proposed item
+            RegStatus regStatusDraft = regStatusManager.findByLocalid(BaseConstants.KEY_STATUS_LOCALID_DRAFT);
+
+            //Copying it to the RegItemproposed
+            RegItemproposed regItemproposed = new RegItemproposed();
+
+            String itemProposedUuid = RegItemproposedUuidHelper.getUuid(regItem.getLocalid(), ((regRelationCollection != null) ? regRelationCollection.getRegItemObject() : null), regItem.getRegItemclass(), regItem);
+            regItemproposed.setUuid(itemProposedUuid);
+            regItemproposed.setLocalid(regItem.getLocalid());
+            regItemproposed.setRegStatus(regStatusDraft);
+            regItemproposed.setRegItemclass(regItem.getRegItemclass());
+            regItemproposed.setInsertdate(regItem.getInsertdate());
+            regItemproposed.setRegUser(regUser);
+            regItemproposed.setRorExport(regItem.getRorExport());
+            regItemproposed.setRegItemReference(regItem);
+
+            // Check if the related RegAction is already available, otherwise
+            // create the RegAction.
+            RegAction regAction = regActionCheck(regUser, regItemRegister, regItemRegistry);
+
+            regItemproposed.setRegAction(regAction);
+
+            // Saving the RegItemproposed
+            regItemproposedManager.add(regItemproposed);
+
+            return regItemproposed;
+        } else {
+            return null;
         }
+    }
+    
+    private RegAction regActionCheck(RegUser regUser, RegItem regItemRegister, RegItem regItemRegistry) throws Exception {
+        RegAction regAction = null;
+
+        RegActionManager regActionManager = new RegActionManager(entityManager);
+        RegStatusManager regStatusManager = new RegStatusManager(entityManager);
+        RegLocalizationManager regLocalizationManager = new RegLocalizationManager(entityManager);
+        RegFieldManager regFieldManager = new RegFieldManager(entityManager);
+        RegLanguagecodeManager regLanguagecodeManager = new RegLanguagecodeManager(entityManager);
+        RegLanguagecode masterLanguage = regLanguagecodeManager.getMasterLanguage();
+
+        ResourceBundle systemLocalization = Configuration.getInstance().getLocalization();
+
+        List<RegAction> regActions;
+        RegStatus regStatus;
 
+        // Getting the RegStatus draft, to check that there are not other RegAction
+        // dratf from the same user
+        regStatus = regStatusManager.findByLocalid(BaseConstants.KEY_STATUS_LOCALID_DRAFT);
+
+        boolean notFound = false;
+
+        // checking if the RegAction is available
+        try {
+            regActions = regActionManager.getAllWithNoComments(regUser, regItemRegister, regItemRegistry, regStatus);
+            if (regActions != null && regActions.isEmpty()) {
+                notFound = true;
+            } else if (regActions != null) {
+                // There should be only one regAction in status draft with 
+                // no comments per each user. 
+                regAction = regActions.get(0);
+            }
+        } catch (NoResultException e) {
+            notFound = true;
+        }
+
+        // Creating the RegAction if not found
+        if (notFound) {
+
+            regAction = new RegAction();
+            Date currentDate = new Date();
+            String newUuid = RegActionUuidHelper.getUuid(regUser, currentDate);
+
+            // Creating the default label
+            RegItem regItemcheck = (regItemRegister != null) ? regItemRegister : regItemRegistry;
+            List<RegLocalization> regLocalization = regLocalizationManager.getAll(regFieldManager.getTitleRegField(), regItemcheck, masterLanguage);
+            String defaultLabel = systemLocalization.getString("label.actionon") + " " + regLocalization.get(0).getValue();
+
+            regAction.setUuid(newUuid);
+            regAction.setLabel(defaultLabel);
+            regAction.setInsertdate(currentDate);
+            regAction.setRegUser(regUser);
+            regAction.setChangeRequest(null);
+            regAction.setRejectMessage(null);
+            regAction.setIssueTrackerLink(null);
+            regAction.setRegStatus(regStatus);
+            regAction.setChangesImplemented(false);
+            regAction.setRegItemRegister(regItemRegister);
+            regAction.setRegItemRegistry(regItemRegistry);
+
+            regActionManager.add(regAction);
+
+        }
+
+        return regAction;
+    }
+
+    
+    /**
+     * DELETE THIS METHOD ENEKO
+     * @param itemsBulkImport
+     * @param regItemContainer
+     * @param regUser
+     * @param regItemclassChild
+     * @param regAction
+     * @param request
+     * @throws Exception 
+     */
+    private void storeProposedItems(HashMap<String, ArrayList<FieldsBulkImport>> itemsBulkImport, RegItem regItemContainer, RegUser regUser, RegItemclass regItemclassChild, RegAction regAction, HttpServletRequest request, ArrayList<String> additionLines) throws Exception {
+        RegItemManager regItemManager = new RegItemManager(entityManager);
+        RegItemproposed regItemproposed = null;
+        RegItemproposedHandler regItemproposedHandler = new RegItemproposedHandler();
+        Boolean bulkEdit = false;
+        
+        try {
+        //Code for when the action is bulk edit
+        Map.Entry<String, ArrayList<FieldsBulkImport>> any = itemsBulkImport.entrySet().iterator().next();
+        //String regItemExistentAlready = RegItemUuidHelper.getUuid(localId, regItemContainer, regItemclassChild);
+        RegItem regItemExistentAlready = regItemManager.getByLocalidAndRegItemClass(any.getKey(), regItemclassChild);
+        bulkEdit = true;
+        for (Map.Entry<String, ArrayList<FieldsBulkImport>> items : itemsBulkImport.entrySet()) {
+            try {
+                //String regItemExistentAlready = RegItemUuidHelper.getUuid(localId, regItemContainer, regItemclassChild);
+                if (regItemExistentAlready != null) {
+                    items.getValue().get(0).getRegFieldsHashMap().values();
+                    HashMap<RegField, String> fields = items.getValue().get(0).getRegFieldsHashMap();
+                    RegItem regItemIterator = regItemManager.getByLocalidAndRegItemClass(items.getKey(), regItemclassChild);
+                    regItemproposedHandler.completeCopyRegItemToRegItemporposedBulkEdit(regItemIterator, regUser, fields);
+                }
+            } catch (Exception ex) {
+
+            }
+        }
+        //Code for when the action is bulk import
+        } catch (Exception e) {
+            for (Map.Entry<String, ArrayList<FieldsBulkImport>> items : itemsBulkImport.entrySet()) {
+                String localId = items.getKey();
+                regItemproposed = createItemProposed(regItemContainer, regItemclassChild, localId, regUser, regAction, request);
+                ArrayList<FieldsBulkImport> array = items.getValue();
+
+                RegLanguagecodeManager regLanguagecodeManager = new RegLanguagecodeManager(entityManager);
+                RegLanguagecode masterLanguage = regLanguagecodeManager.getMasterLanguage();
+
+                ArrayList<FieldsBulkImport> fieldsBulkImportListLocal = new ArrayList<>();
+                for (FieldsBulkImport fieldsBulkImport : array) {
+                    RegLanguagecode fieldLanguage = fieldsBulkImport.getLanguage();
+                    if (fieldLanguage.equals(masterLanguage)) {
+                        storeItemFromBulk(fieldsBulkImport, regItemContainer, regItemclassChild, regItemproposed, localId, array, fieldLanguage, masterLanguage);
+                    } else {
+                        fieldsBulkImportListLocal.add(fieldsBulkImport);
+                    }
+                }
+                
+                if (!fieldsBulkImportListLocal.isEmpty()) {
+                    for (FieldsBulkImport fieldsBulkImport : fieldsBulkImportListLocal) {
+                        RegLanguagecode fieldLanguage = fieldsBulkImport.getLanguage();
+                        storeItemFromBulk(fieldsBulkImport, regItemContainer, regItemclassChild, regItemproposed, localId, array, fieldLanguage, masterLanguage);
+                    }
+                }
+            }
+        }
     }
 
     private void storeItemFromBulk(FieldsBulkImport fieldsBulkImport, RegItem regItemContainer, RegItemclass regItemclassChild, RegItemproposed regItemproposed, String localId, ArrayList<FieldsBulkImport> array, RegLanguagecode fieldLanguage, RegLanguagecode masterLanguage) throws Exception {
@@ -892,21 +1319,34 @@ private void storeItemFromBulk(FieldsBulkImport fieldsBulkImport, RegItem regIte
         }
     }
 
-    private RegItemproposed createItemProposed(RegItem regItemContainer, RegItemclass regItemclassChild, String localId, RegUser regUser, RegAction regAction) throws Exception {
+    private RegItemproposed createItemProposed(RegItem regItemContainer, RegItemclass regItemclassChild, String localId, RegUser regUser, RegAction regAction, HttpServletRequest request) throws Exception {
         RegItemManager regItemManager = new RegItemManager(entityManager);
         RegItemproposed regItemproposed = null;
+        
+       
         try {
-            //            check if item exist already, if yes copy the item in itemproposed
-            String regItemExistentUuid;
-            if (regItemContainer.getRegItemclass().equals(regItemclassChild)) {
-                regItemExistentUuid = RegItemUuidHelper.getUuid(localId, regItemContainer, regItemclassChild);
-            } else {
-                regItemExistentUuid = RegItemUuidHelper.getUuid(localId, null, regItemclassChild);
-            }
-            RegItem regItemExist = regItemManager.get(regItemExistentUuid);
+            //String regItemExistentAlready = RegItemUuidHelper.getUuid(localId, regItemContainer, regItemclassChild);
+            RegItem regItemExistentAlready = regItemManager.getByLocalidAndRegItemClass(localId, regItemclassChild);
+            if(regItemExistentAlready != null){
+                //            check if item exist already, if yes copy the item in itemproposed
+                String regItemExistentUuid;
+                if (regItemContainer.getRegItemclass().equals(regItemclassChild)) {
+                    regItemExistentUuid = RegItemUuidHelper.getUuid(localId, regItemContainer, regItemclassChild);
+                } else {
+                    regItemExistentUuid = RegItemUuidHelper.getUuid(localId, null, regItemclassChild);
+                }
+                RegItem regItemExist = regItemManager.get(regItemExistentUuid);
 
-            RegItemproposedHandler regItemproposedHandler = new RegItemproposedHandler();
-            regItemproposed = regItemproposedHandler.completeCopyRegItemToRegItemporposed(regItemExist, regUser);
+                RegItemproposedHandler regItemproposedHandler = new RegItemproposedHandler();
+                regItemproposed = regItemproposedHandler.completeCopyRegItemToRegItemporposed(regItemExist, regUser); 
+            }
+            
+            else{
+               regItemproposed = createRegItemProposed(localId, regItemclassChild, regUser, regAction);
+               addRegistryRegisterRelation(regItemContainer, regItemproposed);
+               addCollectionRelation(regItemContainer, regItemproposed);
+            }
+            
 
         } catch (Exception ex) {
 //                    create propose item
@@ -916,6 +1356,501 @@ private RegItemproposed createItemProposed(RegItem regItemContainer, RegItemclas
         }
         return regItemproposed;
     }
+    
+    public void handleRegItemproposedNewSave(Map requestParameters, RegUser regUser) throws Exception {
+
+        // Getting the ID of the RegItem (original item)
+        String[] regItemUuidTmp = (String[]) requestParameters.get(BaseConstants.KEY_REQUEST_FORM_ITEMUUID);
+        // !!! Sanitizing input
+        String regItemUuid = InputSanitizerHelper.sanitizeInput(regItemUuidTmp[0]);
+
+        // Init managers
+        RegItemproposedManager regItemproposedManager = new RegItemproposedManager(entityManager);
+
+        // Getting the RegItem on which the proposal is done
+        RegItemproposed regItemproposed = null;
+        try {
+            regItemproposed = regItemproposedManager.get(regItemUuid);
+        } catch (NoResultException e) {
+        }
+
+        // Check if the RegItemproposed is already available
+        try {
+
+            // Checking the ownership
+            if (regItemproposed != null && !regItemproposed.getRegUser().getUuid().equals(regUser.getUuid())) {
+                // If the user is not the owner of the current RegItemproposed, deny the update
+                throw new UnauthorizedUserException(ExceptionConstants.KEY_EXCEPTION_UNAUTHORIZED_USER_OWNER);
+            }
+
+            // The writing operation on the Database are synchronized
+            /* ## Start Synchronized ## */
+            synchronized (sync) {
+                // Update the RegItemproposed
+                if (!entityManager.getTransaction().isActive()) {
+                    entityManager.getTransaction().begin();
+                }
+                updateRegItemproposed(regItemproposed, requestParameters);
+                entityManager.getTransaction().commit();
+            }
+            /* ## End Synchronized ## */
+
+        } catch (NoResultException e) {
+        } finally {
+            if (entityManager != null) {
+                entityManager.close();
+            }
+        }
+    }
+    
+    // Update an existing RegItemproposed
+    private void updateRegItemproposed(RegItemproposed regItemproposed, Map requestParameters) throws Exception {
+
+        //Updating the regItemproposed edit date
+        regItemproposed.setEditdate(new Date());
+
+        // Register Federation export
+        String[] registerFederationExportTmp = (String[]) requestParameters.get(BaseConstants.KEY_FORM_FIELD_NAME_REGISTERFEDERATIONEXPORT);
+        // !!! Sanitizing input
+        String registerFederationExport;
+        boolean registerFederationExportBol;
+
+        if (registerFederationExportTmp != null) {
+            registerFederationExport = InputSanitizerHelper.sanitizeInput(registerFederationExportTmp[0]);
+            registerFederationExportBol = (registerFederationExport != null && registerFederationExport.equals(BaseConstants.KEY_BOOLEAN_STRING_TRUE));
+        } else {
+            registerFederationExportBol = false;
+        }
+
+        regItemproposed.setRorExport(registerFederationExportBol);
+
+        // Updating fields
+        updateFields(regItemproposed, requestParameters);
+
+    }
+    
+     // Update fields
+    private String updateFields(RegItemproposed regItemproposed, Map requestParameters) throws Exception {
+
+        // Init variables        
+        Set s = requestParameters.entrySet();
+        Iterator it = s.iterator();
+        String regLanguagecodeUuidTemp = (String) requestParameters.get("languagecodeUuid");
+        // !!! Sanitizing input
+        String regLanguagecodeUuid = InputSanitizerHelper.sanitizeInput(regLanguagecodeUuidTemp);
+
+        // Init managers
+        RegFieldmappingManager regFieldmappingManager = new RegFieldmappingManager(entityManager);
+        RegLocalizationproposedManager regLocalizationproposedManager = new RegLocalizationproposedManager(entityManager);
+        RegLocalizationManager regLocalizationManager = new RegLocalizationManager(entityManager);
+        RegLanguagecodeManager regLanguagecodeManager = new RegLanguagecodeManager(entityManager);
+
+        // Getting the reg languagecode of the current edited field
+        RegLanguagecode regLanguagecode = regLanguagecodeManager.get(regLanguagecodeUuid);
+        RegLanguagecode masterLanguage = regLanguagecodeManager.getMasterLanguage();
+
+        // Errors string
+        String errors = "";
+
+        // Iterate on all the form fields
+        while (it.hasNext()) {
+
+            Map.Entry<String, String[]> entry = (Map.Entry<String, String[]>) it.next();
+
+            // ** Each field is univocally numbered: in this way there are no field 
+            // in the request with more than one value **
+            // This is better to keep the consistency with right value since with
+            // fields with the same name and multi values different browsers may
+            // have different implementation on the handling of the index/order of the value
+            String key = entry.getKey();
+            String[] tmp = processFieldName(key);
+            String fieldUuid = tmp[0];
+
+            String referenceRegLocalizationUuid = tmp[2];
+
+            // Getting the value
+
+            String[] values = entry.getValue();
+            String value = values[0];
+
+            // Handling charset            
+            byte[] bytes = value.getBytes(Charset.defaultCharset());
+            value = new String(bytes, StandardCharsets.UTF_8);
+
+            // !!! Sanitizing form input
+            value = (value.length() == 0) ? "" : InputSanitizerHelper.sanitizeInput(value);
+
+            // Getting the eventual href
+            String hrefFieldName = processFieldHrefName(key);
+            String[] paramHrefs = (String[]) requestParameters.get(hrefFieldName);
+            String href = "";
+            if (paramHrefs != null) {
+                //For each value there is just one link
+                href = paramHrefs[0];
+                // !!! Sanitizing form input
+                href = InputSanitizerHelper.sanitizeInput(href);
+            }
+
+            try {
+                // Getting the current regFieldMapping
+                RegFieldmapping regFieldmapping = regFieldmappingManager.get(fieldUuid);
+
+                // Getting the RegField
+                RegField regField = regFieldmapping.getRegField();
+
+                // Handling the RelationReference case
+                if (regField.getRegFieldtype().getLocalid().equals(BaseConstants.KEY_FIELD_TYPE_RELATION)) {
+                    if (value.trim().length() > 0) {
+                        RegItemManager regItemManager = new RegItemManager(entityManager);
+                        RegRelationproposedManager regRelationproposedManager = new RegRelationproposedManager(entityManager);
+                        RegRelationpredicateManager regRelationpredicateManager = new RegRelationpredicateManager(entityManager);
+
+                        // Getting the right RegRelationPredicate
+                        RegRelationpredicate regRelationPredicateRealtion = regRelationpredicateManager.get(BaseConstants.KEY_PREDICATE_REFERENCE);
+
+                        // Getting the RegItem pointed by the relation
+                        RegItem regItemRelation = regItemManager.get(value);
+
+                        // Creating the new RegRelationproposed
+                        String newRegRelationproposedUuid = RegRelationproposedUuidHelper.getUuid(regItemproposed, null, regRelationPredicateRealtion, null, regItemRelation);
+                        RegRelationproposed newRegRelationproposed = new RegRelationproposed();
+                        newRegRelationproposed.setInsertdate(new Date());
+                        newRegRelationproposed.setRegItemproposedSubject(regItemproposed);
+                        newRegRelationproposed.setRegRelationpredicate(regRelationPredicateRealtion);
+                        newRegRelationproposed.setRegItemObject(regItemRelation);
+                        newRegRelationproposed.setUuid(newRegRelationproposedUuid);
+
+                        // Adding the newly created RegRelationproposed
+                        regRelationproposedManager.add(newRegRelationproposed);
+
+                        // Creating the new RegLocalizationproposed
+                        RegLocalizationproposed regLocalizationproposed = new RegLocalizationproposed();
+
+                        // Getting the new fieldValueIndex (max of the field index
+                        // of the localizations for the current field)
+                        List<RegLocalizationproposed> tmpLocalizations = regLocalizationproposedManager.getAll(regField, regItemproposed, regLanguagecode);
+                        int fieldValueIndexNew = -1;
+                        for (RegLocalizationproposed tmpRegLocalization : tmpLocalizations) {
+                            if (tmpRegLocalization.getFieldValueIndex() > fieldValueIndexNew) {
+                                fieldValueIndexNew = tmpRegLocalization.getFieldValueIndex();
+                            }
+                        }
+                        fieldValueIndexNew++;
+
+                        // Creating the new uuid
+                        String regLocalizationproposedUuid = "";
+                        regLocalizationproposedUuid = RegLocalizationproposedUuidHelper.getUuid(fieldValueIndexNew, masterLanguage, regItemproposed, regField);
+
+                        // Setting fields
+                        regLocalizationproposed.setUuid(regLocalizationproposedUuid);
+                        regLocalizationproposed.setRegItemproposed(regItemproposed);
+                        regLocalizationproposed.setRegField(regField);
+                        regLocalizationproposed.setInsertdate(new Date());
+                        regLocalizationproposed.setFieldValueIndex(fieldValueIndexNew);
+
+                        regLocalizationproposed.setRegLanguagecode(masterLanguage);
+
+                        regLocalizationproposed.setValue(null);
+                        regLocalizationproposed.setHref(null);
+
+                        regLocalizationproposed.setRegRelationproposedReference(newRegRelationproposed);
+
+                        regLocalizationproposed.setRegAction(regItemproposed.getRegAction());
+
+                        RegLocalization tmpRegLocalizationReference = null;
+                        if (!regFieldmapping.getMultivalue()) {
+                            // Check if there is a null value to remove for this regField
+                            List<RegLocalizationproposed> nullpRegLocalizationproposeds = regLocalizationproposedManager.getAllNull(regField, regItemproposed);
+                            for (RegLocalizationproposed tmpRegLocalizationProposed : nullpRegLocalizationproposeds) {
+                                tmpRegLocalizationReference = tmpRegLocalizationProposed.getRegLocalizationReference();
+                                regLocalizationproposedManager.delete(tmpRegLocalizationProposed);
+                            }
+                        }
+
+                        if (tmpRegLocalizationReference != null) {
+                            regLocalizationproposed.setRegLocalizationReference(tmpRegLocalizationReference);
+                        }
+
+                        // Saving the RegLocalizationproposed
+                        regLocalizationproposedManager.add(regLocalizationproposed);
+                    }
+
+                } else if (regField.getRegFieldtype().getLocalid().equals(BaseConstants.KEY_FIELD_TYPE_PARENT)) {
+                    // Handling the Parent case
+                    if (value.trim().length() > 0) {
+                        RegItemManager regItemManager = new RegItemManager(entityManager);
+                        RegRelationproposedManager regRelationproposedManager = new RegRelationproposedManager(entityManager);
+                        RegRelationpredicateManager regRelationpredicateManager = new RegRelationpredicateManager(entityManager);
+
+                        // Getting the right RegRelationPredicate
+                        RegRelationpredicate regRelationPredicateRealtion = regRelationpredicateManager.get(BaseConstants.KEY_PREDICATE_PARENT);
+
+                        // Getting the RegItem pointed by the relation
+                        RegItem regItemRelation = regItemManager.get(value);
+
+                        // Creating the new RegRelationproposed
+                        String newRegRelationproposedUuid = RegRelationproposedUuidHelper.getUuid(regItemproposed, null, regRelationPredicateRealtion, null, regItemRelation);
+                        RegRelationproposed newRegRelationproposed = new RegRelationproposed();
+                        newRegRelationproposed.setInsertdate(new Date());
+                        newRegRelationproposed.setRegItemproposedSubject(regItemproposed);
+                        newRegRelationproposed.setRegRelationpredicate(regRelationPredicateRealtion);
+                        newRegRelationproposed.setRegItemObject(regItemRelation);
+                        newRegRelationproposed.setUuid(newRegRelationproposedUuid);
+
+                        // Adding the newly created RegRelationproposed
+                        regRelationproposedManager.add(newRegRelationproposed);
+
+                    }
+                } else if (regField.getRegFieldtype().getLocalid().equals(BaseConstants.KEY_FIELD_TYPE_GROUP)) {
+                    // Handling the group case
+                    if (value.trim().length() > 0) {
+                        RegItemproposedRegGroupRegRoleMappingManager regItemproposedRegGroupRegRoleMappingManager = new RegItemproposedRegGroupRegRoleMappingManager(entityManager);
+                        String newUuid = RegItemproposedRegGroupRegRoleMappingUuidHelper.getUuid(regItemproposed.getUuid(), value, regFieldmapping.getRegField().getRegRoleReference().getUuid());
+
+                        try {
+                            // Check if the mapping is already available
+                            regItemproposedRegGroupRegRoleMappingManager.get(newUuid);
+
+                        } catch (NoResultException e) {
+
+                            //Getting the reg group passed from parameter
+                            RegGroupManager regGroupManager = new RegGroupManager(entityManager);
+                            RegGroup regGroup = null;
+                            try {
+                                regGroup = regGroupManager.get(value);
+
+                                RegItemproposedRegGroupRegRoleMapping regItemproposedRegGroupRegRoleMapping = new RegItemproposedRegGroupRegRoleMapping();
+                                regItemproposedRegGroupRegRoleMapping.setUuid(newUuid);
+                                regItemproposedRegGroupRegRoleMapping.setInsertdate(new Date());
+                                regItemproposedRegGroupRegRoleMapping.setRegGroup(regGroup);
+                                regItemproposedRegGroupRegRoleMapping.setRegItemproposed(regItemproposed);
+                                regItemproposedRegGroupRegRoleMapping.setRegRole(regFieldmapping.getRegField().getRegRoleReference());
+
+                                regItemproposedRegGroupRegRoleMappingManager.add(regItemproposedRegGroupRegRoleMapping);
+
+                            } catch (NoResultException e1) {
+                            }
+                        }
+                    }
+                } else {
+
+                    // Check if the RegLocalizationproposed for the specific language is already there
+                    RegLocalization regLocalizationReference = null;
+                    try {
+                        RegLocalizationproposed regLocalizationproposed;
+
+                        // If the reference to the RegLocalizationReference is available,
+                        // checking if the related regLocalizationproposed is available
+                        try {
+                            if (referenceRegLocalizationUuid == null) {
+                                throw new NoResultException();
+                            }
+
+                            regLocalizationReference = regLocalizationManager.get(referenceRegLocalizationUuid);
+                            regLocalizationproposed = regLocalizationproposedManager.getByRegLocalizationReferenceAndLanguage(regLocalizationReference, regLanguagecode);
+
+                            // In case the current language is not the master language,
+                            // search for eventual RegLocalization proposed in that language
+                            if (!regLanguagecode.getMasterlanguage()) {
+                                regLocalizationproposed = getRegLocalizationproposedInCurrentLanguage(regLocalizationproposed, regLocalizationproposedManager, regLanguagecode);
+                            }
+
+                        } catch (NoResultException ex) {
+                            if (referenceRegLocalizationUuid == null) {
+                                throw new NoResultException();
+                            }
+                            // Otherwise, the reference to the RegLocalizationproposed
+                            // is stored in the same field name fragment: checking if a
+                            /// new RegLocalizationproposed is already in the db
+                            regLocalizationproposed = regLocalizationproposedManager.get(referenceRegLocalizationUuid);
+
+                            // In case the current language is not the master language,
+                            // search for eventual RegLocalization proposed in that language
+                            if (!regLanguagecode.getMasterlanguage()) {
+                                regLocalizationproposed = getRegLocalizationproposedInCurrentLanguage(regLocalizationproposed, regLocalizationproposedManager, regLanguagecode);
+                            }
+
+                            // If a new Localizationproposed is in the DB, removing the eventual
+                            // reference to the RegLocalization and setting it to null because in this
+                            // case it is not representing the related RegLocalization
+                            regLocalizationReference = null;
+                        }
+
+                        // Checking if the field has been changed and needs to be updated
+                        if ((regLocalizationproposed.getValue() == null && value != null && value.length() != 0) || (regLocalizationproposed.getValue() != null && !regLocalizationproposed.getValue().equals(value)) || (regFieldmapping.getHashref() && regLocalizationproposed.getHref() != null && !regLocalizationproposed.getHref().equals(href)) || (regFieldmapping.getHashref() && regLocalizationproposed.getHref() == null && href != null && href.length() > 0)) {
+
+                            // Setting the values in the new RegLocalizationproposed
+                            regLocalizationproposed.setValue(value);
+
+                            // Updating the href if the RegFieldmapping has also the href
+                            if (regFieldmapping.getHashref()) {
+                                regLocalizationproposed.setHref((href != null && href.length() > 0) ? href : null);
+                            }
+
+                            // Setting the RegLocalization reference (if available)
+                            if (regLocalizationReference != null) {
+                                regLocalizationproposed.setRegLocalizationReference(regLocalizationReference);
+                            }
+
+                            regLocalizationproposed.setRegAction(regItemproposed.getRegAction());
+
+                            regLocalizationproposedManager.add(regLocalizationproposed);
+                        }
+
+                    } // If the RegLocalizationproposed is not there copy and create it
+                    // in the RegLocalizationproposed
+                    catch (NoResultException e) {
+
+                        // Getting the eventual regLocalization reference
+                        if (referenceRegLocalizationUuid != null) {
+                            try {
+                                regLocalizationReference = regLocalizationManager.get(referenceRegLocalizationUuid);
+                            } catch (NoResultException nr) {
+                                regLocalizationReference = null;
+                            }
+                        } else {
+                            regLocalizationReference = null;
+                        }
+
+                        if (value == null || (value != null && value.length() < 0)) {
+                            value = "";
+                        }
+
+                        RegLocalizationproposed regLocalizationproposed = new RegLocalizationproposed();
+
+                        // Getting the new fieldValueIndex (max of the field index
+                        // of the localizations for the current field)
+                        List<RegLocalizationproposed> tmpLocalizations = regLocalizationproposedManager.getAll(regField, regItemproposed, regLanguagecode);
+                        int fieldValueIndexNew = -1;
+                        for (RegLocalizationproposed tmpRegLocalization : tmpLocalizations) {
+                            if (tmpRegLocalization.getFieldValueIndex() > fieldValueIndexNew) {
+                                fieldValueIndexNew = tmpRegLocalization.getFieldValueIndex();
+                            }
+                        }
+                        fieldValueIndexNew++;
+
+                        // Creating the new uuid
+                        String regLocalizationproposedUuid = "";
+                        // If the regFieldType of the current field is number or date,
+                        // the element is stored only in the master language
+                        if (regField.getRegFieldtype().getLocalid().equals(BaseConstants.KEY_FIELD_TYPE_NUMBER) || regField.getRegFieldtype().getLocalid().equals(BaseConstants.KEY_FIELD_TYPE_DATE)) {
+                            regLocalizationproposedUuid = RegLocalizationproposedUuidHelper.getUuid(fieldValueIndexNew, masterLanguage, regItemproposed, regField);
+                        } else {
+                            regLocalizationproposedUuid = RegLocalizationproposedUuidHelper.getUuid(fieldValueIndexNew, regLanguagecode, regItemproposed, regField);
+                        }
+
+                        // Setting fields
+                        regLocalizationproposed.setUuid(regLocalizationproposedUuid);
+                        regLocalizationproposed.setRegItemproposed(regItemproposed);
+                        regLocalizationproposed.setRegField(regField);
+                        regLocalizationproposed.setInsertdate(new Date());
+                        regLocalizationproposed.setFieldValueIndex(fieldValueIndexNew);
+                        regLocalizationproposed.setRegAction(regItemproposed.getRegAction());
+
+                        // If the regFieldType of the current field is number or date,
+                        // the element is stored only in the master language 
+                        if (regField.getRegFieldtype().getLocalid().equals(BaseConstants.KEY_FIELD_TYPE_NUMBER) || regField.getRegFieldtype().getLocalid().equals(BaseConstants.KEY_FIELD_TYPE_DATE)) {
+                            regLocalizationproposed.setRegLanguagecode(masterLanguage);
+                        } else {
+                            regLocalizationproposed.setRegLanguagecode(regLanguagecode);
+                        }
+
+                        // Setting the RegLocalization refderence (if available)
+                        if (regLocalizationReference != null) {
+                            regLocalizationproposed.setRegLocalizationReference(regLocalizationReference);
+                        }
+
+                        //Setting the value
+                        regLocalizationproposed.setValue(value);
+
+                        // Setting the href if the RegFieldmapping has also the href
+                        if (regFieldmapping.getHashref()) {
+                            regLocalizationproposed.setHref((href != null && href.length() > 0) ? href : null);
+                        }
+
+                        // Saving the RegLocalizationproposed
+                        regLocalizationproposedManager.add(regLocalizationproposed);
+
+                    }
+                }
+
+            } catch (NoResultException e) {
+                // The form field is not a RegField: no action needed
+            } catch (Exception e) {
+                //logger.error(e.getMessage(), e);
+            }
+        }
+
+        return errors;
+
+    }
+    
+    private String processFieldHrefName(String key) {
+        String fieldHrefName;
+
+        // Checking if there is a reference to a RegLocalization
+        String[] tmp;
+        if (key.contains(BaseConstants.KEY_FORM_FIELD_NAME_REFERENCEKEY)) {
+            tmp = key.split(BaseConstants.KEY_FORM_FIELD_NAME_REFERENCEKEY);
+            fieldHrefName = tmp[0] + BaseConstants.KEY_FORM_FIELD_NAME_HREF_SUFFIX;
+        } else {
+            fieldHrefName = key + BaseConstants.KEY_FORM_FIELD_NAME_HREF_SUFFIX;
+        }
+
+        return fieldHrefName;
+    }
+    
+    private RegLocalizationproposed getRegLocalizationproposedInCurrentLanguage(RegLocalizationproposed regLocalizationproposed, RegLocalizationproposedManager regLocalizationproposedManager, RegLanguagecode regLanguagecode) throws Exception {
+
+        String tmpUuid = RegLocalizationproposedUuidHelper.getUuid(
+                regLocalizationproposed.getFieldValueIndex(),
+                regLanguagecode,
+                regLocalizationproposed.getRegItemproposed(),
+                regLocalizationproposed.getRegField()
+        );
+        regLocalizationproposed = regLocalizationproposedManager.get(tmpUuid);
+
+        return regLocalizationproposed;
+    }
+    
+    // This method handles the fields name (composed by multiple parts)
+    private String[] processFieldName(String key) {
+        String fieldUuid;
+        String fieldValueIndex = null;
+        String referenceRegLocalizationUuid = null;
+
+        // Checking if there is a reference to a RegLocalization
+        String[] tmp;
+        if (key.contains(BaseConstants.KEY_FORM_FIELD_NAME_REFERENCEKEY)) {
+            tmp = key.split(BaseConstants.KEY_FORM_FIELD_NAME_REFERENCEKEY);
+
+            // Getting the field uuid and field value index
+            String[] fieldTmp;
+            String tmpUuidAndFieldValueIndex = tmp[0];
+            fieldTmp = tmpUuidAndFieldValueIndex.split(BaseConstants.KEY_FORM_FIELD_NAME_INDEXKEY);
+            fieldUuid = fieldTmp[0];
+            fieldValueIndex = fieldTmp[1];
+
+            // Getting the referenc e localization
+            referenceRegLocalizationUuid = (tmp.length > 1) ? tmp[1] : null;
+        } else if (key.contains(BaseConstants.KEY_FORM_FIELD_NAME_INDEXKEY) && !key.contains(BaseConstants.KEY_FORM_FIELD_NAME_HREF_SUFFIX)) {
+            String[] fieldTmp;
+            fieldTmp = key.split(BaseConstants.KEY_FORM_FIELD_NAME_INDEXKEY);
+            fieldUuid = fieldTmp[0];
+            fieldValueIndex = fieldTmp[1];
+        } else {
+            fieldUuid = key;
+        }
+
+        // Removing the field name index
+        String[] outs = new String[3];
+        outs[0] = fieldUuid;
+        outs[1] = fieldValueIndex;
+        outs[2] = referenceRegLocalizationUuid;
+
+        return outs;
+    }
+
 
     private void storeLocalization(RegLanguagecode fieldLanguage, RegItemproposed regItemproposed, RegField regField, RegLanguagecode masterLanguage, String fieldValue, String localId, ArrayList<FieldsBulkImport> array) throws Exception {
         RegLocalizationproposedManager regLocalizationproposedManager = new RegLocalizationproposedManager(entityManager);
@@ -1212,7 +2147,7 @@ private RegItemproposed createRegItemProposed(String itemRecordLocalID, RegItemc
         RegItemproposedManager regItemproposedManager = new RegItemproposedManager(entityManager);
 
         RegItemproposed regItemproposed = new RegItemproposed();
-        //                add item proposed id not existent
+        //                add item proposed if not existent
         try {
             regItemproposed = regItemproposedManager.get(itemRecordLocalID);
         } catch (Exception ex) {
diff --git a/sources/Re3gistry2JavaAPI/src/main/java/eu/europa/ec/re3gistry2/javaapi/handler/RegItemproposedHandler.java b/sources/Re3gistry2JavaAPI/src/main/java/eu/europa/ec/re3gistry2/javaapi/handler/RegItemproposedHandler.java
index b978cc1c..9e2fc95b 100644
--- a/sources/Re3gistry2JavaAPI/src/main/java/eu/europa/ec/re3gistry2/javaapi/handler/RegItemproposedHandler.java
+++ b/sources/Re3gistry2JavaAPI/src/main/java/eu/europa/ec/re3gistry2/javaapi/handler/RegItemproposedHandler.java
@@ -45,6 +45,7 @@
 import eu.europa.ec.re3gistry2.crudimplementation.RegRelationpredicateManager;
 import eu.europa.ec.re3gistry2.crudimplementation.RegRelationproposedManager;
 import eu.europa.ec.re3gistry2.crudimplementation.RegStatusManager;
+import eu.europa.ec.re3gistry2.javaapi.handler.action.FieldsBulkImport;
 import eu.europa.ec.re3gistry2.model.RegAction;
 import eu.europa.ec.re3gistry2.model.RegField;
 import eu.europa.ec.re3gistry2.model.RegFieldmapping;
@@ -70,6 +71,9 @@
 import eu.europa.ec.re3gistry2.model.uuidhandlers.RegRelationproposedUuidHelper;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -370,6 +374,96 @@ public void handleRegItemproposedAddition(Map requestParameters, RegUser regUser
      * @param regUser
      * @throws Exception
      */
+    public void handleBulkRegItemproposedSave(RegItemproposed itemProposed, RegUser regUser, Map requestParameters) throws Exception {
+
+        // Getting the ID of the RegItem (original item)
+        String regItemUuid = itemProposed.getLocalid();
+
+        // Getting the RegItem on which the proposal is done
+        RegItem regItem = null;
+        try {
+            RegItemManager regItemManager = new RegItemManager(entityManager);
+            regItem = regItemManager.get(regItemUuid);
+        } catch (NoResultException e) {
+        }
+
+        // Init managers
+        RegItemproposedManager regItemproposedManager = new RegItemproposedManager(entityManager);
+
+        // Check if the RegItemproposed is already available
+        try {
+            RegItemproposed regItemproposed = regItemproposedManager.getByRegItemReference(regItem);
+
+            // Checking the ownership
+            if (!regItemproposed.getRegUser().getUuid().equals(regUser.getUuid())) {
+                // If the user is not the owner of the current RegItemproposed, deny the update
+                throw new UnauthorizedUserException(ExceptionConstants.KEY_EXCEPTION_UNAUTHORIZED_USER_OWNER);
+            }
+
+            // The writing operation on the Database are synchronized
+            /* ## Start Synchronized ## */
+            synchronized (sync) {
+                // Update the RegItemproposed
+                if (!entityManager.getTransaction().isActive()) {
+                    entityManager.getTransaction().begin();
+                }
+                updateRegItemproposed(regItemproposed, requestParameters);
+                entityManager.getTransaction().commit();
+            }
+            /* ## End Synchronized ## */
+
+        } catch (NoResultException e) {
+            // If the RegItemproposed is not available, creating it
+
+            // The writing operation on the Database are synchronized
+            /* ## Start Synchronized ## */
+            synchronized (sync) {
+                if (!entityManager.getTransaction().isActive()) {
+                    entityManager.getTransaction().begin();
+                }
+                // Copy the RegItem to the RegItemproposed
+                RegItemproposed regItemproposed = copyRegItemToRegItemproposed(regItem, regUser);
+
+                // Copy all the regRelations
+                copyRegRelationsToRegRelationproposeds(regItem, regItemproposed);
+
+                // Copy groups relations
+                copyRegItemRegGroupRegRoleMappingToRegItemproposedRegGroupRegRoleMapping(regItem, regItemproposed);
+
+                // Register Federation export
+                String[] registerFederationExportTmp = (String[]) requestParameters.get(BaseConstants.KEY_FORM_FIELD_NAME_REGISTERFEDERATIONEXPORT);
+                // !!! Sanitizing input
+                String registerFederationExport;
+                boolean registerFederationExportBol;
+
+                if (registerFederationExportTmp != null) {
+                    registerFederationExport = InputSanitizerHelper.sanitizeInput(registerFederationExportTmp[0]);
+                    registerFederationExportBol = (registerFederationExport != null && registerFederationExport.equals(BaseConstants.KEY_BOOLEAN_STRING_TRUE));
+                } else {
+                    registerFederationExportBol = false;
+                }
+
+                if (regItemproposed != null) {
+                    regItemproposed.setRorExport(registerFederationExportBol);
+                }
+
+                // Update the RegFields
+                updateFields(regItemproposed, requestParameters);
+                entityManager.getTransaction().commit();
+            }
+            /* ## End Synchronized ## */
+        } catch (Exception e) {
+            logger.error(e.getMessage(), e);
+        } finally {
+            if (entityManager != null) {
+                entityManager.close();
+            }
+        }
+    }
+
+    /**
+     * This method handles the save of a proposal when done via bulk edit
+     */
     public void handleRegItemproposedSave(Map requestParameters, RegUser regUser) throws Exception {
 
         // Getting the ID of the RegItem (original item)
@@ -1578,6 +1672,160 @@ private RegLocalizationproposed getRegLocalizationproposedInCurrentLanguage(RegL
         return regLocalizationproposed;
     }
 
+    private void copyRegLocalizationsToRegLocalizationproposedBulkEdit(RegItem regItem, RegItemproposed regItemproposed, String checkDeleteUuid, HashMap<RegField, String> fields) throws Exception {
+
+        RegLocalizationManager regLocalizationManager = new RegLocalizationManager(entityManager);
+        RegLocalizationproposedManager regLocalizationproposedManager = new RegLocalizationproposedManager(entityManager);
+        RegRelationproposedManager regRelationproposedManager = new RegRelationproposedManager(entityManager);
+        RegLanguagecodeManager regLanguacecodeManager = new RegLanguagecodeManager(entityManager);
+        RegLanguagecode masterLanguage = regLanguacecodeManager.getMasterLanguage();
+
+        // Getting all the regLocalizations realted to the RegItem (in the master language)
+        List<RegLocalization> regLocalizations = regLocalizationManager.getAll(regItem, masterLanguage);
+        int i = 0;
+        for (RegLocalization regLocalization : regLocalizations) {
+
+            String newRegLocalizationproposedUuid = RegLocalizationproposedUuidHelper.getUuid(regLocalization.getFieldValueIndex(), regLocalization.getRegLanguagecode(), regItemproposed, regLocalization.getRegField());
+
+            // Checking if the regLocalizationproposed is already available ( it
+            // may have been copyied by the reg relation copyier)
+            try {
+                // If the RegLocalizationproposed is already there, update it accordingly
+                RegLocalizationproposed regLocalizationproposed = regLocalizationproposedManager.get(newRegLocalizationproposedUuid);
+
+                // If the localization is the one passed by the delete action, deleting the values
+                if (checkDeleteUuid != null && regLocalization.getUuid().equals(checkDeleteUuid)) {
+                    // If there is a reference to a RegRelationproposed, deleting also the RegRelationproposed
+                    RegRelationproposed regRelationproposed = regLocalizationproposed.getRegRelationproposedReference();
+
+                    // Removing the values and the reference to the RegRelationproposed
+                    regLocalizationproposed.setValue(null);
+                    regLocalizationproposed.setHref(null);
+                    regLocalizationproposed.setRegRelationproposedReference(null);
+
+//                    regLocalizationproposed.setRegAction(regItemproposed.getRegAction());
+
+                    regLocalizationproposedManager.update(regLocalizationproposed);
+
+                    if (regRelationproposed != null) {
+                        regRelationproposedManager.delete(regRelationproposed);
+                    }
+                }
+
+            } catch (NoResultException e) {
+                // Else, creating the new RegLocalizationproposed
+                RegLocalizationproposed newRegLocalizationproposed = new RegLocalizationproposed();
+                newRegLocalizationproposed.setUuid(newRegLocalizationproposedUuid);
+                newRegLocalizationproposed.setFieldValueIndex(regLocalization.getFieldValueIndex());
+                newRegLocalizationproposed.setInsertdate(new Date());
+                newRegLocalizationproposed.setRegField(regLocalization.getRegField());
+                newRegLocalizationproposed.setRegItemproposed(regItemproposed);
+                newRegLocalizationproposed.setRegLanguagecode(regLocalization.getRegLanguagecode());
+                newRegLocalizationproposed.setRegLocalizationReference(regLocalization);
+//                newRegLocalizationproposed.setRegAction(regItemproposed.getRegAction());
+
+                // If the localization is the one passed by the delete action, deleting the values
+                if (checkDeleteUuid != null && regLocalization.getUuid().equals(checkDeleteUuid)) {
+                    newRegLocalizationproposed.setValue(null);
+                    newRegLocalizationproposed.setHref(null);
+                    newRegLocalizationproposed.setRegRelationproposedReference(null);
+                } else {
+
+                    for (Map.Entry<RegField, String> entry : fields.entrySet()) {
+                        if (entry.getKey().getLocalid().equalsIgnoreCase(regLocalization.getRegField().getLocalid())) {
+                            if (entry.getValue().equalsIgnoreCase("")) {
+                                newRegLocalizationproposed.setValue(regLocalization.getValue());
+                            } else {
+                                newRegLocalizationproposed.setValue(entry.getValue());
+                            }
+                        }
+                    }
+
+                    newRegLocalizationproposed.setHref(regLocalization.getHref());
+
+                    // Getting the related RegRelationproposed
+                    try {
+                        RegRelationproposed regRelationproposed = regRelationproposedManager.getByRegRelationReference(regLocalization.getRegRelationReference());
+                        newRegLocalizationproposed.setRegRelationproposedReference(regRelationproposed);
+                    } catch (NoResultException ex) {
+                        newRegLocalizationproposed.setRegRelationproposedReference(null);
+                    }
+                }
+
+                regLocalizationproposedManager.add(newRegLocalizationproposed);
+            }
+            i++;
+        }
+    }
+
+    private void storeRelarionReference(String fieldValue, RegField regField, RegItemproposed regItemproposed, HashMap<RegField, RegItem> mapCollection, RegItemclass regItemclassChild, RegLanguagecode fieldLanguage, String localId, FieldsBulkImport fieldsBulkImport) {
+        RegRelationproposedManager regRelationproposedManager = new RegRelationproposedManager(entityManager);
+        RegRelationpredicateManager regRelationpredicateManager = new RegRelationpredicateManager(entityManager);
+        RegLocalizationproposedManager regLocalizationproposedManager = new RegLocalizationproposedManager(entityManager);
+        RegItemManager regItemManager = new RegItemManager(entityManager);
+        ArrayList<String> relationReferenceList = new ArrayList<>();
+
+        if (fieldValue.contains(",")) {
+            relationReferenceList = new ArrayList<>(Arrays.asList(fieldValue.split(",")));
+        } else {
+            relationReferenceList.add(fieldValue);
+        }
+
+        int i = 0;
+        for (String valueOfTheField : relationReferenceList) {
+            try {
+                RegItemclass itemClassRelationReference = regField.getRegItemclassReference();
+                String relationreferenceuuid = "";
+                
+                try {
+                    if (mapCollection.containsKey(regField)) {
+                        RegItem itemRelationReferenceCollection = mapCollection.get(regField);
+                        relationreferenceuuid = RegItemUuidHelper.getUuid(valueOfTheField, itemRelationReferenceCollection, itemClassRelationReference);
+                    } else {
+                        relationreferenceuuid = RegItemUuidHelper.getUuid(valueOfTheField, null, itemClassRelationReference);
+                    }
+
+                    RegItem regItemRelationReference = regItemManager.get(relationreferenceuuid);
+
+                    //create relation
+                    RegRelationpredicate regRelationpredicateReference = regRelationpredicateManager.get(BaseConstants.KEY_PREDICATE_REFERENCE);
+                    RegRelationproposed regRelationproposedReference = new RegRelationproposed();
+                    regRelationproposedReference.setInsertdate(new Date());
+                    regRelationproposedReference.setRegItemSubject(null);
+                    regRelationproposedReference.setRegItemproposedSubject(regItemproposed);
+                    regRelationproposedReference.setUuid(RegRelationproposedUuidHelper.getUuid(regItemproposed, null, regRelationpredicateReference, null, regItemRelationReference));
+                    regRelationproposedReference.setRegItemObject(regItemRelationReference);
+
+                    regRelationproposedReference.setRegItemproposedObject(null);
+                    regRelationproposedReference.setRegRelationReference(null);
+                    regRelationproposedReference.setRegRelationpredicate(regRelationpredicateReference);
+
+                    regRelationproposedManager.add(regRelationproposedReference);
+
+//                                            create localization for red relation proposed
+                    RegLocalizationproposed regLocalizationproposed = new RegLocalizationproposed();
+                    regLocalizationproposed.setUuid(RegLocalizationproposedUuidHelper.getUuid(i, fieldLanguage, regItemproposed, regField));
+                    regLocalizationproposed.setRegLanguagecode(fieldLanguage);
+                    regLocalizationproposed.setRegItemproposed(regItemproposed);
+                    regLocalizationproposed.setRegField(regField);
+                    regLocalizationproposed.setRegRelationproposedReference(regRelationproposedReference);
+                    regLocalizationproposed.setInsertdate(new Date());
+                    regLocalizationproposed.setRegAction(regItemproposed.getRegAction());
+
+                    regLocalizationproposedManager.add(regLocalizationproposed);
+                } catch (Exception ex) {
+                    relationreferenceuuid = RegItemproposedUuidHelper.getUuid(valueOfTheField, null, regItemclassChild, null);
+                    RegItemproposedManager regItemproposedManager = new RegItemproposedManager(entityManager);
+                    RegItemproposed regItemproposedrelation = regItemproposedManager.get(relationreferenceuuid);
+                }
+            } catch (Exception e) {
+                //Error
+            }
+            i++;
+
+        }
+    }
+
     // This method copies the RegLocalization to RegLocalizationproposed
     private void copyRegLocalizationsToRegLocalizationproposed(RegItem regItem, RegItemproposed regItemproposed, String checkDeleteUuid) throws Exception {
 
@@ -1754,6 +2002,40 @@ public RegItemproposed completeCopyRegItemToRegItemporposed(RegItem regItem, Reg
         return regItemproposed;
     }
 
+    public RegItemproposed completeCopyRegItemToRegItemporposedBulkEdit(RegItem regItem, RegUser regUser, HashMap<RegField, String> fields) throws Exception {
+        RegItemproposed regItemproposed = null;
+        synchronized (sync) {
+            if (!entityManager.getTransaction().isActive()) {
+                entityManager.getTransaction().begin();
+            }
+            regItemproposed = copyRegItemToRegItemproposed(regItem, regUser);
+            entityManager.getTransaction().commit();
+
+            if (!entityManager.getTransaction().isActive()) {
+                entityManager.getTransaction().begin();
+            }
+            if (regItem != null && regItemproposed != null) {
+                copyRegItemRegGroupRegRoleMappingToRegItemproposedRegGroupRegRoleMapping(regItem, regItemproposed);
+            }
+            entityManager.getTransaction().commit();
+
+            if (!entityManager.getTransaction().isActive()) {
+                entityManager.getTransaction().begin();
+            }
+            if (regItem != null && regItemproposed != null) {
+                copyRegRelationsToRegRelationproposeds(regItem, regItemproposed);
+            }
+            entityManager.getTransaction().commit();
+
+            if (!entityManager.getTransaction().isActive()) {
+                entityManager.getTransaction().begin();
+            }
+            copyRegLocalizationsToRegLocalizationproposedBulkEdit(regItem, regItemproposed, null, fields);
+            entityManager.getTransaction().commit();
+        }
+        return regItemproposed;
+    }
+
     public String newRegisterLite(String registryItemUuid, String registerLocalId, RegItemclass registerItemclass, RegUser regUser, String labelValue, String contentSummaryValue, String registerOwnerGroupUuid, String registerManagerGroupUuid, String controlBodyGroupUuid, String[] submittingOrganizationGroupUuids) throws Exception {
 
         // Instantiating managers
@@ -1898,7 +2180,7 @@ private void mapGroup(RegItemproposed registerRegItemproposed, String groupUuid,
 //                if (groupUuid == null) {
 //                    regGroup = regGroupManager.getByLocalid("registryManager");
 //                } else {
-                    regGroup = regGroupManager.get(groupUuid);
+                regGroup = regGroupManager.get(groupUuid);
 //                }
 
                 if (!entityManager.getTransaction().isActive()) {
