[DEV] update new archidata

.island/release.bash

@@ -5,7 +5,7 @@ version_file="../version.txt"
 # update new release dependency
 cd back
 # update the Maven version number
-mvn versions:set -DnewVersion=$(sed 's/DEV/SNAPSHOT/g' $version_file)
+mvn versions:set -DnewVersion=$(sed 's/dev/SNAPSHOT/g' $version_file)
 if grep -q "DEV" "$version_file"; then
     # update all versions release of dependency
     mvn versions:use-latest-releases 
@@ -19,11 +19,14 @@ cd -
 
 
 cd front
-if grep -q "DEV" "$version_file"; then
+if grep -q "dev" "$version_file"; then
     # update all dependency
     pnpm install
     pnpm run update_packages
 else
     # in case of release ==> can not do it automatically ...
+    echo not implemented
 fi
+
 cd -
+

Dockerfile

@@ -59,15 +59,6 @@ FROM bellsoft/liberica-openjdk-alpine:latest
 # add wget to manage the health check...
 RUN apk add --no-cache wget
 
-#FROM archlinux:base
-#RUN pacman -Syu --noconfirm && pacman-db-upgrade
-## install package
-#RUN pacman -S --noconfirm jdk-openjdk wget
-## intall npm
-#RUN pacman -S --noconfirm npm
-## clean all the caches Need only on the release environment
-#RUN pacman -Scc --noconfirm
-
 ENV LANG=C.UTF-8
 
 COPY --from=buildBack /tmp/out/maven/*.jar /application/application.jar

back/pom.xml

@@ -20,17 +20,17 @@
 		<dependency>
 			<groupId>kangaroo-and-rabbit</groupId>
 			<artifactId>archidata</artifactId>
-			<version>0.8.4</version>
+			<version>0.12.0</version>
 		</dependency>
 		<dependency>
 			<groupId>org.slf4j</groupId>
 			<artifactId>slf4j-simple</artifactId>
-			<version>2.0.9</version>
+			<version>2.1.0-alpha1</version>
 		</dependency>
 		<dependency>
 			<groupId>com.fasterxml.jackson.datatype</groupId>
 			<artifactId>jackson-datatype-jsr310</artifactId>
-			<version>2.16.1</version>
+			<version>2.17.1</version>
 		</dependency>
 		<!--
 		************************************************************ 
@@ -40,15 +40,25 @@
 		<dependency>
 			<groupId>org.junit.jupiter</groupId>
 			<artifactId>junit-jupiter-api</artifactId>
-			<version>5.10.1</version>
+			<version>5.11.0-M2</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.junit.jupiter</groupId>
 			<artifactId>junit-jupiter-engine</artifactId>
-			<version>5.10.1</version>
+			<version>5.11.0-M2</version>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>net.revelc.code.formatter</groupId>
+			<artifactId>formatter-maven-plugin</artifactId>
+			<version>2.24.0</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.maven.plugins</groupId>
+			<artifactId>maven-checkstyle-plugin</artifactId>
+			<version>3.3.1</version>
+		</dependency>
 	</dependencies>
 	<build>
 		<sourceDirectory>src</sourceDirectory>
@@ -185,24 +195,10 @@
 					<mainClass>org.kar.karideo.WebLauncher</mainClass>
 				</configuration>
 			</plugin>
-			<!-- Check the style of the code -->
-			<!--
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-checkstyle-plugin</artifactId>
-				<version>3.1.0</version>
-				<configuration>
-					<configLocation>CheckStyle.xml</configLocation>
-					<consoleOutput>true</consoleOutput>
-					<failOnViolation>true</failOnViolation>
-					<failsOnError>true</failsOnError>
-					<includeTestSourceDirectory>true</includeTestSourceDirectory>
-				</configuration>
-			</plugin>
 			<plugin>
 				<groupId>net.revelc.code.formatter</groupId>
 				<artifactId>formatter-maven-plugin</artifactId>
-				<version>2.12.2</version>
+				<version>2.23.0</version>
 				<configuration>
 					<encoding>UTF-8</encoding>
 					<lineEnding>LF</lineEnding>
@@ -226,7 +222,23 @@
 					</execution>
 				</executions>
 			</plugin>
+			<plugin>
+				<groupId>com.github.spotbugs</groupId>
+				<artifactId>spotbugs-maven-plugin</artifactId>
+				<version>4.8.5.0</version>
+				<configuration>
+					<includeFilterFile>spotbugs-security-include.xml</includeFilterFile>
+					<excludeFilterFile>spotbugs-security-exclude.xml</excludeFilterFile>
+					<!--<plugins>
+						<plugin>
+							<groupId>com.h3xstream.findsecbugs</groupId>
+							<artifactId>findsecbugs-plugin</artifactId>
+							<version>1.12.0</version>
+						</plugin>
+					</plugins>
 					-->
+				</configuration>
+			</plugin>
 		</plugins>
 	</build>
 	<!-- Generate Java-docs As Part Of Project Reports -->

back/src/org/kar/karideo/WebLauncher.java

@@ -10,10 +10,7 @@ import org.glassfish.jersey.server.ResourceConfig;
 import org.kar.archidata.GlobalConfiguration;
 import org.kar.archidata.UpdateJwtPublicKey;
 import org.kar.archidata.api.DataResource;
-import org.kar.archidata.catcher.ExceptionCatcher;
+import org.kar.archidata.catcher.GenericCatcher;
-import org.kar.archidata.catcher.FailExceptionCatcher;
-import org.kar.archidata.catcher.InputExceptionCatcher;
-import org.kar.archidata.catcher.SystemExceptionCatcher;
 import org.kar.archidata.db.DBConfig;
 import org.kar.archidata.filter.CORSFilter;
 import org.kar.archidata.filter.OptionFilter;
@@ -95,10 +92,7 @@ public class WebLauncher {
 		// global authentication system
 		rc.register(KarideoAuthenticationFilter.class);
 		// register exception catcher
-		rc.register(InputExceptionCatcher.class);
+		GenericCatcher.addAll(rc);
-		rc.register(SystemExceptionCatcher.class);
-		rc.register(FailExceptionCatcher.class);
-		rc.register(ExceptionCatcher.class);
 		// add default resource:
 		rc.register(UserResource.class);
 		rc.register(SeriesResource.class);

back/src/org/kar/karideo/WebLauncherLocal.java

@@ -4,7 +4,8 @@ package org.kar.karideo;
 import java.util.List;
 
 import org.kar.archidata.api.DataResource;
-import org.kar.archidata.dataAccess.DataFactoryTsApi;
+import org.kar.archidata.externalRestApi.AnalyzeApi;
+import org.kar.archidata.externalRestApi.TsGenerateApi;
 import org.kar.archidata.tools.ConfigBaseVariable;
 import org.kar.karideo.api.Front;
 import org.kar.karideo.api.HealthCheck;
@@ -14,7 +15,6 @@ import org.kar.karideo.api.SeriesResource;
 import org.kar.karideo.api.TypeResource;
 import org.kar.karideo.api.UserMediaAdvancementResource;
 import org.kar.karideo.api.UserResource;
-import org.kar.karideo.migration.Initialization;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -23,18 +23,18 @@ public class WebLauncherLocal extends WebLauncher {
 
 	private WebLauncherLocal() {}
 
+	public static void generateObjects() throws Exception {
+		LOGGER.info("Generate APIs");
+		final List<Class<?>> listOfResources = List.of(Front.class, HealthCheck.class, SeasonResource.class, SeriesResource.class, TypeResource.class, UserMediaAdvancementResource.class,
+				UserResource.class, MediaResource.class, DataResource.class);
+		final AnalyzeApi api = new AnalyzeApi();
+		api.addAllApi(listOfResources);
+		TsGenerateApi.generateApi(api, "../front/src/app/back-api/");
+		LOGGER.info("Generate APIs (DONE)");
+	}
+
 	public static void main(final String[] args) throws Exception {
-		DataFactoryTsApi.generatePackage(List.of(
+		generateObjects();
-				Front.class,
-				HealthCheck.class,
-				SeasonResource.class,
-				SeriesResource.class,
-				TypeResource.class,
-				UserMediaAdvancementResource.class,
-				UserResource.class,
-				MediaResource.class,
-				DataResource.class),
-				Initialization.CLASSES_BASE, "../front/src/app/back-api/");
 		final WebLauncherLocal launcher = new WebLauncherLocal();
 		launcher.process();
 		LOGGER.info("end-configure the server & wait finish process:");

back/src/org/kar/karideo/api/Front.java

@@ -1,6 +1,5 @@
 package org.kar.karideo.api;
 
-
 import org.kar.archidata.api.FrontGeneric;
 
 import jakarta.ws.rs.Path;

back/src/org/kar/karideo/api/SeasonResource.java

@@ -35,7 +35,6 @@ import jakarta.ws.rs.core.MediaType;
 public class SeasonResource {
 	static final Logger LOGGER = LoggerFactory.getLogger(SeasonResource.class);
 
-
 	@GET
 	@RolesAllowed("USER")
 	@Operation(description = "Get a specific Season with his ID", tags = "GLOBAL")
@@ -52,9 +51,7 @@ public class SeasonResource {
 		return DataAccess.get(Season.class, id);
 	}
 
-	/* =============================================================================
+	/* ============================================================================= ADMIN SECTION: ============================================================================= */
-	 * ADMIN SECTION:
-	 * ============================================================================= */
 
 	@POST
 	@RolesAllowed("ADMIN")

back/src/org/kar/karideo/api/SeriesResource.java

@@ -51,9 +51,7 @@ public class SeriesResource {
 		return DataAccess.get(Series.class, id);
 	}
 
-	/* =============================================================================
+	/* ============================================================================= ADMIN SECTION: ============================================================================= */
-	 * ADMIN SECTION:
-	 * ============================================================================= */
 
 	@POST
 	@RolesAllowed("ADMIN")

back/src/org/kar/karideo/api/TypeResource.java

