sigo-entities 1.2.372 → 1.2.374
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.mts +7 -8
- package/dist/index.d.ts +7 -8
- package/dist/index.js +47 -45
- package/dist/index.mjs +61 -59
- package/package.json +1 -1
package/dist/index.d.mts
CHANGED
|
@@ -9399,13 +9399,12 @@ declare class LoginDto {
|
|
|
9399
9399
|
}
|
|
9400
9400
|
|
|
9401
9401
|
declare class PayloadTokenDto {
|
|
9402
|
-
user: string;
|
|
9403
|
-
names: string;
|
|
9404
9402
|
email: string;
|
|
9405
|
-
|
|
9406
|
-
|
|
9403
|
+
paternalLastName: string;
|
|
9404
|
+
maternalLastName: string;
|
|
9405
|
+
firstNames: string;
|
|
9407
9406
|
identification: string;
|
|
9408
|
-
|
|
9407
|
+
company: CodeNameDto;
|
|
9409
9408
|
country: CodeNameMinLengthDto;
|
|
9410
9409
|
delegation: CodeNameMinLengthDto;
|
|
9411
9410
|
}
|
|
@@ -9433,11 +9432,11 @@ declare class UserEntity extends BaseEntity {
|
|
|
9433
9432
|
firstNames: string;
|
|
9434
9433
|
identification: string;
|
|
9435
9434
|
company: CodeNameDto;
|
|
9436
|
-
country:
|
|
9437
|
-
delegation:
|
|
9435
|
+
country: CodeNameMinLengthDto;
|
|
9436
|
+
delegation: CodeNameMinLengthDto;
|
|
9438
9437
|
}
|
|
9439
9438
|
|
|
9440
|
-
declare function validateCustom<T extends object>(plain:
|
|
9439
|
+
declare function validateCustom<T extends object>(plain: unknown, cls: ClassConstructor<T>, UnprocessableEntityException: ClassConstructor<Error>, groups?: string[]): Promise<T>;
|
|
9441
9440
|
|
|
9442
9441
|
declare function validateRequestBody(dtoClass: any, BadRequestException: any, req: Request, _res: Response, next: NextFunction): Promise<void>;
|
|
9443
9442
|
|
package/dist/index.d.ts
CHANGED
|
@@ -9399,13 +9399,12 @@ declare class LoginDto {
|
|
|
9399
9399
|
}
|
|
9400
9400
|
|
|
9401
9401
|
declare class PayloadTokenDto {
|
|
9402
|
-
user: string;
|
|
9403
|
-
names: string;
|
|
9404
9402
|
email: string;
|
|
9405
|
-
|
|
9406
|
-
|
|
9403
|
+
paternalLastName: string;
|
|
9404
|
+
maternalLastName: string;
|
|
9405
|
+
firstNames: string;
|
|
9407
9406
|
identification: string;
|
|
9408
|
-
|
|
9407
|
+
company: CodeNameDto;
|
|
9409
9408
|
country: CodeNameMinLengthDto;
|
|
9410
9409
|
delegation: CodeNameMinLengthDto;
|
|
9411
9410
|
}
|
|
@@ -9433,11 +9432,11 @@ declare class UserEntity extends BaseEntity {
|
|
|
9433
9432
|
firstNames: string;
|
|
9434
9433
|
identification: string;
|
|
9435
9434
|
company: CodeNameDto;
|
|
9436
|
-
country:
|
|
9437
|
-
delegation:
|
|
9435
|
+
country: CodeNameMinLengthDto;
|
|
9436
|
+
delegation: CodeNameMinLengthDto;
|
|
9438
9437
|
}
|
|
9439
9438
|
|
|
9440
|
-
declare function validateCustom<T extends object>(plain:
|
|
9439
|
+
declare function validateCustom<T extends object>(plain: unknown, cls: ClassConstructor<T>, UnprocessableEntityException: ClassConstructor<Error>, groups?: string[]): Promise<T>;
|
|
9441
9440
|
|
|
9442
9441
|
declare function validateRequestBody(dtoClass: any, BadRequestException: any, req: Request, _res: Response, next: NextFunction): Promise<void>;
|
|
9443
9442
|
|
package/dist/index.js
CHANGED
|
@@ -49813,11 +49813,13 @@ var CodeNameDto = class {
|
|
|
49813
49813
|
name;
|
|
49814
49814
|
};
|
|
49815
49815
|
__decorateClass([
|
|
49816
|
+
(0, import_class_transformer778.Transform)(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
49816
49817
|
(0, import_class_validator755.IsDefined)({ message: 'La propiedad "codigo" es obligatoria.' }),
|
|
49817
49818
|
(0, import_class_validator755.IsString)({ message: 'La propiedad "codigo" debe ser una cadena de texto.' }),
|
|
49818
49819
|
(0, import_class_transformer778.Expose)()
|
|
49819
49820
|
], CodeNameDto.prototype, "code", 2);
|
|
49820
49821
|
__decorateClass([
|
|
49822
|
+
(0, import_class_transformer778.Transform)(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
49821
49823
|
(0, import_class_validator755.IsDefined)({ message: 'La propiedad "nombre" es obligatoria.' }),
|
|
49822
49824
|
(0, import_class_validator755.IsString)({ message: 'La propiedad "nombre" debe ser una cadena de texto.' }),
|
|
49823
49825
|
(0, import_class_transformer778.Expose)()
|
|
@@ -49839,81 +49841,75 @@ var LoginDto = class {
|
|
|
49839
49841
|
password = "";
|
|
49840
49842
|
};
|
|
49841
49843
|
__decorateClass([
|
|
49842
|
-
(0,
|
|
49843
|
-
(0, import_class_validator756.
|
|
49844
|
-
(0,
|
|
49844
|
+
(0, import_class_transformer779.Transform)(({ value }) => typeof value === "string" ? value.trim().toLowerCase() : value, { groups: ["login", "forgot-password"] }),
|
|
49845
|
+
(0, import_class_validator756.IsDefined)({ message: "Debe proporcionar un email", groups: ["login", "forgot-password"] }),
|
|
49846
|
+
(0, import_class_validator756.IsEmail)({}, { message: "El email es inv\xE1lido", groups: ["login", "forgot-password"] }),
|
|
49847
|
+
(0, import_class_transformer779.Expose)({ groups: ["login", "forgot-password"] })
|
|
49845
49848
|
], LoginDto.prototype, "email", 2);
|
|
49846
49849
|
__decorateClass([
|
|
49847
|
-
(0,
|
|
49848
|
-
(0, import_class_validator756.
|
|
49849
|
-
(0,
|
|
49850
|
+
(0, import_class_transformer779.Transform)(({ value }) => typeof value === "string" ? value.trim() : value, { groups: ["login"] }),
|
|
49851
|
+
(0, import_class_validator756.IsDefined)({ message: "Debe proporcionar una contrase\xF1a", groups: ["login"] }),
|
|
49852
|
+
(0, import_class_validator756.Length)(8, 20, { message: "La contrase\xF1a debe tener entre 8 y 20 caracteres", groups: ["login"] }),
|
|
49853
|
+
(0, import_class_transformer779.Expose)({ groups: ["login"] })
|
|
49850
49854
|
], LoginDto.prototype, "password", 2);
|
|
49851
49855
|
|
|
49852
49856
|
// src/v2/dtos/PayloadToken.ts
|
|
49853
49857
|
var import_class_validator757 = require("class-validator");
|
|
49854
49858
|
var import_class_transformer780 = require("class-transformer");
|
|
49855
49859
|
var PayloadTokenDto = class {
|
|
49856
|
-
user;
|
|
49857
|
-
names;
|
|
49858
49860
|
email;
|
|
49859
|
-
|
|
49860
|
-
|
|
49861
|
+
paternalLastName;
|
|
49862
|
+
maternalLastName;
|
|
49863
|
+
firstNames;
|
|
49861
49864
|
identification;
|
|
49862
|
-
|
|
49865
|
+
company;
|
|
49863
49866
|
country;
|
|
49864
49867
|
delegation;
|
|
49865
49868
|
};
|
|
49866
49869
|
__decorateClass([
|
|
49867
|
-
(0, import_class_validator757.IsDefined)({ message: "
|
|
49868
|
-
(0, import_class_validator757.
|
|
49869
|
-
(0, import_class_validator757.IsNotEmpty)({ message: "es requerido" }),
|
|
49870
|
-
(0, import_class_transformer780.Expose)()
|
|
49871
|
-
], PayloadTokenDto.prototype, "user", 2);
|
|
49872
|
-
__decorateClass([
|
|
49873
|
-
(0, import_class_validator757.IsDefined)({ message: "debe proporcionar los nombres" }),
|
|
49874
|
-
(0, import_class_validator757.IsString)({ message: "debe ser una cadena" }),
|
|
49875
|
-
(0, import_class_validator757.IsNotEmpty)({ message: "es requerido" }),
|
|
49870
|
+
(0, import_class_validator757.IsDefined)({ message: "El correo es requerido" }),
|
|
49871
|
+
(0, import_class_validator757.IsEmail)({}, { message: "El correo es invalido" }),
|
|
49876
49872
|
(0, import_class_transformer780.Expose)()
|
|
49877
|
-
], PayloadTokenDto.prototype, "
|
|
49873
|
+
], PayloadTokenDto.prototype, "email", 2);
|
|
49878
49874
|
__decorateClass([
|
|
49879
|
-
(0, import_class_validator757.IsDefined)({ message: "
|
|
49880
|
-
(0, import_class_validator757.
|
|
49881
|
-
(0, import_class_validator757.IsNotEmpty)({ message: "es requerido" }),
|
|
49875
|
+
(0, import_class_validator757.IsDefined)({ message: "El apellido paterno es requerido" }),
|
|
49876
|
+
(0, import_class_validator757.IsString)({ message: "El apellido paterno debe ser una cadena de texto" }),
|
|
49882
49877
|
(0, import_class_transformer780.Expose)()
|
|
49883
|
-
], PayloadTokenDto.prototype, "
|
|
49878
|
+
], PayloadTokenDto.prototype, "paternalLastName", 2);
|
|
49884
49879
|
__decorateClass([
|
|
49885
|
-
(0, import_class_validator757.IsDefined)({ message: "
|
|
49886
|
-
(0, import_class_validator757.IsString)({ message: "debe ser una cadena" }),
|
|
49887
|
-
(0, import_class_validator757.IsNotEmpty)({ message: "es requerido" }),
|
|
49880
|
+
(0, import_class_validator757.IsDefined)({ message: "El apellido materno es requerido" }),
|
|
49881
|
+
(0, import_class_validator757.IsString)({ message: "El apellido materno debe ser una cadena de texto" }),
|
|
49888
49882
|
(0, import_class_transformer780.Expose)()
|
|
49889
|
-
], PayloadTokenDto.prototype, "
|
|
49883
|
+
], PayloadTokenDto.prototype, "maternalLastName", 2);
|
|
49890
49884
|
__decorateClass([
|
|
49891
|
-
(0, import_class_validator757.IsDefined)({ message: "
|
|
49892
|
-
(0, import_class_validator757.IsString)({ message: "debe ser una cadena" }),
|
|
49893
|
-
(0, import_class_validator757.IsNotEmpty)({ message: "es requerido" }),
|
|
49885
|
+
(0, import_class_validator757.IsDefined)({ message: "El nombre es requerido" }),
|
|
49886
|
+
(0, import_class_validator757.IsString)({ message: "El nombre debe ser una cadena de texto" }),
|
|
49894
49887
|
(0, import_class_transformer780.Expose)()
|
|
49895
|
-
], PayloadTokenDto.prototype, "
|
|
49888
|
+
], PayloadTokenDto.prototype, "firstNames", 2);
|
|
49896
49889
|
__decorateClass([
|
|
49897
|
-
(0, import_class_validator757.IsDefined)({ message: "
|
|
49898
|
-
(0, import_class_validator757.IsString)({ message: "debe ser una cadena" }),
|
|
49899
|
-
(0, import_class_validator757.IsNotEmpty)({ message: "es requerido" }),
|
|
49890
|
+
(0, import_class_validator757.IsDefined)({ message: "El n\xFAmero de identificaci\xF3n es requerido" }),
|
|
49891
|
+
(0, import_class_validator757.IsString)({ message: "El n\xFAmero de identificaci\xF3n debe ser una cadena de texto" }),
|
|
49900
49892
|
(0, import_class_transformer780.Expose)()
|
|
49901
49893
|
], PayloadTokenDto.prototype, "identification", 2);
|
|
49902
49894
|
__decorateClass([
|
|
49903
|
-
(0, import_class_validator757.IsDefined)({ message: "
|
|
49904
|
-
(0,
|
|
49895
|
+
(0, import_class_validator757.IsDefined)({ message: "La empresa es requerida" }),
|
|
49896
|
+
(0, import_class_transformer780.Type)(() => CodeNameDto),
|
|
49897
|
+
(0, import_class_validator757.ValidateNested)(),
|
|
49898
|
+
(0, import_class_validator757.IsObject)(),
|
|
49905
49899
|
(0, import_class_transformer780.Expose)()
|
|
49906
|
-
], PayloadTokenDto.prototype, "
|
|
49900
|
+
], PayloadTokenDto.prototype, "company", 2);
|
|
49907
49901
|
__decorateClass([
|
|
49908
49902
|
(0, import_class_validator757.IsDefined)({ message: "debe proporcionar el pa\xEDs" }),
|
|
49909
49903
|
(0, import_class_validator757.ValidateNested)(),
|
|
49910
49904
|
(0, import_class_transformer780.Type)(() => CodeNameMinLengthDto),
|
|
49905
|
+
(0, import_class_validator757.IsObject)(),
|
|
49911
49906
|
(0, import_class_transformer780.Expose)()
|
|
49912
49907
|
], PayloadTokenDto.prototype, "country", 2);
|
|
49913
49908
|
__decorateClass([
|
|
49914
49909
|
(0, import_class_validator757.IsDefined)({ message: "debe proporcionar la delegaci\xF3n" }),
|
|
49915
49910
|
(0, import_class_validator757.ValidateNested)(),
|
|
49916
49911
|
(0, import_class_transformer780.Type)(() => CodeNameMinLengthDto),
|
|
49912
|
+
(0, import_class_validator757.IsObject)(),
|
|
49917
49913
|
(0, import_class_transformer780.Expose)()
|
|
49918
49914
|
], PayloadTokenDto.prototype, "delegation", 2);
|
|
49919
49915
|
|
|
@@ -49990,35 +49986,41 @@ var UserEntity = class extends BaseEntity {
|
|
|
49990
49986
|
firstNames;
|
|
49991
49987
|
identification;
|
|
49992
49988
|
company;
|
|
49993
|
-
country
|
|
49994
|
-
delegation
|
|
49989
|
+
country;
|
|
49990
|
+
delegation;
|
|
49995
49991
|
};
|
|
49996
49992
|
__decorateClass([
|
|
49997
49993
|
(0, import_class_validator761.IsDefined)({ message: "El correo es requerido" }),
|
|
49998
49994
|
(0, import_class_validator761.IsEmail)({}, { message: "El correo es invalido" }),
|
|
49995
|
+
(0, import_class_transformer784.Transform)(({ value }) => typeof value === "string" ? value.trim().toLowerCase() : value),
|
|
49999
49996
|
(0, import_class_transformer784.Expose)()
|
|
50000
49997
|
], UserEntity.prototype, "email", 2);
|
|
50001
49998
|
__decorateClass([
|
|
49999
|
+
(0, import_class_transformer784.Transform)(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
50002
50000
|
(0, import_class_validator761.IsDefined)({ message: "La contrase\xF1a es requerida" }),
|
|
50003
50001
|
(0, import_class_validator761.IsString)({ message: "La contrase\xF1a debe ser una cadena de texto" }),
|
|
50004
50002
|
(0, import_class_transformer784.Expose)()
|
|
50005
50003
|
], UserEntity.prototype, "password", 2);
|
|
50006
50004
|
__decorateClass([
|
|
50005
|
+
(0, import_class_transformer784.Transform)(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
50007
50006
|
(0, import_class_validator761.IsDefined)({ message: "El apellido paterno es requerido" }),
|
|
50008
50007
|
(0, import_class_validator761.IsString)({ message: "El apellido paterno debe ser una cadena de texto" }),
|
|
50009
50008
|
(0, import_class_transformer784.Expose)()
|
|
50010
50009
|
], UserEntity.prototype, "paternalLastName", 2);
|
|
50011
50010
|
__decorateClass([
|
|
50011
|
+
(0, import_class_transformer784.Transform)(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
50012
50012
|
(0, import_class_validator761.IsDefined)({ message: "El apellido materno es requerido" }),
|
|
50013
50013
|
(0, import_class_validator761.IsString)({ message: "El apellido materno debe ser una cadena de texto" }),
|
|
50014
50014
|
(0, import_class_transformer784.Expose)()
|
|
50015
50015
|
], UserEntity.prototype, "maternalLastName", 2);
|
|
50016
50016
|
__decorateClass([
|
|
50017
|
+
(0, import_class_transformer784.Transform)(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
50017
50018
|
(0, import_class_validator761.IsDefined)({ message: "El nombre es requerido" }),
|
|
50018
50019
|
(0, import_class_validator761.IsString)({ message: "El nombre debe ser una cadena de texto" }),
|
|
50019
50020
|
(0, import_class_transformer784.Expose)()
|
|
50020
50021
|
], UserEntity.prototype, "firstNames", 2);
|
|
50021
50022
|
__decorateClass([
|
|
50023
|
+
(0, import_class_transformer784.Transform)(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
50022
50024
|
(0, import_class_validator761.IsDefined)({ message: "El n\xFAmero de identificaci\xF3n es requerido" }),
|
|
50023
50025
|
(0, import_class_validator761.IsString)({ message: "El n\xFAmero de identificaci\xF3n debe ser una cadena de texto" }),
|
|
50024
50026
|
(0, import_class_transformer784.Expose)()
|
|
@@ -50033,14 +50035,14 @@ __decorateClass([
|
|
|
50033
50035
|
__decorateClass([
|
|
50034
50036
|
(0, import_class_validator761.IsDefined)({ message: "debe proporcionar el pa\xEDs" }),
|
|
50035
50037
|
(0, import_class_validator761.ValidateNested)(),
|
|
50036
|
-
(0, import_class_transformer784.Type)(() =>
|
|
50038
|
+
(0, import_class_transformer784.Type)(() => CodeNameMinLengthDto),
|
|
50037
50039
|
(0, import_class_validator761.IsObject)(),
|
|
50038
50040
|
(0, import_class_transformer784.Expose)()
|
|
50039
50041
|
], UserEntity.prototype, "country", 2);
|
|
50040
50042
|
__decorateClass([
|
|
50041
50043
|
(0, import_class_validator761.IsDefined)({ message: "debe proporcionar la delegaci\xF3n" }),
|
|
50042
50044
|
(0, import_class_validator761.ValidateNested)(),
|
|
50043
|
-
(0, import_class_transformer784.Type)(() =>
|
|
50045
|
+
(0, import_class_transformer784.Type)(() => CodeNameMinLengthDto),
|
|
50044
50046
|
(0, import_class_validator761.IsObject)(),
|
|
50045
50047
|
(0, import_class_transformer784.Expose)()
|
|
50046
50048
|
], UserEntity.prototype, "delegation", 2);
|
|
@@ -50063,9 +50065,9 @@ function getFirstError(errors, parentPath = "") {
|
|
|
50063
50065
|
}
|
|
50064
50066
|
|
|
50065
50067
|
// src/v2/utils/validateCustom.ts
|
|
50066
|
-
async function validateCustom(plain, cls, UnprocessableEntityException) {
|
|
50068
|
+
async function validateCustom(plain, cls, UnprocessableEntityException, groups) {
|
|
50067
50069
|
const instance = (0, import_class_transformer785.plainToInstance)(cls, plain, { excludeExtraneousValues: true });
|
|
50068
|
-
const errors = await (0, import_class_validator762.validate)(instance);
|
|
50070
|
+
const errors = await (0, import_class_validator762.validate)(instance, { groups });
|
|
50069
50071
|
if (errors.length) {
|
|
50070
50072
|
const msg = getFirstError(errors);
|
|
50071
50073
|
throw new UnprocessableEntityException(msg);
|
package/dist/index.mjs
CHANGED
|
@@ -49333,18 +49333,20 @@ __decorateClass([
|
|
|
49333
49333
|
], BantelENTITY.prototype, "estado_interno", 2);
|
|
49334
49334
|
|
|
49335
49335
|
// src/v2/dtos/CodeName.ts
|
|
49336
|
-
import { Expose as Expose751 } from "class-transformer";
|
|
49336
|
+
import { Expose as Expose751, Transform as Transform110 } from "class-transformer";
|
|
49337
49337
|
import { IsDefined as IsDefined253, IsString as IsString621, MinLength as MinLength56 } from "class-validator";
|
|
49338
49338
|
var CodeNameDto = class {
|
|
49339
49339
|
code;
|
|
49340
49340
|
name;
|
|
49341
49341
|
};
|
|
49342
49342
|
__decorateClass([
|
|
49343
|
+
Transform110(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
49343
49344
|
IsDefined253({ message: 'La propiedad "codigo" es obligatoria.' }),
|
|
49344
49345
|
IsString621({ message: 'La propiedad "codigo" debe ser una cadena de texto.' }),
|
|
49345
49346
|
Expose751()
|
|
49346
49347
|
], CodeNameDto.prototype, "code", 2);
|
|
49347
49348
|
__decorateClass([
|
|
49349
|
+
Transform110(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
49348
49350
|
IsDefined253({ message: 'La propiedad "nombre" es obligatoria.' }),
|
|
49349
49351
|
IsString621({ message: 'La propiedad "nombre" debe ser una cadena de texto.' }),
|
|
49350
49352
|
Expose751()
|
|
@@ -49359,100 +49361,94 @@ __decorateClass([
|
|
|
49359
49361
|
], CodeNameMinLengthDto.prototype, "name", 2);
|
|
49360
49362
|
|
|
49361
49363
|
// src/v2/dtos/Login.ts
|
|
49362
|
-
import { Expose as Expose752 } from "class-transformer";
|
|
49364
|
+
import { Expose as Expose752, Transform as Transform111 } from "class-transformer";
|
|
49363
49365
|
import { IsDefined as IsDefined254, IsEmail as IsEmail4, Length as Length339 } from "class-validator";
|
|
49364
49366
|
var LoginDto = class {
|
|
49365
49367
|
email = "";
|
|
49366
49368
|
password = "";
|
|
49367
49369
|
};
|
|
49368
49370
|
__decorateClass([
|
|
49369
|
-
|
|
49370
|
-
|
|
49371
|
-
|
|
49371
|
+
Transform111(({ value }) => typeof value === "string" ? value.trim().toLowerCase() : value, { groups: ["login", "forgot-password"] }),
|
|
49372
|
+
IsDefined254({ message: "Debe proporcionar un email", groups: ["login", "forgot-password"] }),
|
|
49373
|
+
IsEmail4({}, { message: "El email es inv\xE1lido", groups: ["login", "forgot-password"] }),
|
|
49374
|
+
Expose752({ groups: ["login", "forgot-password"] })
|
|
49372
49375
|
], LoginDto.prototype, "email", 2);
|
|
49373
49376
|
__decorateClass([
|
|
49374
|
-
|
|
49375
|
-
|
|
49376
|
-
|
|
49377
|
+
Transform111(({ value }) => typeof value === "string" ? value.trim() : value, { groups: ["login"] }),
|
|
49378
|
+
IsDefined254({ message: "Debe proporcionar una contrase\xF1a", groups: ["login"] }),
|
|
49379
|
+
Length339(8, 20, { message: "La contrase\xF1a debe tener entre 8 y 20 caracteres", groups: ["login"] }),
|
|
49380
|
+
Expose752({ groups: ["login"] })
|
|
49377
49381
|
], LoginDto.prototype, "password", 2);
|
|
49378
49382
|
|
|
49379
49383
|
// src/v2/dtos/PayloadToken.ts
|
|
49380
|
-
import {
|
|
49384
|
+
import { IsDefined as IsDefined255, IsEmail as IsEmail5, IsObject as IsObject14, IsString as IsString622, ValidateNested as ValidateNested413 } from "class-validator";
|
|
49381
49385
|
import { Expose as Expose753, Type as Type473 } from "class-transformer";
|
|
49382
49386
|
var PayloadTokenDto = class {
|
|
49383
|
-
user;
|
|
49384
|
-
names;
|
|
49385
49387
|
email;
|
|
49386
|
-
|
|
49387
|
-
|
|
49388
|
+
paternalLastName;
|
|
49389
|
+
maternalLastName;
|
|
49390
|
+
firstNames;
|
|
49388
49391
|
identification;
|
|
49389
|
-
|
|
49392
|
+
company;
|
|
49390
49393
|
country;
|
|
49391
49394
|
delegation;
|
|
49392
49395
|
};
|
|
49393
49396
|
__decorateClass([
|
|
49394
|
-
IsDefined255({ message: "
|
|
49395
|
-
|
|
49396
|
-
IsNotEmpty460({ message: "es requerido" }),
|
|
49397
|
-
Expose753()
|
|
49398
|
-
], PayloadTokenDto.prototype, "user", 2);
|
|
49399
|
-
__decorateClass([
|
|
49400
|
-
IsDefined255({ message: "debe proporcionar los nombres" }),
|
|
49401
|
-
IsString622({ message: "debe ser una cadena" }),
|
|
49402
|
-
IsNotEmpty460({ message: "es requerido" }),
|
|
49397
|
+
IsDefined255({ message: "El correo es requerido" }),
|
|
49398
|
+
IsEmail5({}, { message: "El correo es invalido" }),
|
|
49403
49399
|
Expose753()
|
|
49404
|
-
], PayloadTokenDto.prototype, "
|
|
49400
|
+
], PayloadTokenDto.prototype, "email", 2);
|
|
49405
49401
|
__decorateClass([
|
|
49406
|
-
IsDefined255({ message: "
|
|
49407
|
-
|
|
49408
|
-
IsNotEmpty460({ message: "es requerido" }),
|
|
49402
|
+
IsDefined255({ message: "El apellido paterno es requerido" }),
|
|
49403
|
+
IsString622({ message: "El apellido paterno debe ser una cadena de texto" }),
|
|
49409
49404
|
Expose753()
|
|
49410
|
-
], PayloadTokenDto.prototype, "
|
|
49405
|
+
], PayloadTokenDto.prototype, "paternalLastName", 2);
|
|
49411
49406
|
__decorateClass([
|
|
49412
|
-
IsDefined255({ message: "
|
|
49413
|
-
IsString622({ message: "debe ser una cadena" }),
|
|
49414
|
-
IsNotEmpty460({ message: "es requerido" }),
|
|
49407
|
+
IsDefined255({ message: "El apellido materno es requerido" }),
|
|
49408
|
+
IsString622({ message: "El apellido materno debe ser una cadena de texto" }),
|
|
49415
49409
|
Expose753()
|
|
49416
|
-
], PayloadTokenDto.prototype, "
|
|
49410
|
+
], PayloadTokenDto.prototype, "maternalLastName", 2);
|
|
49417
49411
|
__decorateClass([
|
|
49418
|
-
IsDefined255({ message: "
|
|
49419
|
-
IsString622({ message: "debe ser una cadena" }),
|
|
49420
|
-
IsNotEmpty460({ message: "es requerido" }),
|
|
49412
|
+
IsDefined255({ message: "El nombre es requerido" }),
|
|
49413
|
+
IsString622({ message: "El nombre debe ser una cadena de texto" }),
|
|
49421
49414
|
Expose753()
|
|
49422
|
-
], PayloadTokenDto.prototype, "
|
|
49415
|
+
], PayloadTokenDto.prototype, "firstNames", 2);
|
|
49423
49416
|
__decorateClass([
|
|
49424
|
-
IsDefined255({ message: "
|
|
49425
|
-
IsString622({ message: "debe ser una cadena" }),
|
|
49426
|
-
IsNotEmpty460({ message: "es requerido" }),
|
|
49417
|
+
IsDefined255({ message: "El n\xFAmero de identificaci\xF3n es requerido" }),
|
|
49418
|
+
IsString622({ message: "El n\xFAmero de identificaci\xF3n debe ser una cadena de texto" }),
|
|
49427
49419
|
Expose753()
|
|
49428
49420
|
], PayloadTokenDto.prototype, "identification", 2);
|
|
49429
49421
|
__decorateClass([
|
|
49430
|
-
IsDefined255({ message: "
|
|
49431
|
-
|
|
49422
|
+
IsDefined255({ message: "La empresa es requerida" }),
|
|
49423
|
+
Type473(() => CodeNameDto),
|
|
49424
|
+
ValidateNested413(),
|
|
49425
|
+
IsObject14(),
|
|
49432
49426
|
Expose753()
|
|
49433
|
-
], PayloadTokenDto.prototype, "
|
|
49427
|
+
], PayloadTokenDto.prototype, "company", 2);
|
|
49434
49428
|
__decorateClass([
|
|
49435
49429
|
IsDefined255({ message: "debe proporcionar el pa\xEDs" }),
|
|
49436
49430
|
ValidateNested413(),
|
|
49437
49431
|
Type473(() => CodeNameMinLengthDto),
|
|
49432
|
+
IsObject14(),
|
|
49438
49433
|
Expose753()
|
|
49439
49434
|
], PayloadTokenDto.prototype, "country", 2);
|
|
49440
49435
|
__decorateClass([
|
|
49441
49436
|
IsDefined255({ message: "debe proporcionar la delegaci\xF3n" }),
|
|
49442
49437
|
ValidateNested413(),
|
|
49443
49438
|
Type473(() => CodeNameMinLengthDto),
|
|
49439
|
+
IsObject14(),
|
|
49444
49440
|
Expose753()
|
|
49445
49441
|
], PayloadTokenDto.prototype, "delegation", 2);
|
|
49446
49442
|
|
|
49447
49443
|
// src/v2/dtos/ResponseSignIn.ts
|
|
49448
|
-
import { IsDefined as IsDefined256, IsObject as
|
|
49444
|
+
import { IsDefined as IsDefined256, IsObject as IsObject15, ValidateNested as ValidateNested414 } from "class-validator";
|
|
49449
49445
|
import { Expose as Expose754, Type as Type474 } from "class-transformer";
|
|
49450
49446
|
var ResponseSignInDto = class {
|
|
49451
49447
|
user;
|
|
49452
49448
|
};
|
|
49453
49449
|
__decorateClass([
|
|
49454
49450
|
IsDefined256({ message: "El usuario es requerido" }),
|
|
49455
|
-
|
|
49451
|
+
IsObject15({ message: "El usuario debe ser un objeto" }),
|
|
49456
49452
|
ValidateNested414(),
|
|
49457
49453
|
Type474(() => PayloadTokenDto),
|
|
49458
49454
|
Expose754()
|
|
@@ -49460,11 +49456,11 @@ __decorateClass([
|
|
|
49460
49456
|
|
|
49461
49457
|
// src/v2/entities/Delegacion.ts
|
|
49462
49458
|
import { Expose as Expose756, Type as Type475 } from "class-transformer";
|
|
49463
|
-
import { IsDefined as IsDefined258, IsObject as
|
|
49459
|
+
import { IsDefined as IsDefined258, IsObject as IsObject16, IsString as IsString623, MinLength as MinLength57, ValidateNested as ValidateNested415 } from "class-validator";
|
|
49464
49460
|
|
|
49465
49461
|
// src/v2/entities/Base.ts
|
|
49466
49462
|
import { Expose as Expose755 } from "class-transformer";
|
|
49467
|
-
import { IsBoolean as
|
|
49463
|
+
import { IsBoolean as IsBoolean68, IsDefined as IsDefined257, IsUUID as IsUUID18 } from "class-validator";
|
|
49468
49464
|
var BaseEntity = class {
|
|
49469
49465
|
_id;
|
|
49470
49466
|
active;
|
|
@@ -49476,7 +49472,7 @@ __decorateClass([
|
|
|
49476
49472
|
], BaseEntity.prototype, "_id", 2);
|
|
49477
49473
|
__decorateClass([
|
|
49478
49474
|
IsDefined257({ message: 'La propiedad "activo" es obligatoria.' }),
|
|
49479
|
-
|
|
49475
|
+
IsBoolean68({ message: 'La propiedad "activo" debe ser un valor booleano.' }),
|
|
49480
49476
|
Expose755()
|
|
49481
49477
|
], BaseEntity.prototype, "active", 2);
|
|
49482
49478
|
|
|
@@ -49489,7 +49485,7 @@ var DelegacionEntity = class extends BaseEntity {
|
|
|
49489
49485
|
__decorateClass([
|
|
49490
49486
|
IsDefined258({ message: 'La propiedad "pais" es obligatoria.' }),
|
|
49491
49487
|
Type475(() => CodeNameMinLengthDto),
|
|
49492
|
-
|
|
49488
|
+
IsObject16({ message: 'La propiedad "pais" debe ser un objeto v\xE1lido.' }),
|
|
49493
49489
|
ValidateNested415({ message: 'La propiedad "pais" no es v\xE1lida.' }),
|
|
49494
49490
|
Expose756()
|
|
49495
49491
|
], DelegacionEntity.prototype, "pais", 2);
|
|
@@ -49507,8 +49503,8 @@ __decorateClass([
|
|
|
49507
49503
|
], DelegacionEntity.prototype, "nombre", 2);
|
|
49508
49504
|
|
|
49509
49505
|
// src/v2/entities/User.ts
|
|
49510
|
-
import { IsDefined as IsDefined259, IsEmail as IsEmail6, IsObject as
|
|
49511
|
-
import { Expose as Expose757, Type as Type476 } from "class-transformer";
|
|
49506
|
+
import { IsDefined as IsDefined259, IsEmail as IsEmail6, IsObject as IsObject17, IsString as IsString624, ValidateNested as ValidateNested416 } from "class-validator";
|
|
49507
|
+
import { Expose as Expose757, Transform as Transform112, Type as Type476 } from "class-transformer";
|
|
49512
49508
|
var UserEntity = class extends BaseEntity {
|
|
49513
49509
|
email;
|
|
49514
49510
|
password;
|
|
@@ -49517,35 +49513,41 @@ var UserEntity = class extends BaseEntity {
|
|
|
49517
49513
|
firstNames;
|
|
49518
49514
|
identification;
|
|
49519
49515
|
company;
|
|
49520
|
-
country
|
|
49521
|
-
delegation
|
|
49516
|
+
country;
|
|
49517
|
+
delegation;
|
|
49522
49518
|
};
|
|
49523
49519
|
__decorateClass([
|
|
49524
49520
|
IsDefined259({ message: "El correo es requerido" }),
|
|
49525
49521
|
IsEmail6({}, { message: "El correo es invalido" }),
|
|
49522
|
+
Transform112(({ value }) => typeof value === "string" ? value.trim().toLowerCase() : value),
|
|
49526
49523
|
Expose757()
|
|
49527
49524
|
], UserEntity.prototype, "email", 2);
|
|
49528
49525
|
__decorateClass([
|
|
49526
|
+
Transform112(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
49529
49527
|
IsDefined259({ message: "La contrase\xF1a es requerida" }),
|
|
49530
49528
|
IsString624({ message: "La contrase\xF1a debe ser una cadena de texto" }),
|
|
49531
49529
|
Expose757()
|
|
49532
49530
|
], UserEntity.prototype, "password", 2);
|
|
49533
49531
|
__decorateClass([
|
|
49532
|
+
Transform112(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
49534
49533
|
IsDefined259({ message: "El apellido paterno es requerido" }),
|
|
49535
49534
|
IsString624({ message: "El apellido paterno debe ser una cadena de texto" }),
|
|
49536
49535
|
Expose757()
|
|
49537
49536
|
], UserEntity.prototype, "paternalLastName", 2);
|
|
49538
49537
|
__decorateClass([
|
|
49538
|
+
Transform112(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
49539
49539
|
IsDefined259({ message: "El apellido materno es requerido" }),
|
|
49540
49540
|
IsString624({ message: "El apellido materno debe ser una cadena de texto" }),
|
|
49541
49541
|
Expose757()
|
|
49542
49542
|
], UserEntity.prototype, "maternalLastName", 2);
|
|
49543
49543
|
__decorateClass([
|
|
49544
|
+
Transform112(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
49544
49545
|
IsDefined259({ message: "El nombre es requerido" }),
|
|
49545
49546
|
IsString624({ message: "El nombre debe ser una cadena de texto" }),
|
|
49546
49547
|
Expose757()
|
|
49547
49548
|
], UserEntity.prototype, "firstNames", 2);
|
|
49548
49549
|
__decorateClass([
|
|
49550
|
+
Transform112(({ value }) => typeof value === "string" ? value.trim() : value),
|
|
49549
49551
|
IsDefined259({ message: "El n\xFAmero de identificaci\xF3n es requerido" }),
|
|
49550
49552
|
IsString624({ message: "El n\xFAmero de identificaci\xF3n debe ser una cadena de texto" }),
|
|
49551
49553
|
Expose757()
|
|
@@ -49554,21 +49556,21 @@ __decorateClass([
|
|
|
49554
49556
|
IsDefined259({ message: "La empresa es requerida" }),
|
|
49555
49557
|
Type476(() => CodeNameDto),
|
|
49556
49558
|
ValidateNested416(),
|
|
49557
|
-
|
|
49559
|
+
IsObject17(),
|
|
49558
49560
|
Expose757()
|
|
49559
49561
|
], UserEntity.prototype, "company", 2);
|
|
49560
49562
|
__decorateClass([
|
|
49561
49563
|
IsDefined259({ message: "debe proporcionar el pa\xEDs" }),
|
|
49562
49564
|
ValidateNested416(),
|
|
49563
|
-
Type476(() =>
|
|
49564
|
-
|
|
49565
|
+
Type476(() => CodeNameMinLengthDto),
|
|
49566
|
+
IsObject17(),
|
|
49565
49567
|
Expose757()
|
|
49566
49568
|
], UserEntity.prototype, "country", 2);
|
|
49567
49569
|
__decorateClass([
|
|
49568
49570
|
IsDefined259({ message: "debe proporcionar la delegaci\xF3n" }),
|
|
49569
49571
|
ValidateNested416(),
|
|
49570
|
-
Type476(() =>
|
|
49571
|
-
|
|
49572
|
+
Type476(() => CodeNameMinLengthDto),
|
|
49573
|
+
IsObject17(),
|
|
49572
49574
|
Expose757()
|
|
49573
49575
|
], UserEntity.prototype, "delegation", 2);
|
|
49574
49576
|
|
|
@@ -49590,9 +49592,9 @@ function getFirstError(errors, parentPath = "") {
|
|
|
49590
49592
|
}
|
|
49591
49593
|
|
|
49592
49594
|
// src/v2/utils/validateCustom.ts
|
|
49593
|
-
async function validateCustom(plain, cls, UnprocessableEntityException) {
|
|
49595
|
+
async function validateCustom(plain, cls, UnprocessableEntityException, groups) {
|
|
49594
49596
|
const instance = plainToInstance4(cls, plain, { excludeExtraneousValues: true });
|
|
49595
|
-
const errors = await validate3(instance);
|
|
49597
|
+
const errors = await validate3(instance, { groups });
|
|
49596
49598
|
if (errors.length) {
|
|
49597
49599
|
const msg = getFirstError(errors);
|
|
49598
49600
|
throw new UnprocessableEntityException(msg);
|