Folgender Code wird in der Analysis.vue verwendet:

        <v-data-table-server
            id="tableEdit"
            :key="updatingDataTable"
            v-model="selectedAnalysis"
            v-draggable-columns
            :headers="showHeaders"
            :items="analysisList"
            :items-length="totalItems"
            :items-per-page="pageSize"
            :loading="loadingData"
            :no-data-text="noDataText"
            class="elevation-1"
            data-cy="tableEdit"
            density="compact"
            hover
            item-value="iId"
            loading-text="Please wait, fetching data ..."
            locale="de-AT"
            multi-sort
            return-object
            show-select
            @arrangedColumn="checkOrder"
            @update:options="checkOptions($event)"
            @dblclick:row="handleRowDoubleClick"
        >
const headersMap = ref({
  aId: {title: "ID", value: "aId", sortable: true, selection: null, filter: {start: "", end: ""}},
  sId: {title: "SampleID", value: "sample.sampleId.sId", sortable: true, filter: {start: "", end: ""}},
  sStamp: {title: "SampleTime", value: "sample.sampleId.sStamp", sortable: true, align: 'right'},
  dateIn: {
    title: "DateIn", value: "dateIn", sortable: true, filter: {start: "", end: ""}, editable: true,
    align: 'right'
  },
  dateOut: {
    title: "DateOut", value: "dateOut", sortable: true, filter: {start: "", end: ""}, editable: true,
    align: 'right'
  },
  aFlags: {title: "Flags", value: "aFlags", sortable: true, filter: null, editable: true},
  pol: {title: "pol", value: "pol", sortable: true, editable: true, align: 'right'},
  kal: {title: "kal", value: "kal", sortable: true, editable: true, align: 'right'},
  nat: {title: "nat", value: "nat", sortable: true, editable: true, align: 'right'},
  an: {title: "amino", value: "an", sortable: true, editable: true, align: 'right'},
  glu: {title: "glu", value: "glu", sortable: true, editable: true, align: 'right'},
  dry: {title: "dry", value: "dry", sortable: true, editable: true, align: 'right'},
  boxPos: {title: "Box", value: "boxPos", sortable: true, editable: false, align: 'center'},
  weightBru: {title: "weightBru", value: "weightBru", sortable: true, editable: false, align: 'right'},
  weightNet: {title: "weightNet", value: "weightNet", sortable: true, editable: false, align: 'right'},
  name: {title: "Name", value: "name", sortable: true, editable: false},
  weightMea: {title: "weightMea", value: "weightMea", sortable: true, editable: true, align: 'right'},
  weightNrm: {title: "weightNrm", value: "weightNrm", sortable: true, editable: true, align: 'right'},
  weightCur: {title: "weightCur", value: "weightCur", sortable: true, editable: true, align: 'right'},
  weightDif: {title: "weightDif", value: "weightDif", sortable: true, editable: true, align: 'right'},
  density: {title: "dens", value: "density", sortable: true, editable: true, align: 'right'},
  lane: {title: "lane", value: "lane", sortable: true, filter: null, editable: true, align: 'center'},
  comment: {title: "comment", value: "comment", sortable: true, editable: true},
  dateExported: {title: "dateExported", value: "dateExported", sortable: true, editable: true, align: 'right'},
})

Welche Aussagen treffen dabei zu?

Folgende Axios Konfiguration ist vorgesehen:

import axios from "axios";
import authHeader from "@/services/AuthHeader";
const instance = axios.create({
  headers: {
    'Content-type': 'application/json' },
  timeout: 60000,
  baseURL: "https://venlab.backend.at/api
"
});
instance.interceptors.request.use(
    config => {
      const headers = authHeader();
      if (headers) {
        config.headers = { ...config.headers, ...headers };
      }
      return config;
    },
    error => {
        return Promise.reject(error);
    }
)
export default instance

Ist diese funktionstüchtig?

Folgende Klassen wurden als Mapping in Javascript definiert:

export default class Sample {
    constructor(sample) {
        this.sampleId = {
            sId: sample.sampleId.sId,
            sStamp: sample.sampleId.sStamp,
        };
        this.name = sample.name;
        this.weightNet = sample.weightNet;
        this.weightBru = sample.weightBru;
        this.weightTar = sample.weightTar;
        this.quantity = sample.quantity;
        this.distance = sample.distance;
        this.dateCrumbled = sample.dateCrumbled;
        this.sFlags = sample.sFlags;
        this.lane = sample.lane;
        this.comment = sample.comment;
        this.dateExported = sample.dateExported;
        this.boxPos = sample.boxPos;
    }
}