@@ -34,7 +34,6 @@ import jakarta.ws.rs.core.MediaType;
 public class TypeResource {
 	static final Logger LOGGER = LoggerFactory.getLogger(TypeResource.class);
 
-
 	@GET
 	@RolesAllowed("USER")
 	@Operation(description = "Get all Type", tags = "GLOBAL")
@@ -55,9 +54,7 @@ public class TypeResource {
 		return DataAccess.get(Type.class, id);
 	}
 
-	/* =============================================================================
+	/* ============================================================================= ADMIN SECTION: ============================================================================= */
-	 * ADMIN SECTION:
-	 * ============================================================================= */
 
 	@POST
 	@RolesAllowed("ADMIN")

back/src/org/kar/karideo/api/UserMediaAdvancementResource.java

@@ -46,14 +46,10 @@ public class UserMediaAdvancementResource {
 		return DataAccess.getsWhere(UserMediaAdvancement.class, new Condition(new QueryCondition("userId", "=", gc.userByToken.id)));
 	}
 
-	/* =============================================================================
+	/* ============================================================================= Modification SECTION: ============================================================================= */
-	 * Modification SECTION:
-	 * ============================================================================= */
 
-	public record MediaInformations(
+	public record MediaInformations(int time, float percent, int count) {
-			int time,
+	}
-			float percent,
-			int count) {}
 
 	// @POST
 	// @Path("{id}")
@@ -70,10 +66,8 @@ public class UserMediaAdvancementResource {
 		return DataAccess.insert(elem);
 	}
 
-	public record MediaInformationsDelta(
+	public record MediaInformationsDelta(int time, float percent, boolean addCount) {
-			int time,
+	}
-			float percent,
-			boolean addCount) {}
 
 	@PATCH
 	@Path("{id}")

back/src/org/kar/karideo/migration/Initialization.java

@@ -2,6 +2,7 @@ package org.kar.karideo.migration;
 
 import java.util.List;
 
+import org.kar.archidata.dataAccess.DataAccess;
 import org.kar.archidata.migration.MigrationSqlStep;
 import org.kar.archidata.model.Data;
 import org.kar.archidata.model.User;
@@ -10,12 +11,16 @@ import org.kar.karideo.model.Season;
 import org.kar.karideo.model.Series;
 import org.kar.karideo.model.Type;
 import org.kar.karideo.model.UserMediaAdvancement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class Initialization extends MigrationSqlStep {
+	private static final Logger LOGGER = LoggerFactory.getLogger(Initialization.class);
 
 	public static final int KARSO_INITIALISATION_ID = 1;
 
 	public static final List<Class<?>> CLASSES_BASE = List.of(Data.class, Media.class, Type.class, Series.class, Season.class, User.class, UserMediaAdvancement.class);
+
 	@Override
 	public String getName() {
 		return "Initialization";
@@ -62,4 +67,25 @@ public class Initialization extends MigrationSqlStep {
 				""", "mysql");
 	}
 
+	public static void dropAll() {
+		for (final Class<?> element : CLASSES_BASE) {
+			try {
+				DataAccess.drop(element);
+			} catch (final Exception ex) {
+				LOGGER.error("Fail to drop table !!!!!!");
+				ex.printStackTrace();
+			}
+		}
+	}
+
+	public static void cleanAll() {
+		for (final Class<?> element : CLASSES_BASE) {
+			try {
+				DataAccess.cleanAll(element);
+			} catch (final Exception ex) {
+				LOGGER.error("Fail to clean table !!!!!!");
+				ex.printStackTrace();
+			}
+		}
+	}
 }

back/src/org/kar/karideo/migration/Migration20240226.java

@@ -119,11 +119,7 @@ public class Migration20240226 extends MigrationSqlStep {
 				}
 			}
 		});
-		/* I am not sure then I prefer keep the primary key for the moment
+		/* I am not sure then I prefer keep the primary key for the moment addAction(""" ALTER TABLE `data` DROP `id`; """); */
-		addAction("""
-				ALTER TABLE `data` DROP `id`;
-				""");
-		 */
 		addAction("""
 				ALTER TABLE `data` CHANGE `id` `idOld` bigint NOT NULL DEFAULT 0;
 				""");

back/src/org/kar/karideo/model/Media.java

@@ -9,6 +9,7 @@ import org.kar.archidata.model.GenericDataSoftDelete;
 
 import com.fasterxml.jackson.annotation.JsonInclude;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.FetchType;
@@ -19,43 +20,41 @@ import jakarta.persistence.Table;
 @Table(name = "media")
 @JsonInclude(JsonInclude.Include.NON_NULL)
 public class Media extends GenericDataSoftDelete {
-	// Name of the media (this represent the title)
+	@Schema(description = "Name of the media (this represent the title)")
 	@Column(nullable = false, length = 0)
 	public String name;
-	// Description of the media
+	@Schema(description = "Description of the media")
 	@Column(length = 0)
 	public String description;
-	// Foreign Key Id of the data
+	@Schema(description = "Foreign Key Id of the data")
 	@ManyToOne(fetch = FetchType.LAZY, targetEntity = Data.class)
 	@Column(nullable = false)
 	public UUID dataId;
-	// Type of the media")
+	@Schema(description = "Type of the media")
 	@ManyToOne(fetch = FetchType.LAZY, targetEntity = Type.class)
 	public Long typeId;
-	// Series reference of the media
+	@Schema(description = "Series reference of the media")
 	@ManyToOne(fetch = FetchType.LAZY, targetEntity = Series.class)
 	public Long seriesId;
-	// Season reference of the media
+	@Schema(description = "Season reference of the media")
 	@ManyToOne(fetch = FetchType.LAZY, targetEntity = Season.class)
 	public Long seasonId;
-	// Episode Id
+	@Schema(description = "Episode Id")
 	public Integer episode;
 	// ")
 	public Integer date;
-	// Creation years of the media
+	@Schema(description = "Creation years of the media")
 	public Integer time;
-	// Limitation Age of the media
+	@Schema(description = "Limitation Age of the media")
 	public Integer ageLimit;
-	// List of Id of the specific covers
+	@Schema(description = "List of Id of the specific covers")
 	@DataJson(targetEntity = Data.class)
 	public List<UUID> covers = null;
 
 	@Override
 	public String toString() {
-		return "Media [name=" + this.name + ", description=" + this.description + ", dataId=" + this.dataId + ", typeId=" + this.typeId
+		return "Media [name=" + this.name + ", description=" + this.description + ", dataId=" + this.dataId + ", typeId=" + this.typeId + ", seriesId=" + this.seriesId + ", seasonId=" + this.seasonId
-				+ ", seriesId=" + this.seriesId + ", seasonId=" + this.seasonId + ", episode=" + this.episode + ", date=" + this.date
+				+ ", episode=" + this.episode + ", date=" + this.date + ", time=" + this.time + ", ageLimit=" + this.ageLimit + ", covers=" + this.covers + "]";
-				+ ", time=" + this.time + ", ageLimit=" + this.ageLimit + ", covers=" + this.covers + "]";
 	}
 
-
 }

back/test/src/test/kar/karideo/WebLauncherTest.java

@@ -12,17 +12,23 @@ public class WebLauncherTest extends WebLauncher {
 	public WebLauncherTest() {
 		LOGGER.debug("Configure REST system");
 		// for local test:
-		ConfigBaseVariable.apiAdress = "http://127.0.0.1:12345/test/api/";
+		ConfigBaseVariable.apiAdress = "http://127.0.0.1:12342/test/api/";
+		// Enable the test mode permit to access to the test token (never use it in production).
 		ConfigBaseVariable.testMode = "true";
-		//ConfigBaseVariable.dbPort = "3306";
 		// for the test we a in memory sqlite..
+		if (true) {
+			if (!"true".equalsIgnoreCase(System.getenv("TEST_E2E_MODE"))) {
 				ConfigBaseVariable.dbType = "sqlite";
 				ConfigBaseVariable.dbHost = "memory";
 				// for test we need to connect all time the DB
 				ConfigBaseVariable.dbKeepConnected = "true";
-		
+			}
-		//ConfigBaseVariable.dbHost = "localhost";
+		} else {
-		//ConfigBaseVariable.dbUser = "root";
+			// Enable this if you want to access to a local MySQL base to test with an adminer
-		//ConfigBaseVariable.dbPassword = "ZERTYSDGFVHSDFGHJYZSDFGSQxfgsqdfgsqdrf4564654";
+			ConfigBaseVariable.bdDatabase = "test_db";
+			ConfigBaseVariable.dbPort = "3309";
+			ConfigBaseVariable.dbUser = "root";
+			ConfigBaseVariable.dbPassword = "password";
+		}
 	}
 }

front/package.json

@@ -19,32 +19,32 @@
 	},
 	"private": true,
 	"dependencies": {
-		"@angular/animations": "^17.3.5",
+		"@angular/animations": "^18.0.2",
-		"@angular/cdk": "^17.3.5",
+		"@angular/cdk": "^18.0.2",
-		"@angular/common": "^17.3.5",
+		"@angular/common": "^18.0.2",
-		"@angular/compiler": "^17.3.5",
+		"@angular/compiler": "^18.0.2",
-		"@angular/core": "^17.3.5",
+		"@angular/core": "^18.0.2",
-		"@angular/forms": "^17.3.5",
+		"@angular/forms": "^18.0.2",
-		"@angular/material": "^17.3.5",
+		"@angular/material": "^18.0.2",
-		"@angular/platform-browser": "^17.3.5",
+		"@angular/platform-browser": "^18.0.2",
-		"@angular/platform-browser-dynamic": "^17.3.5",
+		"@angular/platform-browser-dynamic": "^18.0.2",
-		"@angular/router": "^17.3.5",
+		"@angular/router": "^18.0.2",
 		"rxjs": "^7.8.1",
-		"zone.js": "^0.14.4",
+		"zone.js": "^0.14.6",
-		"zod": "3.23.0",
+		"zod": "3.23.8",
-		"@kangaroo-and-rabbit/kar-cw": "^0.2.1"
+		"@kangaroo-and-rabbit/kar-cw": "^0.4.1"
 	},
 	"devDependencies": {
-		"@angular-devkit/build-angular": "^17.3.5",
+		"@angular-devkit/build-angular": "^18.0.3",
-		"@angular-eslint/builder": "17.3.0",
+		"@angular-eslint/builder": "18.0.1",
-		"@angular-eslint/eslint-plugin": "17.3.0",
+		"@angular-eslint/eslint-plugin": "18.0.1",
-		"@angular-eslint/eslint-plugin-template": "17.3.0",
+		"@angular-eslint/eslint-plugin-template": "18.0.1",
-		"@angular-eslint/schematics": "17.3.0",
+		"@angular-eslint/schematics": "18.0.1",
-		"@angular-eslint/template-parser": "17.3.0",
+		"@angular-eslint/template-parser": "18.0.1",
-		"@angular/cli": "^17.3.5",
+		"@angular/cli": "^18.0.3",
-		"@angular/compiler-cli": "^17.3.5",
+		"@angular/compiler-cli": "^18.0.2",
-		"@angular/language-service": "^17.3.5",
+		"@angular/language-service": "^18.0.2",
-		"npm-check-updates": "^16.14.18",
+		"npm-check-updates": "^16.14.20",
-		"tslib": "^2.6.2"
+		"tslib": "^2.6.3"
 	}
 }

front/src/app/back-api/api/data-resource.ts

@@ -1,21 +1,108 @@
 /**
- * API of the server (auto-generated code)
+ * Interface of the server (auto-generated code)
  */
 import {
 	HTTPMimeType,
 	HTTPRequestModel,
-  ModelResponseHttp,
-  RESTCallbacks,
 	RESTConfig,
 	RESTRequestJson,
-  RESTRequestJsonArray,
+	RESTRequestVoid,
-  RESTRequestVoid
+} from "../rest-tools";
-} from "./rest-tools"
+
 import {
 	UUID,
-} from "./model"
+} from "../model";
+
 export namespace DataResource {
 
+	/**
+	 * Get back some data from the data environment (with a beautiful name (permit download with basic name)
+	 */
+	export function retrieveDataFull({
+			restConfig,
+			queries,
+			params,
+			data,
+		}: {
+		restConfig: RESTConfig,
+		queries: {
+			Authorization?: string,
+		},
+		params: {
+			name: string,
+			uuid: UUID,
+		},
+		data: string,
+	}): Promise<object> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/data/{uuid}/{name}",
+				requestType: HTTPRequestModel.GET,
+			},
+			restConfig,
+			params,
+			queries,
+			data,
+		});
+	};
+	/**
+	 * Get back some data from the data environment
+	 */
+	export function retrieveDataId({
+			restConfig,
+			queries,
+			params,
+			data,
+		}: {
+		restConfig: RESTConfig,
+		queries: {
+			Authorization?: string,
+		},
+		params: {
+			uuid: UUID,
+		},
+		data: string,
+	}): Promise<object> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/data/{uuid}",
+				requestType: HTTPRequestModel.GET,
+			},
+			restConfig,
+			params,
+			queries,
+			data,
+		});
+	};
+	/**
+	 * Get a thumbnail of from the data environment (if resize is possible)
+	 */
+	export function retrieveDataThumbnailId({
+			restConfig,
+			queries,
+			params,
+			data,
+		}: {
+		restConfig: RESTConfig,
+		queries: {
+			Authorization?: string,
+		},
+		params: {
+			uuid: UUID,
+		},
+		data: string,
+	}): Promise<object> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/data/thumbnail/{uuid}",
+				requestType: HTTPRequestModel.GET,
+			},
+			restConfig,
+			params,
+			queries,
+			data,
+		});
+	};
 	/**
 	 * Insert a new data in the data environment
 	 */
@@ -38,95 +125,4 @@ export namespace DataResource {
 			data,
 		});
 	};
-	/**
-	 * Get back some data from the data environment
-	 */
-	// TODO: unmanaged "Response" type: please specify @AsyncType or considered as 'void'.
-	export function retrieveDataId({
-			restConfig,
-			queries,
-			params,
-			data,
-		}: {
-		restConfig: RESTConfig,
-		queries: {
-			Authorization?: string,
-		},
-		params: {
-			uuid: UUID,
-		},
-		data: string,
-	}): Promise<void> {
-		return RESTRequestVoid({
-			restModel: {
-				endPoint: "/data/{uuid}",
-				requestType: HTTPRequestModel.GET,
-			},
-			restConfig,
-			params,
-			queries,
-			data,
-		});
-	};
-	/**
-	 * Get a thumbnail of from the data environment (if resize is possible)
-	 */
-	// TODO: unmanaged "Response" type: please specify @AsyncType or considered as 'void'.
-	export function retrieveDataThumbnailId({
-			restConfig,
-			queries,
-			params,
-			data,
-		}: {
-		restConfig: RESTConfig,
-		queries: {
-			Authorization?: string,
-		},
-		params: {
-			uuid: UUID,
-		},
-		data: string,
-	}): Promise<void> {
-		return RESTRequestVoid({
-			restModel: {
-				endPoint: "/data/thumbnail/{uuid}",
-				requestType: HTTPRequestModel.GET,
-			},
-			restConfig,
-			params,
-			queries,
-			data,
-		});
-	};
-	/**
-	 * Get back some data from the data environment (with a beautiful name (permit download with basic name)
-	 */
-	// TODO: unmanaged "Response" type: please specify @AsyncType or considered as 'void'.
-	export function retrieveDataFull({
-			restConfig,
-			queries,
-			params,
-			data,
-		}: {
-		restConfig: RESTConfig,
-		queries: {
-			Authorization?: string,
-		},
-		params: {
-			name: string,
-			uuid: UUID,
-		},
-		data: string,
-	}): Promise<void> {
-		return RESTRequestVoid({
-			restModel: {
-				endPoint: "/data/{uuid}/{name}",
-				requestType: HTTPRequestModel.GET,
-			},
-			restConfig,
-			params,
-			queries,
-			data,
-		});
-	};
 }

front/src/app/back-api/api/front.ts

@@ -0,0 +1,6 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+export namespace Front {
+
+}

front/src/app/back-api/api/health-check.ts

@@ -1,20 +1,18 @@
 /**
- * API of the server (auto-generated code)
+ * Interface of the server (auto-generated code)
  */
 import {
 	HTTPMimeType,
 	HTTPRequestModel,
-  ModelResponseHttp,
-  RESTCallbacks,
 	RESTConfig,
 	RESTRequestJson,
-  RESTRequestJsonArray,
+} from "../rest-tools";
-  RESTRequestVoid
+
-} from "./rest-tools"
 import {
 	HealthResult,
 	isHealthResult,
-} from "./model"
+} from "../model";
+
 export namespace HealthCheck {
 
 	/**
@@ -27,7 +25,7 @@ export namespace HealthCheck {
 	}): Promise<HealthResult> {
 		return RESTRequestJson({
 			restModel: {
-				endPoint: "/health_check",
+				endPoint: "/health_check/",
 				requestType: HTTPRequestModel.GET,
 				accept: HTTPMimeType.JSON,
 			},

front/src/app/back-api/api/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+export * from "./data-resource"
+export * from "./front"
+export * from "./health-check"
+export * from "./media-resource"
+export * from "./season-resource"
+export * from "./series-resource"
+export * from "./type-resource"
+export * from "./user-media-advancement-resource"
+export * from "./user-resource"

front/src/app/back-api/api/media-resource.ts

@@ -1,24 +1,106 @@
 /**
- * API of the server (auto-generated code)
+ * Interface of the server (auto-generated code)
  */
 import {
 	HTTPMimeType,
 	HTTPRequestModel,
-  ModelResponseHttp,
 	RESTCallbacks,
 	RESTConfig,
 	RESTRequestJson,
-  RESTRequestJsonArray,
+	RESTRequestVoid,
-  RESTRequestVoid
+} from "../rest-tools";
-} from "./rest-tools"
+
+import { z as zod } from "zod"
 import {
 	Long,
 	Media,
+	MediaWrite,
 	UUID,
+	ZodMedia,
 	isMedia,
-} from "./model"
+} from "../model";
+
 export namespace MediaResource {
 
+	/**
+	 * Get a specific Media with his ID
+	 */
+	export function get({
+			restConfig,
+			params,
+		}: {
+		restConfig: RESTConfig,
+		params: {
+			id: Long,
+		},
+	}): Promise<Media> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/media/{id}",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+			params,
+		}, isMedia);
+	};
+
+	export const ZodGetsTypeReturn = zod.array(ZodMedia);
+	export type GetsTypeReturn = zod.infer<typeof ZodGetsTypeReturn>;
+	
+	export function isGetsTypeReturn(data: any): data is GetsTypeReturn {
+		try {
+			ZodGetsTypeReturn.parse(data);
+			return true;
+		} catch (e: any) {
+			console.log(`Fail to parse data type='ZodGetsTypeReturn' error=${e}`);
+			return false;
+		}
+	}
+
+	/**
+	 * Get all Media
+	 */
+	export function gets({
+			restConfig,
+		}: {
+		restConfig: RESTConfig,
+	}): Promise<GetsTypeReturn> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/media/",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+		}, isGetsTypeReturn);
+	};
+	/**
+	 * Modify a specific Media
+	 */
+	export function patch({
+			restConfig,
+			params,
+			data,
+		}: {
+		restConfig: RESTConfig,
+		params: {
+			id: Long,
+		},
+		data: MediaWrite,
+	}): Promise<Media> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/media/{id}",
+				requestType: HTTPRequestModel.PATCH,
+				contentType: HTTPMimeType.JSON,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+			params,
+			data,
+		}, isMedia);
+	};
 	/**
 	 * Remove a specific Media
 	 */
@@ -42,70 +124,29 @@ export namespace MediaResource {
 		});
 	};
 	/**
-	 * Get a specific Media with his ID
+	 * Remove a specific cover of a media
 	 */
-	export function get({
+	export function removeCover({
 			restConfig,
 			params,
 		}: {
 		restConfig: RESTConfig,
 		params: {
+			coverId: UUID,
 			id: Long,
 		},
 	}): Promise<Media> {
 		return RESTRequestJson({
 			restModel: {
-				endPoint: "/media/{id}",
+				endPoint: "/media/{id}/cover/{coverId}",
-				requestType: HTTPRequestModel.GET,
+				requestType: HTTPRequestModel.DELETE,
+				contentType: HTTPMimeType.TEXT_PLAIN,
 				accept: HTTPMimeType.JSON,
 			},
 			restConfig,
 			params,
 		}, isMedia);
 	};
-	/**
-	 * Modify a specific Media
-	 */
-	export function patch({
-			restConfig,
-			params,
-			data,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-		data: Media,
-	}): Promise<Media> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/media/{id}",
-				requestType: HTTPRequestModel.PATCH,
-				contentType: HTTPMimeType.JSON,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			params,
-			data,
-		}, isMedia);
-	};
-	/**
-	 * Get all Media
-	 */
-	export function gets({
-			restConfig,
-		}: {
-		restConfig: RESTConfig,
-	}): Promise<Media[]> {
-		return RESTRequestJsonArray({
-			restModel: {
-				endPoint: "/media",
-				requestType: HTTPRequestModel.GET,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-		}, isMedia);
-	};
 	/**
 	 * Upload a new season cover media
 	 */
@@ -138,30 +179,6 @@ export namespace MediaResource {
 			callback,
 		}, isMedia);
 	};
-	/**
-	 * Remove a specific cover of a media
-	 */
-	export function removeCover({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			coverId: UUID,
-			id: Long,
-		},
-	}): Promise<Media> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/media/{id}/cover/{coverId}",
-				requestType: HTTPRequestModel.DELETE,
-				contentType: HTTPMimeType.TEXT_PLAIN,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			params,
-		}, isMedia);
-	};
 	/**
 	 * Create a new Media
 	 */
@@ -185,7 +202,7 @@ export namespace MediaResource {
 	}): Promise<Media> {
 		return RESTRequestJson({
 			restModel: {
-				endPoint: "/media",
+				endPoint: "/media/",
 				requestType: HTTPRequestModel.POST,
 				contentType: HTTPMimeType.MULTIPART,
 				accept: HTTPMimeType.JSON,

front/src/app/back-api/api/season-resource.ts

@@ -1,46 +1,27 @@
 /**
- * API of the server (auto-generated code)
+ * Interface of the server (auto-generated code)
  */
 import {
 	HTTPMimeType,
 	HTTPRequestModel,
-  ModelResponseHttp,
 	RESTCallbacks,
 	RESTConfig,
 	RESTRequestJson,
-  RESTRequestJsonArray,
+	RESTRequestVoid,
-  RESTRequestVoid
+} from "../rest-tools";
-} from "./rest-tools"
+
+import { z as zod } from "zod"
 import {
 	Long,
 	Season,
+	SeasonWrite,
 	UUID,
+	ZodSeason,
 	isSeason,
-} from "./model"
+} from "../model";
+
 export namespace SeasonResource {
 
-	/**
-	 * Remove a specific season
-	 */
-	export function remove({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-	}): Promise<void> {
-		return RESTRequestVoid({
-			restModel: {
-				endPoint: "/season/{id}",
-				requestType: HTTPRequestModel.DELETE,
-				contentType: HTTPMimeType.TEXT_PLAIN,
-			},
-			restConfig,
-			params,
-		});
-	};
 	/**
 	 * Get all season
 	 */
@@ -64,6 +45,37 @@ export namespace SeasonResource {
 			params,
 		}, isSeason);
 	};
+
+	export const ZodGetsTypeReturn = zod.array(ZodSeason);
+	export type GetsTypeReturn = zod.infer<typeof ZodGetsTypeReturn>;
+	
+	export function isGetsTypeReturn(data: any): data is GetsTypeReturn {
+		try {
+			ZodGetsTypeReturn.parse(data);
+			return true;
+		} catch (e: any) {
+			console.log(`Fail to parse data type='ZodGetsTypeReturn' error=${e}`);
+			return false;
+		}
+	}
+
+	/**
+	 * Get a specific Season with his ID
+	 */
+	export function gets({
+			restConfig,
+		}: {
+		restConfig: RESTConfig,
+	}): Promise<GetsTypeReturn> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/season/",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+		}, isGetsTypeReturn);
+	};
 	/**
 	 * Modify a specific season
 	 */
@@ -76,7 +88,7 @@ export namespace SeasonResource {
 		params: {
 			id: Long,
 		},
-		data: Season,
+		data: SeasonWrite,
 	}): Promise<Season> {
 		return RESTRequestJson({
 			restModel: {
@@ -98,11 +110,11 @@ export namespace SeasonResource {
 			data,
 		}: {
 		restConfig: RESTConfig,
-		data: Season,
+		data: SeasonWrite,
 	}): Promise<Season> {
 		return RESTRequestJson({
 			restModel: {
-				endPoint: "/season",
+				endPoint: "/season/",
 				requestType: HTTPRequestModel.POST,
 				contentType: HTTPMimeType.JSON,
 				accept: HTTPMimeType.JSON,
@@ -112,20 +124,49 @@ export namespace SeasonResource {
 		}, isSeason);
 	};
 	/**
-	 * Get a specific Season with his ID
+	 * Remove a specific season
 	 */
-	export function gets({
+	export function remove({
 			restConfig,
+			params,
 		}: {
 		restConfig: RESTConfig,
-	}): Promise<Season[]> {
+		params: {
-		return RESTRequestJsonArray({
+			id: Long,
+		},
+	}): Promise<void> {
+		return RESTRequestVoid({
 			restModel: {
-				endPoint: "/season",
+				endPoint: "/season/{id}",
-				requestType: HTTPRequestModel.GET,
+				requestType: HTTPRequestModel.DELETE,
+				contentType: HTTPMimeType.TEXT_PLAIN,
+			},
+			restConfig,
+			params,
+		});
+	};
+	/**
+	 * Remove a specific cover of a season
+	 */
+	export function removeCover({
+			restConfig,
+			params,
+		}: {
+		restConfig: RESTConfig,
+		params: {
+			coverId: UUID,
+			id: Long,
+		},
+	}): Promise<Season> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/season/{id}/cover/{coverId}",
+				requestType: HTTPRequestModel.DELETE,
+				contentType: HTTPMimeType.TEXT_PLAIN,
 				accept: HTTPMimeType.JSON,
 			},
 			restConfig,
+			params,
 		}, isSeason);
 	};
 	/**
@@ -160,28 +201,4 @@ export namespace SeasonResource {
 			callback,
 		}, isSeason);
 	};
-	/**
-	 * Remove a specific cover of a season
-	 */
-	export function removeCover({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			coverId: UUID,
-			id: Long,
-		},
-	}): Promise<Season> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/season/{id}/cover/{coverId}",
-				requestType: HTTPRequestModel.DELETE,
-				contentType: HTTPMimeType.TEXT_PLAIN,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			params,
-		}, isSeason);
-	};
 }

front/src/app/back-api/api/series-resource.ts

@@ -1,46 +1,27 @@
 /**
- * API of the server (auto-generated code)
+ * Interface of the server (auto-generated code)
  */
 import {
 	HTTPMimeType,
 	HTTPRequestModel,
-  ModelResponseHttp,
 	RESTCallbacks,
 	RESTConfig,
 	RESTRequestJson,
-  RESTRequestJsonArray,
+	RESTRequestVoid,
-  RESTRequestVoid
+} from "../rest-tools";
-} from "./rest-tools"
+
+import { z as zod } from "zod"
 import {
 	Long,
 	Series,
+	SeriesWrite,
 	UUID,
+	ZodSeries,
 	isSeries,
-} from "./model"
+} from "../model";
+
 export namespace SeriesResource {
 
-	/**
-	 * Remove a specific Series
-	 */
-	export function remove({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-	}): Promise<void> {
-		return RESTRequestVoid({
-			restModel: {
-				endPoint: "/series/{id}",
-				requestType: HTTPRequestModel.DELETE,
-				contentType: HTTPMimeType.TEXT_PLAIN,
-			},
-			restConfig,
-			params,
-		});
-	};
 	/**
 	 * Get a specific Series with his ID
 	 */
@@ -64,6 +45,37 @@ export namespace SeriesResource {
 			params,
 		}, isSeries);
 	};
+
+	export const ZodGetsTypeReturn = zod.array(ZodSeries);
+	export type GetsTypeReturn = zod.infer<typeof ZodGetsTypeReturn>;
+	
+	export function isGetsTypeReturn(data: any): data is GetsTypeReturn {
+		try {
+			ZodGetsTypeReturn.parse(data);
+			return true;
+		} catch (e: any) {
+			console.log(`Fail to parse data type='ZodGetsTypeReturn' error=${e}`);
+			return false;
+		}
+	}
+
+	/**
+	 * Get all Series
+	 */
+	export function gets({
+			restConfig,
+		}: {
+		restConfig: RESTConfig,
+	}): Promise<GetsTypeReturn> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/series/",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+		}, isGetsTypeReturn);
+	};
 	/**
 	 * Modify a specific Series
 	 */
@@ -76,7 +88,7 @@ export namespace SeriesResource {
 		params: {
 			id: Long,
 		},
-		data: Series,
+		data: SeriesWrite,
 	}): Promise<Series> {
 		return RESTRequestJson({
 			restModel: {
@@ -98,11 +110,11 @@ export namespace SeriesResource {
 			data,
 		}: {
 		restConfig: RESTConfig,
-		data: Series,
+		data: SeriesWrite,
 	}): Promise<Series> {
 		return RESTRequestJson({
 			restModel: {
-				endPoint: "/series",
+				endPoint: "/series/",
 				requestType: HTTPRequestModel.POST,
 				contentType: HTTPMimeType.JSON,
 				accept: HTTPMimeType.JSON,
@@ -112,20 +124,49 @@ export namespace SeriesResource {
 		}, isSeries);
 	};
 	/**
-	 * Get all Series
+	 * Remove a specific Series
 	 */
-	export function gets({
+	export function remove({
 			restConfig,
+			params,
 		}: {
 		restConfig: RESTConfig,
-	}): Promise<Series[]> {
+		params: {
-		return RESTRequestJsonArray({
+			id: Long,
+		},
+	}): Promise<void> {
+		return RESTRequestVoid({
 			restModel: {
-				endPoint: "/series",
+				endPoint: "/series/{id}",
-				requestType: HTTPRequestModel.GET,
+				requestType: HTTPRequestModel.DELETE,
+				contentType: HTTPMimeType.TEXT_PLAIN,
+			},
+			restConfig,
+			params,
+		});
+	};
+	/**
+	 * Remove a specific Series of a season
+	 */
+	export function removeCover({
+			restConfig,
+			params,
+		}: {
+		restConfig: RESTConfig,
+		params: {
+			coverId: UUID,
+			id: Long,
+		},
+	}): Promise<Series> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/series/{id}/cover/{coverId}",
+				requestType: HTTPRequestModel.DELETE,
+				contentType: HTTPMimeType.TEXT_PLAIN,
 				accept: HTTPMimeType.JSON,
 			},
 			restConfig,
+			params,
 		}, isSeries);
 	};
 	/**
@@ -160,28 +201,4 @@ export namespace SeriesResource {
 			callback,
 		}, isSeries);
 	};
-	/**
-	 * Remove a specific Series of a season
-	 */
-	export function removeCover({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			coverId: UUID,
-			id: Long,
-		},
-	}): Promise<Series> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/series/{id}/cover/{coverId}",
-				requestType: HTTPRequestModel.DELETE,
-				contentType: HTTPMimeType.TEXT_PLAIN,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			params,
-		}, isSeries);
-	};
 }

front/src/app/back-api/api/type-resource.ts

@@ -1,46 +1,27 @@
 /**
- * API of the server (auto-generated code)
+ * Interface of the server (auto-generated code)
  */
 import {
 	HTTPMimeType,
 	HTTPRequestModel,
-  ModelResponseHttp,
 	RESTCallbacks,
 	RESTConfig,
 	RESTRequestJson,
-  RESTRequestJsonArray,
+	RESTRequestVoid,
-  RESTRequestVoid
+} from "../rest-tools";
-} from "./rest-tools"
+
+import { z as zod } from "zod"
 import {
 	Long,
 	Type,
+	TypeWrite,
 	UUID,
+	ZodType,
 	isType,
-} from "./model"
+} from "../model";
+
 export namespace TypeResource {
 
-	/**
-	 * Remove a specific Type
-	 */
-	export function remove({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-	}): Promise<void> {
-		return RESTRequestVoid({
-			restModel: {
-				endPoint: "/type/{id}",
-				requestType: HTTPRequestModel.DELETE,
-				contentType: HTTPMimeType.TEXT_PLAIN,
-			},
-			restConfig,
-			params,
-		});
-	};
 	/**
 	 * Get a specific Type with his ID
 	 */
@@ -64,6 +45,37 @@ export namespace TypeResource {
 			params,
 		}, isType);
 	};
+
+	export const ZodGetsTypeReturn = zod.array(ZodType);
+	export type GetsTypeReturn = zod.infer<typeof ZodGetsTypeReturn>;
+	
+	export function isGetsTypeReturn(data: any): data is GetsTypeReturn {
+		try {
+			ZodGetsTypeReturn.parse(data);
+			return true;
+		} catch (e: any) {
+			console.log(`Fail to parse data type='ZodGetsTypeReturn' error=${e}`);
+			return false;
+		}
+	}
+
+	/**
+	 * Get all Type
+	 */
+	export function gets({
+			restConfig,
+		}: {
+		restConfig: RESTConfig,
+	}): Promise<GetsTypeReturn> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/type/",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+		}, isGetsTypeReturn);
+	};
 	/**
 	 * Modify a specific Type
 	 */
@@ -76,7 +88,7 @@ export namespace TypeResource {
 		params: {
 			id: Long,
 		},
-		data: Type,
+		data: TypeWrite,
 	}): Promise<Type> {
 		return RESTRequestJson({
 			restModel: {
@@ -98,11 +110,11 @@ export namespace TypeResource {
 			data,
 		}: {
 		restConfig: RESTConfig,
-		data: Type,
+		data: TypeWrite,
 	}): Promise<Type> {
 		return RESTRequestJson({
 			restModel: {
-				endPoint: "/type",
+				endPoint: "/type/",
 				requestType: HTTPRequestModel.POST,
 				contentType: HTTPMimeType.JSON,
 				accept: HTTPMimeType.JSON,
@@ -112,20 +124,49 @@ export namespace TypeResource {
 		}, isType);
 	};
 	/**
-	 * Get all Type
+	 * Remove a specific Type
 	 */
-	export function gets({
+	export function remove({
 			restConfig,
+			params,
 		}: {
 		restConfig: RESTConfig,
-	}): Promise<Type[]> {
+		params: {
-		return RESTRequestJsonArray({
+			id: Long,
+		},
+	}): Promise<void> {
+		return RESTRequestVoid({
 			restModel: {
-				endPoint: "/type",
+				endPoint: "/type/{id}",
-				requestType: HTTPRequestModel.GET,
+				requestType: HTTPRequestModel.DELETE,
+				contentType: HTTPMimeType.TEXT_PLAIN,
+			},
+			restConfig,
+			params,
+		});
+	};
+	/**
+	 * Remove a specific cover of a type
+	 */
+	export function removeCover({
+			restConfig,
+			params,
+		}: {
+		restConfig: RESTConfig,
+		params: {
+			coverId: UUID,
+			id: Long,
+		},
+	}): Promise<Type> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/type/{id}/cover/{coverId}",
+				requestType: HTTPRequestModel.DELETE,
+				contentType: HTTPMimeType.TEXT_PLAIN,
 				accept: HTTPMimeType.JSON,
 			},
 			restConfig,
+			params,
 		}, isType);
 	};
 	/**
@@ -160,28 +201,4 @@ export namespace TypeResource {
 			callback,
 		}, isType);
 	};
-	/**
-	 * Remove a specific cover of a type
-	 */
-	export function removeCover({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			coverId: UUID,
-			id: Long,
-		},
-	}): Promise<Type> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/type/{id}/cover/{coverId}",
-				requestType: HTTPRequestModel.DELETE,
-				contentType: HTTPMimeType.TEXT_PLAIN,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			params,
-		}, isType);
-	};
 }

front/src/app/back-api/api/user-media-advancement-resource.ts

@@ -1,46 +1,25 @@
 /**
- * API of the server (auto-generated code)
+ * Interface of the server (auto-generated code)
  */
 import {
 	HTTPMimeType,
 	HTTPRequestModel,
-  ModelResponseHttp,
-  RESTCallbacks,
 	RESTConfig,
 	RESTRequestJson,
-  RESTRequestJsonArray,
+	RESTRequestVoid,
-  RESTRequestVoid
+} from "../rest-tools";
-} from "./rest-tools"
+
+import { z as zod } from "zod"
 import {
 	Long,
-  MediaInformationsDelta,
+	MediaInformationsDeltaWrite,
 	UserMediaAdvancement,
+	ZodUserMediaAdvancement,
 	isUserMediaAdvancement,
-} from "./model"
+} from "../model";
+
 export namespace UserMediaAdvancementResource {
 
-	/**
-	 * Remove a specific user advancement
-	 */
-	export function remove({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-	}): Promise<void> {
-		return RESTRequestVoid({
-			restModel: {
-				endPoint: "/advancement/{id}",
-				requestType: HTTPRequestModel.DELETE,
-				contentType: HTTPMimeType.TEXT_PLAIN,
-			},
-			restConfig,
-			params,
-		});
-	};
 	/**
 	 * Get a specific user advancement with his ID
 	 */
@@ -63,6 +42,37 @@ export namespace UserMediaAdvancementResource {
 			params,
 		}, isUserMediaAdvancement);
 	};
+
+	export const ZodGetsTypeReturn = zod.array(ZodUserMediaAdvancement);
+	export type GetsTypeReturn = zod.infer<typeof ZodGetsTypeReturn>;
+	
+	export function isGetsTypeReturn(data: any): data is GetsTypeReturn {
+		try {
+			ZodGetsTypeReturn.parse(data);
+			return true;
+		} catch (e: any) {
+			console.log(`Fail to parse data type='ZodGetsTypeReturn' error=${e}`);
+			return false;
+		}
+	}
+
+	/**
+	 * Get all user advancement
+	 */
+	export function gets({
+			restConfig,
+		}: {
+		restConfig: RESTConfig,
+	}): Promise<GetsTypeReturn> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/advancement/",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+		}, isGetsTypeReturn);
+	};
 	/**
 	 * Modify a user advancement
 	 */
@@ -75,7 +85,7 @@ export namespace UserMediaAdvancementResource {
 		params: {
 			id: Long,
 		},
-		data: MediaInformationsDelta,
+		data: MediaInformationsDeltaWrite,
 	}): Promise<UserMediaAdvancement> {
 		return RESTRequestJson({
 			restModel: {
@@ -90,20 +100,25 @@ export namespace UserMediaAdvancementResource {
 		}, isUserMediaAdvancement);
 	};
 	/**
-	 * Get all user advancement
+	 * Remove a specific user advancement
 	 */
-	export function gets({
+	export function remove({
 			restConfig,
+			params,
 		}: {
 		restConfig: RESTConfig,
-	}): Promise<UserMediaAdvancement[]> {
+		params: {
-		return RESTRequestJsonArray({
+			id: Long,
+		},
+	}): Promise<void> {
+		return RESTRequestVoid({
 			restModel: {
-				endPoint: "/advancement",
+				endPoint: "/advancement/{id}",
-				requestType: HTTPRequestModel.GET,
+				requestType: HTTPRequestModel.DELETE,
-				accept: HTTPMimeType.JSON,
+				contentType: HTTPMimeType.TEXT_PLAIN,
 			},
 			restConfig,
-		}, isUserMediaAdvancement);
+			params,
+		});
 	};
 }

front/src/app/back-api/api/user-resource.ts

@@ -1,23 +1,23 @@
 /**
- * API of the server (auto-generated code)
+ * Interface of the server (auto-generated code)
  */
 import {
 	HTTPMimeType,
 	HTTPRequestModel,
-  ModelResponseHttp,
-  RESTCallbacks,
 	RESTConfig,
 	RESTRequestJson,
-  RESTRequestJsonArray,
+} from "../rest-tools";
-  RESTRequestVoid
+
-} from "./rest-tools"
+import { z as zod } from "zod"
 import {
 	Long,
 	UserKarideo,
 	UserOut,
+	ZodUserKarideo,
 	isUserKarideo,
 	isUserOut,
-} from "./model"
+} from "../model";
+
 export namespace UserResource {
 
 	/**
@@ -42,23 +42,6 @@ export namespace UserResource {
 			params,
 		}, isUserKarideo);
 	};
-	/**
-	 * Get all the users
-	 */
-	export function gets({
-			restConfig,
-		}: {
-		restConfig: RESTConfig,
-	}): Promise<UserKarideo[]> {
-		return RESTRequestJsonArray({
-			restModel: {
-				endPoint: "/users",
-				requestType: HTTPRequestModel.GET,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-		}, isUserKarideo);
-	};
 	/**
 	 * Get the user personal data
 	 */
@@ -76,4 +59,35 @@ export namespace UserResource {
 			restConfig,
 		}, isUserOut);
 	};
+
+	export const ZodGetsTypeReturn = zod.array(ZodUserKarideo);
+	export type GetsTypeReturn = zod.infer<typeof ZodGetsTypeReturn>;
+	
+	export function isGetsTypeReturn(data: any): data is GetsTypeReturn {
+		try {
+			ZodGetsTypeReturn.parse(data);
+			return true;
+		} catch (e: any) {
+			console.log(`Fail to parse data type='ZodGetsTypeReturn' error=${e}`);
+			return false;
+		}
+	}
+
+	/**
+	 * Get all the users
+	 */
+	export function gets({
+			restConfig,
+		}: {
+		restConfig: RESTConfig,
+	}): Promise<GetsTypeReturn> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/users/",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+		}, isGetsTypeReturn);
+	};
 }

front/src/app/back-api/front.ts

@@ -1,18 +0,0 @@
-/**
- * API of the server (auto-generated code)
- */
-import {
-  HTTPMimeType,
-  HTTPRequestModel,
-  ModelResponseHttp,
-  RESTCallbacks,
-  RESTConfig,
-  RESTRequestJson,
-  RESTRequestJsonArray,
-  RESTRequestVoid
-} from "./rest-tools"
-import {
-} from "./model"
-export namespace Front {
-
-}

front/src/app/back-api/index.ts

@@ -1,13 +1,7 @@
 /**
- * Global import of the package
+ * Interface of the server (auto-generated code)
  */
 export * from "./model";
-export * from "./front";
+export * from "./api";
-export * from "./health-check";
+export * from "./rest-tools";
-export * from "./season-resource";
+
-export * from "./series-resource";
-export * from "./type-resource";
-export * from "./user-media-advancement-resource";
-export * from "./user-resource";
-export * from "./media-resource";
-export * from "./data-resource";

front/src/app/back-api/model.ts

@@ -1,435 +0,0 @@
-/**
- * Interface of the server (auto-generated code)
- */
-import { z as zod } from "zod";
-
-export const ZodUUID = zod.string().uuid();
-export type UUID = zod.infer<typeof ZodUUID>;
-export function isUUID(data: any): data is UUID {
-	try {
-		ZodUUID.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodLong = zod.number();
-export type Long = zod.infer<typeof ZodLong>;
-export function isLong(data: any): data is Long {
-	try {
-		ZodLong.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodInteger = zod.number().safe();
-export type Integer = zod.infer<typeof ZodInteger>;
-export function isInteger(data: any): data is Integer {
-	try {
-		ZodInteger.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodFloat = zod.number();
-export type Float = zod.infer<typeof ZodFloat>;
-export function isFloat(data: any): data is Float {
-	try {
-		ZodFloat.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodInstant = zod.string();
-export type Instant = zod.infer<typeof ZodInstant>;
-export function isInstant(data: any): data is Instant {
-	try {
-		ZodInstant.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodDate = zod.date();
-export type Date = zod.infer<typeof ZodDate>;
-export function isDate(data: any): data is Date {
-	try {
-		ZodDate.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodTimestamp = zod.date();
-export type Timestamp = zod.infer<typeof ZodTimestamp>;
-export function isTimestamp(data: any): data is Timestamp {
-	try {
-		ZodTimestamp.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodLocalDate = zod.date();
-export type LocalDate = zod.infer<typeof ZodLocalDate>;
-export function isLocalDate(data: any): data is LocalDate {
-	try {
-		ZodLocalDate.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodLocalTime = zod.date();
-export type LocalTime = zod.infer<typeof ZodLocalTime>;
-export function isLocalTime(data: any): data is LocalTime {
-	try {
-		ZodLocalTime.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodRestErrorResponse = zod.object({
-	uuid: ZodUUID.optional(),
-	name: zod.string().max(255).optional(),
-	message: zod.string().max(255).optional(),
-	time: zod.string().max(255).optional(),
-	status: ZodInteger,
-	statusMessage: zod.string().max(255).optional()
-});
-export type RestErrorResponse = zod.infer<typeof ZodRestErrorResponse>;
-export function isRestErrorResponse(data: any): data is RestErrorResponse {
-	try {
-		ZodRestErrorResponse.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodHealthResult = zod.object({
-});
-export type HealthResult = zod.infer<typeof ZodHealthResult>;
-export function isHealthResult(data: any): data is HealthResult {
-	try {
-		ZodHealthResult.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodGenericTiming = zod.object({
-	// Create time of the object
-	createdAt: ZodDate.readonly().optional(),
-	// When update the object
-	updatedAt: ZodDate.readonly().optional()
-});
-export type GenericTiming = zod.infer<typeof ZodGenericTiming>;
-export function isGenericTiming(data: any): data is GenericTiming {
-	try {
-		ZodGenericTiming.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodGenericData = ZodGenericTiming.extend({
-	// Unique Id of the object
-	id: ZodLong.readonly().optional()
-});
-export type GenericData = zod.infer<typeof ZodGenericData>;
-export function isGenericData(data: any): data is GenericData {
-	try {
-		ZodGenericData.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodGenericDataSoftDelete = ZodGenericData.extend({
-	// Deleted state
-	deleted: zod.boolean().readonly().optional()
-});
-export type GenericDataSoftDelete = zod.infer<typeof ZodGenericDataSoftDelete>;
-export function isGenericDataSoftDelete(data: any): data is GenericDataSoftDelete {
-	try {
-		ZodGenericDataSoftDelete.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodSeason = ZodGenericDataSoftDelete.extend({
-	// Name of the media (this represent the title)
-	name: zod.string().optional(),
-	// Description of the media
-	description: zod.string().optional(),
-	// series parent ID
-	parentId: ZodLong.optional(),
-	// List of Id of the specific covers
-	covers: zod.array(ZodUUID).optional()
-});
-export type Season = zod.infer<typeof ZodSeason>;
-export function isSeason(data: any): data is Season {
-	try {
-		ZodSeason.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodSeries = ZodGenericDataSoftDelete.extend({
-	// Name of the media (this represent the title)
-	name: zod.string().optional(),
-	// Description of the media
-	description: zod.string().optional(),
-	// series parent ID
-	parentId: ZodLong.optional(),
-	// List of Id of the specific covers
-	covers: zod.array(ZodUUID).optional()
-});
-export type Series = zod.infer<typeof ZodSeries>;
-export function isSeries(data: any): data is Series {
-	try {
-		ZodSeries.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodType = ZodGenericDataSoftDelete.extend({
-	// Name of the media (this represent the title)
-	name: zod.string().optional(),
-	// Description of the media
-	description: zod.string().optional(),
-	// List of Id of the specific covers
-	covers: zod.array(ZodUUID).optional()
-});
-export type Type = zod.infer<typeof ZodType>;
-export function isType(data: any): data is Type {
-	try {
-		ZodType.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodUserMediaAdvancement = ZodGenericDataSoftDelete.extend({
-	// Foreign Key Id of the user
-	userId: ZodLong.optional(),
-	// Id of the media
-	mediaId: ZodLong.optional(),
-	// Percent of advancement in the media
-	percent: ZodFloat.optional(),
-	// Number of second of advancement in the media
-	time: ZodInteger.optional(),
-	// Number of time this media has been read
-	count: ZodInteger.optional()
-});
-export type UserMediaAdvancement = zod.infer<typeof ZodUserMediaAdvancement>;
-export function isUserMediaAdvancement(data: any): data is UserMediaAdvancement {
-	try {
-		ZodUserMediaAdvancement.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodMediaInformationsDelta = zod.object({
-});
-export type MediaInformationsDelta = zod.infer<typeof ZodMediaInformationsDelta>;
-export function isMediaInformationsDelta(data: any): data is MediaInformationsDelta {
-	try {
-		ZodMediaInformationsDelta.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodUser = ZodGenericDataSoftDelete.extend({
-	login: zod.string().max(128).optional(),
-	lastConnection: ZodTimestamp.optional(),
-	admin: zod.boolean(),
-	blocked: zod.boolean(),
-	removed: zod.boolean(),
-	covers: zod.array(ZodLong).optional()
-});
-export type User = zod.infer<typeof ZodUser>;
-export function isUser(data: any): data is User {
-	try {
-		ZodUser.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodUserKarideo = ZodUser.extend({
-});
-export type UserKarideo = zod.infer<typeof ZodUserKarideo>;
-export function isUserKarideo(data: any): data is UserKarideo {
-	try {
-		ZodUserKarideo.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodUserOut = zod.object({
-	id: ZodLong,
-	login: zod.string().max(255).optional()
-});
-export type UserOut = zod.infer<typeof ZodUserOut>;
-export function isUserOut(data: any): data is UserOut {
-	try {
-		ZodUserOut.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodMedia = ZodGenericDataSoftDelete.extend({
-	name: zod.string().optional(),
-	description: zod.string().optional(),
-	dataId: ZodUUID.optional(),
-	typeId: ZodLong.optional(),
-	seriesId: ZodLong.optional(),
-	seasonId: ZodLong.optional(),
-	episode: ZodInteger.optional(),
-	date: ZodInteger.optional(),
-	time: ZodInteger.optional(),
-	ageLimit: ZodInteger.optional(),
-	covers: zod.array(ZodUUID).optional()
-});
-export type Media = zod.infer<typeof ZodMedia>;
-export function isMedia(data: any): data is Media {
-	try {
-		ZodMedia.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodUUIDGenericData = ZodGenericTiming.extend({
-	// Unique UUID of the object
-	uuid: ZodUUID.readonly().optional()
-});
-export type UUIDGenericData = zod.infer<typeof ZodUUIDGenericData>;
-export function isUUIDGenericData(data: any): data is UUIDGenericData {
-	try {
-		ZodUUIDGenericData.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodUUIDGenericDataSoftDelete = ZodUUIDGenericData.extend({
-	// Deleted state
-	deleted: zod.boolean().readonly().optional()
-});
-export type UUIDGenericDataSoftDelete = zod.infer<typeof ZodUUIDGenericDataSoftDelete>;
-export function isUUIDGenericDataSoftDelete(data: any): data is UUIDGenericDataSoftDelete {
-	try {
-		ZodUUIDGenericDataSoftDelete.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-
-export const ZodData = ZodUUIDGenericDataSoftDelete.extend({
-	// Sha512 of the data
-	sha512: zod.string().max(128).optional(),
-	// Mime -type of the media
-	mimeType: zod.string().max(128).optional(),
-	// Size in Byte of the data
-	size: ZodLong.optional()
-});
-export type Data = zod.infer<typeof ZodData>;
-export function isData(data: any): data is Data {
-	try {
-		ZodData.parse(data);
-		return true;
-	} catch (e: any) {
-		console.log(`Fail to parse data ${e}`);
-		return false;
-	}
-}
-
-

front/src/app/back-api/model/float.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+
+export const ZodFloat = zod.number();
+export type Float = zod.infer<typeof ZodFloat>;

front/src/app/back-api/model/generic-data-soft-delete.ts

@@ -0,0 +1,46 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodGenericData} from "./generic-data";
+
+export const ZodGenericDataSoftDelete = ZodGenericData.extend({
+	/**
+	 * Deleted state
+	 */
+	deleted: zod.boolean().readonly().optional(),
+
+});
+
+export type GenericDataSoftDelete = zod.infer<typeof ZodGenericDataSoftDelete>;
+
+export function isGenericDataSoftDelete(data: any): data is GenericDataSoftDelete {
+	try {
+		ZodGenericDataSoftDelete.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodGenericDataSoftDelete' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodGenericDataSoftDeleteWrite = ZodGenericDataSoftDelete.omit({
+	deleted: true,
+	id: true,
+	createdAt: true,
+	updatedAt: true,
+
+}).partial();
+
+export type GenericDataSoftDeleteWrite = zod.infer<typeof ZodGenericDataSoftDeleteWrite>;
+
+export function isGenericDataSoftDeleteWrite(data: any): data is GenericDataSoftDeleteWrite {
+	try {
+		ZodGenericDataSoftDeleteWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodGenericDataSoftDeleteWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/generic-data.ts

@@ -0,0 +1,46 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodLong} from "./long";
+import {ZodGenericTiming} from "./generic-timing";
+
+export const ZodGenericData = ZodGenericTiming.extend({
+	/**
+	 * Unique Id of the object
+	 */
+	id: ZodLong.readonly(),
+
+});
+
+export type GenericData = zod.infer<typeof ZodGenericData>;
+
+export function isGenericData(data: any): data is GenericData {
+	try {
+		ZodGenericData.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodGenericData' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodGenericDataWrite = ZodGenericData.omit({
+	id: true,
+	createdAt: true,
+	updatedAt: true,
+
+}).partial();
+
+export type GenericDataWrite = zod.infer<typeof ZodGenericDataWrite>;
+
+export function isGenericDataWrite(data: any): data is GenericDataWrite {
+	try {
+		ZodGenericDataWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodGenericDataWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/generic-timing.ts

@@ -0,0 +1,48 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodIsoDate} from "./iso-date";
+
+export const ZodGenericTiming = zod.object({
+	/**
+	 * Create time of the object
+	 */
+	createdAt: ZodIsoDate.readonly().optional(),
+	/**
+	 * When update the object
+	 */
+	updatedAt: ZodIsoDate.readonly().optional(),
+
+});
+
+export type GenericTiming = zod.infer<typeof ZodGenericTiming>;
+
+export function isGenericTiming(data: any): data is GenericTiming {
+	try {
+		ZodGenericTiming.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodGenericTiming' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodGenericTimingWrite = ZodGenericTiming.omit({
+	createdAt: true,
+	updatedAt: true,
+
+}).partial();
+
+export type GenericTimingWrite = zod.infer<typeof ZodGenericTimingWrite>;
+
+export function isGenericTimingWrite(data: any): data is GenericTimingWrite {
+	try {
+		ZodGenericTimingWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodGenericTimingWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/health-result.ts

@@ -0,0 +1,35 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+
+export const ZodHealthResult = zod.object({
+
+});
+
+export type HealthResult = zod.infer<typeof ZodHealthResult>;
+
+export function isHealthResult(data: any): data is HealthResult {
+	try {
+		ZodHealthResult.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodHealthResult' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodHealthResultWrite = ZodHealthResult.partial();
+
+export type HealthResultWrite = zod.infer<typeof ZodHealthResultWrite>;
+
+export function isHealthResultWrite(data: any): data is HealthResultWrite {
+	try {
+		ZodHealthResultWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodHealthResultWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+export * from "./float"
+export * from "./generic-data"
+export * from "./generic-data-soft-delete"
+export * from "./generic-timing"
+export * from "./health-result"
+export * from "./int"
+export * from "./integer"
+export * from "./iso-date"
+export * from "./long"
+export * from "./media"
+export * from "./media-informations-delta"
+export * from "./rest-error-response"
+export * from "./season"
+export * from "./series"
+export * from "./timestamp"
+export * from "./type"
+export * from "./user"
+export * from "./user-karideo"
+export * from "./user-media-advancement"
+export * from "./user-out"
+export * from "./uuid"

front/src/app/back-api/model/int.ts

@@ -0,0 +1,35 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+
+export const Zodint = zod.object({
+
+});
+
+export type int = zod.infer<typeof Zodint>;
+
+export function isint(data: any): data is int {
+	try {
+		Zodint.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='Zodint' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodintWrite = Zodint.partial();
+
+export type intWrite = zod.infer<typeof ZodintWrite>;
+
+export function isintWrite(data: any): data is intWrite {
+	try {
+		ZodintWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodintWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/integer.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+
+export const ZodInteger = zod.number().safe();
+export type Integer = zod.infer<typeof ZodInteger>;

front/src/app/back-api/model/iso-date.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+
+export const ZodIsoDate = zod.string().datetime({ precision: 3 });
+export type IsoDate = zod.infer<typeof ZodIsoDate>;

front/src/app/back-api/model/long.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+
+export const ZodLong = zod.number();
+export type Long = zod.infer<typeof ZodLong>;

front/src/app/back-api/model/media-informations-delta.ts

@@ -0,0 +1,35 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+
+export const ZodMediaInformationsDelta = zod.object({
+
+});
+
+export type MediaInformationsDelta = zod.infer<typeof ZodMediaInformationsDelta>;
+
+export function isMediaInformationsDelta(data: any): data is MediaInformationsDelta {
+	try {
+		ZodMediaInformationsDelta.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodMediaInformationsDelta' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodMediaInformationsDeltaWrite = ZodMediaInformationsDelta.partial();
+
+export type MediaInformationsDeltaWrite = zod.infer<typeof ZodMediaInformationsDeltaWrite>;
+
+export function isMediaInformationsDeltaWrite(data: any): data is MediaInformationsDeltaWrite {
+	try {
+		ZodMediaInformationsDeltaWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodMediaInformationsDeltaWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/media.ts

@@ -0,0 +1,86 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodUUID} from "./uuid";
+import {ZodLong} from "./long";
+import {ZodInteger} from "./integer";
+import {ZodGenericDataSoftDelete} from "./generic-data-soft-delete";
+
+export const ZodMedia = ZodGenericDataSoftDelete.extend({
+	/**
+	 * Name of the media (this represent the title)
+	 */
+	name: zod.string(),
+	/**
+	 * Description of the media
+	 */
+	description: zod.string().optional(),
+	/**
+	 * Foreign Key Id of the data
+	 */
+	dataId: ZodUUID,
+	/**
+	 * Type of the media
+	 */
+	typeId: ZodLong.optional(),
+	/**
+	 * Series reference of the media
+	 */
+	seriesId: ZodLong.optional(),
+	/**
+	 * Season reference of the media
+	 */
+	seasonId: ZodLong.optional(),
+	/**
+	 * Episode Id
+	 */
+	episode: ZodInteger.optional(),
+	date: ZodInteger.optional(),
+	/**
+	 * Creation years of the media
+	 */
+	time: ZodInteger.optional(),
+	/**
+	 * Limitation Age of the media
+	 */
+	ageLimit: ZodInteger.optional(),
+	/**
+	 * List of Id of the specific covers
+	 */
+	covers: zod.array(ZodUUID),
+
+});
+
+export type Media = zod.infer<typeof ZodMedia>;
+
+export function isMedia(data: any): data is Media {
+	try {
+		ZodMedia.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodMedia' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodMediaWrite = ZodMedia.omit({
+	deleted: true,
+	id: true,
+	createdAt: true,
+	updatedAt: true,
+
+}).partial();
+
+export type MediaWrite = zod.infer<typeof ZodMediaWrite>;
+
+export function isMediaWrite(data: any): data is MediaWrite {
+	try {
+		ZodMediaWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodMediaWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/rest-error-response.ts

@@ -0,0 +1,43 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodUUID} from "./uuid";
+import {Zodint} from "./int";
+
+export const ZodRestErrorResponse = zod.object({
+	uuid: ZodUUID.optional(),
+	name: zod.string(),
+	message: zod.string(),
+	time: zod.string(),
+	status: Zodint,
+	statusMessage: zod.string(),
+
+});
+
+export type RestErrorResponse = zod.infer<typeof ZodRestErrorResponse>;
+
+export function isRestErrorResponse(data: any): data is RestErrorResponse {
+	try {
+		ZodRestErrorResponse.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodRestErrorResponse' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodRestErrorResponseWrite = ZodRestErrorResponse.partial();
+
+export type RestErrorResponseWrite = zod.infer<typeof ZodRestErrorResponseWrite>;
+
+export function isRestErrorResponseWrite(data: any): data is RestErrorResponseWrite {
+	try {
+		ZodRestErrorResponseWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodRestErrorResponseWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/season.ts

@@ -0,0 +1,60 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodLong} from "./long";
+import {ZodUUID} from "./uuid";
+import {ZodGenericDataSoftDelete} from "./generic-data-soft-delete";
+
+export const ZodSeason = ZodGenericDataSoftDelete.extend({
+	/**
+	 * Name of the media (this represent the title)
+	 */
+	name: zod.string(),
+	/**
+	 * Description of the media
+	 */
+	description: zod.string().optional(),
+	/**
+	 * series parent ID
+	 */
+	parentId: ZodLong,
+	/**
+	 * List of Id of the specific covers
+	 */
+	covers: zod.array(ZodUUID),
+
+});
+
+export type Season = zod.infer<typeof ZodSeason>;
+
+export function isSeason(data: any): data is Season {
+	try {
+		ZodSeason.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodSeason' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodSeasonWrite = ZodSeason.omit({
+	deleted: true,
+	id: true,
+	createdAt: true,
+	updatedAt: true,
+
+}).partial();
+
+export type SeasonWrite = zod.infer<typeof ZodSeasonWrite>;
+
+export function isSeasonWrite(data: any): data is SeasonWrite {
+	try {
+		ZodSeasonWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodSeasonWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/series.ts

@@ -0,0 +1,60 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodLong} from "./long";
+import {ZodUUID} from "./uuid";
+import {ZodGenericDataSoftDelete} from "./generic-data-soft-delete";
+
+export const ZodSeries = ZodGenericDataSoftDelete.extend({
+	/**
+	 * Name of the media (this represent the title)
+	 */
+	name: zod.string(),
+	/**
+	 * Description of the media
+	 */
+	description: zod.string().optional(),
+	/**
+	 * series parent ID
+	 */
+	parentId: ZodLong,
+	/**
+	 * List of Id of the specific covers
+	 */
+	covers: zod.array(ZodUUID),
+
+});
+
+export type Series = zod.infer<typeof ZodSeries>;
+
+export function isSeries(data: any): data is Series {
+	try {
+		ZodSeries.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodSeries' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodSeriesWrite = ZodSeries.omit({
+	deleted: true,
+	id: true,
+	createdAt: true,
+	updatedAt: true,
+
+}).partial();
+
+export type SeriesWrite = zod.infer<typeof ZodSeriesWrite>;
+
+export function isSeriesWrite(data: any): data is SeriesWrite {
+	try {
+		ZodSeriesWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodSeriesWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/timestamp.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+
+export const ZodTimestamp = zod.string().datetime({ precision: 3 });
+export type Timestamp = zod.infer<typeof ZodTimestamp>;

front/src/app/back-api/model/type.ts

@@ -0,0 +1,55 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodUUID} from "./uuid";
+import {ZodGenericDataSoftDelete} from "./generic-data-soft-delete";
+
+export const ZodType = ZodGenericDataSoftDelete.extend({
+	/**
+	 * Name of the media (this represent the title)
+	 */
+	name: zod.string(),
+	/**
+	 * Description of the media
+	 */
+	description: zod.string().optional(),
+	/**
+	 * List of Id of the specific covers
+	 */
+	covers: zod.array(ZodUUID),
+
+});
+
+export type Type = zod.infer<typeof ZodType>;
+
+export function isType(data: any): data is Type {
+	try {
+		ZodType.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodType' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodTypeWrite = ZodType.omit({
+	deleted: true,
+	id: true,
+	createdAt: true,
+	updatedAt: true,
+
+}).partial();
+
+export type TypeWrite = zod.infer<typeof ZodTypeWrite>;
+
+export function isTypeWrite(data: any): data is TypeWrite {
+	try {
+		ZodTypeWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodTypeWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/user-karideo.ts

@@ -0,0 +1,42 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodUser} from "./user";
+
+export const ZodUserKarideo = ZodUser.extend({
+
+});
+
+export type UserKarideo = zod.infer<typeof ZodUserKarideo>;
+
+export function isUserKarideo(data: any): data is UserKarideo {
+	try {
+		ZodUserKarideo.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodUserKarideo' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodUserKarideoWrite = ZodUserKarideo.omit({
+	deleted: true,
+	id: true,
+	createdAt: true,
+	updatedAt: true,
+
+}).partial();
+
+export type UserKarideoWrite = zod.infer<typeof ZodUserKarideoWrite>;
+
+export function isUserKarideoWrite(data: any): data is UserKarideoWrite {
+	try {
+		ZodUserKarideoWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodUserKarideoWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/user-media-advancement.ts

@@ -0,0 +1,65 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodLong} from "./long";
+import {ZodFloat} from "./float";
+import {ZodInteger} from "./integer";
+import {ZodGenericDataSoftDelete} from "./generic-data-soft-delete";
+
+export const ZodUserMediaAdvancement = ZodGenericDataSoftDelete.extend({
+	/**
+	 * Foreign Key Id of the user
+	 */
+	userId: ZodLong,
+	/**
+	 * Id of the media
+	 */
+	mediaId: ZodLong,
+	/**
+	 * Percent of advancement in the media
+	 */
+	percent: ZodFloat,
+	/**
+	 * Number of second of advancement in the media
+	 */
+	time: ZodInteger,
+	/**
+	 * Number of time this media has been read
+	 */
+	count: ZodInteger,
+
+});
+
+export type UserMediaAdvancement = zod.infer<typeof ZodUserMediaAdvancement>;
+
+export function isUserMediaAdvancement(data: any): data is UserMediaAdvancement {
+	try {
+		ZodUserMediaAdvancement.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodUserMediaAdvancement' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodUserMediaAdvancementWrite = ZodUserMediaAdvancement.omit({
+	deleted: true,
+	id: true,
+	createdAt: true,
+	updatedAt: true,
+
+}).partial();
+
+export type UserMediaAdvancementWrite = zod.infer<typeof ZodUserMediaAdvancementWrite>;
+
+export function isUserMediaAdvancementWrite(data: any): data is UserMediaAdvancementWrite {
+	try {
+		ZodUserMediaAdvancementWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodUserMediaAdvancementWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/user-out.ts

@@ -0,0 +1,38 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodLong} from "./long";
+
+export const ZodUserOut = zod.object({
+	id: ZodLong,
+	login: zod.string().max(255).optional(),
+
+});
+
+export type UserOut = zod.infer<typeof ZodUserOut>;
+
+export function isUserOut(data: any): data is UserOut {
+	try {
+		ZodUserOut.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodUserOut' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodUserOutWrite = ZodUserOut.partial();
+
+export type UserOutWrite = zod.infer<typeof ZodUserOutWrite>;
+
+export function isUserOutWrite(data: any): data is UserOutWrite {
+	try {
+		ZodUserOutWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodUserOutWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/user.ts

@@ -0,0 +1,53 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+import {ZodTimestamp} from "./timestamp";
+import {ZodUUID} from "./uuid";
+import {ZodGenericDataSoftDelete} from "./generic-data-soft-delete";
+
+export const ZodUser = ZodGenericDataSoftDelete.extend({
+	login: zod.string().max(128).optional(),
+	lastConnection: ZodTimestamp.optional(),
+	admin: zod.boolean(),
+	blocked: zod.boolean(),
+	removed: zod.boolean(),
+	/**
+	 * List of Id of the specific covers
+	 */
+	covers: zod.array(ZodUUID).optional(),
+
+});
+
+export type User = zod.infer<typeof ZodUser>;
+
+export function isUser(data: any): data is User {
+	try {
+		ZodUser.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodUser' error=${e}`);
+		return false;
+	}
+}
+
+export const ZodUserWrite = ZodUser.omit({
+	deleted: true,
+	id: true,
+	createdAt: true,
+	updatedAt: true,
+
+}).partial();
+
+export type UserWrite = zod.infer<typeof ZodUserWrite>;
+
+export function isUserWrite(data: any): data is UserWrite {
+	try {
+		ZodUserWrite.parse(data);
+		return true;
+	} catch (e: any) {
+		console.log(`Fail to parse data type='ZodUserWrite' error=${e}`);
+		return false;
+	}
+}

front/src/app/back-api/model/uuid.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface of the server (auto-generated code)
+ */
+import { z as zod } from "zod";
+
+
+export const ZodUUID = zod.string().uuid();
+export type UUID = zod.infer<typeof ZodUUID>;

front/src/app/back-api/rest-tools.ts

@@ -4,25 +4,25 @@
  * @license MPL-2
  */
 
-import { RestErrorResponse } from "./model"
+import { RestErrorResponse, isRestErrorResponse } from "./model";
 
 export enum HTTPRequestModel {
-    DELETE = 'DELETE',
+  DELETE = "DELETE",
-    GET = 'GET',
+  GET = "GET",
-    PATCH = 'PATCH',
+  PATCH = "PATCH",
-    POST = 'POST',
+  POST = "POST",
-    PUT = 'PUT',
+  PUT = "PUT",
 }
 export enum HTTPMimeType {
-    ALL = '*/*',
+  ALL = "*/*",
-    CSV = 'text/csv',
+  CSV = "text/csv",
-    IMAGE = 'image/*',
+  IMAGE = "image/*",
-    IMAGE_JPEG = 'image/jpeg',
+  IMAGE_JPEG = "image/jpeg",
-    IMAGE_PNG = 'image/png',
+  IMAGE_PNG = "image/png",
-    JSON = 'application/json',
+  JSON = "application/json",
-    MULTIPART = 'multipart/form-data',
+  MULTIPART = "multipart/form-data",
-    OCTET_STREAM = 'application/octet-stream',
+  OCTET_STREAM = "application/octet-stream",
-    TEXT_PLAIN = 'text/plain',
+  TEXT_PLAIN = "text/plain",
 }
 
 export interface RESTConfig {
@@ -50,23 +50,6 @@ export interface ModelResponseHttp {
   data: any;
 }
 
-export function isArrayOf<TYPE>(
-    data: any,
-    typeChecker: (subData: any) => subData is TYPE,
-    length?: number
-): data is TYPE[] {
-    if (!Array.isArray(data)) {
-        return false;
-    }
-    if (!data.every(typeChecker)) {
-        return false;
-    }
-    if (length !== undefined && data.length != length) {
-        return false;
-    }
-    return true;
-}
-
 function isNullOrUndefined(data: any): data is undefined | null {
   return data === undefined || data === null;
 }
@@ -75,25 +58,24 @@ function isNullOrUndefined(data: any): data is undefined | null {
 export type ProgressCallback = (count: number, total: number) => void;
 
 export interface RESTAbort {
-    abort?: () => boolean
+  abort?: () => boolean;
 }
 
-
 // Rest generic callback have a basic model to upload and download advancement.
 export interface RESTCallbacks {
-    progressUpload?: ProgressCallback,
+  progressUpload?: ProgressCallback;
-    progressDownload?: ProgressCallback,
+  progressDownload?: ProgressCallback;
-    abortHandle?: RESTAbort,
+  abortHandle?: RESTAbort;
-};
+}
 
 export interface RESTRequestType {
-    restModel: RESTModel,
+  restModel: RESTModel;
-    restConfig: RESTConfig,
+  restConfig: RESTConfig;
-    data?: any,
+  data?: any;
-    params?: object,
+  params?: object;
-    queries?: object,
+  queries?: object;
-    callback?: RESTCallbacks,
+  callback?: RESTCallbacks;
-};
+}
 
 function replaceAll(input, searchValue, replaceValue) {
   return input.split(searchValue).join(replaceValue);
@@ -103,24 +85,34 @@ function removeTrailingSlashes(input: string): string {
   if (isNullOrUndefined(input)) {
     return "undefined";
   }
-    return input.replace(/\/+$/, '');
+  return input.replace(/\/+$/, "");
 }
 function removeLeadingSlashes(input: string): string {
   if (isNullOrUndefined(input)) {
     return "";
   }
-    return input.replace(/^\/+/, '');
+  return input.replace(/^\/+/, "");
 }
 
-export function RESTUrl({ restModel, restConfig, params, queries }: RESTRequestType): string {
+export function RESTUrl({
+  restModel,
+  restConfig,
+  params,
+  queries,
+}: RESTRequestType): string {
   // Create the URL PATH:
-    let generateUrl = `${removeTrailingSlashes(restConfig.server)}/${removeLeadingSlashes(restModel.endPoint)}`;
+  let generateUrl = `${removeTrailingSlashes(
+    restConfig.server
+  )}/${removeLeadingSlashes(restModel.endPoint)}`;
   if (params !== undefined) {
     for (let key of Object.keys(params)) {
       generateUrl = replaceAll(generateUrl, `{${key}}`, `${params[key]}`);
     }
   }
-    if (queries === undefined && (restConfig.token === undefined || restModel.tokenInUrl !== true)) {
+  if (
+    queries === undefined &&
+    (restConfig.token === undefined || restModel.tokenInUrl !== true)
+  ) {
     return generateUrl;
   }
   const searchParams = new URLSearchParams();
@@ -128,8 +120,8 @@ export function RESTUrl({ restModel, restConfig, params, queries }: RESTRequestT
     for (let key of Object.keys(queries)) {
       const value = queries[key];
       if (Array.isArray(value)) {
-                for (let iii = 0; iii < value.length; iii++) {
+        for (const element of value) {
-                    searchParams.append(`${key}`, `${value[iii]}`);
+          searchParams.append(`${key}`, `${element}`);
         }
       } else {
         searchParams.append(`${key}`, `${value}`);
@@ -137,36 +129,43 @@ export function RESTUrl({ restModel, restConfig, params, queries }: RESTRequestT
     }
   }
   if (restConfig.token !== undefined && restModel.tokenInUrl === true) {
-        searchParams.append('Authorization', `Bearer ${restConfig.token}`);
+    searchParams.append("Authorization", `Bearer ${restConfig.token}`);
   }
   return generateUrl + "?" + searchParams.toString();
 }
 
-
+export function fetchProgress(
-export function fetchProgress(generateUrl: string, { method, headers, body }: {
+  generateUrl: string,
-    method: HTTPRequestModel,
+  {
-    headers: any,
+    method,
-    body: any,
+    headers,
-}, { progressUpload, progressDownload, abortHandle }: RESTCallbacks): Promise<Response> {
+    body,
-    const xhr = {
+  }: {
-        io: new XMLHttpRequest()
+    method: HTTPRequestModel;
-    }
+    headers: any;
+    body: any;
+  },
+  { progressUpload, progressDownload, abortHandle }: RESTCallbacks
+): Promise<Response> {
+  const xhr: {
+    io?: XMLHttpRequest;
+  } = {
+    io: new XMLHttpRequest(),
+  };
   return new Promise((resolve, reject) => {
     // Stream the upload progress
     if (progressUpload) {
-            xhr.io.upload.addEventListener("progress", (dataEvent) => {
+      xhr.io?.upload.addEventListener("progress", (dataEvent) => {
         if (dataEvent.lengthComputable) {
-                    //console.log(`    ==> has a progress event: ${dataEvent.loaded} / ${dataEvent.total}`);
           progressUpload(dataEvent.loaded, dataEvent.total);
         }
       });
     }
     // Stream the download progress
     if (progressDownload) {
-            xhr.io.addEventListener("progress", (dataEvent) => {
+      xhr.io?.addEventListener("progress", (dataEvent) => {
         if (dataEvent.lengthComputable) {
-                    //console.log(`    ==> download progress:: ${dataEvent.loaded} / ${dataEvent.total}`);
+          progressDownload(dataEvent.loaded, dataEvent.total);
-                    progressUpload(dataEvent.loaded, dataEvent.total);
         }
       });
     }
@@ -177,38 +176,43 @@ export function fetchProgress(generateUrl: string, { method, headers, body }: {
           xhr.io.abort();
           return true;
         }
-                console.log(`Request abort (FAIL) on the XMLHttpRequest: ${generateUrl}`);
+        console.log(
+          `Request abort (FAIL) on the XMLHttpRequest: ${generateUrl}`
+        );
         return false;
-            }
+      };
     }
     // Check if we have an internal Fail:
-        xhr.io.addEventListener('error', () => {
+    xhr.io?.addEventListener("error", () => {
       xhr.io = undefined;
-            reject(new TypeError('Failed to fetch'))
+      reject(new TypeError("Failed to fetch"));
     });
 
     // Capture the end of the stream
-        xhr.io.addEventListener("loadend", () => {
+    xhr.io?.addEventListener("loadend", () => {
-            if (xhr.io.readyState !== XMLHttpRequest.DONE) {
+      if (xhr.io?.readyState !== XMLHttpRequest.DONE) {
-                //console.log(`    ==> READY state`);
         return;
       }
-            if (xhr.io.status === 0) {
+      if (xhr.io?.status === 0) {
         //the stream has been aborted
-                reject(new TypeError('Fetch has been aborted'));
+        reject(new TypeError("Fetch has been aborted"));
         return;
       }
       // Stream is ended, transform in a generic response:
       const response = new Response(xhr.io.response, {
         status: xhr.io.status,
-                statusText: xhr.io.statusText
+        statusText: xhr.io.statusText,
       });
-            const headersArray = replaceAll(xhr.io.getAllResponseHeaders().trim(), "\r\n", "\n").split('\n');
+      const headersArray = replaceAll(
+        xhr.io.getAllResponseHeaders().trim(),
+        "\r\n",
+        "\n"
+      ).split("\n");
       headersArray.forEach(function (header) {
-                const firstColonIndex = header.indexOf(':');
+        const firstColonIndex = header.indexOf(":");
         if (firstColonIndex !== -1) {
-                    var key = header.substring(0, firstColonIndex).trim();
+          const key = header.substring(0, firstColonIndex).trim();
-                    var value = header.substring(firstColonIndex + 1).trim();
+          const value = header.substring(firstColonIndex + 1).trim();
           response.headers.set(key, value);
         } else {
           response.headers.set(header, "");
@@ -217,31 +221,38 @@ export function fetchProgress(generateUrl: string, { method, headers, body }: {
       xhr.io = undefined;
       resolve(response);
     });
-        xhr.io.open(method, generateUrl, true);
+    xhr.io?.open(method, generateUrl, true);
     if (!isNullOrUndefined(headers)) {
       for (const [key, value] of Object.entries(headers)) {
-                xhr.io.setRequestHeader(key, value as string);
+        xhr.io?.setRequestHeader(key, value as string);
       }
     }
-        xhr.io.send(body);
+    xhr.io?.send(body);
   });
 }
 
-export function RESTRequest({ restModel, restConfig, data, params, queries, callback }: RESTRequestType): Promise<ModelResponseHttp> {
+export function RESTRequest({
+  restModel,
+  restConfig,
+  data,
+  params,
+  queries,
+  callback,
+}: RESTRequestType): Promise<ModelResponseHttp> {
   // Create the URL PATH:
   let generateUrl = RESTUrl({ restModel, restConfig, data, params, queries });
   let headers: any = {};
   if (restConfig.token !== undefined && restModel.tokenInUrl !== true) {
-        headers['Authorization'] = `Bearer ${restConfig.token}`;
+    headers["Authorization"] = `Bearer ${restConfig.token}`;
   }
   if (restModel.accept !== undefined) {
-        headers['Accept'] = restModel.accept;
+    headers["Accept"] = restModel.accept;
   }
   if (restModel.requestType !== HTTPRequestModel.GET) {
     // if Get we have not a content type, the body is empty
     if (restModel.contentType !== HTTPMimeType.MULTIPART) {
       // special case of multi-part ==> no content type otherwise the browser does not set the ";bundary=--****"
-            headers['Content-Type'] = restModel.contentType;
+      headers["Content-Type"] = restModel.contentType;
     }
   }
   let body = data;
@@ -252,14 +263,16 @@ export function RESTRequest({ restModel, restConfig, data, params, queries, call
     for (const name in data) {
       formData.append(name, data[name]);
     }
-        body = formData
+    body = formData;
   }
   return new Promise((resolve, reject) => {
     let action: undefined | Promise<Response> = undefined;
-        if (isNullOrUndefined(callback)
+    if (
-            || (isNullOrUndefined(callback.progressDownload)
+      isNullOrUndefined(callback) ||
-                && isNullOrUndefined(callback.progressUpload)
+      (isNullOrUndefined(callback.progressDownload) &&
-                && isNullOrUndefined(callback.abortHandle))) {
+        isNullOrUndefined(callback.progressUpload) &&
+        isNullOrUndefined(callback.abortHandle))
+    ) {
       // No information needed: call the generic fetch interface
       action = fetch(generateUrl, {
         method: restModel.requestType,
@@ -268,99 +281,152 @@ export function RESTRequest({ restModel, restConfig, data, params, queries, call
       });
     } else {
       // need progression information: call old fetch model (XMLHttpRequest) that permit to keep % upload and % download for HTTP1.x
-            action = fetchProgress(generateUrl, {
+      action = fetchProgress(
+        generateUrl,
+        {
           method: restModel.requestType ?? HTTPRequestModel.GET,
           headers,
           body,
-            }, callback);
+        },
+        callback
+      );
     }
-        action.then((response: Response) => {
+    action
+      .then((response: Response) => {
         if (response.status >= 200 && response.status <= 299) {
-                const contentType = response.headers.get('Content-Type');
+          const contentType = response.headers.get("Content-Type");
-                if (restModel.accept !== contentType) {
+          if (
+            !isNullOrUndefined(restModel.accept) &&
+            restModel.accept !== contentType
+          ) {
             reject({
+              name: "Model accept type incompatible",
               time: Date().toString(),
               status: 901,
-                        error: `REST check wrong type: ${restModel.accept} != ${contentType}`,
+              message: `REST Content type are not compatible: ${restModel.accept} != ${contentType}`,
               statusMessage: "Fetch error",
-                        message: "rest-tools.ts Wrong type in the message return type"
+              error: "rest-tools.ts Wrong type in the message return type",
             } as RestErrorResponse);
           } else if (contentType === HTTPMimeType.JSON) {
             response
               .json()
               .then((value: any) => {
-                            //console.log(`RECEIVE ==> ${response.status}=${ JSON.stringify(value, null, 2)}`);
                 resolve({ status: response.status, data: value });
               })
-                        .catch((reason: any) => {
+              .catch((reason: Error) => {
                 reject({
+                  name: "API serialization error",
                   time: Date().toString(),
                   status: 902,
-                                error: `REST parse json fail: ${reason}`,
+                  message: `REST parse json fail: ${reason}`,
                   statusMessage: "Fetch parse error",
-                                message: "rest-tools.ts Wrong message model to parse"
+                  error: "rest-tools.ts Wrong message model to parse",
                 } as RestErrorResponse);
               });
           } else {
             resolve({ status: response.status, data: response.body });
           }
         } else {
+          // the answer is not correct not a 2XX
+          // clone the response to keep the raw data if case of error:
+          response
+            .clone()
+            .json()
+            .then((value: any) => {
+              if (isRestErrorResponse(value)) {
+                reject(value);
+              } else {
+                response
+                  .text()
+                  .then((dataError: string) => {
                     reject({
+                      name: "API serialization error",
+                      time: Date().toString(),
+                      status: 903,
+                      message: `REST parse error json with wrong type fail. ${dataError}`,
+                      statusMessage: "Fetch parse error",
+                      error: "rest-tools.ts Wrong message model to parse",
+                    } as RestErrorResponse);
+                  })
+                  .catch((reason: any) => {
+                    reject({
+                      name: "API serialization error",
                       time: Date().toString(),
                       status: response.status,
-                    error: `${response.body}`,
+                      message: `unmanaged error model: ??? with error: ${reason}`,
-                    statusMessage: "Fetch code error",
+                      statusMessage: "Fetch ERROR parse error",
-                    message: "rest-tools.ts Wrong return code"
+                      error: "rest-tools.ts Wrong message model to parse",
                     } as RestErrorResponse);
+                  });
               }
-        }).catch((error: any) => {
+            })
+            .catch((reason: Error) => {
+              response
+                .text()
+                .then((dataError: string) => {
                   reject({
+                    name: "API serialization error",
+                    time: Date().toString(),
+                    status: response.status,
+                    message: `unmanaged error model: ${dataError} with error: ${reason}`,
+                    statusMessage: "Fetch ERROR TEXT parse error",
+                    error: "rest-tools.ts Wrong message model to parse",
+                  } as RestErrorResponse);
+                })
+                .catch((reason: any) => {
+                  reject({
+                    name: "API serialization error",
+                    time: Date().toString(),
+                    status: response.status,
+                    message: `unmanaged error model: ??? with error: ${reason}`,
+                    statusMessage: "Fetch ERROR TEXT FAIL",
+                    error: "rest-tools.ts Wrong message model to parse",
+                  } as RestErrorResponse);
+                });
+            });
+        }
+      })
+      .catch((error: Error) => {
+        if (isRestErrorResponse(error)) {
+          reject(error);
+        } else {
+          reject({
+            name: "Request fail",
             time: Date(),
             status: 999,
-                error: error,
+            message: error,
             statusMessage: "Fetch catch error",
-                message: "rest-tools.ts detect an error in the fetch request"
+            error: "rest-tools.ts detect an error in the fetch request",
           });
+        }
       });
   });
 }
 
-
+export function RESTRequestJson<TYPE>(
-
+  request: RESTRequestType,
-export function RESTRequestJson<TYPE>(request: RESTRequestType, checker: (data: any) => data is TYPE): Promise<TYPE> {
+  checker?: (data: any) => data is TYPE
+): Promise<TYPE> {
   return new Promise((resolve, reject) => {
-        RESTRequest(request).then((value: ModelResponseHttp) => {
+    RESTRequest(request)
-            if (checker(value.data)) {
+      .then((value: ModelResponseHttp) => {
+        if (isNullOrUndefined(checker)) {
+          console.log(`Have no check of MODEL in API: ${RESTUrl(request)}`);
+          resolve(value.data);
+        } else if (checker === undefined || checker(value.data)) {
           resolve(value.data);
         } else {
           reject({
+            name: "Model check fail",
             time: Date().toString(),
             status: 950,
             error: "REST Fail to verify the data",
             statusMessage: "API cast ERROR",
-                    message: "api.ts Check type as fail"
+            message: "api.ts Check type as fail",
           } as RestErrorResponse);
         }
-        }).catch((reason: RestErrorResponse) => {
+      })
-            reject(reason);
+      .catch((reason: RestErrorResponse) => {
-        });
-    });
-}
-export function RESTRequestJsonArray<TYPE>(request: RESTRequestType, checker: (data: any) => data is TYPE): Promise<TYPE[]> {
-    return new Promise((resolve, reject) => {
-        RESTRequest(request).then((value: ModelResponseHttp) => {
-            if (isArrayOf(value.data, checker)) {
-                resolve(value.data);
-            } else {
-                reject({
-                    time: Date().toString(),
-                    status: 950,
-                    error: "REST Fail to verify the data",
-                    statusMessage: "API cast ERROR",
-                    message: "api.ts Check type as fail"
-                } as RestErrorResponse);
-            }
-        }).catch((reason: RestErrorResponse) => {
         reject(reason);
       });
   });
@@ -368,9 +434,11 @@ export function RESTRequestJsonArray<TYPE>(request: RESTRequestType, checker: (d
 
 export function RESTRequestVoid(request: RESTRequestType): Promise<void> {
   return new Promise((resolve, reject) => {
-        RESTRequest(request).then((value: ModelResponseHttp) => {
+    RESTRequest(request)
+      .then((value: ModelResponseHttp) => {
         resolve();
-        }).catch((reason: RestErrorResponse) => {
+      })
+      .catch((reason: RestErrorResponse) => {
         reject(reason);
       });
   });

front/src/environments/environment.ts

@@ -5,7 +5,9 @@
 
 import { Environment } from "@kangaroo-and-rabbit/kar-cw";
 
-const serverSSOAddress = 'http://atria-soft.org'
+const serverBaseAddress = 'http://atria-soft.org'
+const serverSSOAddress = `${serverBaseAddress}/karso`
+//const serverSSOAddress = 'http://localhost:4200'
 
 const environment_back_prod: Environment = {
 	production: false,
@@ -13,13 +15,13 @@ const environment_back_prod: Environment = {
 	applName: "karideo",
 	defaultServer: "karideo",
 	server: {
-		karideo: `${serverSSOAddress}/karideo/api`,
+		karideo: `${serverBaseAddress}/karideo/api`,
-		karso: `${serverSSOAddress}/karso/api`,
+		karso: `${serverSSOAddress}/api`,
 	},
-	ssoSite: `${serverSSOAddress}/karso/`,
+	ssoSite: `${serverSSOAddress}/`,
-	ssoSignIn: `${serverSSOAddress}/karso/signin/karideo-dev/`,
+	ssoSignIn: `${serverSSOAddress}/signin/karideo-dev/`,
-	ssoSignUp: `${serverSSOAddress}/karso/signup/karideo-dev/`,
+	ssoSignUp: `${serverSSOAddress}/signup/karideo-dev/`,
-	ssoSignOut: `${serverSSOAddress}/karso/signout/karideo-dev/`,
+	ssoSignOut: `${serverSSOAddress}/signout/karideo-dev/`,
 	tokenStoredInPermanentStorage: false,
 };
 
@@ -30,12 +32,12 @@ const environment_local: Environment = {
 	defaultServer: "karideo",
 	server: {
 		karideo: 'http://localhost:18080/karideo/api',
-		karso: `${serverSSOAddress}/karso/api`,
+		karso: `${serverSSOAddress}/api`,
 	},
-	ssoSite: `${serverSSOAddress}/karso/`,
+	ssoSite: `${serverSSOAddress}/`,
-	ssoSignIn: `${serverSSOAddress}/karso/signin/karideo-dev/`,
+	ssoSignIn: `${serverSSOAddress}/signin/karideo-dev/`,
-	ssoSignUp: `${serverSSOAddress}/karso/signup/karideo-dev/`,
+	ssoSignUp: `${serverSSOAddress}/signup/karideo-dev/`,
-	ssoSignOut: `${serverSSOAddress}/karso/signout/karideo-dev/`,
+	ssoSignOut: `${serverSSOAddress}/signout/karideo-dev/`,
 	tokenStoredInPermanentStorage: false,
 	replaceDataToRealServer: true,
 };
@@ -46,13 +48,13 @@ const environment_hybrid: Environment = {
 	applName: "karideo",
 	defaultServer: "karideo",
 	server: {
-		karideo: `${serverSSOAddress}/karideo/api`,
+		karideo: `${serverBaseAddress}/karideo/api`,
-		karso: `${serverSSOAddress}/karso/api`,
+		karso: `${serverSSOAddress}/api`,
 	},
-	ssoSite: `${serverSSOAddress}/karso/`,
+	ssoSite: `${serverSSOAddress}/`,
-	ssoSignIn: `${serverSSOAddress}/karso/signin/karideo-dev/`,
+	ssoSignIn: `${serverSSOAddress}/signin/karideo-dev/`,
-	ssoSignUp: `${serverSSOAddress}/karso/signup/karideo-dev/`,
+	ssoSignUp: `${serverSSOAddress}/signup/karideo-dev/`,
-	ssoSignOut: `${serverSSOAddress}/karso/signout/karideo-dev/`,
+	ssoSignOut: `${serverSSOAddress}/signout/karideo-dev/`,
 	tokenStoredInPermanentStorage: false,
 };