Add support for multi fields relations

src/app/core/editing/session.js

@@ -379,38 +379,70 @@ proto.set3DGeometryType = function({layerId=this.getId(), commitItems}={}){
   }));
 };
 
-proto.commit = function({ids=null, items, relations=true}={}) {
+/**
+ * Commit changes on server (save)
+ * 
+ * @param opts.ids
+ * @param opts.items
+ * @param opts.relations
+ * 
+ * @returns {*}
+ */
+proto.commit = function({
+  ids = null,
+  items,
+  relations = true
+} = {}) {
+
   const d = $.Deferred();
-  let commitItems;
+
+  let commit; // committed items
+
+  // skip when ..
   if (ids) {
-    commitItems = this._history.commit(ids);
+    commit = this._history.commit(ids);
     this._history.clear(ids);
-  } else {
-    if (items) commitItems = items;
-    else {
-      commitItems = this._history.commit();
-      commitItems = this._serializeCommit(commitItems);
-    }
-    if (!relations) commitItems.relations = {};
-    this._editor.commit(commitItems)
-      .then(response => {
-        if (response && response.result) {
-          const {response:data} = response;
-          const {new_relations={}} = data;
-          for (const id in new_relations) {
-            const session = SessionsRegistry.getSession(id);
-            session.getEditor().applyCommitResponse({
-              response: new_relations[id],
-              result: true
-            })
-          }
-          this._history.clear();
-          this.saveChangesOnServer(commitItems);
-          d.resolve(commitItems, response)
-        } else d.reject(response);
-      })
-      .fail(err => d.reject(err));
+    return d.promise();
+  }
+
+  commit = items || this._serializeCommit(this._history.commit());
+
+  if (!relations) {
+    commit.relations = {};
   }
+
+  this._editor
+    .commit(commit)
+    .then(response => {
+
+      // skip when response is null or undefined and response.result is false
+      if (!(response && response.result)) {
+        d.reject(response);
+        return;
+      }
+
+      const { new_relations = {} } = response.response; // check if new relations are saved on server
+
+      // sync server data with local data
+      for (const id in new_relations) {
+        SessionsRegistry
+          .getSession(id)               // get session of relation by id
+          .getEditor()
+          .applyCommitResponse({        // apply commit response to current editing relation layer
+            response: new_relations[id],
+            result: true
+          });
+      }
+
+      this._history.clear();            // clear history
+
+      this.saveChangesOnServer(commit); // dispatch setter event.
+
+      d.resolve(commit, response);
+
+    })
+    .fail(err => d.reject(err));
+
   return d.promise();
 
 };
@@ -442,7 +474,7 @@ proto.clear = function() {
   this._editor.clear();
 };
 
-//return l'history
+//return history
 proto.getHistory = function() {
   return this._history;
 };

src/app/core/layers/tablelayer.js

@@ -254,15 +254,26 @@ proto._setOtherConfigParameters = function(config) {
   // overwrite by vector layer
 };
 
-// return layer fields
-proto.getEditingFields = function(editable=false) {
-  let fields = this.config.editing.fields.length ? this.config.editing.fields: this.config.fields;
-  if (editable) fields = fields.filter(field => field.editable);
+/**
+ * @returns layer fields 
+ */
+proto.getEditingFields = function(editable = false) {
+  let fields = this.config.editing.fields.length
+    ? this.config.editing.fields
+    : this.config.fields;
+  if (editable) {
+    fields = fields.filter(field => field.editable);
+  }
   return fields;
 };
 
-proto.isPkField = function(field){
-  const find_field = this.getEditingFields().find(_field => _field.name === field);
+/**
+ * @param field
+ * 
+ * @returns {boolean} whether field is a Primary Key
+ */
+proto.isPkField = function(field) {
+  const find_field = this.getEditingFields().find(f => f.name === field);
   return find_field && find_field.pk;
 };
 

src/app/core/relations/relation.js

@@ -1,98 +1,171 @@
 const { base, inherit } = require('core/utils/utils');
 const G3WObject = require('core/g3wobject');
 
-function Relation(config={}) {
-  const uniqueSuffix = Date.now();
-  const id = config.id || `id_${uniqueSuffix}`;
-  const name = config.name || `name_${uniqueSuffix}`;
-  const origname = config.origname || `origname_${uniqueSuffix}`;
+/**
+ * Relation Class
+ * 
+ * @param config
+ * 
+ * @constructor
+ */
+function Relation(config = {}) {
+
+  const suffix = Date.now();
+
+  /** BACKCOMP (g3w-admin < v.3.7.0) */
+  const multi_fields = [].concat(config.fieldRef.referencedField);
+
   this.state = {
-    id,
-    name,
-    origname,
-    father: config.referencedLayer,
-    child: config.referencingLayer,
-    fatherField: config.fieldRef.referencedField,
-    childField: config.fieldRef.referencingField,
-    type: config.type,
-    loading: false
+    id:          config.id       || `id_${suffix}`,
+    name:        config.name     || `name_${suffix}`,
+    origname:    config.origname || `origname_${suffix}`,
+    father:      config.referencedLayer,
+    child:       config.referencingLayer,
+    fatherField: multi_fields,
+    childField:  multi_fields,
+    type:        config.type,
+    loading:     false
   };
+
   base(this);
 }
 
 inherit(Relation, G3WObject);
 
 const proto = Relation.prototype;
 
+/**
+ * Get relation id
+ * 
+ * @returns {string}
+ */
 proto.getId = function() {
   return this.state.id;
 };
 
+/**
+ * Set Relation id
+ * 
+ * @param id
+ */
 proto.setId = function(id) {
   this.state.id = id;
 };
 
+/**
+ * Get Relation name
+ * 
+ * @returns {string}
+ */
 proto.getName = function() {
   return this.state.name;
 };
 
+/**
+ * Set Relation name
+ * 
+ * @param name
+ */
 proto.setName = function(name) {
   this.state.name = name;
 };
 
+/**
+ * @TODO check if deprecated (ie. `this.state.title` is not defined in class constructor)
+ * 
+ * Get Relation title
+ * 
+ * @returns { undefined }
+ */
 proto.getTitle = function() {
   return this.state.title;
 };
 
+/**
+ * @TODO check if deprecated (ie. `this.state.title` is not defined in class constructor)
+ * 
+ * Set Relation title
+ * 
+ * @param title
+ * 
+ * @returns { undefined }
+ */
 proto.setTitle = function(title) {
   return this.state.title = title;
 };
 
+/**
+ * @returns { string[] } layerId of child relation
+ */
 proto.getChild = function() {
   return this.state.child;
 };
 
+/**
+ * @returns { string[] } layerId of father relation
+ */
 proto.getFather = function() {
   return this.state.father;
 };
 
+/**
+ * @returns state Object of relation
+ */
 proto.getState = function() {
   return this.state;
 };
 
+/**
+ * @returns { 'MANY' | ONE' | string } relation type
+ */
 proto.getType = function() {
   return this.state.type;
 };
 
+/**
+ * @returns {{ father, child }} relation fields
+ */
 proto.getFields = function() {
   return {
     father: this.state.fatherField,
     child: this.state.childField
   };
 };
 
+/**
+ * Return father relation field name
+ * 
+ * @returns {*}
+ */
 proto.getFatherField = function() {
   return this.state.fatherField;
 };
 
+/**
+ * Return relation child layer field name
+ * 
+ * @returns {*}
+ */
 proto.getChildField = function() {
   return this.state.childField;
 };
 
 /**
- * For editing purpose
+ * Set Loading state relation (for editing purpose)
+ * 
+ * @param bool
  */
-
 proto.setLoading = function(bool=false){
   this.state.loading = bool;
 };
 
+/**
+ * Check Loading state Relation (for editing purpose)
+ * 
+ * @returns { boolean }
+ */
 proto.isLoading = function(){
   return this.state.loading;
 };
 
-/**
- * End editing loading purpose
- */
-
-module.exports = Relation;
+module.exports = Relation;