[VERSION] update dev tag version

.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,14 +19,11 @@ 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,6 +59,15 @@ 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.12.0</version>
+			<version>0.8.4</version>
 		</dependency>
 		<dependency>
 			<groupId>org.slf4j</groupId>
 			<artifactId>slf4j-simple</artifactId>
-			<version>2.1.0-alpha1</version>
+			<version>2.0.9</version>
 		</dependency>
 		<dependency>
 			<groupId>com.fasterxml.jackson.datatype</groupId>
 			<artifactId>jackson-datatype-jsr310</artifactId>
-			<version>2.17.1</version>
+			<version>2.16.1</version>
 		</dependency>
 		<!--
 		************************************************************ 
@@ -40,25 +40,15 @@
 		<dependency>
 			<groupId>org.junit.jupiter</groupId>
 			<artifactId>junit-jupiter-api</artifactId>
-			<version>5.11.0-M2</version>
+			<version>5.10.1</version>
 			<scope>test</scope>
 		</dependency>
 	    <dependency>
 	        <groupId>org.junit.jupiter</groupId>
 	        <artifactId>junit-jupiter-engine</artifactId>
-			<version>5.11.0-M2</version>
+			<version>5.10.1</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>
@@ -195,10 +185,24 @@
 					<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.23.0</version>
+				<version>2.12.2</version>
 				<configuration>
 					<encoding>UTF-8</encoding>
 					<lineEnding>LF</lineEnding>
@@ -222,23 +226,7 @@
 					</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,7 +10,10 @@ 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.GenericCatcher;
