+
[
+ this.getStudentAjaxId(student),
+ ApiStvGroups.add(
+ student.id,
+ data.gruppe_kurzbz,
+ this.currentSemester
+ )
+ ]);
+ } else {
+ const { semester, verband, gruppe } = data;
+ const params = { semester, verband, gruppe };
+ endpoint = students.map(student => [
+ this.getStudentAjaxId(student),
+ ApiStvDetails.saveStudent(
+ student.id,
+ this.currentSemester,
+ params
+ )
+ ]);
+ }
+
+ return this.$api
+ .call(endpoint)
+ .then(this.$reloadList)
+ .catch(this.$fhcAlert.handleSystemError);
}
},
mounted() {
@@ -286,10 +349,21 @@ export default {
- {{node.data.name}}
+ {{ node.data.name }}
+
+
+ {{ node.data.name }}
diff --git a/public/js/directives/dragClick.js b/public/js/directives/dragClick.js
new file mode 100644
index 000000000..5603eb93f
--- /dev/null
+++ b/public/js/directives/dragClick.js
@@ -0,0 +1,53 @@
+import { bindDragEnterLeave } from '../helpers/DragAndDrop.js';
+
+export default {
+ mounted(el, binding) {
+ const delay = parseInt(binding.arg) || 300;
+
+ let timeout = null;
+ function startCountdown() {
+ timeout = window.setTimeout(binding.value, delay);
+ }
+ function stopCountdown() {
+ if (timeout)
+ window.clearTimeout(timeout);
+ timeout = null;
+ }
+
+ let lastTarget;
+ let lastX;
+ let lastY;
+
+ function onDragOver(evt) {
+ if (lastX != evt.offsetX || lastY != evt.offsetY || lastTarget != evt.target) {
+ // moved
+ lastTarget = evt.target;
+ lastX = evt.offsetX;
+ lastY = evt.offsetY;
+
+ stopCountdown();
+ startCountdown();
+ }
+ }
+
+ function onEnter(evt) {
+ lastTarget = evt.target;
+ lastX = evt.offsetX;
+ lastY = evt.offsetY;
+
+ el.addEventListener('dragover', onDragOver);
+
+ startCountdown();
+ }
+ function onLeave() {
+ stopCountdown();
+ el.removeEventListener('dragover', onDragOver);
+ }
+
+ el.fhcDragClickCleanup = bindDragEnterLeave(el, onEnter, onLeave);
+ },
+ beforeUnmount(el) {
+ el.fhcDragClickCleanup();
+ delete el.fhcDragClickCleanup;
+ }
+}
diff --git a/public/js/directives/draggable.js b/public/js/directives/draggable.js
new file mode 100644
index 000000000..64747c15a
--- /dev/null
+++ b/public/js/directives/draggable.js
@@ -0,0 +1,101 @@
+import { setTransferData, convertToValidDragObject } from '../helpers/DragAndDrop.js';
+
+const EFFECTS = [
+ 'none',
+ 'copy',
+ 'copyLink',
+ 'copyMove',
+ 'link',
+ 'linkMove',
+ 'move',
+ 'all',
+ 'uninitialized'
+];
+
+export default {
+ mounted(el, binding) {
+ updateValue(el, binding.value);
+ updateEffectAllowed(el, binding.arg);
+
+ // if modifier capture is set we assume it's on a parent element
+ // i.e: for dragging multiple elements
+ // otherwise set draggable attribute
+ if (!binding.modifiers.capture) {
+ el.draggable = true;
+ }
+
+ const bcc = new BroadcastChannel('fhc-dnd');
+ let blocked = false;
+
+ function onStart(evt) {
+ const value = el.dataset.fhcDraggableValue;
+ if (value) {
+ setTransferData(evt, JSON.parse(value), true);
+ if (el.dataset.fhcEffectAllowed)
+ evt.dataTransfer.effectAllowed = el.dataset.fhcEffectAllowed;
+
+ bcc.onmessage = e => {
+ if (e.data == 'block') {
+ blocked = true;
+ } else if (e.data == 'release') {
+ let evt = null;
+ if (blocked && blocked.evt) {
+ evt = blocked.evt;
+ }
+ blocked = false;
+ if (evt)
+ el.dispatchEvent(evt);
+ }
+ };
+ } else {
+ evt.preventDefault();
+ }
+ }
+
+ function onEnd(evt) {
+ if (blocked) {
+ blocked = {
+ evt,
+ dt: evt.dataTransfer
+ };
+ evt.stopPropagation();
+ el.dispatchEvent(new DragEvent("beforedragend", evt));
+ } else {
+ bcc.onmessage = () => {};
+ }
+ }
+ el.addEventListener('dragstart', onStart, binding.modifiers.capture);
+
+ el.addEventListener('dragend', onEnd, true);
+
+ el.fhcDraggableCleanup = () => {
+ el.removeEventListener('dragstart', onStart, binding.modifiers.capture);
+ el.removeEventListener('dragend', onEnd, true);
+ };
+ },
+ updated(el, binding) {
+ updateValue(el, binding.value);
+ updateEffectAllowed(el, binding.arg);
+ },
+ beforeUnmount(el) {
+ el.fhcDraggableCleanup();
+ delete el.fhcDraggableCleanup;
+ }
+}
+
+// Helper functions
+function updateValue(el, value) {
+ value = convertToValidDragObject(value);
+ if (value) {
+ el.dataset.fhcDraggableValue = JSON.stringify(value);
+ } else if (el.dataset.fhcDraggableValue) {
+ delete el.dataset.fhcDraggableValue;
+ }
+}
+function updateEffectAllowed(el, effectAllowed) {
+ if (effectAllowed && EFFECTS.includes(effectAllowed)) {
+ el.dataset.fhcEffectAllowed = effectAllowed;
+ } else if (el.dataset.fhcEffectAllowed) {
+ delete el.dataset.fhcEffectAllowed;
+ }
+}
diff --git a/public/js/directives/drop.js b/public/js/directives/drop.js
new file mode 100644
index 000000000..4c50e1b8e
--- /dev/null
+++ b/public/js/directives/drop.js
@@ -0,0 +1,77 @@
+import { getValidTransferData, eventHasTypes, bindDragEnterLeave } from '../helpers/DragAndDrop.js';
+
+const EFFECTS = [
+ 'move',
+ 'copy',
+ 'link',
+ 'none'
+];
+
+export default {
+ mounted(el, binding) {
+ const allowedTypes = Object.keys(binding.modifiers);
+ allowedTypes.forEach(type => {
+ if (type.substr(-11) == '-collection') {
+ const singleType = type.substr(0, type.length-11);
+ if (!allowedTypes.includes(singleType))
+ allowedTypes.push(singleType);
+ }
+ });
+
+ const strict = binding.arg.match(/(strict-|-strict)/);
+ const arg = binding.arg.replace(/(strict-|-strict)/, '');
+ const effect = EFFECTS.includes(arg) ? arg : null;
+
+ const bcc = new BroadcastChannel('fhc-dnd');
+ let allowed = false;
+
+ function onEnter(evt) {
+ allowed = eventHasTypes(evt, allowedTypes, strict);
+ if (allowed) {
+ evt.preventDefault();
+ bcc.postMessage('block');
+ }
+ }
+ function onLeave(evt, wasDropped) {
+ if (allowed && !wasDropped) {
+ bcc.postMessage('release');
+ }
+ }
+ function onOver(evt) {
+ if (allowed) {
+ evt.preventDefault();
+ if (effect)
+ evt.dataTransfer.dropEffect = effect;
+ }
+ }
+ function onDrop(evt) {
+ let result = getValidTransferData(evt, allowedTypes, strict);
+ if (!Array.isArray(result) && !binding.modifiers[result.type] && allowedTypes.includes(result.type + '-collection'))
+ result = [result];
+
+ const res = binding.value(evt, result);
+
+ if (res instanceof Promise) {
+ res.then(r => {
+ bcc.postMessage('release');
+ return r;
+ });
+ } else {
+ bcc.postMessage('release');
+ }
+ }
+
+ const cleanupEnterLeave = bindDragEnterLeave(el, onEnter, onLeave);
+ el.addEventListener('dragover', onOver);
+ el.addEventListener('drop', onDrop);
+ el.fhcDropCleanup = () => {
+ cleanupEnterLeave();
+ el.removeEventListener('dragover', onOver);
+ el.removeEventListener('drop', onDrop);
+ };
+ },
+ beforeUnmount(el) {
+ el.fhcDropCleanup();
+ delete el.fhcDropCleanup;
+ }
+}
diff --git a/public/js/helpers/DragAndDrop.js b/public/js/helpers/DragAndDrop.js
index 1160400f7..f98697eb2 100644
--- a/public/js/helpers/DragAndDrop.js
+++ b/public/js/helpers/DragAndDrop.js
@@ -1,67 +1,368 @@
/**
* TODO(chris): This is only a prototype!!!
*/
-const DragAndDrop = {
- TYPE_LE: "lehreinheit",
- TYPE_VEVENT: "vevent",
- getValidTransferData(event, allowedTypes) {
- const json = event.dataTransfer.getData('text');
- let obj;
- try {
- obj = JSON.parse(json);
- if (!obj.type)
- return null;
- if (allowedTypes && !allowedTypes.includes(obj.type))
- return null;
- } catch (error) {
- return null;
- }
- return obj;
+const TYPE_DEFINITION = {
+ lehreinheit: {
+ id: "lehreinheit_id",
+ dragIcon: "fa-solid fa-chalkboard-user",
+ extras: [
+ "stundenblockung"
+ ]
},
- isValidTransferData(event, allowedTypes) {
- return this.getValidTransferData(event, allowedTypes) ? true : false;
+ vevent: {
+ id: "uid",
+ dragIcon: "fa-solid fa-calendar",
+ extras: [
+ "dtstart",
+ "dtend",
+ "summary"
+ ]
},
- getTransferData(event) {
- const json = event.dataTransfer.getData('text');
- return JSON.parse(json);
+ person: {
+ id: "person_id",
+ dragIcon: "fa-solid fa-user"
},
- setTransferData(event, data) {
- switch (data.type) {
- case DragAndDrop.TYPE_LE:
- data = DragAndDrop.fromLe(data);
- break;
- default:
- if (data.dtstart && data.dtend && data.uid && data.summary) {
- data = DragAndDrop.fromVEvent(data);
- break;
- }
- return false; // No type found => abort
- }
-
- event.dataTransfer.setData('text', JSON.stringify(data));
- return true;
+ student: {
+ id: "student_uid",
+ dragIcon: "fa-solid fa-user-graduate"
},
- fromLe(data) {
- const {
- type = DragAndDrop.TYPE_LE,
- lehreinheit_id: id,
- stundenblockung
- } = data;
-
- return { type, id, stundenblockung };
- },
- fromVEvent(data) {
- const {
- type = DragAndDrop.TYPE_VEVENT,
- uid: id,
- dtstart,
- dtend,
- summary
- } = data;
-
- return { type, id, dtstart, dtend, summary };
+ prestudent: {
+ id: "prestudent_id",
+ dragIcon: "fa-solid fa-user-graduate text-muted"
}
+ // TODO: IMPLEMENT OTHER TYPES
};
-export default DragAndDrop;
+const VALID_TYPES = Object.keys(TYPE_DEFINITION);
+
+const TYPE_CONSTANTS = Object.keys(TYPE_DEFINITION).reduce((res, type) => {
+ res['TYPE_' + type.toUpperCase()] = type;
+ return res;
+}, {});
+
+function isValidDragObject(value) {
+ if (!value)
+ return false;
+ if (Array.isArray(value))
+ return value.every(isValidDragObject);
+ if (!value.type)
+ return false;
+
+ if (value.type.substr(-11) == '-collection') {
+ if (!Object.prototype.hasOwnProperty.call(value, 'values'))
+ return false;
+
+ if (!VALID_TYPES.includes(value.type.substr(0, value.type.length-11)))
+ return false;
+ } else {
+ if (!Object.prototype.hasOwnProperty.call(value, 'id'))
+ return false;
+
+ if (!VALID_TYPES.includes(value.type))
+ return false;
+
+ if (TYPE_DEFINITION[value.type].extras) {
+ if (!TYPE_DEFINITION[value.type].extras.every(extra => Object.prototype.hasOwnProperty.call(value, extra)))
+ return false;
+ }
+ }
+
+ return true;
+}
+
+function getValidTransferData(event, allowedTypes, strict) {
+ let obj = null;
+
+ try {
+ obj = getTransferData(event, strict);
+ if (!obj)
+ return null;
+
+ if (!strict && Array.isArray(obj)) {
+ obj = obj.filter(isValidDragObject);
+ if (!obj.length)
+ return null;
+ } else if (!isValidDragObject(obj))
+ return null;
+
+ if (allowedTypes && allowedTypes.length) {
+ if (Array.isArray(obj)) {
+ if (strict && !obj.every(v => allowedTypes.includes(v.type))) {
+ return null;
+ } else if (!strict) {
+ obj = obj.filter(v => allowedTypes.includes(v.type));
+ if (!obj.length)
+ return null;
+ }
+ } else if (!allowedTypes.includes(obj.type)) {
+ return null;
+ }
+ }
+ } catch(_error) {
+ return null;
+ }
+
+ if (Array.isArray(obj) && obj.length == 1)
+ return obj.find(Boolean);
+
+ return obj;
+}
+
+function isValidTransferData(event, allowedTypes, strict) {
+ return getValidTransferData(event, allowedTypes, strict) ? true : false;
+}
+
+function getTransferData(event, strict) {
+ const result = [];
+
+ for (const type of event.dataTransfer.types) {
+ if (type.substr(0, 16) != 'application/fhc-') {
+ if (strict)
+ return null;
+ continue;
+ }
+ let base_type = type.substr(16);
+ let collection = false;
+ if (base_type.substr(-11) == '-collection') {
+ base_type = base_type.substr(0, base_type.length-11);
+ collection = true;
+ }
+ if (!VALID_TYPES.includes(base_type)) {
+ if (strict)
+ return null;
+ continue;
+ }
+ let data = JSON.parse(event.dataTransfer.getData(type));
+ if (collection)
+ result.push(...data.values);
+ else
+ result.push(data);
+ }
+
+ if (!result.length)
+ return null;
+
+ if (result.length == 1)
+ return result[0];
+
+ return result;
+}
+
+function convertToValidDragObject(data, strict) {
+ if (Array.isArray(data)) {
+ const converted = data.map(convertToValidDragObject).filter(Boolean);
+ if (!converted.length)
+ return undefined;
+ if (strict && converted.length != data.length)
+ return undefined;
+
+ const sorted = converted.reduce((res, item) => {
+ if (!res[item.type])
+ res[item.type] = [];
+ res[item.type].push(item);
+ return res;
+ }, {});
+
+ return Object.entries(sorted).map(([type, values]) => {
+ if (values.length > 1) {
+ return {
+ type: type + '-collection',
+ values
+ };
+ }
+ return values[0];
+ });
+ }
+
+ if (Object.prototype.hasOwnProperty.call(data, 'type') && isValidDragObject(data)) {
+ return data;
+ }
+
+ const found = Object.entries(TYPE_DEFINITION).find(([ , typedef ]) => {
+ if (!Object.prototype.hasOwnProperty.call(data, typedef.id))
+ return false;
+ if (typedef.extras) {
+ if (!typedef.extras.every(extra => Object.prototype.hasOwnProperty.call(data, extra)))
+ return false;
+ }
+ return true;
+ });
+
+ if (!found) {
+ return undefined;
+ }
+
+ const [ type, typedef ] = found;
+
+ const newData = {};
+ newData.type = type;
+ newData.id = data[typedef.id];
+ if (typedef.extras)
+ typedef.extras.forEach(extra => newData[extra] = data[extra]);
+
+ return newData;
+}
+
+function setTransferData(event, validDragObject, setDragImage = false) {
+ if (setDragImage) {
+ const dragItems = Array.isArray(validDragObject) ? validDragObject : [ validDragObject ];
+ const dragElements = dragItems.map(item => {
+ const icon = document.createElement('i');
+ const label = document.createElement('span');
+ const iconContainer = document.createElement('span');
+
+ iconContainer.className = 'btn btn-outline-dark bg-light';
+ label.className = 'small';
+
+ if (TYPE_DEFINITION[item.type]) {
+ icon.className = TYPE_DEFINITION[item.type].dragIcon || 'fa-solid fa-question';
+ label.textContent = item.id;
+ } else if (item.type.substr(-11) == '-collection' && TYPE_DEFINITION[item.type.substr(0, item.type.length-11)]) {
+ iconContainer.style.boxShadow = '3px 3px var(--bs-btn-border-color)';
+ icon.className = TYPE_DEFINITION[item.type.substr(0, item.type.length-11)].dragIcon || 'fa-solid fa-question';
+ label.textContent = 'x' + item.values.length;
+ } else {
+ icon.className = 'fa-solid fa-question';
+ label.textContent = item.id || '';
+ }
+
+ iconContainer.append(icon);
+
+ const itemContainer = document.createElement('div');
+ itemContainer.className = 'd-flex flex-column align-items-center gap-2 small';
+ itemContainer.append(iconContainer, label);
+ return itemContainer;
+ });
+
+ const container = document.createElement('div');
+ container.className = 'd-flex flex-row gap-2 small';
+ container.append(...dragElements);
+
+ document.body.append(container);
+ event.dataTransfer.setDragImage(container, -25, 0);
+ requestAnimationFrame(() => {
+ document.body.removeChild(container);
+ });
+ }
+ if (Array.isArray(validDragObject)) {
+ return validDragObject.forEach(data => setTransferData(event, data));
+ }
+
+ event.dataTransfer.setData('application/fhc-' + validDragObject.type, JSON.stringify(validDragObject));
+}
+
+/**
+ * check if the dataTransfer types are in the allowed types array
+ * if strict is disabled at least one type must be the allowed array
+ * otherwise all types have to be in the allowed array
+ *
+ * @param Event event
+ * @param Array allowedTypes
+ * @param Boolean strict
+ */
+function eventHasTypes(event, allowedTypes, strict) {
+ if (!allowedTypes || !allowedTypes.length)
+ allowedTypes = VALID_TYPES;
+ allowedTypes = allowedTypes.map(type => 'application/fhc-' + type);
+
+ const dataTypes = [...event.dataTransfer.types];
+
+ // NOTE(chris): if dragging across browsers the dataTransfer object is
+ // set to a default one without data. Since we do not support dragging
+ // across browsers (yet) we return false which will disallow dropping.
+ if (!dataTypes.length)
+ return false;
+
+ if (!strict)
+ return allowedTypes.some(type => [...event.dataTransfer.types].includes(type));
+
+ return [...event.dataTransfer.types].every(type => allowedTypes.includes(type));
+}
+
+function bindDragEnterLeave(el, onEnter, onLeave) {
+ // NOTE(chris): add save dragenter and dragleave events
+ // that won't fire when hovering over child elements
+
+ let skipLeave = false;
+ let skipLeaveParent = true;
+
+ function init(evt) {
+ skipLeave = false;
+ skipLeaveParent = true;
+ // add global listeners
+ window.addEventListener('dragenter', globalDragenter, true);
+ window.addEventListener('dragleave', globalDragleave, true);
+ window.addEventListener('drop', globalDrop, true);
+ // call enter
+ onEnter(evt);
+ // remove self
+ el.removeEventListener('dragenter', init);
+ }
+
+ function cleanup(evt, wasDropped) {
+ // remove global listeners
+ window.removeEventListener('dragenter', globalDragenter, true);
+ window.removeEventListener('dragleave', globalDragleave, true);
+ window.removeEventListener('drop', globalDrop, true);
+ // call leave
+ onLeave(evt, wasDropped);
+ // add init
+ el.addEventListener('dragenter', init);
+ }
+
+ function globalDragenter(evt) {
+ skipLeaveParent = false;
+ if (el != evt.target && !el.contains(evt.target)) {
+ cleanup(evt);
+ } else {
+ skipLeave = true;
+ }
+ }
+ function globalDragleave(evt) {
+ if (el != evt.target && !el.contains(evt.target)) {
+ if (skipLeaveParent) {
+ skipLeaveParent = false;
+ return;
+ }
+ } else {
+ if (skipLeave) {
+ skipLeave = false;
+ return;
+ }
+ }
+ cleanup(evt);
+ }
+ function globalDrop(evt) {
+ cleanup(evt, true);
+ }
+
+ el.addEventListener('dragenter', init);
+
+ return () => {
+ // cleanup
+ el.removeEventListener('dragenter', init);
+ }
+}
+
+export {
+ isValidDragObject,
+ getValidTransferData,
+ isValidTransferData,
+ getTransferData,
+ convertToValidDragObject,
+ setTransferData,
+ eventHasTypes,
+ bindDragEnterLeave
+};
+export default {
+ ...TYPE_CONSTANTS,
+ isValidDragObject,
+ getValidTransferData,
+ isValidTransferData,
+ getTransferData,
+ convertToValidDragObject,
+ setTransferData,
+ eventHasTypes,
+ bindDragEnterLeave
+};
diff --git a/public/js/plugins/Api.js b/public/js/plugins/Api.js
index 0b8e2fd17..6b9627698 100644
--- a/public/js/plugins/Api.js
+++ b/public/js/plugins/Api.js
@@ -546,6 +546,9 @@ export default {
} else {
console.error("FhcApi: method not allowed:", method);
}
+ },
+ getErrorHandler(config) {
+ return get_error_handler(config);
}
};
diff --git a/system/phrasesupdate.php b/system/phrasesupdate.php
index 376acab3f..b0e0385d3 100644
--- a/system/phrasesupdate.php
+++ b/system/phrasesupdate.php
@@ -1535,6 +1535,26 @@ $phrases = array(
)
)
),
+ array(
+ 'app' => 'core',
+ 'category' => 'ui',
+ 'phrase' => 'change',
+ 'insertvon' => 'system',
+ 'phrases' => array(
+ array(
+ 'sprache' => 'German',
+ 'text' => 'Ändern',
+ 'description' => '',
+ 'insertvon' => 'system'
+ ),
+ array(
+ 'sprache' => 'English',
+ 'text' => 'Change',
+ 'description' => '',
+ 'insertvon' => 'system'
+ )
+ )
+ ),
array(
'app' => 'core',
'category' => 'ui',
@@ -25431,6 +25451,26 @@ array(
)
)
),
+ array(
+ 'app' => 'core',
+ 'category' => 'ui',
+ 'phrase' => 'error_fieldNotFound',
+ 'insertvon' => 'system',
+ 'phrases' => array(
+ array(
+ 'sprache' => 'German',
+ 'text' => '{field} nicht gefunden',
+ 'description' => '',
+ 'insertvon' => 'system'
+ ),
+ array(
+ 'sprache' => 'English',
+ 'text' => '{field} not found',
+ 'description' => '',
+ 'insertvon' => 'system'
+ )
+ )
+ ),
array(
'app' => 'core',
'category' => 'notiz',
@@ -39324,6 +39364,47 @@ array(
)
)
),
+ // groups
+ array(
+ 'app' => 'core',
+ 'category' => 'stv',
+ 'phrase' => 'groups_error_notallstudents',
+ 'insertvon' => 'system',
+ 'phrases' => array(
+ array(
+ 'sprache' => 'German',
+ 'text' => 'Fehler: Es können nur Studierende mit UID verschoben werden.',
+ 'description' => '',
+ 'insertvon' => 'system'
+ ),
+ array(
+ 'sprache' => 'English',
+ 'text' => 'Error: Only students with UID can be moved.',
+ 'description' => '',
+ 'insertvon' => 'system'
+ )
+ )
+ ),
+ array(
+ 'app' => 'core',
+ 'category' => 'stv',
+ 'phrase' => 'groups_error_notsamestg',
+ 'insertvon' => 'system',
+ 'phrases' => array(
+ array(
+ 'sprache' => 'German',
+ 'text' => 'Fehler: Alle Studierenden müssen im selben Studiengang sein.',
+ 'description' => '',
+ 'insertvon' => 'system'
+ ),
+ array(
+ 'sprache' => 'English',
+ 'text' => 'Error: All students must be in the same program.',
+ 'description' => '',
+ 'insertvon' => 'system'
+ )
+ )
+ ),
//**************************** CORE/document_export
array(
@@ -43299,6 +43380,66 @@ array(
)
)
),
+ array(
+ 'app' => 'core',
+ 'category' => 'gruppenmanagement',
+ 'phrase' => 'special_groups',
+ 'insertvon' => 'system',
+ 'phrases' => array(
+ array(
+ 'sprache' => 'German',
+ 'text' => 'Spezialgruppen',
+ 'description' => '',
+ 'insertvon' => 'system'
+ ),
+ array(
+ 'sprache' => 'English',
+ 'text' => 'Special groups',
+ 'description' => '',
+ 'insertvon' => 'system'
+ )
+ )
+ ),
+ array(
+ 'app' => 'core',
+ 'category' => 'gruppenmanagement',
+ 'phrase' => 'add_group',
+ 'insertvon' => 'system',
+ 'phrases' => array(
+ array(
+ 'sprache' => 'German',
+ 'text' => 'Gruppe hinzufügen',
+ 'description' => '',
+ 'insertvon' => 'system'
+ ),
+ array(
+ 'sprache' => 'English',
+ 'text' => 'Add group',
+ 'description' => '',
+ 'insertvon' => 'system'
+ )
+ )
+ ),
+ array(
+ 'app' => 'core',
+ 'category' => 'gruppenmanagement',
+ 'phrase' => 'groups_added',
+ 'insertvon' => 'system',
+ 'phrases' => array(
+ array(
+ 'sprache' => 'German',
+ 'text' => '{n} Gruppen hinzufügen',
+ 'description' => '',
+ 'insertvon' => 'system'
+ ),
+ array(
+ 'sprache' => 'English',
+ 'text' => 'Added {n} groups',
+ 'description' => '',
+ 'insertvon' => 'system'
+ )
+ )
+ ),
array(
'app' => 'core',
'category' => 'gruppenmanagement',
@@ -43339,6 +43480,26 @@ array(
)
)
),
+ array(
+ 'app' => 'core',
+ 'category' => 'gruppenmanagement',
+ 'phrase' => 'error_alreadyInGroup',
+ 'insertvon' => 'system',
+ 'phrases' => array(
+ array(
+ 'sprache' => 'German',
+ 'text' => 'Der Student {uid} ist bereits im {studiensemester_kurzbz} dieser Gruppe zugeteilt. Entfernen Sie vorher diese Zuteilung.',
+ 'description' => '',
+ 'insertvon' => 'system'
+ ),
+ array(
+ 'sprache' => 'English',
+ 'text' => 'Student {uid} is already assigned to this group in {studiensemester_kurzbz}. Remove this assignment beforehand.',
+ 'description' => '',
+ 'insertvon' => 'system'
+ )
+ )
+ ),
//////////// FHC4 Phrases Gruppen End ////////////
array(