Ubuntu
/*!
* Matomo - free/libre analytics platform
*
* @link https://matomo.org
* @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
*/
import {
reactive,
computed,
readonly,
DeepReadonly,
} from 'vue';
import { AjaxHelper } from 'CoreHome';
import { Version } from '../types';
interface VersionsStoreState {
versions: Version[];
isLoadingVersions: boolean;
isLoadingSingle: boolean;
isUpdating: boolean;
}
class VersionsStore {
private privateState = reactive({
versions: [],
isLoadingVersions: false,
isLoadingSingle: false,
isUpdating: false,
});
private state = computed(() => readonly(this.privateState));
readonly isLoading = computed(() => {
const state = this.state.value;
return state.isLoadingVersions || state.isLoadingSingle;
});
readonly isUpdating = computed(() => this.state.value.isUpdating);
readonly versions = computed(() => this.state.value.versions);
private fetchPromise: Promise | null = null;
reload(
idContainer: string,
): ReturnType {
this.privateState.versions = [];
this.fetchPromise = null;
return this.fetchVersions(idContainer);
}
fetchVersions(
idContainer: string|number,
): Promise {
this.privateState.isLoadingVersions = true;
this.privateState.versions = [];
if (!this.fetchPromise) {
this.fetchPromise = AjaxHelper.fetch({
method: 'TagManager.getContainerVersions',
idContainer,
filter_limit: '-1',
});
}
return Promise.resolve(this.fetchPromise).then((versions) => {
this.privateState.versions = versions;
this.privateState.isLoadingVersions = false;
return this.versions.value;
}).finally(() => {
this.privateState.isLoadingVersions = false;
});
}
findVersion(
idContainer: string,
idContainerVersion: number,
): Promise> {
// before going through an API request we first try to find it in loaded versions
const found = this.versions.value.find((v) => v.idcontainerversion === idContainerVersion);
if (found) {
return Promise.resolve(found);
}
// otherwise we fetch it via API
this.privateState.isLoadingSingle = true;
return AjaxHelper.fetch({
idContainerVersion,
idContainer,
method: 'TagManager.getContainerVersion',
filter_limit: '-1',
}).then((record) => {
this.privateState.versions = [...this.privateState.versions, record];
return readonly(record);
}).finally(() => {
this.privateState.isLoadingSingle = false;
});
}
deleteVersion(
idContainer: string,
idContainerVersion: number,
): Promise {
this.privateState.isUpdating = true;
this.privateState.versions = [];
return AjaxHelper.fetch(
{
idContainerVersion,
idContainer,
method: 'TagManager.deleteContainerVersion',
},
{ withTokenInUrl: true },
).finally(() => {
this.privateState.isUpdating = false;
});
}
publishVersion(
idContainer: string,
idContainerVersion: number,
environment: string,
): Promise {
this.privateState.isUpdating = true;
return AjaxHelper.fetch({
idContainer,
idContainerVersion,
environment,
method: 'TagManager.publishContainerVersion',
}).finally(() => {
this.privateState.isUpdating = false;
});
}
createOrUpdateVersion(
version: DeepReadonly|Version,
method: string,
idContainer: string,
): Promise<{ value: number }> {
this.privateState.isUpdating = true;
return AjaxHelper.post<{ value: number }>(
{
method,
idContainer,
idContainerVersion: version.idcontainerversion,
},
{
name: version.name,
description: version.description,
},
{ withTokenInUrl: true },
).finally(() => {
this.privateState.isUpdating = false;
});
}
}
export default new VersionsStore();