+import org.kar.archidata.catcher.ExceptionCatcher;
+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;
@@ -92,7 +95,10 @@ public class WebLauncher {
 		// global authentication system
 		rc.register(KarideoAuthenticationFilter.class);
 		// register exception catcher
-		GenericCatcher.addAll(rc);
+		rc.register(InputExceptionCatcher.class);
+		rc.register(SystemExceptionCatcher.class);
+		rc.register(FailExceptionCatcher.class);
+		rc.register(ExceptionCatcher.class);
 		// add default resource:
 		rc.register(UserResource.class);
 		rc.register(SeriesResource.class);
@@ -108,7 +114,7 @@ public class WebLauncher {
 		// add jackson to be discover when we are ins stand-alone server
 		rc.register(JacksonFeature.class);
 		// enable this to show low level request
-		// rc.property(LoggingFeature.LOGGING_FEATURE_LOGGER_LEVEL_SERVER, Level.WARNING.getName());
+		//rc.property(LoggingFeature.LOGGING_FEATURE_LOGGER_LEVEL_SERVER, Level.WARNING.getName());
 
 		this.server = GrizzlyHttpServerFactory.createHttpServer(getBaseURI(), rc);
 		final HttpServer serverLink = this.server;

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

@@ -4,8 +4,7 @@ package org.kar.karideo;
 import java.util.List;
 
 import org.kar.archidata.api.DataResource;
-import org.kar.archidata.externalRestApi.AnalyzeApi;
+import org.kar.archidata.dataAccess.DataFactoryTsApi;
-import org.kar.archidata.externalRestApi.TsGenerateApi;
 import org.kar.archidata.tools.ConfigBaseVariable;
 import org.kar.karideo.api.Front;
 import org.kar.karideo.api.HealthCheck;
@@ -15,6 +14,7 @@ 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 {
-		generateObjects();
+		DataFactoryTsApi.generatePackage(List.of(
+				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,5 +1,6 @@
 package org.kar.karideo.api;
 
+
 import org.kar.archidata.api.FrontGeneric;
 
 import jakarta.ws.rs.Path;

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

@@ -89,7 +89,7 @@ public class MediaResource {
 			@FormDataParam("fileName") String fileName, //
 			@FormDataParam("universe") String universe, //
 			@FormDataParam("series") String series, //
-			// @FormDataParam("seriesId") String seriesId, // Not used ...
+			//@FormDataParam("seriesId") String seriesId, // Not used ...
 			@FormDataParam("season") String season, //
 			@FormDataParam("episode") String episode, //
 			@FormDataParam("title") String title, //
@@ -107,7 +107,7 @@ public class MediaResource {
 			title = multipartCorrection(title);
 			typeId = multipartCorrection(typeId);
 
-			// public NodeSmall uploadFile(final FormDataMultiPart form) {
+			//public NodeSmall uploadFile(final FormDataMultiPart form) {
 			LOGGER.info("Upload media file: {}", fileMetaData);
 			LOGGER.info("    - fileName: {}", fileName);
 			LOGGER.info("    - universe: {}", universe);
@@ -136,7 +136,7 @@ public class MediaResource {
 					ex.printStackTrace();
 					throw new FailException("can not create input media (the data model has an internal error");
 				}
-			} else if (data != null && data.deleted != null && data.deleted) {
+			} else if (data!= null && data.deleted != null && data.deleted) {
 				LOGGER.info("Data already exist but deleted");
 				System.out.flush();
 				DataTools.undelete(data.uuid);

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

@@ -35,6 +35,7 @@ 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")
@@ -51,7 +52,9 @@ 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,7 +51,9 @@ 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,6 +34,7 @@ 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")
@@ -54,7 +55,9 @@ 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,15 +46,19 @@ public class UserMediaAdvancementResource {
 		return DataAccess.getsWhere(UserMediaAdvancement.class, new Condition(new QueryCondition("userId", "=", gc.userByToken.id)));
 	}
 
-	/* ============================================================================= Modification SECTION: ============================================================================= */
+	/* =============================================================================
+	 * Modification SECTION:
+	 * ============================================================================= */
 
-	public record MediaInformations(int time, float percent, int count) {
+	public record MediaInformations(
-	}
+			int time,
+			float percent,
+			int count) {}
 
-	// @POST
+	//@POST
-	// @Path("{id}")
+	//@Path("{id}")
-	// @RolesAllowed("USER")
+	//@RolesAllowed("USER")
-	// @Consumes(MediaType.APPLICATION_JSON)
+	//@Consumes(MediaType.APPLICATION_JSON)
 	public UserMediaAdvancement post(@Context final SecurityContext sc, @PathParam("id") final Long id, final MediaInformations data) throws Exception {
 		final GenericContext gc = (GenericContext) sc.getUserPrincipal();
 		final UserMediaAdvancement elem = new UserMediaAdvancement();
@@ -66,8 +70,10 @@ public class UserMediaAdvancementResource {
 		return DataAccess.insert(elem);
 	}
 
-	public record MediaInformationsDelta(int time, float percent, boolean addCount) {
+	public record MediaInformationsDelta(
-	}
+			int time,
+			float percent,
+			boolean addCount) {}
 
 	@PATCH
 	@Path("{id}")

back/src/org/kar/karideo/internal/Log.java

@@ -4,57 +4,57 @@ package org.kar.karideo.internal;
 //import io.scenarium.logger.Logger;
 
 public class Log {
-	// private static final String LIB_NAME = "logger";
+//	private static final String LIB_NAME = "logger";
-	// private static final String LIB_NAME_DRAW = Logger.getDrawableName(LIB_NAME);
+//	private static final String LIB_NAME_DRAW = Logger.getDrawableName(LIB_NAME);
-	// private static final boolean PRINT_CRITICAL = Logger.getNeedPrint(LIB_NAME, LogLevel.CRITICAL);
+//	private static final boolean PRINT_CRITICAL = Logger.getNeedPrint(LIB_NAME, LogLevel.CRITICAL);
-	// private static final boolean PRINT_ERROR = Logger.getNeedPrint(LIB_NAME, LogLevel.ERROR);
+//	private static final boolean PRINT_ERROR = Logger.getNeedPrint(LIB_NAME, LogLevel.ERROR);
-	// private static final boolean PRINT_WARNING = Logger.getNeedPrint(LIB_NAME, LogLevel.WARNING);
+//	private static final boolean PRINT_WARNING = Logger.getNeedPrint(LIB_NAME, LogLevel.WARNING);
-	// private static final boolean PRINT_INFO = Logger.getNeedPrint(LIB_NAME, LogLevel.INFO);
+//	private static final boolean PRINT_INFO = Logger.getNeedPrint(LIB_NAME, LogLevel.INFO);
-	// private static final boolean PRINT_DEBUG = Logger.getNeedPrint(LIB_NAME, LogLevel.DEBUG);
+//	private static final boolean PRINT_DEBUG = Logger.getNeedPrint(LIB_NAME, LogLevel.DEBUG);
-	// private static final boolean PRINT_VERBOSE = Logger.getNeedPrint(LIB_NAME, LogLevel.VERBOSE);
+//	private static final boolean PRINT_VERBOSE = Logger.getNeedPrint(LIB_NAME, LogLevel.VERBOSE);
-	// private static final boolean PRINT_TODO = Logger.getNeedPrint(LIB_NAME, LogLevel.TODO);
+//	private static final boolean PRINT_TODO = Logger.getNeedPrint(LIB_NAME, LogLevel.TODO);
-	// private static final boolean PRINT_PRINT = Logger.getNeedPrint(LIB_NAME, LogLevel.PRINT);
+//	private static final boolean PRINT_PRINT = Logger.getNeedPrint(LIB_NAME, LogLevel.PRINT);
-	//
+//
-	// private Log() {}
+//	private Log() {}
-	//
+//
-	// public static void print(String data) {
+//	public static void print(String data) {
-	// if (PRINT_PRINT)
+//		if (PRINT_PRINT)
-	// Logger.print(LIB_NAME_DRAW, data);
+//			Logger.print(LIB_NAME_DRAW, data);
-	// }
+//	}
-	//
+//
-	// public static void todo(String data) {
+//	public static void todo(String data) {
-	// if (PRINT_TODO)
+//		if (PRINT_TODO)
-	// Logger.todo(LIB_NAME_DRAW, data);
+//			Logger.todo(LIB_NAME_DRAW, data);
-	// }
+//	}
-	//
+//
-	// public static void critical(String data) {
+//	public static void critical(String data) {
-	// if (PRINT_CRITICAL)
+//		if (PRINT_CRITICAL)
-	// Logger.critical(LIB_NAME_DRAW, data);
+//			Logger.critical(LIB_NAME_DRAW, data);
-	// }
+//	}
-	//
+//
-	// public static void error(String data) {
+//	public static void error(String data) {
-	// if (PRINT_ERROR)
+//		if (PRINT_ERROR)
-	// Logger.error(LIB_NAME_DRAW, data);
+//			Logger.error(LIB_NAME_DRAW, data);
-	// }
+//	}
-	//
+//
-	// public static void warning(String data) {
+//	public static void warning(String data) {
-	// if (PRINT_WARNING)
+//		if (PRINT_WARNING)
-	// Logger.warning(LIB_NAME_DRAW, data);
+//			Logger.warning(LIB_NAME_DRAW, data);
-	// }
+//	}
-	//
+//
-	// public static void info(String data) {
+//	public static void info(String data) {
-	// if (PRINT_INFO)
+//		if (PRINT_INFO)
-	// Logger.info(LIB_NAME_DRAW, data);
+//			Logger.info(LIB_NAME_DRAW, data);
-	// }
+//	}
-	//
+//
-	// public static void debug(String data) {
+//	public static void debug(String data) {
-	// if (PRINT_DEBUG)
+//		if (PRINT_DEBUG)
-	// Logger.debug(LIB_NAME_DRAW, data);
+//			Logger.debug(LIB_NAME_DRAW, data);
-	// }
+//	}
-	//
+//
-	// public static void verbose(String data) {
+//	public static void verbose(String data) {
-	// if (PRINT_VERBOSE)
+//		if (PRINT_VERBOSE)
-	// Logger.verbose(LIB_NAME_DRAW, data);
+//			Logger.verbose(LIB_NAME_DRAW, data);
-	// }
+//	}
 
 }

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

@@ -2,7 +2,6 @@ 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;
@@ -11,16 +10,12 @@ 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";
@@ -32,7 +27,7 @@ public class Initialization extends MigrationSqlStep {
 
 	@Override
 	public void generateStep() throws Exception {
-		for (final Class<?> clazz : CLASSES_BASE) {
+		for(final Class<?> clazz : CLASSES_BASE) {
 			addClass(clazz);
 		}
 
@@ -67,25 +62,4 @@ 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

@@ -42,10 +42,10 @@ public class Migration20240226 extends MigrationSqlStep {
 				""");
 		addAction(() -> {
 			final List<UUIDConversion> datas = DataAccess.gets(UUIDConversion.class, new AccessDeletedItems(), new OverrideTableName("data"));
-			for (final UUIDConversion elem : datas) {
+			for (final UUIDConversion elem: datas) {
 				elem.uuid = UuidUtils.nextUUID();
 			}
-			for (final UUIDConversion elem : datas) {
+			for (final UUIDConversion elem: datas) {
 				DataAccess.update(elem, elem.id, List.of("uuid"), new OverrideTableName("data"));
 			}
 		});
@@ -53,18 +53,18 @@ public class Migration20240226 extends MigrationSqlStep {
 				ALTER TABLE `data` CHANGE `uuid` `uuid` binary(16) DEFAULT (UUID_TO_BIN(UUID(), TRUE));
 				""");
 		final List<String> tableToTransform = List.of("media", "season", "series", "type", "user");
-		for (final String tableName : tableToTransform) {
+		for (final String tableName : tableToTransform ) {
 			addAction("ALTER TABLE `" + tableName + "` ADD `covers` text NULL;");
 			addAction(() -> {
 				final List<UUIDConversion> datas = DataAccess.gets(UUIDConversion.class, new AccessDeletedItems(), new OverrideTableName("data"));
 				final List<CoverConversion> medias = DataAccess.gets(CoverConversion.class, new AccessDeletedItems(), new OverrideTableName(tableName));
 				final List<LinkTableLongLong> links = DataAccess.gets(LinkTableLongLong.class, new OverrideTableName(tableName + "_link_cover"));
 				LOGGER.info("Get somes data: {} {} {}", datas.size(), medias.size(), links.size());
-				for (final CoverConversion media : medias) {
+				for (final CoverConversion media: medias) {
 					final List<UUID> values = new ArrayList<>();
-					for (final LinkTableLongLong link : links) {
+					for (final 	LinkTableLongLong link: links) {
 						if (link.object1Id.equals(media.id)) {
-							for (final UUIDConversion data : datas) {
+							for (final UUIDConversion data: datas) {
 								if (data.id.equals(link.object2Id)) {
 									values.add(data.uuid);
 									break;
@@ -88,8 +88,8 @@ public class Migration20240226 extends MigrationSqlStep {
 		addAction(() -> {
 			final List<UUIDConversion> datas = DataAccess.gets(UUIDConversion.class, new AccessDeletedItems(), new OverrideTableName("data"));
 			final List<MediaConversion> medias = DataAccess.gets(MediaConversion.class, new AccessDeletedItems(), new OverrideTableName("media"));
-			for (final MediaConversion media : medias) {
+			for (final MediaConversion media: medias) {
-				for (final UUIDConversion data : datas) {
+				for (final UUIDConversion data: datas) {
 					if (data.id.equals(media.dataId)) {
 						media.dataUUID = data.uuid;
 						DataAccess.update(media, media.id, List.of("dataUUID"), new OverrideTableName("media"));
@@ -107,7 +107,7 @@ public class Migration20240226 extends MigrationSqlStep {
 		// Move the files...
 		addAction(() -> {
 			final List<UUIDConversion> datas = DataAccess.gets(UUIDConversion.class, new AccessDeletedItems(), new OverrideTableName("data"));
-			for (final UUIDConversion data : datas) {
+			for (final UUIDConversion data: datas) {
 				final String origin = DataResource.getFileDataOld(data.id);
 				final String destination = DataResource.getFileData(data.uuid);
 				LOGGER.info("move file = {}", origin);
@@ -119,7 +119,11 @@ public class Migration20240226 extends MigrationSqlStep {
 				}
 			}
 		});
-		/* I am not sure then I prefer keep the primary key for the moment addAction(""" ALTER TABLE `data` DROP `id`; """); */
+		/* I am not sure then I prefer keep the primary key for the moment
+		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,7 +9,6 @@ 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;
@@ -20,41 +19,43 @@ import jakarta.persistence.Table;
 @Table(name = "media")
 @JsonInclude(JsonInclude.Include.NON_NULL)
 public class Media extends GenericDataSoftDelete {
-	@Schema(description = "Name of the media (this represent the title)")
+	// Name of the media (this represent the title)
 	@Column(nullable = false, length = 0)
 	public String name;
-	@Schema(description = "Description of the media")
+	// Description of the media
 	@Column(length = 0)
 	public String description;
-	@Schema(description = "Foreign Key Id of the data")
+	// Foreign Key Id of the data
 	@ManyToOne(fetch = FetchType.LAZY, targetEntity = Data.class)
 	@Column(nullable = false)
 	public UUID dataId;
-	@Schema(description = "Type of the media")
+	// Type of the media")
 	@ManyToOne(fetch = FetchType.LAZY, targetEntity = Type.class)
 	public Long typeId;
-	@Schema(description = "Series reference of the media")
+	// Series reference of the media
 	@ManyToOne(fetch = FetchType.LAZY, targetEntity = Series.class)
 	public Long seriesId;
-	@Schema(description = "Season reference of the media")
+	// Season reference of the media
 	@ManyToOne(fetch = FetchType.LAZY, targetEntity = Season.class)
 	public Long seasonId;
-	@Schema(description = "Episode Id")
+	// Episode Id
 	public Integer episode;
 	// ")
 	public Integer date;
-	@Schema(description = "Creation years of the media")
+	// Creation years of the media
 	public Integer time;
-	@Schema(description = "Limitation Age of the media")
+	// Limitation Age of the media
 	public Integer ageLimit;
-	@Schema(description = "List of Id of the specific covers")
+	// 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 + ", seriesId=" + this.seriesId + ", seasonId=" + this.seasonId
+		return "Media [name=" + this.name + ", description=" + this.description + ", dataId=" + this.dataId + ", typeId=" + this.typeId
-				+ ", episode=" + this.episode + ", date=" + this.date + ", time=" + this.time + ", ageLimit=" + this.ageLimit + ", covers=" + this.covers + "]";
+				+ ", seriesId=" + this.seriesId + ", seasonId=" + this.seasonId + ", episode=" + this.episode + ", date=" + this.date
+				+ ", time=" + this.time + ", ageLimit=" + this.ageLimit + ", covers=" + this.covers + "]";
 	}
 
+
 }

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

@@ -55,7 +55,7 @@ public class TestHealthCheck {
 	
 	@Order(1)
 	@Test
-	// @RepeatedTest(10)
+	//@RepeatedTest(10)
 	public void checkHealthCheck() throws Exception {
 		final HealthResult result = api.get(HealthResult.class, "health_check");
 		Assertions.assertEquals(result.value(), "alive and kicking");

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

@@ -12,23 +12,17 @@ public class WebLauncherTest extends WebLauncher {
 	public WebLauncherTest() {
 		LOGGER.debug("Configure REST system");
 		// for local test:
-		ConfigBaseVariable.apiAdress = "http://127.0.0.1:12342/test/api/";
+		ConfigBaseVariable.apiAdress = "http://127.0.0.1:12345/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";
-			}
+		
-		} else {
+		//ConfigBaseVariable.dbHost = "localhost";
-			// Enable this if you want to access to a local MySQL base to test with an adminer
+		//ConfigBaseVariable.dbUser = "root";
-			ConfigBaseVariable.bdDatabase = "test_db";
+		//ConfigBaseVariable.dbPassword = "ZERTYSDGFVHSDFGHJYZSDFGSQxfgsqdfgsqdrf4564654";
-			ConfigBaseVariable.dbPort = "3309";
-			ConfigBaseVariable.dbUser = "root";
-			ConfigBaseVariable.dbPassword = "password";
-		}
 	}
 }

front/package.json

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

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

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

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

@@ -1,12 +0,0 @@
-/**
- * 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/data-resource.ts

@@ -1,108 +1,21 @@
 /**
- * Interface of the server (auto-generated code)
+ * API of the server (auto-generated code)
  */
 import {
   HTTPMimeType,
   HTTPRequestModel,
+  ModelResponseHttp,
+  RESTCallbacks,
   RESTConfig,
   RESTRequestJson,
-	RESTRequestVoid,
+  RESTRequestJsonArray,
-} from "../rest-tools";
+  RESTRequestVoid
-
+} 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
 	 */
@@ -125,4 +38,95 @@ 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/front.ts

@@ -0,0 +1,18 @@
+/**
+ * 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/health-check.ts

@@ -1,18 +1,20 @@
 /**
- * Interface of the server (auto-generated code)
+ * API of the server (auto-generated code)
  */
 import {
   HTTPMimeType,
   HTTPRequestModel,
+  ModelResponseHttp,
+  RESTCallbacks,
   RESTConfig,
   RESTRequestJson,
-} from "../rest-tools";
+  RESTRequestJsonArray,
-
+  RESTRequestVoid
+} from "./rest-tools"
 import {
   HealthResult,
   isHealthResult,
-} from "../model";
+} from "./model"
-
 export namespace HealthCheck {
 
 	/**
@@ -25,7 +27,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/index.ts

@@ -1,7 +1,13 @@
 /**
- * Interface of the server (auto-generated code)
+ * Global import of the package
  */
 export * from "./model";
-export * from "./api";
+export * from "./front";
-export * from "./rest-tools";
+export * from "./health-check";
-
+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/media-resource.ts

@@ -1,106 +1,24 @@
 /**
- * Interface of the server (auto-generated code)
+ * API of the server (auto-generated code)
  */
 import {
   HTTPMimeType,
   HTTPRequestModel,
+  ModelResponseHttp,
   RESTCallbacks,
   RESTConfig,
   RESTRequestJson,
-	RESTRequestVoid,
+  RESTRequestJsonArray,
-} from "../rest-tools";
+  RESTRequestVoid
-
+} 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
 	 */
@@ -124,29 +42,70 @@ export namespace MediaResource {
 		});
 	};
 	/**
-	 * Remove a specific cover of a media
+	 * Get a specific Media with his ID
 	 */
-	export function removeCover({
+	export function get({
 			restConfig,
 			params,
 		}: {
 		restConfig: RESTConfig,
 		params: {
-			coverId: UUID,
 			id: Long,
 		},
 	}): Promise<Media> {
 		return RESTRequestJson({
 			restModel: {
-				endPoint: "/media/{id}/cover/{coverId}",
+				endPoint: "/media/{id}",
-				requestType: HTTPRequestModel.DELETE,
+				requestType: HTTPRequestModel.GET,
-				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
 	 */
@@ -179,6 +138,30 @@ 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
 	 */
@@ -202,7 +185,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/model.ts

@@ -0,0 +1,435 @@
+/**
+ * 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

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,46 +0,0 @@
-/**
- * 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

@@ -1,46 +0,0 @@
-/**
- * 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

@@ -1,48 +0,0 @@
-/**
- * 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

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1,24 +0,0 @@
-/**
- * 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

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1,86 +0,0 @@
-/**
- * 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

@@ -1,43 +0,0 @@
-/**
- * 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

@@ -1,60 +0,0 @@
-/**
- * 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

@@ -1,60 +0,0 @@
-/**
- * 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

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,55 +0,0 @@
-/**
- * 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

@@ -1,42 +0,0 @@
-/**
- * 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

@@ -1,65 +0,0 @@
-/**
- * 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

@@ -1,38 +0,0 @@
-/**
- * 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

@@ -1,53 +0,0 @@
-/**
- * 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

@@ -1,8 +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>;

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

@@ -4,25 +4,25 @@
  * @license MPL-2
  */
 
-import { RestErrorResponse, isRestErrorResponse } from "./model";
+import { RestErrorResponse } 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,6 +50,23 @@ 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;
 }
@@ -58,24 +75,25 @@ 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);
@@ -85,34 +103,24 @@ 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({
+export function RESTUrl({ restModel, restConfig, params, queries }: RESTRequestType): string {
-  restModel,
-  restConfig,
-  params,
-  queries,
-}: RESTRequestType): string {
     // Create the URL PATH:
-  let generateUrl = `${removeTrailingSlashes(
+    let generateUrl = `${removeTrailingSlashes(restConfig.server)}/${removeLeadingSlashes(restModel.endPoint)}`;
-    restConfig.server
-  )}/${removeLeadingSlashes(restModel.endPoint)}`;
     if (params !== undefined) {
         for (let key of Object.keys(params)) {
             generateUrl = replaceAll(generateUrl, `{${key}}`, `${params[key]}`);
         }
     }
-  if (
+    if (queries === undefined && (restConfig.token === undefined || restModel.tokenInUrl !== true)) {
-    queries === undefined &&
-    (restConfig.token === undefined || restModel.tokenInUrl !== true)
-  ) {
         return generateUrl;
     }
     const searchParams = new URLSearchParams();
@@ -120,8 +128,8 @@ export function RESTUrl({
         for (let key of Object.keys(queries)) {
             const value = queries[key];
             if (Array.isArray(value)) {
-        for (const element of value) {
+                for (let iii = 0; iii < value.length; iii++) {
-          searchParams.append(`${key}`, `${element}`);
+                    searchParams.append(`${key}`, `${value[iii]}`);
                 }
             } else {
                 searchParams.append(`${key}`, `${value}`);
@@ -129,43 +137,36 @@ export function RESTUrl({
         }
     }
     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(
+
-  generateUrl: string,
+export function fetchProgress(generateUrl: string, { method, headers, body }: {
-  {
+    method: HTTPRequestModel,
-    method,
+    headers: any,
-    headers,
+    body: any,
-    body,
+}, { progressUpload, progressDownload, abortHandle }: RESTCallbacks): Promise<Response> {
-  }: {
+    const xhr = {
-    method: HTTPRequestModel;
+        io: new XMLHttpRequest()
-    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) {
-          progressDownload(dataEvent.loaded, dataEvent.total);
+                    //console.log(`    ==> download progress:: ${dataEvent.loaded} / ${dataEvent.total}`);
+                    progressUpload(dataEvent.loaded, dataEvent.total);
                 }
             });
         }
@@ -176,43 +177,38 @@ export function fetchProgress(
                     xhr.io.abort();
                     return true;
                 }
-        console.log(
+                console.log(`Request abort (FAIL) on the XMLHttpRequest: ${generateUrl}`);
-          `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(
+            const headersArray = replaceAll(xhr.io.getAllResponseHeaders().trim(), "\r\n", "\n").split('\n');
-        xhr.io.getAllResponseHeaders().trim(),
-        "\r\n",
-        "\n"
-      ).split("\n");
             headersArray.forEach(function (header) {
-        const firstColonIndex = header.indexOf(":");
+                const firstColonIndex = header.indexOf(':');
                 if (firstColonIndex !== -1) {
-          const key = header.substring(0, firstColonIndex).trim();
+                    var key = header.substring(0, firstColonIndex).trim();
-          const value = header.substring(firstColonIndex + 1).trim();
+                    var value = header.substring(firstColonIndex + 1).trim();
                     response.headers.set(key, value);
                 } else {
                     response.headers.set(header, "");
@@ -221,38 +217,31 @@ export function fetchProgress(
             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({
+export function RESTRequest({ restModel, restConfig, data, params, queries, callback }: RESTRequestType): Promise<ModelResponseHttp> {
-  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;
@@ -263,16 +252,14 @@ export function RESTRequest({
         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 (
+        if (isNullOrUndefined(callback)
-      isNullOrUndefined(callback) ||
+            || (isNullOrUndefined(callback.progressDownload)
-      (isNullOrUndefined(callback.progressDownload) &&
+                && isNullOrUndefined(callback.progressUpload)
-        isNullOrUndefined(callback.progressUpload) &&
+                && isNullOrUndefined(callback.abortHandle))) {
-        isNullOrUndefined(callback.abortHandle))
-    ) {
             // No information needed: call the generic fetch interface
             action = fetch(generateUrl, {
                 method: restModel.requestType,
@@ -281,152 +268,99 @@ export function RESTRequest({
             });
         } else {
             // need progression information: call old fetch model (XMLHttpRequest) that permit to keep % upload and % download for HTTP1.x
-      action = fetchProgress(
+            action = fetchProgress(generateUrl, {
-        generateUrl,
-        {
                 method: restModel.requestType ?? HTTPRequestModel.GET,
                 headers,
                 body,
-        },
+            }, callback);
-        callback
-      );
         }
-    action
+        action.then((response: Response) => {
-      .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 (
+                if (restModel.accept !== contentType) {
-            !isNullOrUndefined(restModel.accept) &&
-            restModel.accept !== contentType
-          ) {
                     reject({
-              name: "Model accept type incompatible",
                         time: Date().toString(),
                         status: 901,
-              message: `REST Content type are not compatible: ${restModel.accept} != ${contentType}`,
+                        error: `REST check wrong type: ${restModel.accept} != ${contentType}`,
                         statusMessage: "Fetch error",
-              error: "rest-tools.ts Wrong type in the message return type",
+                        message: "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: Error) => {
+                        .catch((reason: any) => {
                             reject({
-                  name: "API serialization error",
                                 time: Date().toString(),
                                 status: 902,
-                  message: `REST parse json fail: ${reason}`,
+                                error: `REST parse json fail: ${reason}`,
                                 statusMessage: "Fetch parse error",
-                  error: "rest-tools.ts Wrong message model to parse",
+                                message: "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,
-                      message: `unmanaged error model: ??? with error: ${reason}`,
+                    error: `${response.body}`,
-                      statusMessage: "Fetch ERROR parse error",
+                    statusMessage: "Fetch code error",
-                      error: "rest-tools.ts Wrong message model to parse",
+                    message: "rest-tools.ts Wrong return code"
                 } 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,
-            message: error,
+                error: error,
                 statusMessage: "Fetch catch error",
-            error: "rest-tools.ts detect an error in the fetch request",
+                message: "rest-tools.ts detect an error in the fetch request"
             });
-        }
         });
     });
 }
 
-export function RESTRequestJson<TYPE>(
+
-  request: RESTRequestType,
+
-  checker?: (data: any) => data is TYPE
+export function RESTRequestJson<TYPE>(request: RESTRequestType, checker: (data: any) => data is TYPE): Promise<TYPE> {
-): Promise<TYPE> {
     return new Promise((resolve, reject) => {
-    RESTRequest(request)
+        RESTRequest(request).then((value: ModelResponseHttp) => {
-      .then((value: ModelResponseHttp) => {
+            if (checker(value.data)) {
-        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) => {
-      .catch((reason: RestErrorResponse) => {
+            reject(reason);
+        });
+    });
+}
+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);
         });
     });
@@ -434,11 +368,9 @@ export function RESTRequestJson<TYPE>(
 
 export function RESTRequestVoid(request: RESTRequestType): Promise<void> {
     return new Promise((resolve, reject) => {
-    RESTRequest(request)
+        RESTRequest(request).then((value: ModelResponseHttp) => {
-      .then((value: ModelResponseHttp) => {
             resolve();
-      })
+        }).catch((reason: RestErrorResponse) => {
-      .catch((reason: RestErrorResponse) => {
             reject(reason);
         });
     });

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

@@ -1,128 +1,24 @@
 /**
- * Interface of the server (auto-generated code)
+ * API of the server (auto-generated code)
  */
 import {
   HTTPMimeType,
   HTTPRequestModel,
+  ModelResponseHttp,
   RESTCallbacks,
   RESTConfig,
   RESTRequestJson,
-	RESTRequestVoid,
+  RESTRequestJsonArray,
-} from "../rest-tools";
+  RESTRequestVoid
-
+} from "./rest-tools"
-import { z as zod } from "zod"
 import {
   Long,
   Season,
-	SeasonWrite,
   UUID,
-	ZodSeason,
   isSeason,
-} from "../model";
+} from "./model"
-
 export namespace SeasonResource {
 
-	/**
-	 * Get all season
-	 */
-	export function get({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-	}): Promise<Season> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/season/{id}",
-				requestType: HTTPRequestModel.GET,
-				contentType: HTTPMimeType.JSON,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			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
-	 */
-	export function patch({
-			restConfig,
-			params,
-			data,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-		data: SeasonWrite,
-	}): Promise<Season> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/season/{id}",
-				requestType: HTTPRequestModel.PATCH,
-				contentType: HTTPMimeType.JSON,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			params,
-			data,
-		}, isSeason);
-	};
-	/**
-	 * Create a new season
-	 */
-	export function post({
-			restConfig,
-			data,
-		}: {
-		restConfig: RESTConfig,
-		data: SeasonWrite,
-	}): Promise<Season> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/season/",
-				requestType: HTTPRequestModel.POST,
-				contentType: HTTPMimeType.JSON,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			data,
-		}, isSeason);
-	};
 	/**
 	 * Remove a specific season
 	 */
@@ -146,29 +42,92 @@ export namespace SeasonResource {
 		});
 	};
 	/**
-	 * Remove a specific cover of a season
+	 * Get all season
 	 */
-	export function removeCover({
+	export function get({
 			restConfig,
 			params,
 		}: {
 		restConfig: RESTConfig,
 		params: {
-			coverId: UUID,
 			id: Long,
 		},
 	}): Promise<Season> {
 		return RESTRequestJson({
 			restModel: {
-				endPoint: "/season/{id}/cover/{coverId}",
+				endPoint: "/season/{id}",
-				requestType: HTTPRequestModel.DELETE,
+				requestType: HTTPRequestModel.GET,
-				contentType: HTTPMimeType.TEXT_PLAIN,
+				contentType: HTTPMimeType.JSON,
 				accept: HTTPMimeType.JSON,
 			},
 			restConfig,
 			params,
 		}, isSeason);
 	};
+	/**
+	 * Modify a specific season
+	 */
+	export function patch({
+			restConfig,
+			params,
+			data,
+		}: {
+		restConfig: RESTConfig,
+		params: {
+			id: Long,
+		},
+		data: Season,
+	}): Promise<Season> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/season/{id}",
+				requestType: HTTPRequestModel.PATCH,
+				contentType: HTTPMimeType.JSON,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+			params,
+			data,
+		}, isSeason);
+	};
+	/**
+	 * Create a new season
+	 */
+	export function post({
+			restConfig,
+			data,
+		}: {
+		restConfig: RESTConfig,
+		data: Season,
+	}): Promise<Season> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/season",
+				requestType: HTTPRequestModel.POST,
+				contentType: HTTPMimeType.JSON,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+			data,
+		}, isSeason);
+	};
+	/**
+	 * Get a specific Season with his ID
+	 */
+	export function gets({
+			restConfig,
+		}: {
+		restConfig: RESTConfig,
+	}): Promise<Season[]> {
+		return RESTRequestJsonArray({
+			restModel: {
+				endPoint: "/season",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+		}, isSeason);
+	};
 	/**
 	 * Upload a new season cover season
 	 */
@@ -201,4 +160,28 @@ 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/series-resource.ts

@@ -1,128 +1,24 @@
 /**
- * Interface of the server (auto-generated code)
+ * API of the server (auto-generated code)
  */
 import {
   HTTPMimeType,
   HTTPRequestModel,
+  ModelResponseHttp,
   RESTCallbacks,
   RESTConfig,
   RESTRequestJson,
-	RESTRequestVoid,
+  RESTRequestJsonArray,
-} from "../rest-tools";
+  RESTRequestVoid
-
+} from "./rest-tools"
-import { z as zod } from "zod"
 import {
   Long,
   Series,
-	SeriesWrite,
   UUID,
-	ZodSeries,
   isSeries,
-} from "../model";
+} from "./model"
-
 export namespace SeriesResource {
 
-	/**
-	 * Get a specific Series with his ID
-	 */
-	export function get({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-	}): Promise<Series> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/series/{id}",
-				requestType: HTTPRequestModel.GET,
-				contentType: HTTPMimeType.JSON,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			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
-	 */
-	export function patch({
-			restConfig,
-			params,
-			data,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-		data: SeriesWrite,
-	}): Promise<Series> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/series/{id}",
-				requestType: HTTPRequestModel.PATCH,
-				contentType: HTTPMimeType.JSON,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			params,
-			data,
-		}, isSeries);
-	};
-	/**
-	 * Create a new Series
-	 */
-	export function post({
-			restConfig,
-			data,
-		}: {
-		restConfig: RESTConfig,
-		data: SeriesWrite,
-	}): Promise<Series> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/series/",
-				requestType: HTTPRequestModel.POST,
-				contentType: HTTPMimeType.JSON,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			data,
-		}, isSeries);
-	};
 	/**
 	 * Remove a specific Series
 	 */
@@ -146,29 +42,92 @@ export namespace SeriesResource {
 		});
 	};
 	/**
-	 * Remove a specific Series of a season
+	 * Get a specific Series with his ID
 	 */
-	export function removeCover({
+	export function get({
 			restConfig,
 			params,
 		}: {
 		restConfig: RESTConfig,
 		params: {
-			coverId: UUID,
 			id: Long,
 		},
 	}): Promise<Series> {
 		return RESTRequestJson({
 			restModel: {
-				endPoint: "/series/{id}/cover/{coverId}",
+				endPoint: "/series/{id}",
-				requestType: HTTPRequestModel.DELETE,
+				requestType: HTTPRequestModel.GET,
-				contentType: HTTPMimeType.TEXT_PLAIN,
+				contentType: HTTPMimeType.JSON,
 				accept: HTTPMimeType.JSON,
 			},
 			restConfig,
 			params,
 		}, isSeries);
 	};
+	/**
+	 * Modify a specific Series
+	 */
+	export function patch({
+			restConfig,
+			params,
+			data,
+		}: {
+		restConfig: RESTConfig,
+		params: {
+			id: Long,
+		},
+		data: Series,
+	}): Promise<Series> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/series/{id}",
+				requestType: HTTPRequestModel.PATCH,
+				contentType: HTTPMimeType.JSON,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+			params,
+			data,
+		}, isSeries);
+	};
+	/**
+	 * Create a new Series
+	 */
+	export function post({
+			restConfig,
+			data,
+		}: {
+		restConfig: RESTConfig,
+		data: Series,
+	}): Promise<Series> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/series",
+				requestType: HTTPRequestModel.POST,
+				contentType: HTTPMimeType.JSON,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+			data,
+		}, isSeries);
+	};
+	/**
+	 * Get all Series
+	 */
+	export function gets({
+			restConfig,
+		}: {
+		restConfig: RESTConfig,
+	}): Promise<Series[]> {
+		return RESTRequestJsonArray({
+			restModel: {
+				endPoint: "/series",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+		}, isSeries);
+	};
 	/**
 	 * Upload a new season cover Series
 	 */
@@ -201,4 +160,28 @@ 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/type-resource.ts

@@ -1,128 +1,24 @@
 /**
- * Interface of the server (auto-generated code)
+ * API of the server (auto-generated code)
  */
 import {
   HTTPMimeType,
   HTTPRequestModel,
+  ModelResponseHttp,
   RESTCallbacks,
   RESTConfig,
   RESTRequestJson,
-	RESTRequestVoid,
+  RESTRequestJsonArray,
-} from "../rest-tools";
+  RESTRequestVoid
-
+} from "./rest-tools"
-import { z as zod } from "zod"
 import {
   Long,
   Type,
-	TypeWrite,
   UUID,
-	ZodType,
   isType,
-} from "../model";
+} from "./model"
-
 export namespace TypeResource {
 
-	/**
-	 * Get a specific Type with his ID
-	 */
-	export function get({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-	}): Promise<Type> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/type/{id}",
-				requestType: HTTPRequestModel.GET,
-				contentType: HTTPMimeType.JSON,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			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
-	 */
-	export function patch({
-			restConfig,
-			params,
-			data,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-		data: TypeWrite,
-	}): Promise<Type> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/type/{id}",
-				requestType: HTTPRequestModel.PATCH,
-				contentType: HTTPMimeType.JSON,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			params,
-			data,
-		}, isType);
-	};
-	/**
-	 * Create a new Type
-	 */
-	export function post({
-			restConfig,
-			data,
-		}: {
-		restConfig: RESTConfig,
-		data: TypeWrite,
-	}): Promise<Type> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/type/",
-				requestType: HTTPRequestModel.POST,
-				contentType: HTTPMimeType.JSON,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			data,
-		}, isType);
-	};
 	/**
 	 * Remove a specific Type
 	 */
@@ -146,29 +42,92 @@ export namespace TypeResource {
 		});
 	};
 	/**
-	 * Remove a specific cover of a type
+	 * Get a specific Type with his ID
 	 */
-	export function removeCover({
+	export function get({
 			restConfig,
 			params,
 		}: {
 		restConfig: RESTConfig,
 		params: {
-			coverId: UUID,
 			id: Long,
 		},
 	}): Promise<Type> {
 		return RESTRequestJson({
 			restModel: {
-				endPoint: "/type/{id}/cover/{coverId}",
+				endPoint: "/type/{id}",
-				requestType: HTTPRequestModel.DELETE,
+				requestType: HTTPRequestModel.GET,
-				contentType: HTTPMimeType.TEXT_PLAIN,
+				contentType: HTTPMimeType.JSON,
 				accept: HTTPMimeType.JSON,
 			},
 			restConfig,
 			params,
 		}, isType);
 	};
+	/**
+	 * Modify a specific Type
+	 */
+	export function patch({
+			restConfig,
+			params,
+			data,
+		}: {
+		restConfig: RESTConfig,
+		params: {
+			id: Long,
+		},
+		data: Type,
+	}): Promise<Type> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/type/{id}",
+				requestType: HTTPRequestModel.PATCH,
+				contentType: HTTPMimeType.JSON,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+			params,
+			data,
+		}, isType);
+	};
+	/**
+	 * Create a new Type
+	 */
+	export function post({
+			restConfig,
+			data,
+		}: {
+		restConfig: RESTConfig,
+		data: Type,
+	}): Promise<Type> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/type",
+				requestType: HTTPRequestModel.POST,
+				contentType: HTTPMimeType.JSON,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+			data,
+		}, isType);
+	};
+	/**
+	 * Get all Type
+	 */
+	export function gets({
+			restConfig,
+		}: {
+		restConfig: RESTConfig,
+	}): Promise<Type[]> {
+		return RESTRequestJsonArray({
+			restModel: {
+				endPoint: "/type",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+		}, isType);
+	};
 	/**
 	 * Upload a new season cover Type
 	 */
@@ -201,4 +160,28 @@ 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/user-media-advancement-resource.ts

@@ -1,104 +1,24 @@
 /**
- * Interface of the server (auto-generated code)
+ * API of the server (auto-generated code)
  */
 import {
   HTTPMimeType,
   HTTPRequestModel,
+  ModelResponseHttp,
+  RESTCallbacks,
   RESTConfig,
   RESTRequestJson,
-	RESTRequestVoid,
+  RESTRequestJsonArray,
-} from "../rest-tools";
+  RESTRequestVoid
-
+} from "./rest-tools"
-import { z as zod } from "zod"
 import {
   Long,
-	MediaInformationsDeltaWrite,
+  MediaInformationsDelta,
   UserMediaAdvancement,
-	ZodUserMediaAdvancement,
   isUserMediaAdvancement,
-} from "../model";
+} from "./model"
-
 export namespace UserMediaAdvancementResource {
 
-	/**
-	 * Get a specific user advancement with his ID
-	 */
-	export function get({
-			restConfig,
-			params,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-	}): Promise<UserMediaAdvancement> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/advancement/{id}",
-				requestType: HTTPRequestModel.GET,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			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
-	 */
-	export function patch({
-			restConfig,
-			params,
-			data,
-		}: {
-		restConfig: RESTConfig,
-		params: {
-			id: Long,
-		},
-		data: MediaInformationsDeltaWrite,
-	}): Promise<UserMediaAdvancement> {
-		return RESTRequestJson({
-			restModel: {
-				endPoint: "/advancement/{id}",
-				requestType: HTTPRequestModel.PATCH,
-				contentType: HTTPMimeType.JSON,
-				accept: HTTPMimeType.JSON,
-			},
-			restConfig,
-			params,
-			data,
-		}, isUserMediaAdvancement);
-	};
 	/**
 	 * Remove a specific user advancement
 	 */
@@ -121,4 +41,69 @@ export namespace UserMediaAdvancementResource {
 			params,
 		});
 	};
+	/**
+	 * Get a specific user advancement with his ID
+	 */
+	export function get({
+			restConfig,
+			params,
+		}: {
+		restConfig: RESTConfig,
+		params: {
+			id: Long,
+		},
+	}): Promise<UserMediaAdvancement> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/advancement/{id}",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+			params,
+		}, isUserMediaAdvancement);
+	};
+	/**
+	 * Modify a user advancement
+	 */
+	export function patch({
+			restConfig,
+			params,
+			data,
+		}: {
+		restConfig: RESTConfig,
+		params: {
+			id: Long,
+		},
+		data: MediaInformationsDelta,
+	}): Promise<UserMediaAdvancement> {
+		return RESTRequestJson({
+			restModel: {
+				endPoint: "/advancement/{id}",
+				requestType: HTTPRequestModel.PATCH,
+				contentType: HTTPMimeType.JSON,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+			params,
+			data,
+		}, isUserMediaAdvancement);
+	};
+	/**
+	 * Get all user advancement
+	 */
+	export function gets({
+			restConfig,
+		}: {
+		restConfig: RESTConfig,
+	}): Promise<UserMediaAdvancement[]> {
+		return RESTRequestJsonArray({
+			restModel: {
+				endPoint: "/advancement",
+				requestType: HTTPRequestModel.GET,
+				accept: HTTPMimeType.JSON,
+			},
+			restConfig,
+		}, isUserMediaAdvancement);
+	};
 }

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

@@ -1,23 +1,23 @@
 /**
- * Interface of the server (auto-generated code)
+ * API of the server (auto-generated code)
  */
 import {
   HTTPMimeType,
   HTTPRequestModel,
+  ModelResponseHttp,
+  RESTCallbacks,
   RESTConfig,
   RESTRequestJson,
-} from "../rest-tools";
+  RESTRequestJsonArray,
-
+  RESTRequestVoid
-import { z as zod } from "zod"
+} from "./rest-tools"
 import {
   Long,
   UserKarideo,
   UserOut,
-	ZodUserKarideo,
   isUserKarideo,
   isUserOut,
-} from "../model";
+} from "./model"
-
 export namespace UserResource {
 
 	/**
@@ -42,6 +42,23 @@ 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
 	 */
@@ -59,35 +76,4 @@ 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/environments/environment.ts

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

version.txt

@@ -1 +1 @@
-0.3.0
+0.3.0-dev