@admc-go-th/admc-library 1.0.87 → 1.0.89
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/databases/schema/appFaq.ts +134 -0
- package/databases/schema/index.ts +1 -1
- package/databases/tables/appFaq.d.ts +40 -0
- package/databases/tables/appFaq.js +150 -0
- package/databases/tables/index.d.ts +1 -1
- package/databases/tables/index.js +536 -530
- package/package.json +1 -1
|
@@ -30,13 +30,13 @@ var tables_exports = {};
|
|
|
30
30
|
__export(tables_exports, {
|
|
31
31
|
appBlessings: () => appBlessings,
|
|
32
32
|
appBlessingsTransaction: () => appBlessingsTransaction,
|
|
33
|
+
appFaq: () => appFaq,
|
|
33
34
|
authAssignment: () => authAssignment,
|
|
34
35
|
authItem: () => authItem,
|
|
35
36
|
authItemChild: () => authItemChild,
|
|
36
37
|
authRole: () => authRole,
|
|
37
38
|
authRoleChild: () => authRoleChild,
|
|
38
39
|
files: () => files,
|
|
39
|
-
formFaq: () => formFaq,
|
|
40
40
|
helper: () => helper,
|
|
41
41
|
logs: () => logs,
|
|
42
42
|
mdBanner: () => mdBanner,
|
|
@@ -266,18 +266,9 @@ appBlessings = __decorateClass([
|
|
|
266
266
|
})
|
|
267
267
|
], appBlessings);
|
|
268
268
|
|
|
269
|
-
// src/databases/tables/
|
|
270
|
-
var import_sequelize_typescript10 = require("sequelize-typescript");
|
|
271
|
-
|
|
272
|
-
// src/databases/tables/users.ts
|
|
273
|
-
var import_sequelize_typescript7 = require("sequelize-typescript");
|
|
274
|
-
|
|
275
|
-
// src/databases/tables/mdContent.ts
|
|
276
|
-
var import_sequelize_typescript4 = require("sequelize-typescript");
|
|
277
|
-
|
|
278
|
-
// src/databases/tables/mdContentGroup.ts
|
|
269
|
+
// src/databases/tables/appFaq.ts
|
|
279
270
|
var import_sequelize_typescript3 = require("sequelize-typescript");
|
|
280
|
-
var
|
|
271
|
+
var appFaq = class extends import_sequelize_typescript3.Model {
|
|
281
272
|
};
|
|
282
273
|
__decorateClass([
|
|
283
274
|
(0, import_sequelize_typescript3.Column)({
|
|
@@ -285,1500 +276,1515 @@ __decorateClass([
|
|
|
285
276
|
autoIncrement: true,
|
|
286
277
|
type: import_sequelize_typescript3.DataType.INTEGER
|
|
287
278
|
})
|
|
288
|
-
],
|
|
279
|
+
], appFaq.prototype, "id", 2);
|
|
289
280
|
__decorateClass([
|
|
290
281
|
(0, import_sequelize_typescript3.Column)({
|
|
291
282
|
allowNull: true,
|
|
292
283
|
type: import_sequelize_typescript3.DataType.STRING(60)
|
|
293
284
|
})
|
|
294
|
-
],
|
|
285
|
+
], appFaq.prototype, "uuid", 2);
|
|
295
286
|
__decorateClass([
|
|
296
287
|
(0, import_sequelize_typescript3.Column)({
|
|
297
|
-
field: "
|
|
288
|
+
field: "title_name",
|
|
298
289
|
allowNull: true,
|
|
299
|
-
type: import_sequelize_typescript3.DataType.STRING(
|
|
290
|
+
type: import_sequelize_typescript3.DataType.STRING(50)
|
|
300
291
|
})
|
|
301
|
-
],
|
|
292
|
+
], appFaq.prototype, "titleName", 2);
|
|
302
293
|
__decorateClass([
|
|
303
294
|
(0, import_sequelize_typescript3.Column)({
|
|
295
|
+
field: "first_name",
|
|
296
|
+
allowNull: true,
|
|
304
297
|
type: import_sequelize_typescript3.DataType.STRING(255)
|
|
305
298
|
})
|
|
306
|
-
],
|
|
299
|
+
], appFaq.prototype, "firstName", 2);
|
|
307
300
|
__decorateClass([
|
|
308
301
|
(0, import_sequelize_typescript3.Column)({
|
|
302
|
+
field: "last_name",
|
|
309
303
|
allowNull: true,
|
|
310
304
|
type: import_sequelize_typescript3.DataType.STRING(255)
|
|
311
305
|
})
|
|
312
|
-
],
|
|
306
|
+
], appFaq.prototype, "lastName", 2);
|
|
307
|
+
__decorateClass([
|
|
308
|
+
(0, import_sequelize_typescript3.Column)({
|
|
309
|
+
allowNull: true,
|
|
310
|
+
type: import_sequelize_typescript3.DataType.STRING(255)
|
|
311
|
+
})
|
|
312
|
+
], appFaq.prototype, "phone", 2);
|
|
313
|
+
__decorateClass([
|
|
314
|
+
(0, import_sequelize_typescript3.Column)({
|
|
315
|
+
allowNull: true,
|
|
316
|
+
type: import_sequelize_typescript3.DataType.STRING(255)
|
|
317
|
+
})
|
|
318
|
+
], appFaq.prototype, "email", 2);
|
|
319
|
+
__decorateClass([
|
|
320
|
+
(0, import_sequelize_typescript3.Column)({
|
|
321
|
+
allowNull: true,
|
|
322
|
+
type: import_sequelize_typescript3.DataType.STRING(255)
|
|
323
|
+
})
|
|
324
|
+
], appFaq.prototype, "question", 2);
|
|
325
|
+
__decorateClass([
|
|
326
|
+
(0, import_sequelize_typescript3.Column)({
|
|
327
|
+
allowNull: true,
|
|
328
|
+
type: import_sequelize_typescript3.DataType.STRING
|
|
329
|
+
})
|
|
330
|
+
], appFaq.prototype, "detail", 2);
|
|
331
|
+
__decorateClass([
|
|
332
|
+
(0, import_sequelize_typescript3.Column)({
|
|
333
|
+
allowNull: true,
|
|
334
|
+
type: import_sequelize_typescript3.DataType.JSON
|
|
335
|
+
})
|
|
336
|
+
], appFaq.prototype, "attachments", 2);
|
|
337
|
+
__decorateClass([
|
|
338
|
+
(0, import_sequelize_typescript3.Column)({
|
|
339
|
+
allowNull: true,
|
|
340
|
+
type: import_sequelize_typescript3.DataType.STRING
|
|
341
|
+
})
|
|
342
|
+
], appFaq.prototype, "answer", 2);
|
|
313
343
|
__decorateClass([
|
|
314
344
|
(0, import_sequelize_typescript3.Column)({
|
|
315
345
|
allowNull: true,
|
|
316
346
|
type: import_sequelize_typescript3.DataType.INTEGER
|
|
317
347
|
})
|
|
318
|
-
],
|
|
348
|
+
], appFaq.prototype, "status", 2);
|
|
319
349
|
__decorateClass([
|
|
320
350
|
(0, import_sequelize_typescript3.Column)({
|
|
321
351
|
field: "created_by",
|
|
322
352
|
allowNull: true,
|
|
323
353
|
type: import_sequelize_typescript3.DataType.STRING(60)
|
|
324
354
|
})
|
|
325
|
-
],
|
|
355
|
+
], appFaq.prototype, "createdBy", 2);
|
|
326
356
|
__decorateClass([
|
|
327
357
|
(0, import_sequelize_typescript3.Column)({
|
|
328
358
|
field: "created_date",
|
|
329
359
|
allowNull: true,
|
|
330
360
|
type: import_sequelize_typescript3.DataType.DATE
|
|
331
361
|
})
|
|
332
|
-
],
|
|
362
|
+
], appFaq.prototype, "createdDate", 2);
|
|
333
363
|
__decorateClass([
|
|
334
364
|
(0, import_sequelize_typescript3.Column)({
|
|
335
365
|
field: "updated_by",
|
|
336
366
|
allowNull: true,
|
|
337
367
|
type: import_sequelize_typescript3.DataType.STRING(60)
|
|
338
368
|
})
|
|
339
|
-
],
|
|
369
|
+
], appFaq.prototype, "updatedBy", 2);
|
|
340
370
|
__decorateClass([
|
|
341
371
|
(0, import_sequelize_typescript3.Column)({
|
|
342
372
|
field: "updated_date",
|
|
343
373
|
allowNull: true,
|
|
344
374
|
type: import_sequelize_typescript3.DataType.DATE
|
|
345
375
|
})
|
|
376
|
+
], appFaq.prototype, "updatedDate", 2);
|
|
377
|
+
appFaq = __decorateClass([
|
|
378
|
+
(0, import_sequelize_typescript3.Table)({
|
|
379
|
+
tableName: "app_faq",
|
|
380
|
+
timestamps: false
|
|
381
|
+
})
|
|
382
|
+
], appFaq);
|
|
383
|
+
|
|
384
|
+
// src/databases/tables/authAssignment.ts
|
|
385
|
+
var import_sequelize_typescript11 = require("sequelize-typescript");
|
|
386
|
+
|
|
387
|
+
// src/databases/tables/users.ts
|
|
388
|
+
var import_sequelize_typescript8 = require("sequelize-typescript");
|
|
389
|
+
|
|
390
|
+
// src/databases/tables/mdContent.ts
|
|
391
|
+
var import_sequelize_typescript5 = require("sequelize-typescript");
|
|
392
|
+
|
|
393
|
+
// src/databases/tables/mdContentGroup.ts
|
|
394
|
+
var import_sequelize_typescript4 = require("sequelize-typescript");
|
|
395
|
+
var mdContentGroup = class extends import_sequelize_typescript4.Model {
|
|
396
|
+
};
|
|
397
|
+
__decorateClass([
|
|
398
|
+
(0, import_sequelize_typescript4.Column)({
|
|
399
|
+
primaryKey: true,
|
|
400
|
+
autoIncrement: true,
|
|
401
|
+
type: import_sequelize_typescript4.DataType.INTEGER
|
|
402
|
+
})
|
|
403
|
+
], mdContentGroup.prototype, "id", 2);
|
|
404
|
+
__decorateClass([
|
|
405
|
+
(0, import_sequelize_typescript4.Column)({
|
|
406
|
+
allowNull: true,
|
|
407
|
+
type: import_sequelize_typescript4.DataType.STRING(60)
|
|
408
|
+
})
|
|
409
|
+
], mdContentGroup.prototype, "uuid", 2);
|
|
410
|
+
__decorateClass([
|
|
411
|
+
(0, import_sequelize_typescript4.Column)({
|
|
412
|
+
field: "key_name",
|
|
413
|
+
allowNull: true,
|
|
414
|
+
type: import_sequelize_typescript4.DataType.STRING(100)
|
|
415
|
+
})
|
|
416
|
+
], mdContentGroup.prototype, "keyName", 2);
|
|
417
|
+
__decorateClass([
|
|
418
|
+
(0, import_sequelize_typescript4.Column)({
|
|
419
|
+
type: import_sequelize_typescript4.DataType.STRING(255)
|
|
420
|
+
})
|
|
421
|
+
], mdContentGroup.prototype, "name", 2);
|
|
422
|
+
__decorateClass([
|
|
423
|
+
(0, import_sequelize_typescript4.Column)({
|
|
424
|
+
allowNull: true,
|
|
425
|
+
type: import_sequelize_typescript4.DataType.STRING(255)
|
|
426
|
+
})
|
|
427
|
+
], mdContentGroup.prototype, "description", 2);
|
|
428
|
+
__decorateClass([
|
|
429
|
+
(0, import_sequelize_typescript4.Column)({
|
|
430
|
+
allowNull: true,
|
|
431
|
+
type: import_sequelize_typescript4.DataType.INTEGER
|
|
432
|
+
})
|
|
433
|
+
], mdContentGroup.prototype, "status", 2);
|
|
434
|
+
__decorateClass([
|
|
435
|
+
(0, import_sequelize_typescript4.Column)({
|
|
436
|
+
field: "created_by",
|
|
437
|
+
allowNull: true,
|
|
438
|
+
type: import_sequelize_typescript4.DataType.STRING(60)
|
|
439
|
+
})
|
|
440
|
+
], mdContentGroup.prototype, "createdBy", 2);
|
|
441
|
+
__decorateClass([
|
|
442
|
+
(0, import_sequelize_typescript4.Column)({
|
|
443
|
+
field: "created_date",
|
|
444
|
+
allowNull: true,
|
|
445
|
+
type: import_sequelize_typescript4.DataType.DATE
|
|
446
|
+
})
|
|
447
|
+
], mdContentGroup.prototype, "createdDate", 2);
|
|
448
|
+
__decorateClass([
|
|
449
|
+
(0, import_sequelize_typescript4.Column)({
|
|
450
|
+
field: "updated_by",
|
|
451
|
+
allowNull: true,
|
|
452
|
+
type: import_sequelize_typescript4.DataType.STRING(60)
|
|
453
|
+
})
|
|
454
|
+
], mdContentGroup.prototype, "updatedBy", 2);
|
|
455
|
+
__decorateClass([
|
|
456
|
+
(0, import_sequelize_typescript4.Column)({
|
|
457
|
+
field: "updated_date",
|
|
458
|
+
allowNull: true,
|
|
459
|
+
type: import_sequelize_typescript4.DataType.DATE
|
|
460
|
+
})
|
|
346
461
|
], mdContentGroup.prototype, "updatedDate", 2);
|
|
347
462
|
__decorateClass([
|
|
348
|
-
(0,
|
|
463
|
+
(0, import_sequelize_typescript4.HasMany)(() => mdContent, {
|
|
349
464
|
sourceKey: "id"
|
|
350
465
|
})
|
|
351
466
|
], mdContentGroup.prototype, "mdContents", 2);
|
|
352
467
|
mdContentGroup = __decorateClass([
|
|
353
|
-
(0,
|
|
468
|
+
(0, import_sequelize_typescript4.Table)({
|
|
354
469
|
tableName: "md_content_group",
|
|
355
470
|
timestamps: false
|
|
356
471
|
})
|
|
357
472
|
], mdContentGroup);
|
|
358
473
|
|
|
359
474
|
// src/databases/tables/mdContent.ts
|
|
360
|
-
var mdContent = class extends
|
|
475
|
+
var mdContent = class extends import_sequelize_typescript5.Model {
|
|
361
476
|
};
|
|
362
477
|
__decorateClass([
|
|
363
|
-
(0,
|
|
478
|
+
(0, import_sequelize_typescript5.Column)({
|
|
364
479
|
primaryKey: true,
|
|
365
480
|
autoIncrement: true,
|
|
366
|
-
type:
|
|
481
|
+
type: import_sequelize_typescript5.DataType.INTEGER
|
|
367
482
|
})
|
|
368
483
|
], mdContent.prototype, "id", 2);
|
|
369
484
|
__decorateClass([
|
|
370
|
-
(0,
|
|
371
|
-
type:
|
|
485
|
+
(0, import_sequelize_typescript5.Column)({
|
|
486
|
+
type: import_sequelize_typescript5.DataType.STRING(60)
|
|
372
487
|
})
|
|
373
488
|
], mdContent.prototype, "uuid", 2);
|
|
374
489
|
__decorateClass([
|
|
375
|
-
(0,
|
|
490
|
+
(0, import_sequelize_typescript5.Column)({
|
|
376
491
|
field: "key_name",
|
|
377
492
|
allowNull: true,
|
|
378
|
-
type:
|
|
493
|
+
type: import_sequelize_typescript5.DataType.STRING(100)
|
|
379
494
|
})
|
|
380
495
|
], mdContent.prototype, "keyName", 2);
|
|
381
496
|
__decorateClass([
|
|
382
|
-
(0,
|
|
383
|
-
(0,
|
|
497
|
+
(0, import_sequelize_typescript5.ForeignKey)(() => mdContentGroup),
|
|
498
|
+
(0, import_sequelize_typescript5.Column)({
|
|
384
499
|
field: "group_id",
|
|
385
500
|
allowNull: true,
|
|
386
|
-
type:
|
|
501
|
+
type: import_sequelize_typescript5.DataType.INTEGER
|
|
387
502
|
})
|
|
388
503
|
], mdContent.prototype, "groupId", 2);
|
|
389
504
|
__decorateClass([
|
|
390
|
-
(0,
|
|
391
|
-
(0,
|
|
505
|
+
(0, import_sequelize_typescript5.ForeignKey)(() => users),
|
|
506
|
+
(0, import_sequelize_typescript5.Column)({
|
|
392
507
|
field: "user_id",
|
|
393
|
-
type:
|
|
508
|
+
type: import_sequelize_typescript5.DataType.INTEGER
|
|
394
509
|
})
|
|
395
510
|
], mdContent.prototype, "userId", 2);
|
|
396
511
|
__decorateClass([
|
|
397
|
-
(0,
|
|
512
|
+
(0, import_sequelize_typescript5.Column)({
|
|
398
513
|
allowNull: true,
|
|
399
|
-
type:
|
|
514
|
+
type: import_sequelize_typescript5.DataType.STRING(255)
|
|
400
515
|
})
|
|
401
516
|
], mdContent.prototype, "title", 2);
|
|
402
517
|
__decorateClass([
|
|
403
|
-
(0,
|
|
518
|
+
(0, import_sequelize_typescript5.Column)({
|
|
404
519
|
allowNull: true,
|
|
405
|
-
type:
|
|
520
|
+
type: import_sequelize_typescript5.DataType.STRING
|
|
406
521
|
})
|
|
407
522
|
], mdContent.prototype, "description", 2);
|
|
408
523
|
__decorateClass([
|
|
409
|
-
(0,
|
|
524
|
+
(0, import_sequelize_typescript5.Column)({
|
|
410
525
|
allowNull: true,
|
|
411
|
-
type:
|
|
526
|
+
type: import_sequelize_typescript5.DataType.STRING
|
|
412
527
|
})
|
|
413
528
|
], mdContent.prototype, "detail", 2);
|
|
414
529
|
__decorateClass([
|
|
415
|
-
(0,
|
|
530
|
+
(0, import_sequelize_typescript5.Column)({
|
|
416
531
|
field: "meta_title",
|
|
417
532
|
allowNull: true,
|
|
418
|
-
type:
|
|
533
|
+
type: import_sequelize_typescript5.DataType.STRING(255)
|
|
419
534
|
})
|
|
420
535
|
], mdContent.prototype, "metaTitle", 2);
|
|
421
536
|
__decorateClass([
|
|
422
|
-
(0,
|
|
537
|
+
(0, import_sequelize_typescript5.Column)({
|
|
423
538
|
field: "meta_keyword",
|
|
424
539
|
allowNull: true,
|
|
425
|
-
type:
|
|
540
|
+
type: import_sequelize_typescript5.DataType.STRING(255)
|
|
426
541
|
})
|
|
427
542
|
], mdContent.prototype, "metaKeyword", 2);
|
|
428
543
|
__decorateClass([
|
|
429
|
-
(0,
|
|
544
|
+
(0, import_sequelize_typescript5.Column)({
|
|
430
545
|
field: "meta_description",
|
|
431
546
|
allowNull: true,
|
|
432
|
-
type:
|
|
547
|
+
type: import_sequelize_typescript5.DataType.STRING(255)
|
|
433
548
|
})
|
|
434
549
|
], mdContent.prototype, "metaDescription", 2);
|
|
435
550
|
__decorateClass([
|
|
436
|
-
(0,
|
|
551
|
+
(0, import_sequelize_typescript5.Column)({
|
|
437
552
|
field: "image_cover",
|
|
438
553
|
allowNull: true,
|
|
439
|
-
type:
|
|
554
|
+
type: import_sequelize_typescript5.DataType.STRING(60)
|
|
440
555
|
})
|
|
441
556
|
], mdContent.prototype, "imageCover", 2);
|
|
442
557
|
__decorateClass([
|
|
443
|
-
(0,
|
|
558
|
+
(0, import_sequelize_typescript5.Column)({
|
|
444
559
|
allowNull: true,
|
|
445
|
-
type:
|
|
560
|
+
type: import_sequelize_typescript5.DataType.STRING(60)
|
|
446
561
|
})
|
|
447
562
|
], mdContent.prototype, "video", 2);
|
|
448
563
|
__decorateClass([
|
|
449
|
-
(0,
|
|
564
|
+
(0, import_sequelize_typescript5.Column)({
|
|
450
565
|
field: "image_gallery",
|
|
451
566
|
allowNull: true,
|
|
452
|
-
type:
|
|
567
|
+
type: import_sequelize_typescript5.DataType.JSON
|
|
453
568
|
})
|
|
454
569
|
], mdContent.prototype, "imageGallery", 2);
|
|
455
570
|
__decorateClass([
|
|
456
|
-
(0,
|
|
571
|
+
(0, import_sequelize_typescript5.Column)({
|
|
457
572
|
allowNull: true,
|
|
458
|
-
type:
|
|
573
|
+
type: import_sequelize_typescript5.DataType.JSON
|
|
459
574
|
})
|
|
460
575
|
], mdContent.prototype, "attachments", 2);
|
|
461
576
|
__decorateClass([
|
|
462
|
-
(0,
|
|
577
|
+
(0, import_sequelize_typescript5.Column)({
|
|
463
578
|
allowNull: true,
|
|
464
|
-
type:
|
|
579
|
+
type: import_sequelize_typescript5.DataType.INTEGER
|
|
465
580
|
})
|
|
466
581
|
], mdContent.prototype, "sort", 2);
|
|
467
582
|
__decorateClass([
|
|
468
|
-
(0,
|
|
583
|
+
(0, import_sequelize_typescript5.Column)({
|
|
469
584
|
allowNull: true,
|
|
470
|
-
type:
|
|
585
|
+
type: import_sequelize_typescript5.DataType.INTEGER
|
|
471
586
|
})
|
|
472
587
|
], mdContent.prototype, "publish", 2);
|
|
473
588
|
__decorateClass([
|
|
474
|
-
(0,
|
|
589
|
+
(0, import_sequelize_typescript5.Column)({
|
|
475
590
|
allowNull: true,
|
|
476
|
-
type:
|
|
591
|
+
type: import_sequelize_typescript5.DataType.INTEGER
|
|
477
592
|
})
|
|
478
593
|
], mdContent.prototype, "status", 2);
|
|
479
594
|
__decorateClass([
|
|
480
|
-
(0,
|
|
595
|
+
(0, import_sequelize_typescript5.Column)({
|
|
481
596
|
field: "has_expire",
|
|
482
597
|
allowNull: true,
|
|
483
|
-
type:
|
|
598
|
+
type: import_sequelize_typescript5.DataType.INTEGER
|
|
484
599
|
})
|
|
485
600
|
], mdContent.prototype, "hasExpire", 2);
|
|
486
601
|
__decorateClass([
|
|
487
|
-
(0,
|
|
602
|
+
(0, import_sequelize_typescript5.Column)({
|
|
488
603
|
field: "start_date",
|
|
489
604
|
allowNull: true,
|
|
490
|
-
type:
|
|
605
|
+
type: import_sequelize_typescript5.DataType.DATE
|
|
491
606
|
})
|
|
492
607
|
], mdContent.prototype, "startDate", 2);
|
|
493
608
|
__decorateClass([
|
|
494
|
-
(0,
|
|
609
|
+
(0, import_sequelize_typescript5.Column)({
|
|
495
610
|
field: "expire_date",
|
|
496
611
|
allowNull: true,
|
|
497
|
-
type:
|
|
612
|
+
type: import_sequelize_typescript5.DataType.DATE
|
|
498
613
|
})
|
|
499
614
|
], mdContent.prototype, "expireDate", 2);
|
|
500
615
|
__decorateClass([
|
|
501
|
-
(0,
|
|
616
|
+
(0, import_sequelize_typescript5.Column)({
|
|
502
617
|
field: "created_by",
|
|
503
618
|
allowNull: true,
|
|
504
|
-
type:
|
|
619
|
+
type: import_sequelize_typescript5.DataType.STRING(60)
|
|
505
620
|
})
|
|
506
621
|
], mdContent.prototype, "createdBy", 2);
|
|
507
622
|
__decorateClass([
|
|
508
|
-
(0,
|
|
623
|
+
(0, import_sequelize_typescript5.Column)({
|
|
509
624
|
field: "created_date",
|
|
510
625
|
allowNull: true,
|
|
511
|
-
type:
|
|
626
|
+
type: import_sequelize_typescript5.DataType.DATE
|
|
512
627
|
})
|
|
513
628
|
], mdContent.prototype, "createdDate", 2);
|
|
514
629
|
__decorateClass([
|
|
515
|
-
(0,
|
|
630
|
+
(0, import_sequelize_typescript5.Column)({
|
|
516
631
|
field: "updated_by",
|
|
517
632
|
allowNull: true,
|
|
518
|
-
type:
|
|
633
|
+
type: import_sequelize_typescript5.DataType.STRING(60)
|
|
519
634
|
})
|
|
520
635
|
], mdContent.prototype, "updatedBy", 2);
|
|
521
636
|
__decorateClass([
|
|
522
|
-
(0,
|
|
637
|
+
(0, import_sequelize_typescript5.Column)({
|
|
523
638
|
field: "updated_date",
|
|
524
639
|
allowNull: true,
|
|
525
|
-
type:
|
|
640
|
+
type: import_sequelize_typescript5.DataType.DATE
|
|
526
641
|
})
|
|
527
642
|
], mdContent.prototype, "updatedDate", 2);
|
|
528
643
|
__decorateClass([
|
|
529
|
-
(0,
|
|
644
|
+
(0, import_sequelize_typescript5.BelongsTo)(() => users)
|
|
530
645
|
], mdContent.prototype, "user", 2);
|
|
531
646
|
__decorateClass([
|
|
532
|
-
(0,
|
|
647
|
+
(0, import_sequelize_typescript5.BelongsTo)(() => mdContentGroup)
|
|
533
648
|
], mdContent.prototype, "mdContentGroup", 2);
|
|
534
649
|
mdContent = __decorateClass([
|
|
535
|
-
(0,
|
|
650
|
+
(0, import_sequelize_typescript5.Table)({
|
|
536
651
|
tableName: "md_content",
|
|
537
652
|
timestamps: false
|
|
538
653
|
})
|
|
539
654
|
], mdContent);
|
|
540
655
|
|
|
541
656
|
// src/databases/tables/mdQuestionnaire.ts
|
|
542
|
-
var
|
|
543
|
-
var mdQuestionnaire = class extends
|
|
657
|
+
var import_sequelize_typescript6 = require("sequelize-typescript");
|
|
658
|
+
var mdQuestionnaire = class extends import_sequelize_typescript6.Model {
|
|
544
659
|
};
|
|
545
660
|
__decorateClass([
|
|
546
|
-
(0,
|
|
661
|
+
(0, import_sequelize_typescript6.Column)({
|
|
547
662
|
primaryKey: true,
|
|
548
663
|
autoIncrement: true,
|
|
549
|
-
type:
|
|
664
|
+
type: import_sequelize_typescript6.DataType.INTEGER
|
|
550
665
|
})
|
|
551
666
|
], mdQuestionnaire.prototype, "id", 2);
|
|
552
667
|
__decorateClass([
|
|
553
|
-
(0,
|
|
668
|
+
(0, import_sequelize_typescript6.Column)({
|
|
554
669
|
allowNull: true,
|
|
555
|
-
type:
|
|
670
|
+
type: import_sequelize_typescript6.DataType.STRING(60)
|
|
556
671
|
})
|
|
557
672
|
], mdQuestionnaire.prototype, "uuid", 2);
|
|
558
673
|
__decorateClass([
|
|
559
|
-
(0,
|
|
674
|
+
(0, import_sequelize_typescript6.Column)({
|
|
560
675
|
field: "key_name",
|
|
561
676
|
allowNull: true,
|
|
562
|
-
type:
|
|
677
|
+
type: import_sequelize_typescript6.DataType.STRING(100)
|
|
563
678
|
})
|
|
564
679
|
], mdQuestionnaire.prototype, "keyName", 2);
|
|
565
680
|
__decorateClass([
|
|
566
|
-
(0,
|
|
567
|
-
(0,
|
|
681
|
+
(0, import_sequelize_typescript6.ForeignKey)(() => users),
|
|
682
|
+
(0, import_sequelize_typescript6.Column)({
|
|
568
683
|
field: "user_id",
|
|
569
684
|
allowNull: true,
|
|
570
|
-
type:
|
|
685
|
+
type: import_sequelize_typescript6.DataType.INTEGER
|
|
571
686
|
})
|
|
572
687
|
], mdQuestionnaire.prototype, "userId", 2);
|
|
573
688
|
__decorateClass([
|
|
574
|
-
(0,
|
|
689
|
+
(0, import_sequelize_typescript6.Column)({
|
|
575
690
|
allowNull: true,
|
|
576
|
-
type:
|
|
691
|
+
type: import_sequelize_typescript6.DataType.STRING(255)
|
|
577
692
|
})
|
|
578
693
|
], mdQuestionnaire.prototype, "title", 2);
|
|
579
694
|
__decorateClass([
|
|
580
|
-
(0,
|
|
695
|
+
(0, import_sequelize_typescript6.Column)({
|
|
581
696
|
allowNull: true,
|
|
582
|
-
type:
|
|
697
|
+
type: import_sequelize_typescript6.DataType.STRING
|
|
583
698
|
})
|
|
584
699
|
], mdQuestionnaire.prototype, "description", 2);
|
|
585
700
|
__decorateClass([
|
|
586
|
-
(0,
|
|
701
|
+
(0, import_sequelize_typescript6.Column)({
|
|
587
702
|
allowNull: true,
|
|
588
|
-
type:
|
|
703
|
+
type: import_sequelize_typescript6.DataType.JSON
|
|
589
704
|
})
|
|
590
705
|
], mdQuestionnaire.prototype, "forms", 2);
|
|
591
706
|
__decorateClass([
|
|
592
|
-
(0,
|
|
707
|
+
(0, import_sequelize_typescript6.Column)({
|
|
593
708
|
field: "confirm_message",
|
|
594
709
|
allowNull: true,
|
|
595
|
-
type:
|
|
710
|
+
type: import_sequelize_typescript6.DataType.STRING(255)
|
|
596
711
|
})
|
|
597
712
|
], mdQuestionnaire.prototype, "confirmMessage", 2);
|
|
598
713
|
__decorateClass([
|
|
599
|
-
(0,
|
|
714
|
+
(0, import_sequelize_typescript6.Column)({
|
|
600
715
|
allowNull: true,
|
|
601
|
-
type:
|
|
716
|
+
type: import_sequelize_typescript6.DataType.STRING(60)
|
|
602
717
|
})
|
|
603
718
|
], mdQuestionnaire.prototype, "submitter", 2);
|
|
604
719
|
__decorateClass([
|
|
605
|
-
(0,
|
|
720
|
+
(0, import_sequelize_typescript6.Column)({
|
|
606
721
|
allowNull: true,
|
|
607
|
-
type:
|
|
722
|
+
type: import_sequelize_typescript6.DataType.INTEGER
|
|
608
723
|
})
|
|
609
724
|
], mdQuestionnaire.prototype, "sort", 2);
|
|
610
725
|
__decorateClass([
|
|
611
|
-
(0,
|
|
726
|
+
(0, import_sequelize_typescript6.Column)({
|
|
612
727
|
allowNull: true,
|
|
613
|
-
type:
|
|
728
|
+
type: import_sequelize_typescript6.DataType.INTEGER
|
|
614
729
|
})
|
|
615
730
|
], mdQuestionnaire.prototype, "status", 2);
|
|
616
731
|
__decorateClass([
|
|
617
|
-
(0,
|
|
732
|
+
(0, import_sequelize_typescript6.Column)({
|
|
618
733
|
field: "has_expire",
|
|
619
734
|
allowNull: true,
|
|
620
|
-
type:
|
|
735
|
+
type: import_sequelize_typescript6.DataType.INTEGER
|
|
621
736
|
})
|
|
622
737
|
], mdQuestionnaire.prototype, "hasExpire", 2);
|
|
623
738
|
__decorateClass([
|
|
624
|
-
(0,
|
|
739
|
+
(0, import_sequelize_typescript6.Column)({
|
|
625
740
|
field: "start_date",
|
|
626
741
|
allowNull: true,
|
|
627
|
-
type:
|
|
742
|
+
type: import_sequelize_typescript6.DataType.DATE
|
|
628
743
|
})
|
|
629
744
|
], mdQuestionnaire.prototype, "startDate", 2);
|
|
630
745
|
__decorateClass([
|
|
631
|
-
(0,
|
|
746
|
+
(0, import_sequelize_typescript6.Column)({
|
|
632
747
|
field: "expire_date",
|
|
633
748
|
allowNull: true,
|
|
634
|
-
type:
|
|
749
|
+
type: import_sequelize_typescript6.DataType.DATE
|
|
635
750
|
})
|
|
636
751
|
], mdQuestionnaire.prototype, "expireDate", 2);
|
|
637
752
|
__decorateClass([
|
|
638
|
-
(0,
|
|
753
|
+
(0, import_sequelize_typescript6.Column)({
|
|
639
754
|
field: "created_by",
|
|
640
755
|
allowNull: true,
|
|
641
|
-
type:
|
|
756
|
+
type: import_sequelize_typescript6.DataType.STRING(60)
|
|
642
757
|
})
|
|
643
758
|
], mdQuestionnaire.prototype, "createdBy", 2);
|
|
644
759
|
__decorateClass([
|
|
645
|
-
(0,
|
|
760
|
+
(0, import_sequelize_typescript6.Column)({
|
|
646
761
|
field: "created_date",
|
|
647
762
|
allowNull: true,
|
|
648
|
-
type:
|
|
763
|
+
type: import_sequelize_typescript6.DataType.DATE
|
|
649
764
|
})
|
|
650
765
|
], mdQuestionnaire.prototype, "createdDate", 2);
|
|
651
766
|
__decorateClass([
|
|
652
|
-
(0,
|
|
767
|
+
(0, import_sequelize_typescript6.Column)({
|
|
653
768
|
field: "updated_by",
|
|
654
769
|
allowNull: true,
|
|
655
|
-
type:
|
|
770
|
+
type: import_sequelize_typescript6.DataType.STRING(60)
|
|
656
771
|
})
|
|
657
772
|
], mdQuestionnaire.prototype, "updatedBy", 2);
|
|
658
773
|
__decorateClass([
|
|
659
|
-
(0,
|
|
774
|
+
(0, import_sequelize_typescript6.Column)({
|
|
660
775
|
field: "updated_date",
|
|
661
776
|
allowNull: true,
|
|
662
|
-
type:
|
|
777
|
+
type: import_sequelize_typescript6.DataType.DATE
|
|
663
778
|
})
|
|
664
779
|
], mdQuestionnaire.prototype, "updatedDate", 2);
|
|
665
780
|
__decorateClass([
|
|
666
|
-
(0,
|
|
781
|
+
(0, import_sequelize_typescript6.BelongsTo)(() => users)
|
|
667
782
|
], mdQuestionnaire.prototype, "user", 2);
|
|
668
783
|
mdQuestionnaire = __decorateClass([
|
|
669
|
-
(0,
|
|
784
|
+
(0, import_sequelize_typescript6.Table)({
|
|
670
785
|
tableName: "md_questionnaire",
|
|
671
786
|
timestamps: false
|
|
672
787
|
})
|
|
673
788
|
], mdQuestionnaire);
|
|
674
789
|
|
|
675
790
|
// src/databases/tables/usersVerify.ts
|
|
676
|
-
var
|
|
677
|
-
var usersVerify = class extends
|
|
791
|
+
var import_sequelize_typescript7 = require("sequelize-typescript");
|
|
792
|
+
var usersVerify = class extends import_sequelize_typescript7.Model {
|
|
678
793
|
};
|
|
679
794
|
__decorateClass([
|
|
680
|
-
(0,
|
|
795
|
+
(0, import_sequelize_typescript7.Column)({
|
|
681
796
|
primaryKey: true,
|
|
682
797
|
autoIncrement: true,
|
|
683
|
-
type:
|
|
798
|
+
type: import_sequelize_typescript7.DataType.INTEGER
|
|
684
799
|
})
|
|
685
800
|
], usersVerify.prototype, "id", 2);
|
|
686
801
|
__decorateClass([
|
|
687
|
-
(0,
|
|
688
|
-
(0,
|
|
802
|
+
(0, import_sequelize_typescript7.ForeignKey)(() => users),
|
|
803
|
+
(0, import_sequelize_typescript7.Column)({
|
|
689
804
|
field: "user_id",
|
|
690
805
|
allowNull: true,
|
|
691
|
-
type:
|
|
806
|
+
type: import_sequelize_typescript7.DataType.INTEGER
|
|
692
807
|
})
|
|
693
808
|
], usersVerify.prototype, "userId", 2);
|
|
694
809
|
__decorateClass([
|
|
695
|
-
(0,
|
|
810
|
+
(0, import_sequelize_typescript7.Column)({
|
|
696
811
|
allowNull: true,
|
|
697
|
-
type:
|
|
812
|
+
type: import_sequelize_typescript7.DataType.INTEGER,
|
|
698
813
|
comment: "0 = email",
|
|
699
814
|
defaultValue: "0"
|
|
700
815
|
})
|
|
701
816
|
], usersVerify.prototype, "type", 2);
|
|
702
817
|
__decorateClass([
|
|
703
|
-
(0,
|
|
818
|
+
(0, import_sequelize_typescript7.Column)({
|
|
704
819
|
allowNull: true,
|
|
705
|
-
type:
|
|
820
|
+
type: import_sequelize_typescript7.DataType.STRING(50)
|
|
706
821
|
})
|
|
707
822
|
], usersVerify.prototype, "code", 2);
|
|
708
823
|
__decorateClass([
|
|
709
|
-
(0,
|
|
824
|
+
(0, import_sequelize_typescript7.Column)({
|
|
710
825
|
allowNull: true,
|
|
711
|
-
type:
|
|
826
|
+
type: import_sequelize_typescript7.DataType.STRING(50)
|
|
712
827
|
})
|
|
713
828
|
], usersVerify.prototype, "reference", 2);
|
|
714
829
|
__decorateClass([
|
|
715
|
-
(0,
|
|
830
|
+
(0, import_sequelize_typescript7.Column)({
|
|
716
831
|
allowNull: true,
|
|
717
|
-
type:
|
|
832
|
+
type: import_sequelize_typescript7.DataType.INTEGER,
|
|
718
833
|
comment: "0 = wait, 1 = verified",
|
|
719
834
|
defaultValue: "0"
|
|
720
835
|
})
|
|
721
836
|
], usersVerify.prototype, "status", 2);
|
|
722
837
|
__decorateClass([
|
|
723
|
-
(0,
|
|
838
|
+
(0, import_sequelize_typescript7.Column)({
|
|
724
839
|
field: "created_date",
|
|
725
840
|
allowNull: true,
|
|
726
|
-
type:
|
|
841
|
+
type: import_sequelize_typescript7.DataType.DATE
|
|
727
842
|
})
|
|
728
843
|
], usersVerify.prototype, "createdDate", 2);
|
|
729
844
|
__decorateClass([
|
|
730
|
-
(0,
|
|
845
|
+
(0, import_sequelize_typescript7.BelongsTo)(() => users)
|
|
731
846
|
], usersVerify.prototype, "user", 2);
|
|
732
847
|
usersVerify = __decorateClass([
|
|
733
|
-
(0,
|
|
848
|
+
(0, import_sequelize_typescript7.Table)({
|
|
734
849
|
tableName: "users_verify",
|
|
735
850
|
timestamps: false
|
|
736
851
|
})
|
|
737
852
|
], usersVerify);
|
|
738
853
|
|
|
739
854
|
// src/databases/tables/users.ts
|
|
740
|
-
var users = class extends
|
|
855
|
+
var users = class extends import_sequelize_typescript8.Model {
|
|
741
856
|
};
|
|
742
857
|
__decorateClass([
|
|
743
|
-
(0,
|
|
858
|
+
(0, import_sequelize_typescript8.Column)({
|
|
744
859
|
primaryKey: true,
|
|
745
860
|
autoIncrement: true,
|
|
746
|
-
type:
|
|
861
|
+
type: import_sequelize_typescript8.DataType.INTEGER
|
|
747
862
|
})
|
|
748
863
|
], users.prototype, "id", 2);
|
|
749
864
|
__decorateClass([
|
|
750
|
-
(0,
|
|
751
|
-
type:
|
|
865
|
+
(0, import_sequelize_typescript8.Column)({
|
|
866
|
+
type: import_sequelize_typescript8.DataType.STRING(60)
|
|
752
867
|
})
|
|
753
868
|
], users.prototype, "uuid", 2);
|
|
754
869
|
__decorateClass([
|
|
755
|
-
(0,
|
|
756
|
-
type:
|
|
870
|
+
(0, import_sequelize_typescript8.Column)({
|
|
871
|
+
type: import_sequelize_typescript8.DataType.STRING(100)
|
|
757
872
|
})
|
|
758
873
|
], users.prototype, "username", 2);
|
|
759
874
|
__decorateClass([
|
|
760
|
-
(0,
|
|
875
|
+
(0, import_sequelize_typescript8.Column)({
|
|
761
876
|
field: "password_hash",
|
|
762
877
|
allowNull: true,
|
|
763
|
-
type:
|
|
878
|
+
type: import_sequelize_typescript8.DataType.STRING(255)
|
|
764
879
|
})
|
|
765
880
|
], users.prototype, "passwordHash", 2);
|
|
766
881
|
__decorateClass([
|
|
767
|
-
(0,
|
|
882
|
+
(0, import_sequelize_typescript8.Column)({
|
|
768
883
|
field: "password_reset_token",
|
|
769
884
|
allowNull: true,
|
|
770
|
-
type:
|
|
885
|
+
type: import_sequelize_typescript8.DataType.STRING(255)
|
|
771
886
|
})
|
|
772
887
|
], users.prototype, "passwordResetToken", 2);
|
|
773
888
|
__decorateClass([
|
|
774
|
-
(0,
|
|
889
|
+
(0, import_sequelize_typescript8.Column)({
|
|
775
890
|
field: "verification_token",
|
|
776
891
|
allowNull: true,
|
|
777
|
-
type:
|
|
892
|
+
type: import_sequelize_typescript8.DataType.STRING(255)
|
|
778
893
|
})
|
|
779
894
|
], users.prototype, "verificationToken", 2);
|
|
780
895
|
__decorateClass([
|
|
781
|
-
(0,
|
|
896
|
+
(0, import_sequelize_typescript8.Column)({
|
|
782
897
|
allowNull: true,
|
|
783
|
-
type:
|
|
898
|
+
type: import_sequelize_typescript8.DataType.STRING(255)
|
|
784
899
|
})
|
|
785
900
|
], users.prototype, "email", 2);
|
|
786
901
|
__decorateClass([
|
|
787
|
-
(0,
|
|
902
|
+
(0, import_sequelize_typescript8.Column)({
|
|
788
903
|
field: "auth_key",
|
|
789
904
|
allowNull: true,
|
|
790
|
-
type:
|
|
905
|
+
type: import_sequelize_typescript8.DataType.STRING(32)
|
|
791
906
|
})
|
|
792
907
|
], users.prototype, "authKey", 2);
|
|
793
908
|
__decorateClass([
|
|
794
|
-
(0,
|
|
909
|
+
(0, import_sequelize_typescript8.Column)({
|
|
795
910
|
field: "secret_key",
|
|
796
911
|
allowNull: true,
|
|
797
|
-
type:
|
|
912
|
+
type: import_sequelize_typescript8.DataType.STRING(255)
|
|
798
913
|
})
|
|
799
914
|
], users.prototype, "secretKey", 2);
|
|
800
915
|
__decorateClass([
|
|
801
|
-
(0,
|
|
916
|
+
(0, import_sequelize_typescript8.Column)({
|
|
802
917
|
field: "access_token",
|
|
803
918
|
allowNull: true,
|
|
804
|
-
type:
|
|
919
|
+
type: import_sequelize_typescript8.DataType.STRING
|
|
805
920
|
})
|
|
806
921
|
], users.prototype, "accessToken", 2);
|
|
807
922
|
__decorateClass([
|
|
808
|
-
(0,
|
|
923
|
+
(0, import_sequelize_typescript8.Column)({
|
|
809
924
|
field: "user_level",
|
|
810
925
|
allowNull: true,
|
|
811
|
-
type:
|
|
926
|
+
type: import_sequelize_typescript8.DataType.INTEGER
|
|
812
927
|
})
|
|
813
928
|
], users.prototype, "userLevel", 2);
|
|
814
929
|
__decorateClass([
|
|
815
|
-
(0,
|
|
930
|
+
(0, import_sequelize_typescript8.Column)({
|
|
816
931
|
field: "user_authen",
|
|
817
932
|
allowNull: true,
|
|
818
|
-
type:
|
|
933
|
+
type: import_sequelize_typescript8.DataType.STRING(64)
|
|
819
934
|
})
|
|
820
935
|
], users.prototype, "userAuthen", 2);
|
|
821
936
|
__decorateClass([
|
|
822
|
-
(0,
|
|
937
|
+
(0, import_sequelize_typescript8.Column)({
|
|
823
938
|
field: "user_type",
|
|
824
939
|
allowNull: true,
|
|
825
|
-
type:
|
|
940
|
+
type: import_sequelize_typescript8.DataType.INTEGER
|
|
826
941
|
})
|
|
827
942
|
], users.prototype, "userType", 2);
|
|
828
943
|
__decorateClass([
|
|
829
|
-
(0,
|
|
944
|
+
(0, import_sequelize_typescript8.Column)({
|
|
830
945
|
allowNull: true,
|
|
831
|
-
type:
|
|
946
|
+
type: import_sequelize_typescript8.DataType.STRING(10)
|
|
832
947
|
})
|
|
833
948
|
], users.prototype, "prefix", 2);
|
|
834
949
|
__decorateClass([
|
|
835
|
-
(0,
|
|
950
|
+
(0, import_sequelize_typescript8.Column)({
|
|
836
951
|
field: "first_name",
|
|
837
952
|
allowNull: true,
|
|
838
|
-
type:
|
|
953
|
+
type: import_sequelize_typescript8.DataType.STRING(100)
|
|
839
954
|
})
|
|
840
955
|
], users.prototype, "firstName", 2);
|
|
841
956
|
__decorateClass([
|
|
842
|
-
(0,
|
|
957
|
+
(0, import_sequelize_typescript8.Column)({
|
|
843
958
|
field: "last_name",
|
|
844
959
|
allowNull: true,
|
|
845
|
-
type:
|
|
960
|
+
type: import_sequelize_typescript8.DataType.STRING(100)
|
|
846
961
|
})
|
|
847
962
|
], users.prototype, "lastName", 2);
|
|
848
963
|
__decorateClass([
|
|
849
|
-
(0,
|
|
964
|
+
(0, import_sequelize_typescript8.Column)({
|
|
850
965
|
allowNull: true,
|
|
851
|
-
type:
|
|
966
|
+
type: import_sequelize_typescript8.DataType.STRING(20)
|
|
852
967
|
})
|
|
853
968
|
], users.prototype, "phone", 2);
|
|
854
969
|
__decorateClass([
|
|
855
|
-
(0,
|
|
970
|
+
(0, import_sequelize_typescript8.Column)({
|
|
856
971
|
allowNull: true,
|
|
857
|
-
type:
|
|
972
|
+
type: import_sequelize_typescript8.DataType.SMALLINT
|
|
858
973
|
})
|
|
859
974
|
], users.prototype, "status", 2);
|
|
860
975
|
__decorateClass([
|
|
861
|
-
(0,
|
|
976
|
+
(0, import_sequelize_typescript8.Column)({
|
|
862
977
|
allowNull: true,
|
|
863
|
-
type:
|
|
978
|
+
type: import_sequelize_typescript8.DataType.INTEGER
|
|
864
979
|
})
|
|
865
980
|
], users.prototype, "is_2fa", 2);
|
|
866
981
|
__decorateClass([
|
|
867
|
-
(0,
|
|
982
|
+
(0, import_sequelize_typescript8.Column)({
|
|
868
983
|
field: "created_by",
|
|
869
984
|
allowNull: true,
|
|
870
|
-
type:
|
|
985
|
+
type: import_sequelize_typescript8.DataType.STRING(60)
|
|
871
986
|
})
|
|
872
987
|
], users.prototype, "createdBy", 2);
|
|
873
988
|
__decorateClass([
|
|
874
|
-
(0,
|
|
989
|
+
(0, import_sequelize_typescript8.Column)({
|
|
875
990
|
field: "created_date",
|
|
876
991
|
allowNull: true,
|
|
877
|
-
type:
|
|
992
|
+
type: import_sequelize_typescript8.DataType.DATE
|
|
878
993
|
})
|
|
879
994
|
], users.prototype, "createdDate", 2);
|
|
880
995
|
__decorateClass([
|
|
881
|
-
(0,
|
|
996
|
+
(0, import_sequelize_typescript8.Column)({
|
|
882
997
|
field: "updated_by",
|
|
883
998
|
allowNull: true,
|
|
884
|
-
type:
|
|
999
|
+
type: import_sequelize_typescript8.DataType.STRING(60)
|
|
885
1000
|
})
|
|
886
1001
|
], users.prototype, "updatedBy", 2);
|
|
887
1002
|
__decorateClass([
|
|
888
|
-
(0,
|
|
1003
|
+
(0, import_sequelize_typescript8.Column)({
|
|
889
1004
|
field: "updated_date",
|
|
890
1005
|
allowNull: true,
|
|
891
|
-
type:
|
|
1006
|
+
type: import_sequelize_typescript8.DataType.DATE
|
|
892
1007
|
})
|
|
893
1008
|
], users.prototype, "updatedDate", 2);
|
|
894
1009
|
__decorateClass([
|
|
895
|
-
(0,
|
|
1010
|
+
(0, import_sequelize_typescript8.Column)({
|
|
896
1011
|
allowNull: true,
|
|
897
|
-
type:
|
|
1012
|
+
type: import_sequelize_typescript8.DataType.STRING(255)
|
|
898
1013
|
})
|
|
899
1014
|
], users.prototype, "address", 2);
|
|
900
1015
|
__decorateClass([
|
|
901
|
-
(0,
|
|
1016
|
+
(0, import_sequelize_typescript8.Column)({
|
|
902
1017
|
allowNull: true,
|
|
903
|
-
type:
|
|
1018
|
+
type: import_sequelize_typescript8.DataType.STRING(255)
|
|
904
1019
|
})
|
|
905
1020
|
], users.prototype, "other", 2);
|
|
906
1021
|
__decorateClass([
|
|
907
|
-
(0,
|
|
1022
|
+
(0, import_sequelize_typescript8.Column)({
|
|
908
1023
|
field: "is_email_verified",
|
|
909
1024
|
allowNull: true,
|
|
910
|
-
type:
|
|
1025
|
+
type: import_sequelize_typescript8.DataType.INTEGER
|
|
911
1026
|
})
|
|
912
1027
|
], users.prototype, "isEmailVerified", 2);
|
|
913
1028
|
__decorateClass([
|
|
914
|
-
(0,
|
|
1029
|
+
(0, import_sequelize_typescript8.Column)({
|
|
915
1030
|
field: "photo_uuid",
|
|
916
1031
|
allowNull: true,
|
|
917
|
-
type:
|
|
1032
|
+
type: import_sequelize_typescript8.DataType.STRING(60)
|
|
918
1033
|
})
|
|
919
1034
|
], users.prototype, "photoUuid", 2);
|
|
920
1035
|
__decorateClass([
|
|
921
|
-
(0,
|
|
1036
|
+
(0, import_sequelize_typescript8.HasMany)(() => authAssignment, {
|
|
922
1037
|
sourceKey: "id"
|
|
923
1038
|
})
|
|
924
1039
|
], users.prototype, "authAssignments", 2);
|
|
925
1040
|
__decorateClass([
|
|
926
|
-
(0,
|
|
1041
|
+
(0, import_sequelize_typescript8.HasMany)(() => mdContent, {
|
|
927
1042
|
sourceKey: "id"
|
|
928
1043
|
})
|
|
929
1044
|
], users.prototype, "mdContents", 2);
|
|
930
1045
|
__decorateClass([
|
|
931
|
-
(0,
|
|
1046
|
+
(0, import_sequelize_typescript8.HasMany)(() => mdQuestionnaire, {
|
|
932
1047
|
sourceKey: "id"
|
|
933
1048
|
})
|
|
934
1049
|
], users.prototype, "mdQuestionnaires", 2);
|
|
935
1050
|
__decorateClass([
|
|
936
|
-
(0,
|
|
1051
|
+
(0, import_sequelize_typescript8.HasMany)(() => usersVerify, {
|
|
937
1052
|
sourceKey: "id"
|
|
938
1053
|
})
|
|
939
1054
|
], users.prototype, "usersVerifies", 2);
|
|
940
1055
|
users = __decorateClass([
|
|
941
|
-
(0,
|
|
1056
|
+
(0, import_sequelize_typescript8.Table)({
|
|
942
1057
|
tableName: "users",
|
|
943
1058
|
timestamps: false
|
|
944
1059
|
})
|
|
945
1060
|
], users);
|
|
946
1061
|
|
|
947
1062
|
// src/databases/tables/authRole.ts
|
|
948
|
-
var
|
|
1063
|
+
var import_sequelize_typescript10 = require("sequelize-typescript");
|
|
949
1064
|
|
|
950
1065
|
// src/databases/tables/authRoleChild.ts
|
|
951
|
-
var
|
|
952
|
-
var authRoleChild = class extends
|
|
1066
|
+
var import_sequelize_typescript9 = require("sequelize-typescript");
|
|
1067
|
+
var authRoleChild = class extends import_sequelize_typescript9.Model {
|
|
953
1068
|
};
|
|
954
1069
|
__decorateClass([
|
|
955
|
-
(0,
|
|
956
|
-
(0,
|
|
1070
|
+
(0, import_sequelize_typescript9.ForeignKey)(() => authRole),
|
|
1071
|
+
(0, import_sequelize_typescript9.Column)({
|
|
957
1072
|
field: "role_id",
|
|
958
1073
|
primaryKey: true,
|
|
959
|
-
type:
|
|
1074
|
+
type: import_sequelize_typescript9.DataType.INTEGER
|
|
960
1075
|
})
|
|
961
1076
|
], authRoleChild.prototype, "roleId", 2);
|
|
962
1077
|
__decorateClass([
|
|
963
|
-
(0,
|
|
1078
|
+
(0, import_sequelize_typescript9.Column)({
|
|
964
1079
|
field: "key_name",
|
|
965
1080
|
primaryKey: true,
|
|
966
|
-
type:
|
|
1081
|
+
type: import_sequelize_typescript9.DataType.STRING(255)
|
|
967
1082
|
})
|
|
968
1083
|
], authRoleChild.prototype, "keyName", 2);
|
|
969
1084
|
__decorateClass([
|
|
970
|
-
(0,
|
|
1085
|
+
(0, import_sequelize_typescript9.Column)({
|
|
971
1086
|
allowNull: true,
|
|
972
|
-
type:
|
|
1087
|
+
type: import_sequelize_typescript9.DataType.JSON
|
|
973
1088
|
})
|
|
974
1089
|
], authRoleChild.prototype, "permission", 2);
|
|
975
1090
|
__decorateClass([
|
|
976
|
-
(0,
|
|
1091
|
+
(0, import_sequelize_typescript9.BelongsTo)(() => authRole)
|
|
977
1092
|
], authRoleChild.prototype, "authRole", 2);
|
|
978
1093
|
authRoleChild = __decorateClass([
|
|
979
|
-
(0,
|
|
1094
|
+
(0, import_sequelize_typescript9.Table)({
|
|
980
1095
|
tableName: "auth_role_child",
|
|
981
1096
|
timestamps: false
|
|
982
1097
|
})
|
|
983
1098
|
], authRoleChild);
|
|
984
1099
|
|
|
985
1100
|
// src/databases/tables/authRole.ts
|
|
986
|
-
var authRole = class extends
|
|
1101
|
+
var authRole = class extends import_sequelize_typescript10.Model {
|
|
987
1102
|
};
|
|
988
1103
|
__decorateClass([
|
|
989
|
-
(0,
|
|
1104
|
+
(0, import_sequelize_typescript10.Column)({
|
|
990
1105
|
primaryKey: true,
|
|
991
1106
|
autoIncrement: true,
|
|
992
|
-
type:
|
|
1107
|
+
type: import_sequelize_typescript10.DataType.INTEGER
|
|
993
1108
|
})
|
|
994
1109
|
], authRole.prototype, "id", 2);
|
|
995
1110
|
__decorateClass([
|
|
996
|
-
(0,
|
|
997
|
-
type:
|
|
1111
|
+
(0, import_sequelize_typescript10.Column)({
|
|
1112
|
+
type: import_sequelize_typescript10.DataType.STRING(60)
|
|
998
1113
|
})
|
|
999
1114
|
], authRole.prototype, "uuid", 2);
|
|
1000
1115
|
__decorateClass([
|
|
1001
|
-
(0,
|
|
1002
|
-
type:
|
|
1116
|
+
(0, import_sequelize_typescript10.Column)({
|
|
1117
|
+
type: import_sequelize_typescript10.DataType.STRING(100)
|
|
1003
1118
|
})
|
|
1004
1119
|
], authRole.prototype, "name", 2);
|
|
1005
1120
|
__decorateClass([
|
|
1006
|
-
(0,
|
|
1121
|
+
(0, import_sequelize_typescript10.Column)({
|
|
1007
1122
|
allowNull: true,
|
|
1008
|
-
type:
|
|
1123
|
+
type: import_sequelize_typescript10.DataType.STRING(255)
|
|
1009
1124
|
})
|
|
1010
1125
|
], authRole.prototype, "display", 2);
|
|
1011
1126
|
__decorateClass([
|
|
1012
|
-
(0,
|
|
1127
|
+
(0, import_sequelize_typescript10.Column)({
|
|
1013
1128
|
allowNull: true,
|
|
1014
|
-
type:
|
|
1129
|
+
type: import_sequelize_typescript10.DataType.INTEGER
|
|
1015
1130
|
})
|
|
1016
1131
|
], authRole.prototype, "status", 2);
|
|
1017
1132
|
__decorateClass([
|
|
1018
|
-
(0,
|
|
1133
|
+
(0, import_sequelize_typescript10.Column)({
|
|
1019
1134
|
field: "created_by",
|
|
1020
1135
|
allowNull: true,
|
|
1021
|
-
type:
|
|
1136
|
+
type: import_sequelize_typescript10.DataType.STRING(60)
|
|
1022
1137
|
})
|
|
1023
1138
|
], authRole.prototype, "createdBy", 2);
|
|
1024
1139
|
__decorateClass([
|
|
1025
|
-
(0,
|
|
1140
|
+
(0, import_sequelize_typescript10.Column)({
|
|
1026
1141
|
field: "created_date",
|
|
1027
1142
|
allowNull: true,
|
|
1028
|
-
type:
|
|
1143
|
+
type: import_sequelize_typescript10.DataType.DATE
|
|
1029
1144
|
})
|
|
1030
1145
|
], authRole.prototype, "createdDate", 2);
|
|
1031
1146
|
__decorateClass([
|
|
1032
|
-
(0,
|
|
1147
|
+
(0, import_sequelize_typescript10.Column)({
|
|
1033
1148
|
field: "updated_by",
|
|
1034
1149
|
allowNull: true,
|
|
1035
|
-
type:
|
|
1150
|
+
type: import_sequelize_typescript10.DataType.STRING(60)
|
|
1036
1151
|
})
|
|
1037
1152
|
], authRole.prototype, "updatedBy", 2);
|
|
1038
1153
|
__decorateClass([
|
|
1039
|
-
(0,
|
|
1154
|
+
(0, import_sequelize_typescript10.Column)({
|
|
1040
1155
|
field: "updated_date",
|
|
1041
1156
|
allowNull: true,
|
|
1042
|
-
type:
|
|
1157
|
+
type: import_sequelize_typescript10.DataType.DATE
|
|
1043
1158
|
})
|
|
1044
1159
|
], authRole.prototype, "updatedDate", 2);
|
|
1045
1160
|
__decorateClass([
|
|
1046
|
-
(0,
|
|
1161
|
+
(0, import_sequelize_typescript10.HasMany)(() => authAssignment, {
|
|
1047
1162
|
sourceKey: "id"
|
|
1048
1163
|
})
|
|
1049
1164
|
], authRole.prototype, "authAssignments", 2);
|
|
1050
1165
|
__decorateClass([
|
|
1051
|
-
(0,
|
|
1166
|
+
(0, import_sequelize_typescript10.HasMany)(() => authRoleChild, {
|
|
1052
1167
|
sourceKey: "id"
|
|
1053
1168
|
})
|
|
1054
1169
|
], authRole.prototype, "authRoleChildren", 2);
|
|
1055
1170
|
authRole = __decorateClass([
|
|
1056
|
-
(0,
|
|
1171
|
+
(0, import_sequelize_typescript10.Table)({
|
|
1057
1172
|
tableName: "auth_role",
|
|
1058
1173
|
timestamps: false
|
|
1059
1174
|
})
|
|
1060
1175
|
], authRole);
|
|
1061
1176
|
|
|
1062
1177
|
// src/databases/tables/authAssignment.ts
|
|
1063
|
-
var authAssignment = class extends
|
|
1178
|
+
var authAssignment = class extends import_sequelize_typescript11.Model {
|
|
1064
1179
|
};
|
|
1065
1180
|
__decorateClass([
|
|
1066
|
-
(0,
|
|
1067
|
-
(0,
|
|
1181
|
+
(0, import_sequelize_typescript11.ForeignKey)(() => authRole),
|
|
1182
|
+
(0, import_sequelize_typescript11.Column)({
|
|
1068
1183
|
field: "role_id",
|
|
1069
1184
|
primaryKey: true,
|
|
1070
|
-
type:
|
|
1185
|
+
type: import_sequelize_typescript11.DataType.INTEGER
|
|
1071
1186
|
})
|
|
1072
1187
|
], authAssignment.prototype, "roleId", 2);
|
|
1073
1188
|
__decorateClass([
|
|
1074
|
-
(0,
|
|
1075
|
-
(0,
|
|
1189
|
+
(0, import_sequelize_typescript11.ForeignKey)(() => users),
|
|
1190
|
+
(0, import_sequelize_typescript11.Column)({
|
|
1076
1191
|
field: "user_id",
|
|
1077
1192
|
primaryKey: true,
|
|
1078
|
-
type:
|
|
1193
|
+
type: import_sequelize_typescript11.DataType.INTEGER
|
|
1079
1194
|
})
|
|
1080
1195
|
], authAssignment.prototype, "userId", 2);
|
|
1081
1196
|
__decorateClass([
|
|
1082
|
-
(0,
|
|
1197
|
+
(0, import_sequelize_typescript11.Column)({
|
|
1083
1198
|
field: "created_by",
|
|
1084
1199
|
allowNull: true,
|
|
1085
|
-
type:
|
|
1200
|
+
type: import_sequelize_typescript11.DataType.STRING(60)
|
|
1086
1201
|
})
|
|
1087
1202
|
], authAssignment.prototype, "createdBy", 2);
|
|
1088
1203
|
__decorateClass([
|
|
1089
|
-
(0,
|
|
1204
|
+
(0, import_sequelize_typescript11.Column)({
|
|
1090
1205
|
field: "created_date",
|
|
1091
1206
|
allowNull: true,
|
|
1092
|
-
type:
|
|
1207
|
+
type: import_sequelize_typescript11.DataType.DATE
|
|
1093
1208
|
})
|
|
1094
1209
|
], authAssignment.prototype, "createdDate", 2);
|
|
1095
1210
|
__decorateClass([
|
|
1096
|
-
(0,
|
|
1211
|
+
(0, import_sequelize_typescript11.Column)({
|
|
1097
1212
|
field: "updated_by",
|
|
1098
1213
|
allowNull: true,
|
|
1099
|
-
type:
|
|
1214
|
+
type: import_sequelize_typescript11.DataType.STRING(60)
|
|
1100
1215
|
})
|
|
1101
1216
|
], authAssignment.prototype, "updatedBy", 2);
|
|
1102
1217
|
__decorateClass([
|
|
1103
|
-
(0,
|
|
1218
|
+
(0, import_sequelize_typescript11.Column)({
|
|
1104
1219
|
field: "updated_date",
|
|
1105
1220
|
allowNull: true,
|
|
1106
|
-
type:
|
|
1221
|
+
type: import_sequelize_typescript11.DataType.DATE
|
|
1107
1222
|
})
|
|
1108
1223
|
], authAssignment.prototype, "updatedDate", 2);
|
|
1109
1224
|
__decorateClass([
|
|
1110
|
-
(0,
|
|
1225
|
+
(0, import_sequelize_typescript11.BelongsTo)(() => users)
|
|
1111
1226
|
], authAssignment.prototype, "user", 2);
|
|
1112
1227
|
__decorateClass([
|
|
1113
|
-
(0,
|
|
1228
|
+
(0, import_sequelize_typescript11.BelongsTo)(() => authRole)
|
|
1114
1229
|
], authAssignment.prototype, "authRole", 2);
|
|
1115
1230
|
authAssignment = __decorateClass([
|
|
1116
|
-
(0,
|
|
1231
|
+
(0, import_sequelize_typescript11.Table)({
|
|
1117
1232
|
tableName: "auth_assignment",
|
|
1118
1233
|
timestamps: false
|
|
1119
1234
|
})
|
|
1120
1235
|
], authAssignment);
|
|
1121
1236
|
|
|
1122
1237
|
// src/databases/tables/authItem.ts
|
|
1123
|
-
var
|
|
1238
|
+
var import_sequelize_typescript15 = require("sequelize-typescript");
|
|
1124
1239
|
|
|
1125
1240
|
// src/databases/tables/menu.ts
|
|
1126
|
-
var
|
|
1241
|
+
var import_sequelize_typescript13 = require("sequelize-typescript");
|
|
1127
1242
|
|
|
1128
1243
|
// src/databases/tables/msModule.ts
|
|
1129
|
-
var
|
|
1130
|
-
var msModule = class extends
|
|
1244
|
+
var import_sequelize_typescript12 = require("sequelize-typescript");
|
|
1245
|
+
var msModule = class extends import_sequelize_typescript12.Model {
|
|
1131
1246
|
};
|
|
1132
1247
|
__decorateClass([
|
|
1133
|
-
(0,
|
|
1248
|
+
(0, import_sequelize_typescript12.Column)({
|
|
1134
1249
|
primaryKey: true,
|
|
1135
1250
|
autoIncrement: true,
|
|
1136
|
-
type:
|
|
1251
|
+
type: import_sequelize_typescript12.DataType.INTEGER
|
|
1137
1252
|
})
|
|
1138
1253
|
], msModule.prototype, "id", 2);
|
|
1139
1254
|
__decorateClass([
|
|
1140
|
-
(0,
|
|
1255
|
+
(0, import_sequelize_typescript12.Column)({
|
|
1141
1256
|
allowNull: true,
|
|
1142
|
-
type:
|
|
1257
|
+
type: import_sequelize_typescript12.DataType.STRING(100)
|
|
1143
1258
|
})
|
|
1144
1259
|
], msModule.prototype, "key", 2);
|
|
1145
1260
|
__decorateClass([
|
|
1146
|
-
(0,
|
|
1147
|
-
type:
|
|
1261
|
+
(0, import_sequelize_typescript12.Column)({
|
|
1262
|
+
type: import_sequelize_typescript12.DataType.STRING(100)
|
|
1148
1263
|
})
|
|
1149
1264
|
], msModule.prototype, "name", 2);
|
|
1150
1265
|
__decorateClass([
|
|
1151
|
-
(0,
|
|
1266
|
+
(0, import_sequelize_typescript12.Column)({
|
|
1152
1267
|
allowNull: true,
|
|
1153
|
-
type:
|
|
1268
|
+
type: import_sequelize_typescript12.DataType.STRING(255)
|
|
1154
1269
|
})
|
|
1155
1270
|
], msModule.prototype, "description", 2);
|
|
1156
1271
|
__decorateClass([
|
|
1157
|
-
(0,
|
|
1272
|
+
(0, import_sequelize_typescript12.Column)({
|
|
1158
1273
|
allowNull: true,
|
|
1159
|
-
type:
|
|
1274
|
+
type: import_sequelize_typescript12.DataType.INTEGER
|
|
1160
1275
|
})
|
|
1161
1276
|
], msModule.prototype, "status", 2);
|
|
1162
1277
|
__decorateClass([
|
|
1163
|
-
(0,
|
|
1278
|
+
(0, import_sequelize_typescript12.Column)({
|
|
1164
1279
|
field: "created_by",
|
|
1165
1280
|
allowNull: true,
|
|
1166
|
-
type:
|
|
1281
|
+
type: import_sequelize_typescript12.DataType.STRING(60)
|
|
1167
1282
|
})
|
|
1168
1283
|
], msModule.prototype, "createdBy", 2);
|
|
1169
1284
|
__decorateClass([
|
|
1170
|
-
(0,
|
|
1285
|
+
(0, import_sequelize_typescript12.Column)({
|
|
1171
1286
|
field: "created_date",
|
|
1172
1287
|
allowNull: true,
|
|
1173
|
-
type:
|
|
1288
|
+
type: import_sequelize_typescript12.DataType.DATE
|
|
1174
1289
|
})
|
|
1175
1290
|
], msModule.prototype, "createdDate", 2);
|
|
1176
1291
|
__decorateClass([
|
|
1177
|
-
(0,
|
|
1292
|
+
(0, import_sequelize_typescript12.Column)({
|
|
1178
1293
|
field: "updated_by",
|
|
1179
1294
|
allowNull: true,
|
|
1180
|
-
type:
|
|
1295
|
+
type: import_sequelize_typescript12.DataType.STRING(60)
|
|
1181
1296
|
})
|
|
1182
1297
|
], msModule.prototype, "updatedBy", 2);
|
|
1183
1298
|
__decorateClass([
|
|
1184
|
-
(0,
|
|
1299
|
+
(0, import_sequelize_typescript12.Column)({
|
|
1185
1300
|
field: "updated_date",
|
|
1186
1301
|
allowNull: true,
|
|
1187
|
-
type:
|
|
1302
|
+
type: import_sequelize_typescript12.DataType.DATE
|
|
1188
1303
|
})
|
|
1189
1304
|
], msModule.prototype, "updatedDate", 2);
|
|
1190
1305
|
__decorateClass([
|
|
1191
|
-
(0,
|
|
1306
|
+
(0, import_sequelize_typescript12.HasMany)(() => menu, {
|
|
1192
1307
|
sourceKey: "id"
|
|
1193
1308
|
})
|
|
1194
1309
|
], msModule.prototype, "menus", 2);
|
|
1195
1310
|
msModule = __decorateClass([
|
|
1196
|
-
(0,
|
|
1311
|
+
(0, import_sequelize_typescript12.Table)({
|
|
1197
1312
|
tableName: "ms_module",
|
|
1198
1313
|
timestamps: false
|
|
1199
1314
|
})
|
|
1200
1315
|
], msModule);
|
|
1201
1316
|
|
|
1202
1317
|
// src/databases/tables/menu.ts
|
|
1203
|
-
var menu = class extends
|
|
1318
|
+
var menu = class extends import_sequelize_typescript13.Model {
|
|
1204
1319
|
};
|
|
1205
1320
|
__decorateClass([
|
|
1206
|
-
(0,
|
|
1321
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1207
1322
|
primaryKey: true,
|
|
1208
1323
|
autoIncrement: true,
|
|
1209
|
-
type:
|
|
1324
|
+
type: import_sequelize_typescript13.DataType.INTEGER
|
|
1210
1325
|
})
|
|
1211
1326
|
], menu.prototype, "id", 2);
|
|
1212
1327
|
__decorateClass([
|
|
1213
|
-
(0,
|
|
1214
|
-
type:
|
|
1328
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1329
|
+
type: import_sequelize_typescript13.DataType.STRING(60)
|
|
1215
1330
|
})
|
|
1216
1331
|
], menu.prototype, "uuid", 2);
|
|
1217
1332
|
__decorateClass([
|
|
1218
|
-
(0,
|
|
1219
|
-
(0,
|
|
1333
|
+
(0, import_sequelize_typescript13.ForeignKey)(() => authItem),
|
|
1334
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1220
1335
|
field: "key_name",
|
|
1221
1336
|
allowNull: true,
|
|
1222
|
-
type:
|
|
1337
|
+
type: import_sequelize_typescript13.DataType.STRING(100)
|
|
1223
1338
|
})
|
|
1224
1339
|
], menu.prototype, "keyName", 2);
|
|
1225
1340
|
__decorateClass([
|
|
1226
|
-
(0,
|
|
1341
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1227
1342
|
allowNull: true,
|
|
1228
|
-
type:
|
|
1343
|
+
type: import_sequelize_typescript13.DataType.STRING(255)
|
|
1229
1344
|
})
|
|
1230
1345
|
], menu.prototype, "icon", 2);
|
|
1231
1346
|
__decorateClass([
|
|
1232
|
-
(0,
|
|
1347
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1233
1348
|
allowNull: true,
|
|
1234
|
-
type:
|
|
1349
|
+
type: import_sequelize_typescript13.DataType.STRING(255)
|
|
1235
1350
|
})
|
|
1236
1351
|
], menu.prototype, "display", 2);
|
|
1237
1352
|
__decorateClass([
|
|
1238
|
-
(0,
|
|
1353
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1239
1354
|
allowNull: true,
|
|
1240
|
-
type:
|
|
1355
|
+
type: import_sequelize_typescript13.DataType.STRING(255)
|
|
1241
1356
|
})
|
|
1242
1357
|
], menu.prototype, "description", 2);
|
|
1243
1358
|
__decorateClass([
|
|
1244
|
-
(0,
|
|
1245
|
-
(0,
|
|
1359
|
+
(0, import_sequelize_typescript13.ForeignKey)(() => msModule),
|
|
1360
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1246
1361
|
field: "module_id",
|
|
1247
1362
|
allowNull: true,
|
|
1248
|
-
type:
|
|
1363
|
+
type: import_sequelize_typescript13.DataType.INTEGER
|
|
1249
1364
|
})
|
|
1250
1365
|
], menu.prototype, "moduleId", 2);
|
|
1251
1366
|
__decorateClass([
|
|
1252
|
-
(0,
|
|
1367
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1253
1368
|
allowNull: true,
|
|
1254
|
-
type:
|
|
1369
|
+
type: import_sequelize_typescript13.DataType.INTEGER
|
|
1255
1370
|
})
|
|
1256
1371
|
], menu.prototype, "sort", 2);
|
|
1257
1372
|
__decorateClass([
|
|
1258
|
-
(0,
|
|
1373
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1259
1374
|
allowNull: true,
|
|
1260
|
-
type:
|
|
1375
|
+
type: import_sequelize_typescript13.DataType.INTEGER
|
|
1261
1376
|
})
|
|
1262
1377
|
], menu.prototype, "status", 2);
|
|
1263
1378
|
__decorateClass([
|
|
1264
|
-
(0,
|
|
1379
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1265
1380
|
allowNull: true,
|
|
1266
|
-
type:
|
|
1381
|
+
type: import_sequelize_typescript13.DataType.JSON
|
|
1267
1382
|
})
|
|
1268
1383
|
], menu.prototype, "data", 2);
|
|
1269
1384
|
__decorateClass([
|
|
1270
|
-
(0,
|
|
1385
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1271
1386
|
field: "show_frontend",
|
|
1272
1387
|
allowNull: true,
|
|
1273
|
-
type:
|
|
1388
|
+
type: import_sequelize_typescript13.DataType.INTEGER
|
|
1274
1389
|
})
|
|
1275
1390
|
], menu.prototype, "showFrontend", 2);
|
|
1276
1391
|
__decorateClass([
|
|
1277
|
-
(0,
|
|
1392
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1278
1393
|
field: "created_by",
|
|
1279
1394
|
allowNull: true,
|
|
1280
|
-
type:
|
|
1395
|
+
type: import_sequelize_typescript13.DataType.STRING(60)
|
|
1281
1396
|
})
|
|
1282
1397
|
], menu.prototype, "createdBy", 2);
|
|
1283
1398
|
__decorateClass([
|
|
1284
|
-
(0,
|
|
1399
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1285
1400
|
field: "created_date",
|
|
1286
1401
|
allowNull: true,
|
|
1287
|
-
type:
|
|
1402
|
+
type: import_sequelize_typescript13.DataType.DATE
|
|
1288
1403
|
})
|
|
1289
1404
|
], menu.prototype, "createdDate", 2);
|
|
1290
1405
|
__decorateClass([
|
|
1291
|
-
(0,
|
|
1406
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1292
1407
|
field: "updated_by",
|
|
1293
1408
|
allowNull: true,
|
|
1294
|
-
type:
|
|
1409
|
+
type: import_sequelize_typescript13.DataType.STRING(60)
|
|
1295
1410
|
})
|
|
1296
1411
|
], menu.prototype, "updatedBy", 2);
|
|
1297
1412
|
__decorateClass([
|
|
1298
|
-
(0,
|
|
1413
|
+
(0, import_sequelize_typescript13.Column)({
|
|
1299
1414
|
field: "updated_date",
|
|
1300
1415
|
allowNull: true,
|
|
1301
|
-
type:
|
|
1416
|
+
type: import_sequelize_typescript13.DataType.DATE
|
|
1302
1417
|
})
|
|
1303
1418
|
], menu.prototype, "updatedDate", 2);
|
|
1304
1419
|
__decorateClass([
|
|
1305
|
-
(0,
|
|
1420
|
+
(0, import_sequelize_typescript13.BelongsTo)(() => msModule)
|
|
1306
1421
|
], menu.prototype, "msModule", 2);
|
|
1307
1422
|
__decorateClass([
|
|
1308
|
-
(0,
|
|
1423
|
+
(0, import_sequelize_typescript13.BelongsTo)(() => authItem)
|
|
1309
1424
|
], menu.prototype, "authItem", 2);
|
|
1310
1425
|
menu = __decorateClass([
|
|
1311
|
-
(0,
|
|
1426
|
+
(0, import_sequelize_typescript13.Table)({
|
|
1312
1427
|
tableName: "menu",
|
|
1313
1428
|
timestamps: false
|
|
1314
1429
|
})
|
|
1315
1430
|
], menu);
|
|
1316
1431
|
|
|
1317
1432
|
// src/databases/tables/authItemChild.ts
|
|
1318
|
-
var
|
|
1319
|
-
var authItemChild = class extends
|
|
1433
|
+
var import_sequelize_typescript14 = require("sequelize-typescript");
|
|
1434
|
+
var authItemChild = class extends import_sequelize_typescript14.Model {
|
|
1320
1435
|
};
|
|
1321
1436
|
__decorateClass([
|
|
1322
|
-
(0,
|
|
1323
|
-
(0,
|
|
1437
|
+
(0, import_sequelize_typescript14.ForeignKey)(() => authItem),
|
|
1438
|
+
(0, import_sequelize_typescript14.Column)({
|
|
1324
1439
|
primaryKey: true,
|
|
1325
|
-
type:
|
|
1440
|
+
type: import_sequelize_typescript14.DataType.STRING(64)
|
|
1326
1441
|
})
|
|
1327
1442
|
], authItemChild.prototype, "parent", 2);
|
|
1328
1443
|
__decorateClass([
|
|
1329
|
-
(0,
|
|
1330
|
-
(0,
|
|
1444
|
+
(0, import_sequelize_typescript14.ForeignKey)(() => authItem),
|
|
1445
|
+
(0, import_sequelize_typescript14.Column)({
|
|
1331
1446
|
primaryKey: true,
|
|
1332
|
-
type:
|
|
1447
|
+
type: import_sequelize_typescript14.DataType.STRING(64)
|
|
1333
1448
|
})
|
|
1334
1449
|
], authItemChild.prototype, "child", 2);
|
|
1335
1450
|
__decorateClass([
|
|
1336
|
-
(0,
|
|
1451
|
+
(0, import_sequelize_typescript14.BelongsTo)(() => authItem)
|
|
1337
1452
|
], authItemChild.prototype, "authItem", 2);
|
|
1338
1453
|
authItemChild = __decorateClass([
|
|
1339
|
-
(0,
|
|
1454
|
+
(0, import_sequelize_typescript14.Table)({
|
|
1340
1455
|
tableName: "auth_item_child",
|
|
1341
1456
|
timestamps: false
|
|
1342
1457
|
})
|
|
1343
1458
|
], authItemChild);
|
|
1344
1459
|
|
|
1345
1460
|
// src/databases/tables/authItem.ts
|
|
1346
|
-
var authItem = class extends
|
|
1461
|
+
var authItem = class extends import_sequelize_typescript15.Model {
|
|
1347
1462
|
};
|
|
1348
1463
|
__decorateClass([
|
|
1349
|
-
(0,
|
|
1464
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1350
1465
|
field: "key_name",
|
|
1351
1466
|
primaryKey: true,
|
|
1352
|
-
type:
|
|
1467
|
+
type: import_sequelize_typescript15.DataType.STRING(100)
|
|
1353
1468
|
})
|
|
1354
1469
|
], authItem.prototype, "keyName", 2);
|
|
1355
1470
|
__decorateClass([
|
|
1356
|
-
(0,
|
|
1357
|
-
type:
|
|
1471
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1472
|
+
type: import_sequelize_typescript15.DataType.SMALLINT
|
|
1358
1473
|
})
|
|
1359
1474
|
], authItem.prototype, "type", 2);
|
|
1360
1475
|
__decorateClass([
|
|
1361
|
-
(0,
|
|
1362
|
-
type:
|
|
1476
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1477
|
+
type: import_sequelize_typescript15.DataType.STRING(255)
|
|
1363
1478
|
})
|
|
1364
1479
|
], authItem.prototype, "display", 2);
|
|
1365
1480
|
__decorateClass([
|
|
1366
|
-
(0,
|
|
1481
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1367
1482
|
allowNull: true,
|
|
1368
|
-
type:
|
|
1483
|
+
type: import_sequelize_typescript15.DataType.STRING
|
|
1369
1484
|
})
|
|
1370
1485
|
], authItem.prototype, "description", 2);
|
|
1371
1486
|
__decorateClass([
|
|
1372
|
-
(0,
|
|
1487
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1373
1488
|
allowNull: true,
|
|
1374
|
-
type:
|
|
1489
|
+
type: import_sequelize_typescript15.DataType.INTEGER,
|
|
1375
1490
|
defaultValue: "1"
|
|
1376
1491
|
})
|
|
1377
1492
|
], authItem.prototype, "status", 2);
|
|
1378
1493
|
__decorateClass([
|
|
1379
|
-
(0,
|
|
1494
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1380
1495
|
field: "created_by",
|
|
1381
1496
|
allowNull: true,
|
|
1382
|
-
type:
|
|
1497
|
+
type: import_sequelize_typescript15.DataType.STRING(60)
|
|
1383
1498
|
})
|
|
1384
1499
|
], authItem.prototype, "createdBy", 2);
|
|
1385
1500
|
__decorateClass([
|
|
1386
|
-
(0,
|
|
1501
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1387
1502
|
field: "created_date",
|
|
1388
1503
|
allowNull: true,
|
|
1389
|
-
type:
|
|
1504
|
+
type: import_sequelize_typescript15.DataType.DATE
|
|
1390
1505
|
})
|
|
1391
1506
|
], authItem.prototype, "createdDate", 2);
|
|
1392
1507
|
__decorateClass([
|
|
1393
|
-
(0,
|
|
1508
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1394
1509
|
field: "updated_by",
|
|
1395
1510
|
allowNull: true,
|
|
1396
|
-
type:
|
|
1511
|
+
type: import_sequelize_typescript15.DataType.STRING(60)
|
|
1397
1512
|
})
|
|
1398
1513
|
], authItem.prototype, "updatedBy", 2);
|
|
1399
1514
|
__decorateClass([
|
|
1400
|
-
(0,
|
|
1515
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1401
1516
|
field: "updated_date",
|
|
1402
1517
|
allowNull: true,
|
|
1403
|
-
type:
|
|
1518
|
+
type: import_sequelize_typescript15.DataType.DATE
|
|
1404
1519
|
})
|
|
1405
1520
|
], authItem.prototype, "updatedDate", 2);
|
|
1406
1521
|
__decorateClass([
|
|
1407
|
-
(0,
|
|
1522
|
+
(0, import_sequelize_typescript15.HasOne)(() => menu, {
|
|
1408
1523
|
sourceKey: "keyName"
|
|
1409
1524
|
})
|
|
1410
1525
|
], authItem.prototype, "menu", 2);
|
|
1411
1526
|
__decorateClass([
|
|
1412
|
-
(0,
|
|
1527
|
+
(0, import_sequelize_typescript15.HasMany)(() => authItemChild, {
|
|
1413
1528
|
sourceKey: "keyName"
|
|
1414
1529
|
})
|
|
1415
1530
|
], authItem.prototype, "authItemChildren", 2);
|
|
1416
1531
|
authItem = __decorateClass([
|
|
1417
|
-
(0,
|
|
1532
|
+
(0, import_sequelize_typescript15.Table)({
|
|
1418
1533
|
tableName: "auth_item",
|
|
1419
1534
|
timestamps: false
|
|
1420
1535
|
})
|
|
1421
1536
|
], authItem);
|
|
1422
1537
|
|
|
1423
1538
|
// src/databases/tables/files.ts
|
|
1424
|
-
var
|
|
1539
|
+
var import_sequelize_typescript17 = require("sequelize-typescript");
|
|
1425
1540
|
|
|
1426
1541
|
// src/databases/tables/mdBanner.ts
|
|
1427
|
-
var
|
|
1428
|
-
var mdBanner = class extends
|
|
1542
|
+
var import_sequelize_typescript16 = require("sequelize-typescript");
|
|
1543
|
+
var mdBanner = class extends import_sequelize_typescript16.Model {
|
|
1429
1544
|
};
|
|
1430
1545
|
__decorateClass([
|
|
1431
|
-
(0,
|
|
1546
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1432
1547
|
primaryKey: true,
|
|
1433
1548
|
autoIncrement: true,
|
|
1434
|
-
type:
|
|
1549
|
+
type: import_sequelize_typescript16.DataType.INTEGER
|
|
1435
1550
|
})
|
|
1436
1551
|
], mdBanner.prototype, "id", 2);
|
|
1437
1552
|
__decorateClass([
|
|
1438
|
-
(0,
|
|
1553
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1439
1554
|
allowNull: true,
|
|
1440
|
-
type:
|
|
1555
|
+
type: import_sequelize_typescript16.DataType.STRING(60)
|
|
1441
1556
|
})
|
|
1442
1557
|
], mdBanner.prototype, "uuid", 2);
|
|
1443
1558
|
__decorateClass([
|
|
1444
|
-
(0,
|
|
1559
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1445
1560
|
field: "key_name",
|
|
1446
1561
|
allowNull: true,
|
|
1447
|
-
type:
|
|
1562
|
+
type: import_sequelize_typescript16.DataType.STRING(100)
|
|
1448
1563
|
})
|
|
1449
1564
|
], mdBanner.prototype, "keyName", 2);
|
|
1450
1565
|
__decorateClass([
|
|
1451
|
-
(0,
|
|
1566
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1452
1567
|
allowNull: true,
|
|
1453
|
-
type:
|
|
1568
|
+
type: import_sequelize_typescript16.DataType.STRING(255)
|
|
1454
1569
|
})
|
|
1455
1570
|
], mdBanner.prototype, "title", 2);
|
|
1456
1571
|
__decorateClass([
|
|
1457
|
-
(0,
|
|
1572
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1458
1573
|
allowNull: true,
|
|
1459
|
-
type:
|
|
1574
|
+
type: import_sequelize_typescript16.DataType.STRING
|
|
1460
1575
|
})
|
|
1461
1576
|
], mdBanner.prototype, "description", 2);
|
|
1462
1577
|
__decorateClass([
|
|
1463
|
-
(0,
|
|
1464
|
-
(0,
|
|
1578
|
+
(0, import_sequelize_typescript16.ForeignKey)(() => files),
|
|
1579
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1465
1580
|
field: "file_uuid",
|
|
1466
1581
|
allowNull: true,
|
|
1467
|
-
type:
|
|
1582
|
+
type: import_sequelize_typescript16.DataType.STRING(60)
|
|
1468
1583
|
})
|
|
1469
1584
|
], mdBanner.prototype, "fileUuid", 2);
|
|
1470
1585
|
__decorateClass([
|
|
1471
|
-
(0,
|
|
1586
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1472
1587
|
allowNull: true,
|
|
1473
|
-
type:
|
|
1588
|
+
type: import_sequelize_typescript16.DataType.STRING(60)
|
|
1474
1589
|
})
|
|
1475
1590
|
], mdBanner.prototype, "video", 2);
|
|
1476
1591
|
__decorateClass([
|
|
1477
|
-
(0,
|
|
1592
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1478
1593
|
allowNull: true,
|
|
1479
|
-
type:
|
|
1594
|
+
type: import_sequelize_typescript16.DataType.STRING(255)
|
|
1480
1595
|
})
|
|
1481
1596
|
], mdBanner.prototype, "url", 2);
|
|
1482
1597
|
__decorateClass([
|
|
1483
|
-
(0,
|
|
1598
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1484
1599
|
allowNull: true,
|
|
1485
|
-
type:
|
|
1600
|
+
type: import_sequelize_typescript16.DataType.STRING(10)
|
|
1486
1601
|
})
|
|
1487
1602
|
], mdBanner.prototype, "target", 2);
|
|
1488
1603
|
__decorateClass([
|
|
1489
|
-
(0,
|
|
1604
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1490
1605
|
allowNull: true,
|
|
1491
|
-
type:
|
|
1606
|
+
type: import_sequelize_typescript16.DataType.INTEGER
|
|
1492
1607
|
})
|
|
1493
1608
|
], mdBanner.prototype, "sort", 2);
|
|
1494
1609
|
__decorateClass([
|
|
1495
|
-
(0,
|
|
1610
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1496
1611
|
allowNull: true,
|
|
1497
|
-
type:
|
|
1612
|
+
type: import_sequelize_typescript16.DataType.INTEGER
|
|
1498
1613
|
})
|
|
1499
1614
|
], mdBanner.prototype, "status", 2);
|
|
1500
1615
|
__decorateClass([
|
|
1501
|
-
(0,
|
|
1616
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1502
1617
|
field: "has_expire",
|
|
1503
1618
|
allowNull: true,
|
|
1504
|
-
type:
|
|
1619
|
+
type: import_sequelize_typescript16.DataType.INTEGER
|
|
1505
1620
|
})
|
|
1506
1621
|
], mdBanner.prototype, "hasExpire", 2);
|
|
1507
1622
|
__decorateClass([
|
|
1508
|
-
(0,
|
|
1623
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1509
1624
|
field: "start_date",
|
|
1510
1625
|
allowNull: true,
|
|
1511
|
-
type:
|
|
1626
|
+
type: import_sequelize_typescript16.DataType.DATE
|
|
1512
1627
|
})
|
|
1513
1628
|
], mdBanner.prototype, "startDate", 2);
|
|
1514
1629
|
__decorateClass([
|
|
1515
|
-
(0,
|
|
1630
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1516
1631
|
field: "expire_date",
|
|
1517
1632
|
allowNull: true,
|
|
1518
|
-
type:
|
|
1633
|
+
type: import_sequelize_typescript16.DataType.DATE
|
|
1519
1634
|
})
|
|
1520
1635
|
], mdBanner.prototype, "expireDate", 2);
|
|
1521
1636
|
__decorateClass([
|
|
1522
|
-
(0,
|
|
1637
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1523
1638
|
field: "created_by",
|
|
1524
1639
|
allowNull: true,
|
|
1525
|
-
type:
|
|
1640
|
+
type: import_sequelize_typescript16.DataType.STRING(60)
|
|
1526
1641
|
})
|
|
1527
1642
|
], mdBanner.prototype, "createdBy", 2);
|
|
1528
1643
|
__decorateClass([
|
|
1529
|
-
(0,
|
|
1644
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1530
1645
|
field: "created_date",
|
|
1531
1646
|
allowNull: true,
|
|
1532
|
-
type:
|
|
1647
|
+
type: import_sequelize_typescript16.DataType.DATE
|
|
1533
1648
|
})
|
|
1534
1649
|
], mdBanner.prototype, "createdDate", 2);
|
|
1535
1650
|
__decorateClass([
|
|
1536
|
-
(0,
|
|
1651
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1537
1652
|
field: "updated_by",
|
|
1538
1653
|
allowNull: true,
|
|
1539
|
-
type:
|
|
1654
|
+
type: import_sequelize_typescript16.DataType.STRING(60)
|
|
1540
1655
|
})
|
|
1541
1656
|
], mdBanner.prototype, "updatedBy", 2);
|
|
1542
1657
|
__decorateClass([
|
|
1543
|
-
(0,
|
|
1658
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1544
1659
|
field: "updated_date",
|
|
1545
1660
|
allowNull: true,
|
|
1546
|
-
type:
|
|
1661
|
+
type: import_sequelize_typescript16.DataType.DATE
|
|
1547
1662
|
})
|
|
1548
1663
|
], mdBanner.prototype, "updatedDate", 2);
|
|
1549
1664
|
__decorateClass([
|
|
1550
|
-
(0,
|
|
1665
|
+
(0, import_sequelize_typescript16.BelongsTo)(() => files)
|
|
1551
1666
|
], mdBanner.prototype, "file", 2);
|
|
1552
1667
|
mdBanner = __decorateClass([
|
|
1553
|
-
(0,
|
|
1668
|
+
(0, import_sequelize_typescript16.Table)({
|
|
1554
1669
|
tableName: "md_banner",
|
|
1555
1670
|
timestamps: false
|
|
1556
1671
|
})
|
|
1557
1672
|
], mdBanner);
|
|
1558
1673
|
|
|
1559
1674
|
// src/databases/tables/files.ts
|
|
1560
|
-
var files = class extends
|
|
1675
|
+
var files = class extends import_sequelize_typescript17.Model {
|
|
1561
1676
|
};
|
|
1562
1677
|
__decorateClass([
|
|
1563
|
-
(0,
|
|
1678
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1564
1679
|
primaryKey: true,
|
|
1565
1680
|
autoIncrement: true,
|
|
1566
|
-
type:
|
|
1681
|
+
type: import_sequelize_typescript17.DataType.INTEGER
|
|
1567
1682
|
})
|
|
1568
1683
|
], files.prototype, "id", 2);
|
|
1569
1684
|
__decorateClass([
|
|
1570
|
-
(0,
|
|
1571
|
-
type:
|
|
1685
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1686
|
+
type: import_sequelize_typescript17.DataType.STRING(60)
|
|
1572
1687
|
})
|
|
1573
1688
|
], files.prototype, "uuid", 2);
|
|
1574
1689
|
__decorateClass([
|
|
1575
|
-
(0,
|
|
1690
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1576
1691
|
field: "user_uuid",
|
|
1577
1692
|
allowNull: true,
|
|
1578
|
-
type:
|
|
1693
|
+
type: import_sequelize_typescript17.DataType.STRING(60)
|
|
1579
1694
|
})
|
|
1580
1695
|
], files.prototype, "userUuid", 2);
|
|
1581
1696
|
__decorateClass([
|
|
1582
|
-
(0,
|
|
1697
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1583
1698
|
allowNull: true,
|
|
1584
|
-
type:
|
|
1699
|
+
type: import_sequelize_typescript17.DataType.STRING(255)
|
|
1585
1700
|
})
|
|
1586
1701
|
], files.prototype, "name", 2);
|
|
1587
1702
|
__decorateClass([
|
|
1588
|
-
(0,
|
|
1703
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1589
1704
|
field: "original_name",
|
|
1590
1705
|
allowNull: true,
|
|
1591
|
-
type:
|
|
1706
|
+
type: import_sequelize_typescript17.DataType.STRING(255)
|
|
1592
1707
|
})
|
|
1593
1708
|
], files.prototype, "originalName", 2);
|
|
1594
1709
|
__decorateClass([
|
|
1595
|
-
(0,
|
|
1710
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1596
1711
|
allowNull: true,
|
|
1597
|
-
type:
|
|
1712
|
+
type: import_sequelize_typescript17.DataType.STRING(255)
|
|
1598
1713
|
})
|
|
1599
1714
|
], files.prototype, "mimetype", 2);
|
|
1600
1715
|
__decorateClass([
|
|
1601
|
-
(0,
|
|
1716
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1602
1717
|
field: "file_path",
|
|
1603
1718
|
allowNull: true,
|
|
1604
|
-
type:
|
|
1719
|
+
type: import_sequelize_typescript17.DataType.STRING(255)
|
|
1605
1720
|
})
|
|
1606
1721
|
], files.prototype, "filePath", 2);
|
|
1607
1722
|
__decorateClass([
|
|
1608
|
-
(0,
|
|
1723
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1609
1724
|
field: "file_size",
|
|
1610
1725
|
allowNull: true,
|
|
1611
|
-
type:
|
|
1726
|
+
type: import_sequelize_typescript17.DataType.BIGINT
|
|
1612
1727
|
})
|
|
1613
1728
|
], files.prototype, "fileSize", 2);
|
|
1614
1729
|
__decorateClass([
|
|
1615
|
-
(0,
|
|
1730
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1616
1731
|
allowNull: true,
|
|
1617
|
-
type:
|
|
1732
|
+
type: import_sequelize_typescript17.DataType.STRING(255)
|
|
1618
1733
|
})
|
|
1619
1734
|
], files.prototype, "path", 2);
|
|
1620
1735
|
__decorateClass([
|
|
1621
|
-
(0,
|
|
1736
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1622
1737
|
allowNull: true,
|
|
1623
|
-
type:
|
|
1738
|
+
type: import_sequelize_typescript17.DataType.INTEGER
|
|
1624
1739
|
})
|
|
1625
1740
|
], files.prototype, "status", 2);
|
|
1626
1741
|
__decorateClass([
|
|
1627
|
-
(0,
|
|
1742
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1628
1743
|
field: "created_by",
|
|
1629
1744
|
allowNull: true,
|
|
1630
|
-
type:
|
|
1745
|
+
type: import_sequelize_typescript17.DataType.STRING(60)
|
|
1631
1746
|
})
|
|
1632
1747
|
], files.prototype, "createdBy", 2);
|
|
1633
1748
|
__decorateClass([
|
|
1634
|
-
(0,
|
|
1749
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1635
1750
|
field: "created_date",
|
|
1636
1751
|
allowNull: true,
|
|
1637
|
-
type:
|
|
1752
|
+
type: import_sequelize_typescript17.DataType.DATE
|
|
1638
1753
|
})
|
|
1639
1754
|
], files.prototype, "createdDate", 2);
|
|
1640
1755
|
__decorateClass([
|
|
1641
|
-
(0,
|
|
1756
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1642
1757
|
field: "updated_by",
|
|
1643
1758
|
allowNull: true,
|
|
1644
|
-
type:
|
|
1759
|
+
type: import_sequelize_typescript17.DataType.STRING(60)
|
|
1645
1760
|
})
|
|
1646
1761
|
], files.prototype, "updatedBy", 2);
|
|
1647
1762
|
__decorateClass([
|
|
1648
|
-
(0,
|
|
1763
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1649
1764
|
field: "updated_date",
|
|
1650
1765
|
allowNull: true,
|
|
1651
|
-
type:
|
|
1766
|
+
type: import_sequelize_typescript17.DataType.DATE
|
|
1652
1767
|
})
|
|
1653
1768
|
], files.prototype, "updatedDate", 2);
|
|
1654
1769
|
__decorateClass([
|
|
1655
|
-
(0,
|
|
1770
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1656
1771
|
allowNull: true,
|
|
1657
|
-
type:
|
|
1772
|
+
type: import_sequelize_typescript17.DataType.INTEGER,
|
|
1658
1773
|
defaultValue: "0"
|
|
1659
1774
|
})
|
|
1660
1775
|
], files.prototype, "view", 2);
|
|
1661
1776
|
__decorateClass([
|
|
1662
|
-
(0,
|
|
1777
|
+
(0, import_sequelize_typescript17.HasOne)(() => mdBanner, {
|
|
1663
1778
|
sourceKey: "uuid"
|
|
1664
1779
|
})
|
|
1665
1780
|
], files.prototype, "mdBanner", 2);
|
|
1666
1781
|
files = __decorateClass([
|
|
1667
|
-
(0,
|
|
1782
|
+
(0, import_sequelize_typescript17.Table)({
|
|
1668
1783
|
tableName: "files",
|
|
1669
1784
|
timestamps: false
|
|
1670
1785
|
})
|
|
1671
1786
|
], files);
|
|
1672
1787
|
|
|
1673
|
-
// src/databases/tables/formFaq.ts
|
|
1674
|
-
var import_sequelize_typescript17 = require("sequelize-typescript");
|
|
1675
|
-
var formFaq = class extends import_sequelize_typescript17.Model {
|
|
1676
|
-
};
|
|
1677
|
-
__decorateClass([
|
|
1678
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1679
|
-
primaryKey: true,
|
|
1680
|
-
autoIncrement: true,
|
|
1681
|
-
type: import_sequelize_typescript17.DataType.INTEGER
|
|
1682
|
-
})
|
|
1683
|
-
], formFaq.prototype, "id", 2);
|
|
1684
|
-
__decorateClass([
|
|
1685
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1686
|
-
allowNull: true,
|
|
1687
|
-
type: import_sequelize_typescript17.DataType.STRING(60)
|
|
1688
|
-
})
|
|
1689
|
-
], formFaq.prototype, "uuid", 2);
|
|
1690
|
-
__decorateClass([
|
|
1691
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1692
|
-
field: "title_name",
|
|
1693
|
-
allowNull: true,
|
|
1694
|
-
type: import_sequelize_typescript17.DataType.STRING(50)
|
|
1695
|
-
})
|
|
1696
|
-
], formFaq.prototype, "titleName", 2);
|
|
1697
|
-
__decorateClass([
|
|
1698
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1699
|
-
field: "first_name",
|
|
1700
|
-
allowNull: true,
|
|
1701
|
-
type: import_sequelize_typescript17.DataType.STRING(255)
|
|
1702
|
-
})
|
|
1703
|
-
], formFaq.prototype, "firstName", 2);
|
|
1704
|
-
__decorateClass([
|
|
1705
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1706
|
-
field: "last_name",
|
|
1707
|
-
allowNull: true,
|
|
1708
|
-
type: import_sequelize_typescript17.DataType.STRING(255)
|
|
1709
|
-
})
|
|
1710
|
-
], formFaq.prototype, "lastName", 2);
|
|
1711
|
-
__decorateClass([
|
|
1712
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1713
|
-
allowNull: true,
|
|
1714
|
-
type: import_sequelize_typescript17.DataType.STRING(255)
|
|
1715
|
-
})
|
|
1716
|
-
], formFaq.prototype, "phone", 2);
|
|
1717
|
-
__decorateClass([
|
|
1718
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1719
|
-
allowNull: true,
|
|
1720
|
-
type: import_sequelize_typescript17.DataType.STRING(255)
|
|
1721
|
-
})
|
|
1722
|
-
], formFaq.prototype, "email", 2);
|
|
1723
|
-
__decorateClass([
|
|
1724
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1725
|
-
allowNull: true,
|
|
1726
|
-
type: import_sequelize_typescript17.DataType.STRING(255)
|
|
1727
|
-
})
|
|
1728
|
-
], formFaq.prototype, "question", 2);
|
|
1729
|
-
__decorateClass([
|
|
1730
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1731
|
-
allowNull: true,
|
|
1732
|
-
type: import_sequelize_typescript17.DataType.STRING
|
|
1733
|
-
})
|
|
1734
|
-
], formFaq.prototype, "detail", 2);
|
|
1735
|
-
__decorateClass([
|
|
1736
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1737
|
-
allowNull: true,
|
|
1738
|
-
type: import_sequelize_typescript17.DataType.JSON
|
|
1739
|
-
})
|
|
1740
|
-
], formFaq.prototype, "attachments", 2);
|
|
1741
|
-
__decorateClass([
|
|
1742
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1743
|
-
allowNull: true,
|
|
1744
|
-
type: import_sequelize_typescript17.DataType.INTEGER
|
|
1745
|
-
})
|
|
1746
|
-
], formFaq.prototype, "status", 2);
|
|
1747
|
-
__decorateClass([
|
|
1748
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1749
|
-
field: "created_by",
|
|
1750
|
-
allowNull: true,
|
|
1751
|
-
type: import_sequelize_typescript17.DataType.STRING(60)
|
|
1752
|
-
})
|
|
1753
|
-
], formFaq.prototype, "createdBy", 2);
|
|
1754
|
-
__decorateClass([
|
|
1755
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1756
|
-
field: "created_date",
|
|
1757
|
-
allowNull: true,
|
|
1758
|
-
type: import_sequelize_typescript17.DataType.DATE
|
|
1759
|
-
})
|
|
1760
|
-
], formFaq.prototype, "createdDate", 2);
|
|
1761
|
-
__decorateClass([
|
|
1762
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1763
|
-
field: "updated_by",
|
|
1764
|
-
allowNull: true,
|
|
1765
|
-
type: import_sequelize_typescript17.DataType.STRING(60)
|
|
1766
|
-
})
|
|
1767
|
-
], formFaq.prototype, "updatedBy", 2);
|
|
1768
|
-
__decorateClass([
|
|
1769
|
-
(0, import_sequelize_typescript17.Column)({
|
|
1770
|
-
field: "updated_date",
|
|
1771
|
-
allowNull: true,
|
|
1772
|
-
type: import_sequelize_typescript17.DataType.DATE
|
|
1773
|
-
})
|
|
1774
|
-
], formFaq.prototype, "updatedDate", 2);
|
|
1775
|
-
formFaq = __decorateClass([
|
|
1776
|
-
(0, import_sequelize_typescript17.Table)({
|
|
1777
|
-
tableName: "form_faq",
|
|
1778
|
-
timestamps: false
|
|
1779
|
-
})
|
|
1780
|
-
], formFaq);
|
|
1781
|
-
|
|
1782
1788
|
// src/databases/tables/helper.ts
|
|
1783
1789
|
var import_sequelize_typescript18 = require("sequelize-typescript");
|
|
1784
1790
|
var helper = class extends import_sequelize_typescript18.Model {
|
|
@@ -5360,13 +5366,13 @@ userRoleV = __decorateClass([
|
|
|
5360
5366
|
0 && (module.exports = {
|
|
5361
5367
|
appBlessings,
|
|
5362
5368
|
appBlessingsTransaction,
|
|
5369
|
+
appFaq,
|
|
5363
5370
|
authAssignment,
|
|
5364
5371
|
authItem,
|
|
5365
5372
|
authItemChild,
|
|
5366
5373
|
authRole,
|
|
5367
5374
|
authRoleChild,
|
|
5368
5375
|
files,
|
|
5369
|
-
formFaq,
|
|
5370
5376
|
helper,
|
|
5371
5377
|
logs,
|
|
5372
5378
|
mdBanner,
|