export default class Analysis {
    constructor(analysis) {
        this.aId = analysis.aId;
        this.sample = {
            sampleId: {
                sId: analysis.sample.sampleId.sId,
                sStamp: analysis.sample.sampleId.sStamp,
            },
            weightNet: analysis.sample.weightNet,
            weightBru: analysis.sample.weightBru,
            name: analysis.sample.name,
        };
        this.aFlags = analysis.aFlags;
        this.dateIn = analysis.dateIn;
        this.dateOut = analysis.dateOut;
        this.pol = analysis.pol;
        this.nat = analysis.nat;
        this.kal = analysis.kal;
        this.an = analysis.an;
        this.glu = analysis.glu;
        this.dry = analysis.dry;
        this.boxPos = analysis.sample.boxPos;
        this.weightNet = analysis.sample.weightNet;
        this.weightBru = analysis.sample.weightBru;
        this.name = analysis.sample.name;
        this.weightMea = analysis.weightMea;
        this.weightNrm = analysis.weightNrm;
        this.weightCur = analysis.weightCur;
        this.weightDif = analysis.weightDif;
        this.density = analysis.density;
        this.lane = analysis.lane;
        this.comment = analysis.comment;
        this.dateExported = analysis.dateExported;
    }
}

Welche Antworten sind zutreffend?

Folgendes Mapping für Box ist vorgesehen:

export default class Box {
    constructor(box) {
        this.bId = box.bId;
        this.name = box.name;
        this.numMax = box.numMax;
        this.type = box.type;
        this.comment = box.comment;
        this.dateExported = box.dateExported;
    }
}

Ist diese vollständig?

Folgender Code wird als Axios Schnittstelle in der JS-Implementierung verwendet:

import http from "../plugins/axios";
import store from "../store";
class AnalysisDataService {
    getAll() {
        return http.get("/analysis");
    }
    getView(params, cancelToken) {
        return http.get("/analysis/view", {params: params, cancelToken: cancelToken});
    }
    get(id) {
        return http.get(`/analysis/${id}`);
    }
    create(data) {
        if (store.getters["auth/assignedRoles"].includes("ROLE_ADMIN")) return http.post("/analysis", data);
        else return Promise.resolve("");
    }
    update(id, data) {
        if (store.getters["auth/assignedRoles"].includes("ROLE_ADMIN")) return http.put(`/analysis/${id}`, data);
        else return Promise.resolve("");
    }
    delete(id) {
        if (store.getters["auth/assignedRoles"].includes("ROLE_ADMIN")) return http.delete(`/analysis/${id}`);
        else return Promise.resolve("");
    }
    findById(id) {
        return http.get(`/analysis/${id}`);
    }
    findBySampleIds(params) {
        return http.get(`/analysis/samples`, {params: params});
    }
    findByStartsWithSampleId(sId) {
        return http.get(`/analysis/sid/startsWith/${sId}`);
    }
    findBySampleId(sId, timestamp) {
        return http.get(`/analysis/sid/${sId}/${timestamp}`);
    }
    getFileExport(type, params) {
        return http.get(`/analysis/export/${type}`, {params: params, responseType: 'blob'});
    }
    getExportFileName() {
        return http.get(`/analysis/exportfilename`);
    }
    checkFileExport(filename, params) {
        return http.get(`/export/check/${filename}`, {params: params});
    }
    downloadFileExport(filename, params) {
        return http.get(`/export/download/${filename}`, {params: params, responseType: 'blob'});
    }
}
export default new AnalysisDataService();

Welche Antworten treffen zu?

Ein Domain Model im Kontext von MVC bildet die fachliche Domäne als Objektmodell mit Daten und Verhalten ab und ist Kern der Geschäftslogik.

Im MVC steht das Model für das Domänenmodell: Es repräsentiert den fachlichen Zustand der Anwendung und kapselt Geschäftsregeln und Invarianten, unabhängig von UI oder Persistenzdetails.

Views greifen nur lesend auf das Domain Model zu, Controller lösen Änderungen aus, indem sie Operationen auf dem Domain Model ausführen.

​

Eine Vue.js-Anwendung wird als JavaScript-Code im Browser des Benutzers ausgeführt. Der Browser lädt die HTML-, CSS- und JavaScript-Dateien der Anwendung. Sobald der JavaScript-Code geladen ist, initialisiert Vue die Anwendung, "mountet" sie an ein bestimmtes DOM-Element (oft ein

<

div id="app">) und übernimmt die Kontrolle über diesen Bereich, um die Komponenten zu rendern und auf Benutzerinteraktionen zu reagieren.