@admc-go-th/admc-library 1.0.94 → 1.0.95
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.
|
@@ -0,0 +1,83 @@
|
|
|
1
|
+
import {
|
|
2
|
+
Model, Table, Column, DataType, Index, Sequelize, ForeignKey
|
|
3
|
+
} from "sequelize-typescript";
|
|
4
|
+
|
|
5
|
+
export interface msProvinceAttributes {
|
|
6
|
+
id: number;
|
|
7
|
+
code?: string;
|
|
8
|
+
name?: string;
|
|
9
|
+
geoId?: number;
|
|
10
|
+
courtId?: number;
|
|
11
|
+
createdBy?: string;
|
|
12
|
+
createdDate?: Date;
|
|
13
|
+
updatedBy?: string;
|
|
14
|
+
updatedDate?: Date;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
@Table({
|
|
18
|
+
tableName: "ms_province",
|
|
19
|
+
timestamps: false
|
|
20
|
+
})
|
|
21
|
+
export class msProvince extends Model<msProvinceAttributes, msProvinceAttributes> implements msProvinceAttributes {
|
|
22
|
+
|
|
23
|
+
@Column({
|
|
24
|
+
primaryKey: true,
|
|
25
|
+
type: DataType.INTEGER
|
|
26
|
+
})
|
|
27
|
+
declare id: number;
|
|
28
|
+
|
|
29
|
+
@Column({
|
|
30
|
+
allowNull: true,
|
|
31
|
+
type: DataType.STRING(255)
|
|
32
|
+
})
|
|
33
|
+
declare code?: string;
|
|
34
|
+
|
|
35
|
+
@Column({
|
|
36
|
+
allowNull: true,
|
|
37
|
+
type: DataType.STRING(255)
|
|
38
|
+
})
|
|
39
|
+
declare name?: string;
|
|
40
|
+
|
|
41
|
+
@Column({
|
|
42
|
+
field: "geo_id",
|
|
43
|
+
allowNull: true,
|
|
44
|
+
type: DataType.INTEGER
|
|
45
|
+
})
|
|
46
|
+
declare geoId?: number;
|
|
47
|
+
|
|
48
|
+
@Column({
|
|
49
|
+
field: "court_id",
|
|
50
|
+
allowNull: true,
|
|
51
|
+
type: DataType.INTEGER
|
|
52
|
+
})
|
|
53
|
+
declare courtId?: number;
|
|
54
|
+
|
|
55
|
+
@Column({
|
|
56
|
+
field: "created_by",
|
|
57
|
+
allowNull: true,
|
|
58
|
+
type: DataType.STRING(60)
|
|
59
|
+
})
|
|
60
|
+
declare createdBy?: string;
|
|
61
|
+
|
|
62
|
+
@Column({
|
|
63
|
+
field: "created_date",
|
|
64
|
+
allowNull: true,
|
|
65
|
+
type: DataType.DATE
|
|
66
|
+
})
|
|
67
|
+
declare createdDate?: Date;
|
|
68
|
+
|
|
69
|
+
@Column({
|
|
70
|
+
field: "updated_by",
|
|
71
|
+
allowNull: true,
|
|
72
|
+
type: DataType.STRING(60)
|
|
73
|
+
})
|
|
74
|
+
declare updatedBy?: string;
|
|
75
|
+
|
|
76
|
+
@Column({
|
|
77
|
+
field: "updated_date",
|
|
78
|
+
allowNull: true,
|
|
79
|
+
type: DataType.DATE
|
|
80
|
+
})
|
|
81
|
+
declare updatedDate?: Date;
|
|
82
|
+
|
|
83
|
+
}
|
|
@@ -24,6 +24,7 @@ export { mdSetting, mdSettingAttributes } from './mdSetting.js';
|
|
|
24
24
|
export { a as mdTranslate, m as mdTranslateAttributes, c as mdTranslateGroup, b as mdTranslateGroupAttributes } from '../../mdTranslate-OuC5tJKe.js';
|
|
25
25
|
export { mdWords, mdWordsAttributes } from './mdWords.js';
|
|
26
26
|
export { member, memberAttributes } from './member.js';
|
|
27
|
+
export { msProvince, msProvinceAttributes } from './msProvince.js';
|
|
27
28
|
export { oauthAccessToken, oauthAccessTokenAttributes } from './oauthAccessToken.js';
|
|
28
29
|
export { oauthRefreshToken, oauthRefreshTokenAttributes } from './oauthRefreshToken.js';
|
|
29
30
|
export { a as recruitment, r as recruitmentAttributes, c as recruitmentGroup, b as recruitmentGroupAttributes } from '../../recruitment-DmJeINPg.js';
|
|
@@ -72,6 +72,7 @@ __export(tables_exports, {
|
|
|
72
72
|
member: () => member,
|
|
73
73
|
menu: () => menu,
|
|
74
74
|
msModule: () => msModule,
|
|
75
|
+
msProvince: () => msProvince,
|
|
75
76
|
oauthAccessToken: () => oauthAccessToken,
|
|
76
77
|
oauthRefreshToken: () => oauthRefreshToken,
|
|
77
78
|
recruitment: () => recruitment,
|
|
@@ -5340,65 +5341,80 @@ member = __decorateClass([
|
|
|
5340
5341
|
})
|
|
5341
5342
|
], member);
|
|
5342
5343
|
|
|
5343
|
-
// src/databases/tables/
|
|
5344
|
+
// src/databases/tables/msProvince.ts
|
|
5344
5345
|
var import_sequelize_typescript47 = require("sequelize-typescript");
|
|
5345
|
-
var
|
|
5346
|
+
var msProvince = class extends import_sequelize_typescript47.Model {
|
|
5346
5347
|
};
|
|
5347
5348
|
__decorateClass([
|
|
5348
5349
|
(0, import_sequelize_typescript47.Column)({
|
|
5349
5350
|
primaryKey: true,
|
|
5350
|
-
autoIncrement: true,
|
|
5351
5351
|
type: import_sequelize_typescript47.DataType.INTEGER
|
|
5352
5352
|
})
|
|
5353
|
-
],
|
|
5353
|
+
], msProvince.prototype, "id", 2);
|
|
5354
5354
|
__decorateClass([
|
|
5355
5355
|
(0, import_sequelize_typescript47.Column)({
|
|
5356
|
-
|
|
5357
|
-
type: import_sequelize_typescript47.DataType.STRING
|
|
5356
|
+
allowNull: true,
|
|
5357
|
+
type: import_sequelize_typescript47.DataType.STRING(255)
|
|
5358
5358
|
})
|
|
5359
|
-
],
|
|
5359
|
+
], msProvince.prototype, "code", 2);
|
|
5360
5360
|
__decorateClass([
|
|
5361
5361
|
(0, import_sequelize_typescript47.Column)({
|
|
5362
|
-
|
|
5363
|
-
type: import_sequelize_typescript47.DataType.STRING(
|
|
5362
|
+
allowNull: true,
|
|
5363
|
+
type: import_sequelize_typescript47.DataType.STRING(255)
|
|
5364
5364
|
})
|
|
5365
|
-
],
|
|
5365
|
+
], msProvince.prototype, "name", 2);
|
|
5366
5366
|
__decorateClass([
|
|
5367
5367
|
(0, import_sequelize_typescript47.Column)({
|
|
5368
|
-
field: "
|
|
5368
|
+
field: "geo_id",
|
|
5369
5369
|
allowNull: true,
|
|
5370
5370
|
type: import_sequelize_typescript47.DataType.INTEGER
|
|
5371
5371
|
})
|
|
5372
|
-
],
|
|
5372
|
+
], msProvince.prototype, "geoId", 2);
|
|
5373
5373
|
__decorateClass([
|
|
5374
5374
|
(0, import_sequelize_typescript47.Column)({
|
|
5375
|
-
|
|
5376
|
-
|
|
5375
|
+
field: "court_id",
|
|
5376
|
+
allowNull: true,
|
|
5377
|
+
type: import_sequelize_typescript47.DataType.INTEGER
|
|
5377
5378
|
})
|
|
5378
|
-
],
|
|
5379
|
+
], msProvince.prototype, "courtId", 2);
|
|
5379
5380
|
__decorateClass([
|
|
5380
5381
|
(0, import_sequelize_typescript47.Column)({
|
|
5382
|
+
field: "created_by",
|
|
5381
5383
|
allowNull: true,
|
|
5382
|
-
type: import_sequelize_typescript47.DataType.STRING(
|
|
5384
|
+
type: import_sequelize_typescript47.DataType.STRING(60)
|
|
5383
5385
|
})
|
|
5384
|
-
],
|
|
5386
|
+
], msProvince.prototype, "createdBy", 2);
|
|
5385
5387
|
__decorateClass([
|
|
5386
5388
|
(0, import_sequelize_typescript47.Column)({
|
|
5387
5389
|
field: "created_date",
|
|
5388
|
-
|
|
5389
|
-
|
|
5390
|
+
allowNull: true,
|
|
5391
|
+
type: import_sequelize_typescript47.DataType.DATE
|
|
5390
5392
|
})
|
|
5391
|
-
],
|
|
5392
|
-
|
|
5393
|
+
], msProvince.prototype, "createdDate", 2);
|
|
5394
|
+
__decorateClass([
|
|
5395
|
+
(0, import_sequelize_typescript47.Column)({
|
|
5396
|
+
field: "updated_by",
|
|
5397
|
+
allowNull: true,
|
|
5398
|
+
type: import_sequelize_typescript47.DataType.STRING(60)
|
|
5399
|
+
})
|
|
5400
|
+
], msProvince.prototype, "updatedBy", 2);
|
|
5401
|
+
__decorateClass([
|
|
5402
|
+
(0, import_sequelize_typescript47.Column)({
|
|
5403
|
+
field: "updated_date",
|
|
5404
|
+
allowNull: true,
|
|
5405
|
+
type: import_sequelize_typescript47.DataType.DATE
|
|
5406
|
+
})
|
|
5407
|
+
], msProvince.prototype, "updatedDate", 2);
|
|
5408
|
+
msProvince = __decorateClass([
|
|
5393
5409
|
(0, import_sequelize_typescript47.Table)({
|
|
5394
|
-
tableName: "
|
|
5410
|
+
tableName: "ms_province",
|
|
5395
5411
|
timestamps: false
|
|
5396
5412
|
})
|
|
5397
|
-
],
|
|
5413
|
+
], msProvince);
|
|
5398
5414
|
|
|
5399
|
-
// src/databases/tables/
|
|
5415
|
+
// src/databases/tables/oauthAccessToken.ts
|
|
5400
5416
|
var import_sequelize_typescript48 = require("sequelize-typescript");
|
|
5401
|
-
var
|
|
5417
|
+
var oauthAccessToken = class extends import_sequelize_typescript48.Model {
|
|
5402
5418
|
};
|
|
5403
5419
|
__decorateClass([
|
|
5404
5420
|
(0, import_sequelize_typescript48.Column)({
|
|
@@ -5406,439 +5422,495 @@ __decorateClass([
|
|
|
5406
5422
|
autoIncrement: true,
|
|
5407
5423
|
type: import_sequelize_typescript48.DataType.INTEGER
|
|
5408
5424
|
})
|
|
5409
|
-
],
|
|
5425
|
+
], oauthAccessToken.prototype, "id", 2);
|
|
5410
5426
|
__decorateClass([
|
|
5411
5427
|
(0, import_sequelize_typescript48.Column)({
|
|
5412
|
-
field: "
|
|
5413
|
-
type: import_sequelize_typescript48.DataType.STRING
|
|
5428
|
+
field: "access_token",
|
|
5429
|
+
type: import_sequelize_typescript48.DataType.STRING
|
|
5414
5430
|
})
|
|
5415
|
-
],
|
|
5431
|
+
], oauthAccessToken.prototype, "accessToken", 2);
|
|
5416
5432
|
__decorateClass([
|
|
5417
5433
|
(0, import_sequelize_typescript48.Column)({
|
|
5418
5434
|
field: "client_id",
|
|
5419
5435
|
type: import_sequelize_typescript48.DataType.STRING(32)
|
|
5420
5436
|
})
|
|
5421
|
-
],
|
|
5437
|
+
], oauthAccessToken.prototype, "clientId", 2);
|
|
5422
5438
|
__decorateClass([
|
|
5423
5439
|
(0, import_sequelize_typescript48.Column)({
|
|
5424
5440
|
field: "user_id",
|
|
5425
5441
|
allowNull: true,
|
|
5426
5442
|
type: import_sequelize_typescript48.DataType.INTEGER
|
|
5427
5443
|
})
|
|
5428
|
-
],
|
|
5444
|
+
], oauthAccessToken.prototype, "userId", 2);
|
|
5429
5445
|
__decorateClass([
|
|
5430
5446
|
(0, import_sequelize_typescript48.Column)({
|
|
5431
5447
|
type: import_sequelize_typescript48.DataType.DATE,
|
|
5432
5448
|
defaultValue: import_sequelize_typescript48.DataType.NOW
|
|
5433
5449
|
})
|
|
5434
|
-
],
|
|
5450
|
+
], oauthAccessToken.prototype, "expires", 2);
|
|
5435
5451
|
__decorateClass([
|
|
5436
5452
|
(0, import_sequelize_typescript48.Column)({
|
|
5437
5453
|
allowNull: true,
|
|
5438
|
-
type: import_sequelize_typescript48.DataType.STRING(
|
|
5454
|
+
type: import_sequelize_typescript48.DataType.STRING(2e3)
|
|
5439
5455
|
})
|
|
5440
|
-
],
|
|
5456
|
+
], oauthAccessToken.prototype, "scope", 2);
|
|
5441
5457
|
__decorateClass([
|
|
5442
5458
|
(0, import_sequelize_typescript48.Column)({
|
|
5443
5459
|
field: "created_date",
|
|
5444
5460
|
type: import_sequelize_typescript48.DataType.DATE,
|
|
5445
5461
|
defaultValue: import_sequelize_typescript48.DataType.NOW
|
|
5446
5462
|
})
|
|
5463
|
+
], oauthAccessToken.prototype, "createdDate", 2);
|
|
5464
|
+
oauthAccessToken = __decorateClass([
|
|
5465
|
+
(0, import_sequelize_typescript48.Table)({
|
|
5466
|
+
tableName: "oauth_access_token",
|
|
5467
|
+
timestamps: false
|
|
5468
|
+
})
|
|
5469
|
+
], oauthAccessToken);
|
|
5470
|
+
|
|
5471
|
+
// src/databases/tables/oauthRefreshToken.ts
|
|
5472
|
+
var import_sequelize_typescript49 = require("sequelize-typescript");
|
|
5473
|
+
var oauthRefreshToken = class extends import_sequelize_typescript49.Model {
|
|
5474
|
+
};
|
|
5475
|
+
__decorateClass([
|
|
5476
|
+
(0, import_sequelize_typescript49.Column)({
|
|
5477
|
+
primaryKey: true,
|
|
5478
|
+
autoIncrement: true,
|
|
5479
|
+
type: import_sequelize_typescript49.DataType.INTEGER
|
|
5480
|
+
})
|
|
5481
|
+
], oauthRefreshToken.prototype, "id", 2);
|
|
5482
|
+
__decorateClass([
|
|
5483
|
+
(0, import_sequelize_typescript49.Column)({
|
|
5484
|
+
field: "refresh_token",
|
|
5485
|
+
type: import_sequelize_typescript49.DataType.STRING(1e3)
|
|
5486
|
+
})
|
|
5487
|
+
], oauthRefreshToken.prototype, "refreshToken", 2);
|
|
5488
|
+
__decorateClass([
|
|
5489
|
+
(0, import_sequelize_typescript49.Column)({
|
|
5490
|
+
field: "client_id",
|
|
5491
|
+
type: import_sequelize_typescript49.DataType.STRING(32)
|
|
5492
|
+
})
|
|
5493
|
+
], oauthRefreshToken.prototype, "clientId", 2);
|
|
5494
|
+
__decorateClass([
|
|
5495
|
+
(0, import_sequelize_typescript49.Column)({
|
|
5496
|
+
field: "user_id",
|
|
5497
|
+
allowNull: true,
|
|
5498
|
+
type: import_sequelize_typescript49.DataType.INTEGER
|
|
5499
|
+
})
|
|
5500
|
+
], oauthRefreshToken.prototype, "userId", 2);
|
|
5501
|
+
__decorateClass([
|
|
5502
|
+
(0, import_sequelize_typescript49.Column)({
|
|
5503
|
+
type: import_sequelize_typescript49.DataType.DATE,
|
|
5504
|
+
defaultValue: import_sequelize_typescript49.DataType.NOW
|
|
5505
|
+
})
|
|
5506
|
+
], oauthRefreshToken.prototype, "expires", 2);
|
|
5507
|
+
__decorateClass([
|
|
5508
|
+
(0, import_sequelize_typescript49.Column)({
|
|
5509
|
+
allowNull: true,
|
|
5510
|
+
type: import_sequelize_typescript49.DataType.STRING(1e3)
|
|
5511
|
+
})
|
|
5512
|
+
], oauthRefreshToken.prototype, "scope", 2);
|
|
5513
|
+
__decorateClass([
|
|
5514
|
+
(0, import_sequelize_typescript49.Column)({
|
|
5515
|
+
field: "created_date",
|
|
5516
|
+
type: import_sequelize_typescript49.DataType.DATE,
|
|
5517
|
+
defaultValue: import_sequelize_typescript49.DataType.NOW
|
|
5518
|
+
})
|
|
5447
5519
|
], oauthRefreshToken.prototype, "createdDate", 2);
|
|
5448
5520
|
oauthRefreshToken = __decorateClass([
|
|
5449
|
-
(0,
|
|
5521
|
+
(0, import_sequelize_typescript49.Table)({
|
|
5450
5522
|
tableName: "oauth_refresh_token",
|
|
5451
5523
|
timestamps: false
|
|
5452
5524
|
})
|
|
5453
5525
|
], oauthRefreshToken);
|
|
5454
5526
|
|
|
5455
5527
|
// src/databases/tables/recruitment.ts
|
|
5456
|
-
var
|
|
5528
|
+
var import_sequelize_typescript51 = require("sequelize-typescript");
|
|
5457
5529
|
|
|
5458
5530
|
// src/databases/tables/recruitmentGroup.ts
|
|
5459
|
-
var
|
|
5460
|
-
var recruitmentGroup = class extends
|
|
5531
|
+
var import_sequelize_typescript50 = require("sequelize-typescript");
|
|
5532
|
+
var recruitmentGroup = class extends import_sequelize_typescript50.Model {
|
|
5461
5533
|
};
|
|
5462
5534
|
__decorateClass([
|
|
5463
|
-
(0,
|
|
5535
|
+
(0, import_sequelize_typescript50.Column)({
|
|
5464
5536
|
primaryKey: true,
|
|
5465
5537
|
autoIncrement: true,
|
|
5466
|
-
type:
|
|
5538
|
+
type: import_sequelize_typescript50.DataType.INTEGER
|
|
5467
5539
|
})
|
|
5468
5540
|
], recruitmentGroup.prototype, "id", 2);
|
|
5469
5541
|
__decorateClass([
|
|
5470
|
-
(0,
|
|
5542
|
+
(0, import_sequelize_typescript50.Column)({
|
|
5471
5543
|
allowNull: true,
|
|
5472
|
-
type:
|
|
5544
|
+
type: import_sequelize_typescript50.DataType.STRING(60)
|
|
5473
5545
|
})
|
|
5474
5546
|
], recruitmentGroup.prototype, "uuid", 2);
|
|
5475
5547
|
__decorateClass([
|
|
5476
|
-
(0,
|
|
5548
|
+
(0, import_sequelize_typescript50.Column)({
|
|
5477
5549
|
field: "user_id",
|
|
5478
5550
|
allowNull: true,
|
|
5479
|
-
type:
|
|
5551
|
+
type: import_sequelize_typescript50.DataType.INTEGER
|
|
5480
5552
|
})
|
|
5481
5553
|
], recruitmentGroup.prototype, "userId", 2);
|
|
5482
5554
|
__decorateClass([
|
|
5483
|
-
(0,
|
|
5484
|
-
type:
|
|
5555
|
+
(0, import_sequelize_typescript50.Column)({
|
|
5556
|
+
type: import_sequelize_typescript50.DataType.STRING(255)
|
|
5485
5557
|
})
|
|
5486
5558
|
], recruitmentGroup.prototype, "name", 2);
|
|
5487
5559
|
__decorateClass([
|
|
5488
|
-
(0,
|
|
5560
|
+
(0, import_sequelize_typescript50.Column)({
|
|
5489
5561
|
allowNull: true,
|
|
5490
|
-
type:
|
|
5562
|
+
type: import_sequelize_typescript50.DataType.STRING(255)
|
|
5491
5563
|
})
|
|
5492
5564
|
], recruitmentGroup.prototype, "description", 2);
|
|
5493
5565
|
__decorateClass([
|
|
5494
|
-
(0,
|
|
5566
|
+
(0, import_sequelize_typescript50.Column)({
|
|
5495
5567
|
allowNull: true,
|
|
5496
|
-
type:
|
|
5568
|
+
type: import_sequelize_typescript50.DataType.INTEGER
|
|
5497
5569
|
})
|
|
5498
5570
|
], recruitmentGroup.prototype, "sort", 2);
|
|
5499
5571
|
__decorateClass([
|
|
5500
|
-
(0,
|
|
5572
|
+
(0, import_sequelize_typescript50.Column)({
|
|
5501
5573
|
allowNull: true,
|
|
5502
|
-
type:
|
|
5574
|
+
type: import_sequelize_typescript50.DataType.INTEGER
|
|
5503
5575
|
})
|
|
5504
5576
|
], recruitmentGroup.prototype, "status", 2);
|
|
5505
5577
|
__decorateClass([
|
|
5506
|
-
(0,
|
|
5578
|
+
(0, import_sequelize_typescript50.Column)({
|
|
5507
5579
|
field: "created_by",
|
|
5508
5580
|
allowNull: true,
|
|
5509
|
-
type:
|
|
5581
|
+
type: import_sequelize_typescript50.DataType.STRING(60)
|
|
5510
5582
|
})
|
|
5511
5583
|
], recruitmentGroup.prototype, "createdBy", 2);
|
|
5512
5584
|
__decorateClass([
|
|
5513
|
-
(0,
|
|
5585
|
+
(0, import_sequelize_typescript50.Column)({
|
|
5514
5586
|
field: "created_date",
|
|
5515
5587
|
allowNull: true,
|
|
5516
|
-
type:
|
|
5588
|
+
type: import_sequelize_typescript50.DataType.DATE
|
|
5517
5589
|
})
|
|
5518
5590
|
], recruitmentGroup.prototype, "createdDate", 2);
|
|
5519
5591
|
__decorateClass([
|
|
5520
|
-
(0,
|
|
5592
|
+
(0, import_sequelize_typescript50.Column)({
|
|
5521
5593
|
field: "updated_by",
|
|
5522
5594
|
allowNull: true,
|
|
5523
|
-
type:
|
|
5595
|
+
type: import_sequelize_typescript50.DataType.STRING(60)
|
|
5524
5596
|
})
|
|
5525
5597
|
], recruitmentGroup.prototype, "updatedBy", 2);
|
|
5526
5598
|
__decorateClass([
|
|
5527
|
-
(0,
|
|
5599
|
+
(0, import_sequelize_typescript50.Column)({
|
|
5528
5600
|
field: "updated_date",
|
|
5529
5601
|
allowNull: true,
|
|
5530
|
-
type:
|
|
5602
|
+
type: import_sequelize_typescript50.DataType.DATE
|
|
5531
5603
|
})
|
|
5532
5604
|
], recruitmentGroup.prototype, "updatedDate", 2);
|
|
5533
5605
|
__decorateClass([
|
|
5534
|
-
(0,
|
|
5606
|
+
(0, import_sequelize_typescript50.HasMany)(() => recruitment, {
|
|
5535
5607
|
sourceKey: "id"
|
|
5536
5608
|
})
|
|
5537
5609
|
], recruitmentGroup.prototype, "recruitments", 2);
|
|
5538
5610
|
recruitmentGroup = __decorateClass([
|
|
5539
|
-
(0,
|
|
5611
|
+
(0, import_sequelize_typescript50.Table)({
|
|
5540
5612
|
tableName: "recruitment_group",
|
|
5541
5613
|
timestamps: false
|
|
5542
5614
|
})
|
|
5543
5615
|
], recruitmentGroup);
|
|
5544
5616
|
|
|
5545
5617
|
// src/databases/tables/recruitment.ts
|
|
5546
|
-
var recruitment = class extends
|
|
5618
|
+
var recruitment = class extends import_sequelize_typescript51.Model {
|
|
5547
5619
|
};
|
|
5548
5620
|
__decorateClass([
|
|
5549
|
-
(0,
|
|
5621
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5550
5622
|
primaryKey: true,
|
|
5551
5623
|
autoIncrement: true,
|
|
5552
|
-
type:
|
|
5624
|
+
type: import_sequelize_typescript51.DataType.INTEGER
|
|
5553
5625
|
})
|
|
5554
5626
|
], recruitment.prototype, "id", 2);
|
|
5555
5627
|
__decorateClass([
|
|
5556
|
-
(0,
|
|
5628
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5557
5629
|
allowNull: true,
|
|
5558
|
-
type:
|
|
5630
|
+
type: import_sequelize_typescript51.DataType.STRING(60)
|
|
5559
5631
|
})
|
|
5560
5632
|
], recruitment.prototype, "uuid", 2);
|
|
5561
5633
|
__decorateClass([
|
|
5562
|
-
(0,
|
|
5563
|
-
(0,
|
|
5634
|
+
(0, import_sequelize_typescript51.ForeignKey)(() => recruitmentGroup),
|
|
5635
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5564
5636
|
field: "group_id",
|
|
5565
5637
|
allowNull: true,
|
|
5566
|
-
type:
|
|
5638
|
+
type: import_sequelize_typescript51.DataType.INTEGER
|
|
5567
5639
|
})
|
|
5568
5640
|
], recruitment.prototype, "groupId", 2);
|
|
5569
5641
|
__decorateClass([
|
|
5570
|
-
(0,
|
|
5642
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5571
5643
|
field: "position_name",
|
|
5572
5644
|
allowNull: true,
|
|
5573
|
-
type:
|
|
5645
|
+
type: import_sequelize_typescript51.DataType.STRING(255)
|
|
5574
5646
|
})
|
|
5575
5647
|
], recruitment.prototype, "positionName", 2);
|
|
5576
5648
|
__decorateClass([
|
|
5577
|
-
(0,
|
|
5649
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5578
5650
|
field: "account_listed",
|
|
5579
5651
|
allowNull: true,
|
|
5580
|
-
type:
|
|
5652
|
+
type: import_sequelize_typescript51.DataType.INTEGER
|
|
5581
5653
|
})
|
|
5582
5654
|
], recruitment.prototype, "accountListed", 2);
|
|
5583
5655
|
__decorateClass([
|
|
5584
|
-
(0,
|
|
5656
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5585
5657
|
field: "account_age",
|
|
5586
5658
|
allowNull: true,
|
|
5587
|
-
type:
|
|
5659
|
+
type: import_sequelize_typescript51.DataType.INTEGER
|
|
5588
5660
|
})
|
|
5589
5661
|
], recruitment.prototype, "accountAge", 2);
|
|
5590
5662
|
__decorateClass([
|
|
5591
|
-
(0,
|
|
5663
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5592
5664
|
field: "account_expires",
|
|
5593
5665
|
allowNull: true,
|
|
5594
|
-
type:
|
|
5666
|
+
type: import_sequelize_typescript51.DataType.DATEONLY
|
|
5595
5667
|
})
|
|
5596
5668
|
], recruitment.prototype, "accountExpires", 2);
|
|
5597
5669
|
__decorateClass([
|
|
5598
|
-
(0,
|
|
5670
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5599
5671
|
field: "called_position",
|
|
5600
5672
|
allowNull: true,
|
|
5601
|
-
type:
|
|
5673
|
+
type: import_sequelize_typescript51.DataType.INTEGER
|
|
5602
5674
|
})
|
|
5603
5675
|
], recruitment.prototype, "calledPosition", 2);
|
|
5604
5676
|
__decorateClass([
|
|
5605
|
-
(0,
|
|
5677
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5606
5678
|
allowNull: true,
|
|
5607
|
-
type:
|
|
5679
|
+
type: import_sequelize_typescript51.DataType.INTEGER
|
|
5608
5680
|
})
|
|
5609
5681
|
], recruitment.prototype, "status", 2);
|
|
5610
5682
|
__decorateClass([
|
|
5611
|
-
(0,
|
|
5683
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5612
5684
|
field: "created_by",
|
|
5613
5685
|
allowNull: true,
|
|
5614
|
-
type:
|
|
5686
|
+
type: import_sequelize_typescript51.DataType.STRING(60)
|
|
5615
5687
|
})
|
|
5616
5688
|
], recruitment.prototype, "createdBy", 2);
|
|
5617
5689
|
__decorateClass([
|
|
5618
|
-
(0,
|
|
5690
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5619
5691
|
field: "created_date",
|
|
5620
5692
|
allowNull: true,
|
|
5621
|
-
type:
|
|
5693
|
+
type: import_sequelize_typescript51.DataType.DATE
|
|
5622
5694
|
})
|
|
5623
5695
|
], recruitment.prototype, "createdDate", 2);
|
|
5624
5696
|
__decorateClass([
|
|
5625
|
-
(0,
|
|
5697
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5626
5698
|
field: "updated_by",
|
|
5627
5699
|
allowNull: true,
|
|
5628
|
-
type:
|
|
5700
|
+
type: import_sequelize_typescript51.DataType.STRING(60)
|
|
5629
5701
|
})
|
|
5630
5702
|
], recruitment.prototype, "updatedBy", 2);
|
|
5631
5703
|
__decorateClass([
|
|
5632
|
-
(0,
|
|
5704
|
+
(0, import_sequelize_typescript51.Column)({
|
|
5633
5705
|
field: "updated_date",
|
|
5634
5706
|
allowNull: true,
|
|
5635
|
-
type:
|
|
5707
|
+
type: import_sequelize_typescript51.DataType.DATE
|
|
5636
5708
|
})
|
|
5637
5709
|
], recruitment.prototype, "updatedDate", 2);
|
|
5638
5710
|
__decorateClass([
|
|
5639
|
-
(0,
|
|
5711
|
+
(0, import_sequelize_typescript51.BelongsTo)(() => recruitmentGroup)
|
|
5640
5712
|
], recruitment.prototype, "recruitmentGroup", 2);
|
|
5641
5713
|
recruitment = __decorateClass([
|
|
5642
|
-
(0,
|
|
5714
|
+
(0, import_sequelize_typescript51.Table)({
|
|
5643
5715
|
tableName: "recruitment",
|
|
5644
5716
|
timestamps: false
|
|
5645
5717
|
})
|
|
5646
5718
|
], recruitment);
|
|
5647
5719
|
|
|
5648
5720
|
// src/databases/tables/settings.ts
|
|
5649
|
-
var
|
|
5650
|
-
var settings = class extends
|
|
5721
|
+
var import_sequelize_typescript52 = require("sequelize-typescript");
|
|
5722
|
+
var settings = class extends import_sequelize_typescript52.Model {
|
|
5651
5723
|
};
|
|
5652
5724
|
__decorateClass([
|
|
5653
|
-
(0,
|
|
5725
|
+
(0, import_sequelize_typescript52.Column)({
|
|
5654
5726
|
primaryKey: true,
|
|
5655
5727
|
autoIncrement: true,
|
|
5656
|
-
type:
|
|
5728
|
+
type: import_sequelize_typescript52.DataType.INTEGER
|
|
5657
5729
|
})
|
|
5658
5730
|
], settings.prototype, "id", 2);
|
|
5659
5731
|
__decorateClass([
|
|
5660
|
-
(0,
|
|
5732
|
+
(0, import_sequelize_typescript52.Column)({
|
|
5661
5733
|
allowNull: true,
|
|
5662
|
-
type:
|
|
5734
|
+
type: import_sequelize_typescript52.DataType.STRING(255)
|
|
5663
5735
|
})
|
|
5664
5736
|
], settings.prototype, "key", 2);
|
|
5665
5737
|
__decorateClass([
|
|
5666
|
-
(0,
|
|
5738
|
+
(0, import_sequelize_typescript52.Column)({
|
|
5667
5739
|
allowNull: true,
|
|
5668
|
-
type:
|
|
5740
|
+
type: import_sequelize_typescript52.DataType.STRING
|
|
5669
5741
|
})
|
|
5670
5742
|
], settings.prototype, "value", 2);
|
|
5671
5743
|
__decorateClass([
|
|
5672
|
-
(0,
|
|
5744
|
+
(0, import_sequelize_typescript52.Column)({
|
|
5673
5745
|
allowNull: true,
|
|
5674
|
-
type:
|
|
5746
|
+
type: import_sequelize_typescript52.DataType.JSON
|
|
5675
5747
|
})
|
|
5676
5748
|
], settings.prototype, "data", 2);
|
|
5677
5749
|
__decorateClass([
|
|
5678
|
-
(0,
|
|
5750
|
+
(0, import_sequelize_typescript52.Column)({
|
|
5679
5751
|
field: "updated_by",
|
|
5680
5752
|
allowNull: true,
|
|
5681
|
-
type:
|
|
5753
|
+
type: import_sequelize_typescript52.DataType.STRING(60)
|
|
5682
5754
|
})
|
|
5683
5755
|
], settings.prototype, "updatedBy", 2);
|
|
5684
5756
|
__decorateClass([
|
|
5685
|
-
(0,
|
|
5757
|
+
(0, import_sequelize_typescript52.Column)({
|
|
5686
5758
|
field: "updated_date",
|
|
5687
5759
|
allowNull: true,
|
|
5688
|
-
type:
|
|
5760
|
+
type: import_sequelize_typescript52.DataType.DATE
|
|
5689
5761
|
})
|
|
5690
5762
|
], settings.prototype, "updatedDate", 2);
|
|
5691
5763
|
settings = __decorateClass([
|
|
5692
|
-
(0,
|
|
5764
|
+
(0, import_sequelize_typescript52.Table)({
|
|
5693
5765
|
tableName: "settings",
|
|
5694
5766
|
timestamps: false
|
|
5695
5767
|
})
|
|
5696
5768
|
], settings);
|
|
5697
5769
|
|
|
5698
5770
|
// src/databases/tables/userCenterV.ts
|
|
5699
|
-
var
|
|
5700
|
-
var userCenterV = class extends
|
|
5771
|
+
var import_sequelize_typescript53 = require("sequelize-typescript");
|
|
5772
|
+
var userCenterV = class extends import_sequelize_typescript53.Model {
|
|
5701
5773
|
};
|
|
5702
5774
|
__decorateClass([
|
|
5703
|
-
(0,
|
|
5704
|
-
type:
|
|
5775
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5776
|
+
type: import_sequelize_typescript53.DataType.INTEGER,
|
|
5705
5777
|
defaultValue: "0"
|
|
5706
5778
|
})
|
|
5707
5779
|
], userCenterV.prototype, "id", 2);
|
|
5708
5780
|
__decorateClass([
|
|
5709
|
-
(0,
|
|
5710
|
-
type:
|
|
5781
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5782
|
+
type: import_sequelize_typescript53.DataType.STRING(60)
|
|
5711
5783
|
})
|
|
5712
5784
|
], userCenterV.prototype, "uuid", 2);
|
|
5713
5785
|
__decorateClass([
|
|
5714
|
-
(0,
|
|
5715
|
-
type:
|
|
5786
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5787
|
+
type: import_sequelize_typescript53.DataType.STRING(100)
|
|
5716
5788
|
})
|
|
5717
5789
|
], userCenterV.prototype, "username", 2);
|
|
5718
5790
|
__decorateClass([
|
|
5719
|
-
(0,
|
|
5791
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5720
5792
|
field: "password_hash",
|
|
5721
5793
|
allowNull: true,
|
|
5722
|
-
type:
|
|
5794
|
+
type: import_sequelize_typescript53.DataType.STRING(255)
|
|
5723
5795
|
})
|
|
5724
5796
|
], userCenterV.prototype, "passwordHash", 2);
|
|
5725
5797
|
__decorateClass([
|
|
5726
|
-
(0,
|
|
5798
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5727
5799
|
field: "password_reset_token",
|
|
5728
5800
|
allowNull: true,
|
|
5729
|
-
type:
|
|
5801
|
+
type: import_sequelize_typescript53.DataType.STRING(255)
|
|
5730
5802
|
})
|
|
5731
5803
|
], userCenterV.prototype, "passwordResetToken", 2);
|
|
5732
5804
|
__decorateClass([
|
|
5733
|
-
(0,
|
|
5805
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5734
5806
|
field: "verification_token",
|
|
5735
5807
|
allowNull: true,
|
|
5736
|
-
type:
|
|
5808
|
+
type: import_sequelize_typescript53.DataType.STRING(255)
|
|
5737
5809
|
})
|
|
5738
5810
|
], userCenterV.prototype, "verificationToken", 2);
|
|
5739
5811
|
__decorateClass([
|
|
5740
|
-
(0,
|
|
5812
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5741
5813
|
allowNull: true,
|
|
5742
|
-
type:
|
|
5814
|
+
type: import_sequelize_typescript53.DataType.STRING(255)
|
|
5743
5815
|
})
|
|
5744
5816
|
], userCenterV.prototype, "email", 2);
|
|
5745
5817
|
__decorateClass([
|
|
5746
|
-
(0,
|
|
5818
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5747
5819
|
field: "auth_key",
|
|
5748
5820
|
allowNull: true,
|
|
5749
|
-
type:
|
|
5821
|
+
type: import_sequelize_typescript53.DataType.STRING(32)
|
|
5750
5822
|
})
|
|
5751
5823
|
], userCenterV.prototype, "authKey", 2);
|
|
5752
5824
|
__decorateClass([
|
|
5753
|
-
(0,
|
|
5825
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5754
5826
|
field: "access_token",
|
|
5755
5827
|
allowNull: true,
|
|
5756
|
-
type:
|
|
5828
|
+
type: import_sequelize_typescript53.DataType.STRING
|
|
5757
5829
|
})
|
|
5758
5830
|
], userCenterV.prototype, "accessToken", 2);
|
|
5759
5831
|
__decorateClass([
|
|
5760
|
-
(0,
|
|
5832
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5761
5833
|
field: "user_level",
|
|
5762
5834
|
allowNull: true,
|
|
5763
|
-
type:
|
|
5835
|
+
type: import_sequelize_typescript53.DataType.INTEGER
|
|
5764
5836
|
})
|
|
5765
5837
|
], userCenterV.prototype, "userLevel", 2);
|
|
5766
5838
|
__decorateClass([
|
|
5767
|
-
(0,
|
|
5839
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5768
5840
|
field: "user_authen",
|
|
5769
5841
|
allowNull: true,
|
|
5770
|
-
type:
|
|
5842
|
+
type: import_sequelize_typescript53.DataType.STRING(64)
|
|
5771
5843
|
})
|
|
5772
5844
|
], userCenterV.prototype, "userAuthen", 2);
|
|
5773
5845
|
__decorateClass([
|
|
5774
|
-
(0,
|
|
5846
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5775
5847
|
field: "user_type",
|
|
5776
5848
|
allowNull: true,
|
|
5777
|
-
type:
|
|
5849
|
+
type: import_sequelize_typescript53.DataType.INTEGER
|
|
5778
5850
|
})
|
|
5779
5851
|
], userCenterV.prototype, "userType", 2);
|
|
5780
5852
|
__decorateClass([
|
|
5781
|
-
(0,
|
|
5853
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5782
5854
|
allowNull: true,
|
|
5783
|
-
type:
|
|
5855
|
+
type: import_sequelize_typescript53.DataType.STRING(10)
|
|
5784
5856
|
})
|
|
5785
5857
|
], userCenterV.prototype, "prefix", 2);
|
|
5786
5858
|
__decorateClass([
|
|
5787
|
-
(0,
|
|
5859
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5788
5860
|
field: "first_name",
|
|
5789
5861
|
allowNull: true,
|
|
5790
|
-
type:
|
|
5862
|
+
type: import_sequelize_typescript53.DataType.STRING(100)
|
|
5791
5863
|
})
|
|
5792
5864
|
], userCenterV.prototype, "firstName", 2);
|
|
5793
5865
|
__decorateClass([
|
|
5794
|
-
(0,
|
|
5866
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5795
5867
|
field: "last_name",
|
|
5796
5868
|
allowNull: true,
|
|
5797
|
-
type:
|
|
5869
|
+
type: import_sequelize_typescript53.DataType.STRING(100)
|
|
5798
5870
|
})
|
|
5799
5871
|
], userCenterV.prototype, "lastName", 2);
|
|
5800
5872
|
__decorateClass([
|
|
5801
|
-
(0,
|
|
5873
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5802
5874
|
allowNull: true,
|
|
5803
|
-
type:
|
|
5875
|
+
type: import_sequelize_typescript53.DataType.STRING(20)
|
|
5804
5876
|
})
|
|
5805
5877
|
], userCenterV.prototype, "phone", 2);
|
|
5806
5878
|
__decorateClass([
|
|
5807
|
-
(0,
|
|
5879
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5808
5880
|
allowNull: true,
|
|
5809
|
-
type:
|
|
5881
|
+
type: import_sequelize_typescript53.DataType.SMALLINT
|
|
5810
5882
|
})
|
|
5811
5883
|
], userCenterV.prototype, "status", 2);
|
|
5812
5884
|
__decorateClass([
|
|
5813
|
-
(0,
|
|
5885
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5814
5886
|
field: "created_by",
|
|
5815
5887
|
allowNull: true,
|
|
5816
|
-
type:
|
|
5888
|
+
type: import_sequelize_typescript53.DataType.STRING(60)
|
|
5817
5889
|
})
|
|
5818
5890
|
], userCenterV.prototype, "createdBy", 2);
|
|
5819
5891
|
__decorateClass([
|
|
5820
|
-
(0,
|
|
5892
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5821
5893
|
field: "created_date",
|
|
5822
5894
|
allowNull: true,
|
|
5823
|
-
type:
|
|
5895
|
+
type: import_sequelize_typescript53.DataType.DATE
|
|
5824
5896
|
})
|
|
5825
5897
|
], userCenterV.prototype, "createdDate", 2);
|
|
5826
5898
|
__decorateClass([
|
|
5827
|
-
(0,
|
|
5899
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5828
5900
|
field: "updated_by",
|
|
5829
5901
|
allowNull: true,
|
|
5830
|
-
type:
|
|
5902
|
+
type: import_sequelize_typescript53.DataType.STRING(60)
|
|
5831
5903
|
})
|
|
5832
5904
|
], userCenterV.prototype, "updatedBy", 2);
|
|
5833
5905
|
__decorateClass([
|
|
5834
|
-
(0,
|
|
5906
|
+
(0, import_sequelize_typescript53.Column)({
|
|
5835
5907
|
field: "updated_date",
|
|
5836
5908
|
allowNull: true,
|
|
5837
|
-
type:
|
|
5909
|
+
type: import_sequelize_typescript53.DataType.DATE
|
|
5838
5910
|
})
|
|
5839
5911
|
], userCenterV.prototype, "updatedDate", 2);
|
|
5840
5912
|
userCenterV = __decorateClass([
|
|
5841
|
-
(0,
|
|
5913
|
+
(0, import_sequelize_typescript53.Table)({
|
|
5842
5914
|
tableName: "user_center_v",
|
|
5843
5915
|
timestamps: false,
|
|
5844
5916
|
comment: "VIEW"
|
|
@@ -5846,38 +5918,38 @@ userCenterV = __decorateClass([
|
|
|
5846
5918
|
], userCenterV);
|
|
5847
5919
|
|
|
5848
5920
|
// src/databases/tables/userRoleV.ts
|
|
5849
|
-
var
|
|
5850
|
-
var userRoleV = class extends
|
|
5921
|
+
var import_sequelize_typescript54 = require("sequelize-typescript");
|
|
5922
|
+
var userRoleV = class extends import_sequelize_typescript54.Model {
|
|
5851
5923
|
};
|
|
5852
5924
|
__decorateClass([
|
|
5853
|
-
(0,
|
|
5854
|
-
type:
|
|
5925
|
+
(0, import_sequelize_typescript54.Column)({
|
|
5926
|
+
type: import_sequelize_typescript54.DataType.INTEGER,
|
|
5855
5927
|
defaultValue: "0"
|
|
5856
5928
|
})
|
|
5857
5929
|
], userRoleV.prototype, "id", 2);
|
|
5858
5930
|
__decorateClass([
|
|
5859
|
-
(0,
|
|
5931
|
+
(0, import_sequelize_typescript54.Column)({
|
|
5860
5932
|
field: "website_th",
|
|
5861
5933
|
allowNull: true,
|
|
5862
|
-
type:
|
|
5934
|
+
type: import_sequelize_typescript54.DataType.STRING(60)
|
|
5863
5935
|
})
|
|
5864
5936
|
], userRoleV.prototype, "websiteTh", 2);
|
|
5865
5937
|
__decorateClass([
|
|
5866
|
-
(0,
|
|
5938
|
+
(0, import_sequelize_typescript54.Column)({
|
|
5867
5939
|
field: "website_en",
|
|
5868
5940
|
allowNull: true,
|
|
5869
|
-
type:
|
|
5941
|
+
type: import_sequelize_typescript54.DataType.STRING(60)
|
|
5870
5942
|
})
|
|
5871
5943
|
], userRoleV.prototype, "websiteEn", 2);
|
|
5872
5944
|
__decorateClass([
|
|
5873
|
-
(0,
|
|
5945
|
+
(0, import_sequelize_typescript54.Column)({
|
|
5874
5946
|
field: "website_fr",
|
|
5875
5947
|
allowNull: true,
|
|
5876
|
-
type:
|
|
5948
|
+
type: import_sequelize_typescript54.DataType.STRING(60)
|
|
5877
5949
|
})
|
|
5878
5950
|
], userRoleV.prototype, "websiteFr", 2);
|
|
5879
5951
|
userRoleV = __decorateClass([
|
|
5880
|
-
(0,
|
|
5952
|
+
(0, import_sequelize_typescript54.Table)({
|
|
5881
5953
|
tableName: "user_role_v",
|
|
5882
5954
|
timestamps: false,
|
|
5883
5955
|
comment: "VIEW"
|
|
@@ -5929,6 +6001,7 @@ userRoleV = __decorateClass([
|
|
|
5929
6001
|
member,
|
|
5930
6002
|
menu,
|
|
5931
6003
|
msModule,
|
|
6004
|
+
msProvince,
|
|
5932
6005
|
oauthAccessToken,
|
|
5933
6006
|
oauthRefreshToken,
|
|
5934
6007
|
recruitment,
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
import { Model } from 'sequelize-typescript';
|
|
2
|
+
|
|
3
|
+
interface msProvinceAttributes {
|
|
4
|
+
id: number;
|
|
5
|
+
code?: string;
|
|
6
|
+
name?: string;
|
|
7
|
+
geoId?: number;
|
|
8
|
+
courtId?: number;
|
|
9
|
+
createdBy?: string;
|
|
10
|
+
createdDate?: Date;
|
|
11
|
+
updatedBy?: string;
|
|
12
|
+
updatedDate?: Date;
|
|
13
|
+
}
|
|
14
|
+
declare class msProvince extends Model<msProvinceAttributes, msProvinceAttributes> implements msProvinceAttributes {
|
|
15
|
+
id: number;
|
|
16
|
+
code?: string;
|
|
17
|
+
name?: string;
|
|
18
|
+
geoId?: number;
|
|
19
|
+
courtId?: number;
|
|
20
|
+
createdBy?: string;
|
|
21
|
+
createdDate?: Date;
|
|
22
|
+
updatedBy?: string;
|
|
23
|
+
updatedDate?: Date;
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
export { msProvince, type msProvinceAttributes };
|
|
@@ -0,0 +1,106 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __defProp = Object.defineProperty;
|
|
3
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
4
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
5
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
6
|
+
var __export = (target, all) => {
|
|
7
|
+
for (var name in all)
|
|
8
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
|
9
|
+
};
|
|
10
|
+
var __copyProps = (to, from, except, desc) => {
|
|
11
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
12
|
+
for (let key of __getOwnPropNames(from))
|
|
13
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
14
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
15
|
+
}
|
|
16
|
+
return to;
|
|
17
|
+
};
|
|
18
|
+
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
19
|
+
var __decorateClass = (decorators, target, key, kind) => {
|
|
20
|
+
var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
|
|
21
|
+
for (var i = decorators.length - 1, decorator; i >= 0; i--)
|
|
22
|
+
if (decorator = decorators[i])
|
|
23
|
+
result = (kind ? decorator(target, key, result) : decorator(result)) || result;
|
|
24
|
+
if (kind && result) __defProp(target, key, result);
|
|
25
|
+
return result;
|
|
26
|
+
};
|
|
27
|
+
|
|
28
|
+
// src/databases/tables/msProvince.ts
|
|
29
|
+
var msProvince_exports = {};
|
|
30
|
+
__export(msProvince_exports, {
|
|
31
|
+
msProvince: () => msProvince
|
|
32
|
+
});
|
|
33
|
+
module.exports = __toCommonJS(msProvince_exports);
|
|
34
|
+
var import_sequelize_typescript = require("sequelize-typescript");
|
|
35
|
+
var msProvince = class extends import_sequelize_typescript.Model {
|
|
36
|
+
};
|
|
37
|
+
__decorateClass([
|
|
38
|
+
(0, import_sequelize_typescript.Column)({
|
|
39
|
+
primaryKey: true,
|
|
40
|
+
type: import_sequelize_typescript.DataType.INTEGER
|
|
41
|
+
})
|
|
42
|
+
], msProvince.prototype, "id", 2);
|
|
43
|
+
__decorateClass([
|
|
44
|
+
(0, import_sequelize_typescript.Column)({
|
|
45
|
+
allowNull: true,
|
|
46
|
+
type: import_sequelize_typescript.DataType.STRING(255)
|
|
47
|
+
})
|
|
48
|
+
], msProvince.prototype, "code", 2);
|
|
49
|
+
__decorateClass([
|
|
50
|
+
(0, import_sequelize_typescript.Column)({
|
|
51
|
+
allowNull: true,
|
|
52
|
+
type: import_sequelize_typescript.DataType.STRING(255)
|
|
53
|
+
})
|
|
54
|
+
], msProvince.prototype, "name", 2);
|
|
55
|
+
__decorateClass([
|
|
56
|
+
(0, import_sequelize_typescript.Column)({
|
|
57
|
+
field: "geo_id",
|
|
58
|
+
allowNull: true,
|
|
59
|
+
type: import_sequelize_typescript.DataType.INTEGER
|
|
60
|
+
})
|
|
61
|
+
], msProvince.prototype, "geoId", 2);
|
|
62
|
+
__decorateClass([
|
|
63
|
+
(0, import_sequelize_typescript.Column)({
|
|
64
|
+
field: "court_id",
|
|
65
|
+
allowNull: true,
|
|
66
|
+
type: import_sequelize_typescript.DataType.INTEGER
|
|
67
|
+
})
|
|
68
|
+
], msProvince.prototype, "courtId", 2);
|
|
69
|
+
__decorateClass([
|
|
70
|
+
(0, import_sequelize_typescript.Column)({
|
|
71
|
+
field: "created_by",
|
|
72
|
+
allowNull: true,
|
|
73
|
+
type: import_sequelize_typescript.DataType.STRING(60)
|
|
74
|
+
})
|
|
75
|
+
], msProvince.prototype, "createdBy", 2);
|
|
76
|
+
__decorateClass([
|
|
77
|
+
(0, import_sequelize_typescript.Column)({
|
|
78
|
+
field: "created_date",
|
|
79
|
+
allowNull: true,
|
|
80
|
+
type: import_sequelize_typescript.DataType.DATE
|
|
81
|
+
})
|
|
82
|
+
], msProvince.prototype, "createdDate", 2);
|
|
83
|
+
__decorateClass([
|
|
84
|
+
(0, import_sequelize_typescript.Column)({
|
|
85
|
+
field: "updated_by",
|
|
86
|
+
allowNull: true,
|
|
87
|
+
type: import_sequelize_typescript.DataType.STRING(60)
|
|
88
|
+
})
|
|
89
|
+
], msProvince.prototype, "updatedBy", 2);
|
|
90
|
+
__decorateClass([
|
|
91
|
+
(0, import_sequelize_typescript.Column)({
|
|
92
|
+
field: "updated_date",
|
|
93
|
+
allowNull: true,
|
|
94
|
+
type: import_sequelize_typescript.DataType.DATE
|
|
95
|
+
})
|
|
96
|
+
], msProvince.prototype, "updatedDate", 2);
|
|
97
|
+
msProvince = __decorateClass([
|
|
98
|
+
(0, import_sequelize_typescript.Table)({
|
|
99
|
+
tableName: "ms_province",
|
|
100
|
+
timestamps: false
|
|
101
|
+
})
|
|
102
|
+
], msProvince);
|
|
103
|
+
// Annotate the CommonJS export names for ESM import in node:
|
|
104
|
+
0 && (module.exports = {
|
|
105
|
+
msProvince
|
|
106
|
+
});
|