@admc-go-th/admc-library 1.0.69 → 1.0.71
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/formFaq.ts +127 -0
- package/databases/schema/helper.ts +7 -0
- package/databases/schema/index.ts +1 -0
- package/databases/schema/member.ts +15 -0
- package/databases/tables/formFaq.d.ts +38 -0
- package/databases/tables/formFaq.js +144 -0
- package/databases/tables/helper.d.ts +2 -0
- package/databases/tables/helper.js +6 -0
- package/databases/tables/index.d.ts +1 -0
- package/databases/tables/index.js +968 -838
- package/databases/tables/member.d.ts +4 -0
- package/databases/tables/member.js +13 -0
- package/package.json +1 -1
|
@@ -34,6 +34,7 @@ __export(tables_exports, {
|
|
|
34
34
|
authRole: () => authRole,
|
|
35
35
|
authRoleChild: () => authRoleChild,
|
|
36
36
|
files: () => files,
|
|
37
|
+
formFaq: () => formFaq,
|
|
37
38
|
helper: () => helper,
|
|
38
39
|
logs: () => logs,
|
|
39
40
|
mdBanner: () => mdBanner,
|
|
@@ -1475,9 +1476,9 @@ files = __decorateClass([
|
|
|
1475
1476
|
})
|
|
1476
1477
|
], files);
|
|
1477
1478
|
|
|
1478
|
-
// src/databases/tables/
|
|
1479
|
+
// src/databases/tables/formFaq.ts
|
|
1479
1480
|
var import_sequelize_typescript15 = require("sequelize-typescript");
|
|
1480
|
-
var
|
|
1481
|
+
var formFaq = class extends import_sequelize_typescript15.Model {
|
|
1481
1482
|
};
|
|
1482
1483
|
__decorateClass([
|
|
1483
1484
|
(0, import_sequelize_typescript15.Column)({
|
|
@@ -1485,89 +1486,108 @@ __decorateClass([
|
|
|
1485
1486
|
autoIncrement: true,
|
|
1486
1487
|
type: import_sequelize_typescript15.DataType.INTEGER
|
|
1487
1488
|
})
|
|
1488
|
-
],
|
|
1489
|
+
], formFaq.prototype, "id", 2);
|
|
1490
|
+
__decorateClass([
|
|
1491
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1492
|
+
allowNull: true,
|
|
1493
|
+
type: import_sequelize_typescript15.DataType.STRING(60)
|
|
1494
|
+
})
|
|
1495
|
+
], formFaq.prototype, "uuid", 2);
|
|
1496
|
+
__decorateClass([
|
|
1497
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1498
|
+
field: "title_name",
|
|
1499
|
+
allowNull: true,
|
|
1500
|
+
type: import_sequelize_typescript15.DataType.STRING(50)
|
|
1501
|
+
})
|
|
1502
|
+
], formFaq.prototype, "titleName", 2);
|
|
1489
1503
|
__decorateClass([
|
|
1490
1504
|
(0, import_sequelize_typescript15.Column)({
|
|
1505
|
+
field: "first_name",
|
|
1491
1506
|
allowNull: true,
|
|
1492
1507
|
type: import_sequelize_typescript15.DataType.STRING(255)
|
|
1493
1508
|
})
|
|
1494
|
-
],
|
|
1509
|
+
], formFaq.prototype, "firstName", 2);
|
|
1495
1510
|
__decorateClass([
|
|
1496
1511
|
(0, import_sequelize_typescript15.Column)({
|
|
1512
|
+
field: "last_name",
|
|
1497
1513
|
allowNull: true,
|
|
1498
1514
|
type: import_sequelize_typescript15.DataType.STRING(255)
|
|
1499
1515
|
})
|
|
1500
|
-
],
|
|
1516
|
+
], formFaq.prototype, "lastName", 2);
|
|
1501
1517
|
__decorateClass([
|
|
1502
1518
|
(0, import_sequelize_typescript15.Column)({
|
|
1503
|
-
field: "disable_beacon",
|
|
1504
1519
|
allowNull: true,
|
|
1505
|
-
type: import_sequelize_typescript15.DataType.
|
|
1520
|
+
type: import_sequelize_typescript15.DataType.STRING(255)
|
|
1506
1521
|
})
|
|
1507
|
-
],
|
|
1522
|
+
], formFaq.prototype, "phone", 2);
|
|
1508
1523
|
__decorateClass([
|
|
1509
1524
|
(0, import_sequelize_typescript15.Column)({
|
|
1510
1525
|
allowNull: true,
|
|
1511
1526
|
type: import_sequelize_typescript15.DataType.STRING(255)
|
|
1512
1527
|
})
|
|
1513
|
-
],
|
|
1528
|
+
], formFaq.prototype, "email", 2);
|
|
1514
1529
|
__decorateClass([
|
|
1515
1530
|
(0, import_sequelize_typescript15.Column)({
|
|
1516
|
-
field: "disable_scrolling",
|
|
1517
1531
|
allowNull: true,
|
|
1518
|
-
type: import_sequelize_typescript15.DataType.
|
|
1532
|
+
type: import_sequelize_typescript15.DataType.STRING(255)
|
|
1519
1533
|
})
|
|
1520
|
-
],
|
|
1534
|
+
], formFaq.prototype, "question", 2);
|
|
1521
1535
|
__decorateClass([
|
|
1522
1536
|
(0, import_sequelize_typescript15.Column)({
|
|
1523
1537
|
allowNull: true,
|
|
1524
|
-
type: import_sequelize_typescript15.DataType.
|
|
1538
|
+
type: import_sequelize_typescript15.DataType.STRING
|
|
1525
1539
|
})
|
|
1526
|
-
],
|
|
1540
|
+
], formFaq.prototype, "detail", 2);
|
|
1541
|
+
__decorateClass([
|
|
1542
|
+
(0, import_sequelize_typescript15.Column)({
|
|
1543
|
+
allowNull: true,
|
|
1544
|
+
type: import_sequelize_typescript15.DataType.JSON
|
|
1545
|
+
})
|
|
1546
|
+
], formFaq.prototype, "attachments", 2);
|
|
1527
1547
|
__decorateClass([
|
|
1528
1548
|
(0, import_sequelize_typescript15.Column)({
|
|
1529
1549
|
allowNull: true,
|
|
1530
1550
|
type: import_sequelize_typescript15.DataType.INTEGER
|
|
1531
1551
|
})
|
|
1532
|
-
],
|
|
1552
|
+
], formFaq.prototype, "status", 2);
|
|
1533
1553
|
__decorateClass([
|
|
1534
1554
|
(0, import_sequelize_typescript15.Column)({
|
|
1535
1555
|
field: "created_by",
|
|
1536
1556
|
allowNull: true,
|
|
1537
1557
|
type: import_sequelize_typescript15.DataType.STRING(60)
|
|
1538
1558
|
})
|
|
1539
|
-
],
|
|
1559
|
+
], formFaq.prototype, "createdBy", 2);
|
|
1540
1560
|
__decorateClass([
|
|
1541
1561
|
(0, import_sequelize_typescript15.Column)({
|
|
1542
1562
|
field: "created_date",
|
|
1543
1563
|
allowNull: true,
|
|
1544
1564
|
type: import_sequelize_typescript15.DataType.DATE
|
|
1545
1565
|
})
|
|
1546
|
-
],
|
|
1566
|
+
], formFaq.prototype, "createdDate", 2);
|
|
1547
1567
|
__decorateClass([
|
|
1548
1568
|
(0, import_sequelize_typescript15.Column)({
|
|
1549
1569
|
field: "updated_by",
|
|
1550
1570
|
allowNull: true,
|
|
1551
1571
|
type: import_sequelize_typescript15.DataType.STRING(60)
|
|
1552
1572
|
})
|
|
1553
|
-
],
|
|
1573
|
+
], formFaq.prototype, "updatedBy", 2);
|
|
1554
1574
|
__decorateClass([
|
|
1555
1575
|
(0, import_sequelize_typescript15.Column)({
|
|
1556
1576
|
field: "updated_date",
|
|
1557
1577
|
allowNull: true,
|
|
1558
1578
|
type: import_sequelize_typescript15.DataType.DATE
|
|
1559
1579
|
})
|
|
1560
|
-
],
|
|
1561
|
-
|
|
1580
|
+
], formFaq.prototype, "updatedDate", 2);
|
|
1581
|
+
formFaq = __decorateClass([
|
|
1562
1582
|
(0, import_sequelize_typescript15.Table)({
|
|
1563
|
-
tableName: "
|
|
1583
|
+
tableName: "form_faq",
|
|
1564
1584
|
timestamps: false
|
|
1565
1585
|
})
|
|
1566
|
-
],
|
|
1586
|
+
], formFaq);
|
|
1567
1587
|
|
|
1568
|
-
// src/databases/tables/
|
|
1588
|
+
// src/databases/tables/helper.ts
|
|
1569
1589
|
var import_sequelize_typescript16 = require("sequelize-typescript");
|
|
1570
|
-
var
|
|
1590
|
+
var helper = class extends import_sequelize_typescript16.Model {
|
|
1571
1591
|
};
|
|
1572
1592
|
__decorateClass([
|
|
1573
1593
|
(0, import_sequelize_typescript16.Column)({
|
|
@@ -1575,50 +1595,95 @@ __decorateClass([
|
|
|
1575
1595
|
autoIncrement: true,
|
|
1576
1596
|
type: import_sequelize_typescript16.DataType.INTEGER
|
|
1577
1597
|
})
|
|
1578
|
-
],
|
|
1598
|
+
], helper.prototype, "id", 2);
|
|
1579
1599
|
__decorateClass([
|
|
1580
1600
|
(0, import_sequelize_typescript16.Column)({
|
|
1581
|
-
field: "user_uuid",
|
|
1582
1601
|
allowNull: true,
|
|
1583
|
-
type: import_sequelize_typescript16.DataType.STRING(
|
|
1602
|
+
type: import_sequelize_typescript16.DataType.STRING(10)
|
|
1584
1603
|
})
|
|
1585
|
-
],
|
|
1604
|
+
], helper.prototype, "device", 2);
|
|
1586
1605
|
__decorateClass([
|
|
1587
1606
|
(0, import_sequelize_typescript16.Column)({
|
|
1588
1607
|
allowNull: true,
|
|
1589
|
-
type: import_sequelize_typescript16.DataType.STRING(
|
|
1608
|
+
type: import_sequelize_typescript16.DataType.STRING(255)
|
|
1590
1609
|
})
|
|
1591
|
-
],
|
|
1610
|
+
], helper.prototype, "target", 2);
|
|
1592
1611
|
__decorateClass([
|
|
1593
1612
|
(0, import_sequelize_typescript16.Column)({
|
|
1594
1613
|
allowNull: true,
|
|
1595
|
-
type: import_sequelize_typescript16.DataType.
|
|
1614
|
+
type: import_sequelize_typescript16.DataType.STRING(255)
|
|
1596
1615
|
})
|
|
1597
|
-
],
|
|
1616
|
+
], helper.prototype, "content", 2);
|
|
1617
|
+
__decorateClass([
|
|
1618
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1619
|
+
field: "disable_beacon",
|
|
1620
|
+
allowNull: true,
|
|
1621
|
+
type: import_sequelize_typescript16.DataType.INTEGER
|
|
1622
|
+
})
|
|
1623
|
+
], helper.prototype, "disableBeacon", 2);
|
|
1624
|
+
__decorateClass([
|
|
1625
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1626
|
+
allowNull: true,
|
|
1627
|
+
type: import_sequelize_typescript16.DataType.STRING(255)
|
|
1628
|
+
})
|
|
1629
|
+
], helper.prototype, "placement", 2);
|
|
1630
|
+
__decorateClass([
|
|
1631
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1632
|
+
field: "disable_scrolling",
|
|
1633
|
+
allowNull: true,
|
|
1634
|
+
type: import_sequelize_typescript16.DataType.INTEGER
|
|
1635
|
+
})
|
|
1636
|
+
], helper.prototype, "disableScrolling", 2);
|
|
1637
|
+
__decorateClass([
|
|
1638
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1639
|
+
allowNull: true,
|
|
1640
|
+
type: import_sequelize_typescript16.DataType.INTEGER
|
|
1641
|
+
})
|
|
1642
|
+
], helper.prototype, "sort", 2);
|
|
1643
|
+
__decorateClass([
|
|
1644
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1645
|
+
allowNull: true,
|
|
1646
|
+
type: import_sequelize_typescript16.DataType.INTEGER
|
|
1647
|
+
})
|
|
1648
|
+
], helper.prototype, "status", 2);
|
|
1598
1649
|
__decorateClass([
|
|
1599
1650
|
(0, import_sequelize_typescript16.Column)({
|
|
1600
1651
|
field: "created_by",
|
|
1601
1652
|
allowNull: true,
|
|
1602
1653
|
type: import_sequelize_typescript16.DataType.STRING(60)
|
|
1603
1654
|
})
|
|
1604
|
-
],
|
|
1655
|
+
], helper.prototype, "createdBy", 2);
|
|
1605
1656
|
__decorateClass([
|
|
1606
1657
|
(0, import_sequelize_typescript16.Column)({
|
|
1607
1658
|
field: "created_date",
|
|
1608
1659
|
allowNull: true,
|
|
1609
1660
|
type: import_sequelize_typescript16.DataType.DATE
|
|
1610
1661
|
})
|
|
1611
|
-
],
|
|
1612
|
-
|
|
1662
|
+
], helper.prototype, "createdDate", 2);
|
|
1663
|
+
__decorateClass([
|
|
1664
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1665
|
+
field: "updated_by",
|
|
1666
|
+
allowNull: true,
|
|
1667
|
+
type: import_sequelize_typescript16.DataType.STRING(60)
|
|
1668
|
+
})
|
|
1669
|
+
], helper.prototype, "updatedBy", 2);
|
|
1670
|
+
__decorateClass([
|
|
1671
|
+
(0, import_sequelize_typescript16.Column)({
|
|
1672
|
+
field: "updated_date",
|
|
1673
|
+
allowNull: true,
|
|
1674
|
+
type: import_sequelize_typescript16.DataType.DATE
|
|
1675
|
+
})
|
|
1676
|
+
], helper.prototype, "updatedDate", 2);
|
|
1677
|
+
helper = __decorateClass([
|
|
1613
1678
|
(0, import_sequelize_typescript16.Table)({
|
|
1614
|
-
tableName: "
|
|
1679
|
+
tableName: "helper",
|
|
1615
1680
|
timestamps: false
|
|
1616
1681
|
})
|
|
1617
|
-
],
|
|
1682
|
+
], helper);
|
|
1618
1683
|
|
|
1619
|
-
// src/databases/tables/
|
|
1684
|
+
// src/databases/tables/logs.ts
|
|
1620
1685
|
var import_sequelize_typescript17 = require("sequelize-typescript");
|
|
1621
|
-
var
|
|
1686
|
+
var logs = class extends import_sequelize_typescript17.Model {
|
|
1622
1687
|
};
|
|
1623
1688
|
__decorateClass([
|
|
1624
1689
|
(0, import_sequelize_typescript17.Column)({
|
|
@@ -1626,2603 +1691,2667 @@ __decorateClass([
|
|
|
1626
1691
|
autoIncrement: true,
|
|
1627
1692
|
type: import_sequelize_typescript17.DataType.INTEGER
|
|
1628
1693
|
})
|
|
1629
|
-
],
|
|
1694
|
+
], logs.prototype, "id", 2);
|
|
1630
1695
|
__decorateClass([
|
|
1631
1696
|
(0, import_sequelize_typescript17.Column)({
|
|
1697
|
+
field: "user_uuid",
|
|
1698
|
+
allowNull: true,
|
|
1632
1699
|
type: import_sequelize_typescript17.DataType.STRING(60)
|
|
1633
1700
|
})
|
|
1634
|
-
],
|
|
1701
|
+
], logs.prototype, "userUuid", 2);
|
|
1635
1702
|
__decorateClass([
|
|
1636
1703
|
(0, import_sequelize_typescript17.Column)({
|
|
1704
|
+
allowNull: true,
|
|
1705
|
+
type: import_sequelize_typescript17.DataType.STRING(50)
|
|
1706
|
+
})
|
|
1707
|
+
], logs.prototype, "type", 2);
|
|
1708
|
+
__decorateClass([
|
|
1709
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1710
|
+
allowNull: true,
|
|
1711
|
+
type: import_sequelize_typescript17.DataType.JSON
|
|
1712
|
+
})
|
|
1713
|
+
], logs.prototype, "data", 2);
|
|
1714
|
+
__decorateClass([
|
|
1715
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1716
|
+
field: "created_by",
|
|
1717
|
+
allowNull: true,
|
|
1718
|
+
type: import_sequelize_typescript17.DataType.STRING(60)
|
|
1719
|
+
})
|
|
1720
|
+
], logs.prototype, "createdBy", 2);
|
|
1721
|
+
__decorateClass([
|
|
1722
|
+
(0, import_sequelize_typescript17.Column)({
|
|
1723
|
+
field: "created_date",
|
|
1724
|
+
allowNull: true,
|
|
1725
|
+
type: import_sequelize_typescript17.DataType.DATE
|
|
1726
|
+
})
|
|
1727
|
+
], logs.prototype, "createdDate", 2);
|
|
1728
|
+
logs = __decorateClass([
|
|
1729
|
+
(0, import_sequelize_typescript17.Table)({
|
|
1730
|
+
tableName: "logs",
|
|
1731
|
+
timestamps: false
|
|
1732
|
+
})
|
|
1733
|
+
], logs);
|
|
1734
|
+
|
|
1735
|
+
// src/databases/tables/mdCmsSingle.ts
|
|
1736
|
+
var import_sequelize_typescript18 = require("sequelize-typescript");
|
|
1737
|
+
var mdCmsSingle = class extends import_sequelize_typescript18.Model {
|
|
1738
|
+
};
|
|
1739
|
+
__decorateClass([
|
|
1740
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1741
|
+
primaryKey: true,
|
|
1742
|
+
autoIncrement: true,
|
|
1743
|
+
type: import_sequelize_typescript18.DataType.INTEGER
|
|
1744
|
+
})
|
|
1745
|
+
], mdCmsSingle.prototype, "id", 2);
|
|
1746
|
+
__decorateClass([
|
|
1747
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1748
|
+
type: import_sequelize_typescript18.DataType.STRING(60)
|
|
1749
|
+
})
|
|
1750
|
+
], mdCmsSingle.prototype, "uuid", 2);
|
|
1751
|
+
__decorateClass([
|
|
1752
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1637
1753
|
field: "key_name",
|
|
1638
1754
|
allowNull: true,
|
|
1639
|
-
type:
|
|
1755
|
+
type: import_sequelize_typescript18.DataType.STRING(100)
|
|
1640
1756
|
})
|
|
1641
1757
|
], mdCmsSingle.prototype, "keyName", 2);
|
|
1642
1758
|
__decorateClass([
|
|
1643
|
-
(0,
|
|
1759
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1644
1760
|
field: "group_id",
|
|
1645
1761
|
allowNull: true,
|
|
1646
|
-
type:
|
|
1762
|
+
type: import_sequelize_typescript18.DataType.INTEGER
|
|
1647
1763
|
})
|
|
1648
1764
|
], mdCmsSingle.prototype, "groupId", 2);
|
|
1649
1765
|
__decorateClass([
|
|
1650
|
-
(0,
|
|
1766
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1651
1767
|
field: "user_id",
|
|
1652
|
-
type:
|
|
1768
|
+
type: import_sequelize_typescript18.DataType.INTEGER
|
|
1653
1769
|
})
|
|
1654
1770
|
], mdCmsSingle.prototype, "userId", 2);
|
|
1655
1771
|
__decorateClass([
|
|
1656
|
-
(0,
|
|
1772
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1657
1773
|
allowNull: true,
|
|
1658
|
-
type:
|
|
1774
|
+
type: import_sequelize_typescript18.DataType.STRING(255)
|
|
1659
1775
|
})
|
|
1660
1776
|
], mdCmsSingle.prototype, "title", 2);
|
|
1661
1777
|
__decorateClass([
|
|
1662
|
-
(0,
|
|
1778
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1663
1779
|
allowNull: true,
|
|
1664
|
-
type:
|
|
1780
|
+
type: import_sequelize_typescript18.DataType.STRING
|
|
1665
1781
|
})
|
|
1666
1782
|
], mdCmsSingle.prototype, "description", 2);
|
|
1667
1783
|
__decorateClass([
|
|
1668
|
-
(0,
|
|
1784
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1669
1785
|
allowNull: true,
|
|
1670
|
-
type:
|
|
1786
|
+
type: import_sequelize_typescript18.DataType.STRING
|
|
1671
1787
|
})
|
|
1672
1788
|
], mdCmsSingle.prototype, "detail", 2);
|
|
1673
1789
|
__decorateClass([
|
|
1674
|
-
(0,
|
|
1790
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1675
1791
|
field: "meta_title",
|
|
1676
1792
|
allowNull: true,
|
|
1677
|
-
type:
|
|
1793
|
+
type: import_sequelize_typescript18.DataType.STRING(255)
|
|
1678
1794
|
})
|
|
1679
1795
|
], mdCmsSingle.prototype, "metaTitle", 2);
|
|
1680
1796
|
__decorateClass([
|
|
1681
|
-
(0,
|
|
1797
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1682
1798
|
field: "meta_keyword",
|
|
1683
1799
|
allowNull: true,
|
|
1684
|
-
type:
|
|
1800
|
+
type: import_sequelize_typescript18.DataType.STRING(255)
|
|
1685
1801
|
})
|
|
1686
1802
|
], mdCmsSingle.prototype, "metaKeyword", 2);
|
|
1687
1803
|
__decorateClass([
|
|
1688
|
-
(0,
|
|
1804
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1689
1805
|
field: "meta_description",
|
|
1690
1806
|
allowNull: true,
|
|
1691
|
-
type:
|
|
1807
|
+
type: import_sequelize_typescript18.DataType.STRING(255)
|
|
1692
1808
|
})
|
|
1693
1809
|
], mdCmsSingle.prototype, "metaDescription", 2);
|
|
1694
1810
|
__decorateClass([
|
|
1695
|
-
(0,
|
|
1811
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1696
1812
|
field: "image_cover",
|
|
1697
1813
|
allowNull: true,
|
|
1698
|
-
type:
|
|
1814
|
+
type: import_sequelize_typescript18.DataType.STRING(60)
|
|
1699
1815
|
})
|
|
1700
1816
|
], mdCmsSingle.prototype, "imageCover", 2);
|
|
1701
1817
|
__decorateClass([
|
|
1702
|
-
(0,
|
|
1818
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1703
1819
|
allowNull: true,
|
|
1704
|
-
type:
|
|
1820
|
+
type: import_sequelize_typescript18.DataType.JSON
|
|
1705
1821
|
})
|
|
1706
1822
|
], mdCmsSingle.prototype, "attachments", 2);
|
|
1707
1823
|
__decorateClass([
|
|
1708
|
-
(0,
|
|
1824
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1709
1825
|
allowNull: true,
|
|
1710
|
-
type:
|
|
1826
|
+
type: import_sequelize_typescript18.DataType.INTEGER
|
|
1711
1827
|
})
|
|
1712
1828
|
], mdCmsSingle.prototype, "sort", 2);
|
|
1713
1829
|
__decorateClass([
|
|
1714
|
-
(0,
|
|
1830
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1715
1831
|
allowNull: true,
|
|
1716
|
-
type:
|
|
1832
|
+
type: import_sequelize_typescript18.DataType.INTEGER
|
|
1717
1833
|
})
|
|
1718
1834
|
], mdCmsSingle.prototype, "publish", 2);
|
|
1719
1835
|
__decorateClass([
|
|
1720
|
-
(0,
|
|
1836
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1721
1837
|
allowNull: true,
|
|
1722
|
-
type:
|
|
1838
|
+
type: import_sequelize_typescript18.DataType.INTEGER
|
|
1723
1839
|
})
|
|
1724
1840
|
], mdCmsSingle.prototype, "status", 2);
|
|
1725
1841
|
__decorateClass([
|
|
1726
|
-
(0,
|
|
1842
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1727
1843
|
field: "has_expire",
|
|
1728
1844
|
allowNull: true,
|
|
1729
|
-
type:
|
|
1845
|
+
type: import_sequelize_typescript18.DataType.INTEGER
|
|
1730
1846
|
})
|
|
1731
1847
|
], mdCmsSingle.prototype, "hasExpire", 2);
|
|
1732
1848
|
__decorateClass([
|
|
1733
|
-
(0,
|
|
1849
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1734
1850
|
field: "start_date",
|
|
1735
1851
|
allowNull: true,
|
|
1736
|
-
type:
|
|
1852
|
+
type: import_sequelize_typescript18.DataType.DATE
|
|
1737
1853
|
})
|
|
1738
1854
|
], mdCmsSingle.prototype, "startDate", 2);
|
|
1739
1855
|
__decorateClass([
|
|
1740
|
-
(0,
|
|
1856
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1741
1857
|
field: "expire_date",
|
|
1742
1858
|
allowNull: true,
|
|
1743
|
-
type:
|
|
1859
|
+
type: import_sequelize_typescript18.DataType.DATE
|
|
1744
1860
|
})
|
|
1745
1861
|
], mdCmsSingle.prototype, "expireDate", 2);
|
|
1746
1862
|
__decorateClass([
|
|
1747
|
-
(0,
|
|
1863
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1748
1864
|
field: "created_by",
|
|
1749
1865
|
allowNull: true,
|
|
1750
|
-
type:
|
|
1866
|
+
type: import_sequelize_typescript18.DataType.STRING(60)
|
|
1751
1867
|
})
|
|
1752
1868
|
], mdCmsSingle.prototype, "createdBy", 2);
|
|
1753
1869
|
__decorateClass([
|
|
1754
|
-
(0,
|
|
1870
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1755
1871
|
field: "created_date",
|
|
1756
1872
|
allowNull: true,
|
|
1757
|
-
type:
|
|
1873
|
+
type: import_sequelize_typescript18.DataType.DATE
|
|
1758
1874
|
})
|
|
1759
1875
|
], mdCmsSingle.prototype, "createdDate", 2);
|
|
1760
1876
|
__decorateClass([
|
|
1761
|
-
(0,
|
|
1877
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1762
1878
|
field: "updated_by",
|
|
1763
1879
|
allowNull: true,
|
|
1764
|
-
type:
|
|
1880
|
+
type: import_sequelize_typescript18.DataType.STRING(60)
|
|
1765
1881
|
})
|
|
1766
1882
|
], mdCmsSingle.prototype, "updatedBy", 2);
|
|
1767
1883
|
__decorateClass([
|
|
1768
|
-
(0,
|
|
1884
|
+
(0, import_sequelize_typescript18.Column)({
|
|
1769
1885
|
field: "updated_date",
|
|
1770
1886
|
allowNull: true,
|
|
1771
|
-
type:
|
|
1887
|
+
type: import_sequelize_typescript18.DataType.DATE
|
|
1772
1888
|
})
|
|
1773
1889
|
], mdCmsSingle.prototype, "updatedDate", 2);
|
|
1774
1890
|
mdCmsSingle = __decorateClass([
|
|
1775
|
-
(0,
|
|
1891
|
+
(0, import_sequelize_typescript18.Table)({
|
|
1776
1892
|
tableName: "md_cms_single",
|
|
1777
1893
|
timestamps: false
|
|
1778
1894
|
})
|
|
1779
1895
|
], mdCmsSingle);
|
|
1780
1896
|
|
|
1781
1897
|
// src/databases/tables/mdConfiguration.ts
|
|
1782
|
-
var
|
|
1783
|
-
var mdConfiguration = class extends
|
|
1898
|
+
var import_sequelize_typescript19 = require("sequelize-typescript");
|
|
1899
|
+
var mdConfiguration = class extends import_sequelize_typescript19.Model {
|
|
1784
1900
|
};
|
|
1785
1901
|
__decorateClass([
|
|
1786
|
-
(0,
|
|
1902
|
+
(0, import_sequelize_typescript19.Column)({
|
|
1787
1903
|
primaryKey: true,
|
|
1788
1904
|
autoIncrement: true,
|
|
1789
|
-
type:
|
|
1905
|
+
type: import_sequelize_typescript19.DataType.INTEGER
|
|
1790
1906
|
})
|
|
1791
1907
|
], mdConfiguration.prototype, "id", 2);
|
|
1792
1908
|
__decorateClass([
|
|
1793
|
-
(0,
|
|
1909
|
+
(0, import_sequelize_typescript19.Column)({
|
|
1794
1910
|
allowNull: true,
|
|
1795
|
-
type:
|
|
1911
|
+
type: import_sequelize_typescript19.DataType.STRING(60)
|
|
1796
1912
|
})
|
|
1797
1913
|
], mdConfiguration.prototype, "uuid", 2);
|
|
1798
1914
|
__decorateClass([
|
|
1799
|
-
(0,
|
|
1915
|
+
(0, import_sequelize_typescript19.Column)({
|
|
1800
1916
|
field: "key_name",
|
|
1801
1917
|
allowNull: true,
|
|
1802
|
-
type:
|
|
1918
|
+
type: import_sequelize_typescript19.DataType.STRING(100)
|
|
1803
1919
|
})
|
|
1804
1920
|
], mdConfiguration.prototype, "keyName", 2);
|
|
1805
1921
|
__decorateClass([
|
|
1806
|
-
(0,
|
|
1922
|
+
(0, import_sequelize_typescript19.Column)({
|
|
1807
1923
|
allowNull: true,
|
|
1808
|
-
type:
|
|
1924
|
+
type: import_sequelize_typescript19.DataType.STRING(255)
|
|
1809
1925
|
})
|
|
1810
1926
|
], mdConfiguration.prototype, "name", 2);
|
|
1811
1927
|
__decorateClass([
|
|
1812
|
-
(0,
|
|
1928
|
+
(0, import_sequelize_typescript19.Column)({
|
|
1813
1929
|
allowNull: true,
|
|
1814
|
-
type:
|
|
1930
|
+
type: import_sequelize_typescript19.DataType.STRING
|
|
1815
1931
|
})
|
|
1816
1932
|
], mdConfiguration.prototype, "value", 2);
|
|
1817
1933
|
__decorateClass([
|
|
1818
|
-
(0,
|
|
1934
|
+
(0, import_sequelize_typescript19.Column)({
|
|
1819
1935
|
allowNull: true,
|
|
1820
|
-
type:
|
|
1936
|
+
type: import_sequelize_typescript19.DataType.INTEGER
|
|
1821
1937
|
})
|
|
1822
1938
|
], mdConfiguration.prototype, "status", 2);
|
|
1823
1939
|
__decorateClass([
|
|
1824
|
-
(0,
|
|
1940
|
+
(0, import_sequelize_typescript19.Column)({
|
|
1825
1941
|
allowNull: true,
|
|
1826
|
-
type:
|
|
1942
|
+
type: import_sequelize_typescript19.DataType.INTEGER
|
|
1827
1943
|
})
|
|
1828
1944
|
], mdConfiguration.prototype, "total", 2);
|
|
1829
1945
|
__decorateClass([
|
|
1830
|
-
(0,
|
|
1946
|
+
(0, import_sequelize_typescript19.Column)({
|
|
1831
1947
|
field: "created_by",
|
|
1832
1948
|
allowNull: true,
|
|
1833
|
-
type:
|
|
1949
|
+
type: import_sequelize_typescript19.DataType.STRING(60)
|
|
1834
1950
|
})
|
|
1835
1951
|
], mdConfiguration.prototype, "createdBy", 2);
|
|
1836
1952
|
__decorateClass([
|
|
1837
|
-
(0,
|
|
1953
|
+
(0, import_sequelize_typescript19.Column)({
|
|
1838
1954
|
field: "created_date",
|
|
1839
1955
|
allowNull: true,
|
|
1840
|
-
type:
|
|
1956
|
+
type: import_sequelize_typescript19.DataType.DATE
|
|
1841
1957
|
})
|
|
1842
1958
|
], mdConfiguration.prototype, "createdDate", 2);
|
|
1843
1959
|
__decorateClass([
|
|
1844
|
-
(0,
|
|
1960
|
+
(0, import_sequelize_typescript19.Column)({
|
|
1845
1961
|
field: "updated_by",
|
|
1846
1962
|
allowNull: true,
|
|
1847
|
-
type:
|
|
1963
|
+
type: import_sequelize_typescript19.DataType.STRING(60)
|
|
1848
1964
|
})
|
|
1849
1965
|
], mdConfiguration.prototype, "updatedBy", 2);
|
|
1850
1966
|
__decorateClass([
|
|
1851
|
-
(0,
|
|
1967
|
+
(0, import_sequelize_typescript19.Column)({
|
|
1852
1968
|
field: "updated_date",
|
|
1853
1969
|
allowNull: true,
|
|
1854
|
-
type:
|
|
1970
|
+
type: import_sequelize_typescript19.DataType.DATE
|
|
1855
1971
|
})
|
|
1856
1972
|
], mdConfiguration.prototype, "updatedDate", 2);
|
|
1857
1973
|
mdConfiguration = __decorateClass([
|
|
1858
|
-
(0,
|
|
1974
|
+
(0, import_sequelize_typescript19.Table)({
|
|
1859
1975
|
tableName: "md_configuration",
|
|
1860
1976
|
timestamps: false
|
|
1861
1977
|
})
|
|
1862
1978
|
], mdConfiguration);
|
|
1863
1979
|
|
|
1864
1980
|
// src/databases/tables/mdDocumentPdf.ts
|
|
1865
|
-
var
|
|
1866
|
-
var mdDocumentPdf = class extends
|
|
1981
|
+
var import_sequelize_typescript20 = require("sequelize-typescript");
|
|
1982
|
+
var mdDocumentPdf = class extends import_sequelize_typescript20.Model {
|
|
1867
1983
|
};
|
|
1868
1984
|
__decorateClass([
|
|
1869
|
-
(0,
|
|
1985
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1870
1986
|
primaryKey: true,
|
|
1871
1987
|
autoIncrement: true,
|
|
1872
|
-
type:
|
|
1988
|
+
type: import_sequelize_typescript20.DataType.INTEGER
|
|
1873
1989
|
})
|
|
1874
1990
|
], mdDocumentPdf.prototype, "id", 2);
|
|
1875
1991
|
__decorateClass([
|
|
1876
|
-
(0,
|
|
1992
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1877
1993
|
allowNull: true,
|
|
1878
|
-
type:
|
|
1994
|
+
type: import_sequelize_typescript20.DataType.STRING(60)
|
|
1879
1995
|
})
|
|
1880
1996
|
], mdDocumentPdf.prototype, "uuid", 2);
|
|
1881
1997
|
__decorateClass([
|
|
1882
|
-
(0,
|
|
1998
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1883
1999
|
field: "key_name",
|
|
1884
2000
|
allowNull: true,
|
|
1885
|
-
type:
|
|
2001
|
+
type: import_sequelize_typescript20.DataType.STRING(100)
|
|
1886
2002
|
})
|
|
1887
2003
|
], mdDocumentPdf.prototype, "keyName", 2);
|
|
1888
2004
|
__decorateClass([
|
|
1889
|
-
(0,
|
|
2005
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1890
2006
|
field: "user_id",
|
|
1891
2007
|
allowNull: true,
|
|
1892
|
-
type:
|
|
2008
|
+
type: import_sequelize_typescript20.DataType.INTEGER
|
|
1893
2009
|
})
|
|
1894
2010
|
], mdDocumentPdf.prototype, "userId", 2);
|
|
1895
2011
|
__decorateClass([
|
|
1896
|
-
(0,
|
|
2012
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1897
2013
|
allowNull: true,
|
|
1898
|
-
type:
|
|
2014
|
+
type: import_sequelize_typescript20.DataType.STRING(255)
|
|
1899
2015
|
})
|
|
1900
2016
|
], mdDocumentPdf.prototype, "title", 2);
|
|
1901
2017
|
__decorateClass([
|
|
1902
|
-
(0,
|
|
2018
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1903
2019
|
allowNull: true,
|
|
1904
|
-
type:
|
|
2020
|
+
type: import_sequelize_typescript20.DataType.STRING
|
|
1905
2021
|
})
|
|
1906
2022
|
], mdDocumentPdf.prototype, "description", 2);
|
|
1907
2023
|
__decorateClass([
|
|
1908
|
-
(0,
|
|
2024
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1909
2025
|
field: "file_uuid",
|
|
1910
2026
|
allowNull: true,
|
|
1911
|
-
type:
|
|
2027
|
+
type: import_sequelize_typescript20.DataType.STRING(60)
|
|
1912
2028
|
})
|
|
1913
2029
|
], mdDocumentPdf.prototype, "fileUuid", 2);
|
|
1914
2030
|
__decorateClass([
|
|
1915
|
-
(0,
|
|
2031
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1916
2032
|
allowNull: true,
|
|
1917
|
-
type:
|
|
2033
|
+
type: import_sequelize_typescript20.DataType.JSON
|
|
1918
2034
|
})
|
|
1919
2035
|
], mdDocumentPdf.prototype, "attachments", 2);
|
|
1920
2036
|
__decorateClass([
|
|
1921
|
-
(0,
|
|
2037
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1922
2038
|
field: "total_download",
|
|
1923
2039
|
allowNull: true,
|
|
1924
|
-
type:
|
|
2040
|
+
type: import_sequelize_typescript20.DataType.INTEGER
|
|
1925
2041
|
})
|
|
1926
2042
|
], mdDocumentPdf.prototype, "totalDownload", 2);
|
|
1927
2043
|
__decorateClass([
|
|
1928
|
-
(0,
|
|
2044
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1929
2045
|
allowNull: true,
|
|
1930
|
-
type:
|
|
2046
|
+
type: import_sequelize_typescript20.DataType.INTEGER
|
|
1931
2047
|
})
|
|
1932
2048
|
], mdDocumentPdf.prototype, "sort", 2);
|
|
1933
2049
|
__decorateClass([
|
|
1934
|
-
(0,
|
|
2050
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1935
2051
|
allowNull: true,
|
|
1936
|
-
type:
|
|
2052
|
+
type: import_sequelize_typescript20.DataType.INTEGER
|
|
1937
2053
|
})
|
|
1938
2054
|
], mdDocumentPdf.prototype, "status", 2);
|
|
1939
2055
|
__decorateClass([
|
|
1940
|
-
(0,
|
|
2056
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1941
2057
|
field: "has_expire",
|
|
1942
2058
|
allowNull: true,
|
|
1943
|
-
type:
|
|
2059
|
+
type: import_sequelize_typescript20.DataType.INTEGER
|
|
1944
2060
|
})
|
|
1945
2061
|
], mdDocumentPdf.prototype, "hasExpire", 2);
|
|
1946
2062
|
__decorateClass([
|
|
1947
|
-
(0,
|
|
2063
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1948
2064
|
field: "start_date",
|
|
1949
2065
|
allowNull: true,
|
|
1950
|
-
type:
|
|
2066
|
+
type: import_sequelize_typescript20.DataType.DATE
|
|
1951
2067
|
})
|
|
1952
2068
|
], mdDocumentPdf.prototype, "startDate", 2);
|
|
1953
2069
|
__decorateClass([
|
|
1954
|
-
(0,
|
|
2070
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1955
2071
|
field: "expire_date",
|
|
1956
2072
|
allowNull: true,
|
|
1957
|
-
type:
|
|
2073
|
+
type: import_sequelize_typescript20.DataType.DATE
|
|
1958
2074
|
})
|
|
1959
2075
|
], mdDocumentPdf.prototype, "expireDate", 2);
|
|
1960
2076
|
__decorateClass([
|
|
1961
|
-
(0,
|
|
2077
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1962
2078
|
field: "created_by",
|
|
1963
2079
|
allowNull: true,
|
|
1964
|
-
type:
|
|
2080
|
+
type: import_sequelize_typescript20.DataType.STRING(60)
|
|
1965
2081
|
})
|
|
1966
2082
|
], mdDocumentPdf.prototype, "createdBy", 2);
|
|
1967
2083
|
__decorateClass([
|
|
1968
|
-
(0,
|
|
2084
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1969
2085
|
field: "created_date",
|
|
1970
2086
|
allowNull: true,
|
|
1971
|
-
type:
|
|
2087
|
+
type: import_sequelize_typescript20.DataType.DATE
|
|
1972
2088
|
})
|
|
1973
2089
|
], mdDocumentPdf.prototype, "createdDate", 2);
|
|
1974
2090
|
__decorateClass([
|
|
1975
|
-
(0,
|
|
2091
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1976
2092
|
field: "updated_by",
|
|
1977
2093
|
allowNull: true,
|
|
1978
|
-
type:
|
|
2094
|
+
type: import_sequelize_typescript20.DataType.STRING(60)
|
|
1979
2095
|
})
|
|
1980
2096
|
], mdDocumentPdf.prototype, "updatedBy", 2);
|
|
1981
2097
|
__decorateClass([
|
|
1982
|
-
(0,
|
|
2098
|
+
(0, import_sequelize_typescript20.Column)({
|
|
1983
2099
|
field: "updated_date",
|
|
1984
2100
|
allowNull: true,
|
|
1985
|
-
type:
|
|
2101
|
+
type: import_sequelize_typescript20.DataType.DATE
|
|
1986
2102
|
})
|
|
1987
2103
|
], mdDocumentPdf.prototype, "updatedDate", 2);
|
|
1988
2104
|
mdDocumentPdf = __decorateClass([
|
|
1989
|
-
(0,
|
|
2105
|
+
(0, import_sequelize_typescript20.Table)({
|
|
1990
2106
|
tableName: "md_document_pdf",
|
|
1991
2107
|
timestamps: false
|
|
1992
2108
|
})
|
|
1993
2109
|
], mdDocumentPdf);
|
|
1994
2110
|
|
|
1995
2111
|
// src/databases/tables/mdDownload.ts
|
|
1996
|
-
var
|
|
2112
|
+
var import_sequelize_typescript22 = require("sequelize-typescript");
|
|
1997
2113
|
|
|
1998
2114
|
// src/databases/tables/mdDownloadGroup.ts
|
|
1999
|
-
var
|
|
2000
|
-
var mdDownloadGroup = class extends
|
|
2115
|
+
var import_sequelize_typescript21 = require("sequelize-typescript");
|
|
2116
|
+
var mdDownloadGroup = class extends import_sequelize_typescript21.Model {
|
|
2001
2117
|
};
|
|
2002
2118
|
__decorateClass([
|
|
2003
|
-
(0,
|
|
2119
|
+
(0, import_sequelize_typescript21.Column)({
|
|
2004
2120
|
primaryKey: true,
|
|
2005
2121
|
autoIncrement: true,
|
|
2006
|
-
type:
|
|
2122
|
+
type: import_sequelize_typescript21.DataType.INTEGER
|
|
2007
2123
|
})
|
|
2008
2124
|
], mdDownloadGroup.prototype, "id", 2);
|
|
2009
2125
|
__decorateClass([
|
|
2010
|
-
(0,
|
|
2126
|
+
(0, import_sequelize_typescript21.Column)({
|
|
2011
2127
|
allowNull: true,
|
|
2012
|
-
type:
|
|
2128
|
+
type: import_sequelize_typescript21.DataType.STRING(60)
|
|
2013
2129
|
})
|
|
2014
2130
|
], mdDownloadGroup.prototype, "uuid", 2);
|
|
2015
2131
|
__decorateClass([
|
|
2016
|
-
(0,
|
|
2132
|
+
(0, import_sequelize_typescript21.Column)({
|
|
2017
2133
|
field: "key_name",
|
|
2018
2134
|
allowNull: true,
|
|
2019
|
-
type:
|
|
2135
|
+
type: import_sequelize_typescript21.DataType.STRING(100)
|
|
2020
2136
|
})
|
|
2021
2137
|
], mdDownloadGroup.prototype, "keyName", 2);
|
|
2022
2138
|
__decorateClass([
|
|
2023
|
-
(0,
|
|
2139
|
+
(0, import_sequelize_typescript21.Column)({
|
|
2024
2140
|
field: "user_id",
|
|
2025
2141
|
allowNull: true,
|
|
2026
|
-
type:
|
|
2142
|
+
type: import_sequelize_typescript21.DataType.INTEGER
|
|
2027
2143
|
})
|
|
2028
2144
|
], mdDownloadGroup.prototype, "userId", 2);
|
|
2029
2145
|
__decorateClass([
|
|
2030
|
-
(0,
|
|
2031
|
-
type:
|
|
2146
|
+
(0, import_sequelize_typescript21.Column)({
|
|
2147
|
+
type: import_sequelize_typescript21.DataType.STRING(255)
|
|
2032
2148
|
})
|
|
2033
2149
|
], mdDownloadGroup.prototype, "name", 2);
|
|
2034
2150
|
__decorateClass([
|
|
2035
|
-
(0,
|
|
2151
|
+
(0, import_sequelize_typescript21.Column)({
|
|
2036
2152
|
allowNull: true,
|
|
2037
|
-
type:
|
|
2153
|
+
type: import_sequelize_typescript21.DataType.STRING(255)
|
|
2038
2154
|
})
|
|
2039
2155
|
], mdDownloadGroup.prototype, "description", 2);
|
|
2040
2156
|
__decorateClass([
|
|
2041
|
-
(0,
|
|
2157
|
+
(0, import_sequelize_typescript21.Column)({
|
|
2042
2158
|
allowNull: true,
|
|
2043
|
-
type:
|
|
2159
|
+
type: import_sequelize_typescript21.DataType.INTEGER
|
|
2044
2160
|
})
|
|
2045
2161
|
], mdDownloadGroup.prototype, "status", 2);
|
|
2046
2162
|
__decorateClass([
|
|
2047
|
-
(0,
|
|
2163
|
+
(0, import_sequelize_typescript21.Column)({
|
|
2048
2164
|
field: "created_by",
|
|
2049
2165
|
allowNull: true,
|
|
2050
|
-
type:
|
|
2166
|
+
type: import_sequelize_typescript21.DataType.STRING(60)
|
|
2051
2167
|
})
|
|
2052
2168
|
], mdDownloadGroup.prototype, "createdBy", 2);
|
|
2053
2169
|
__decorateClass([
|
|
2054
|
-
(0,
|
|
2170
|
+
(0, import_sequelize_typescript21.Column)({
|
|
2055
2171
|
field: "created_date",
|
|
2056
2172
|
allowNull: true,
|
|
2057
|
-
type:
|
|
2173
|
+
type: import_sequelize_typescript21.DataType.DATE
|
|
2058
2174
|
})
|
|
2059
2175
|
], mdDownloadGroup.prototype, "createdDate", 2);
|
|
2060
2176
|
__decorateClass([
|
|
2061
|
-
(0,
|
|
2177
|
+
(0, import_sequelize_typescript21.Column)({
|
|
2062
2178
|
field: "updated_by",
|
|
2063
2179
|
allowNull: true,
|
|
2064
|
-
type:
|
|
2180
|
+
type: import_sequelize_typescript21.DataType.STRING(60)
|
|
2065
2181
|
})
|
|
2066
2182
|
], mdDownloadGroup.prototype, "updatedBy", 2);
|
|
2067
2183
|
__decorateClass([
|
|
2068
|
-
(0,
|
|
2184
|
+
(0, import_sequelize_typescript21.Column)({
|
|
2069
2185
|
field: "updated_date",
|
|
2070
2186
|
allowNull: true,
|
|
2071
|
-
type:
|
|
2187
|
+
type: import_sequelize_typescript21.DataType.DATE
|
|
2072
2188
|
})
|
|
2073
2189
|
], mdDownloadGroup.prototype, "updatedDate", 2);
|
|
2074
2190
|
__decorateClass([
|
|
2075
|
-
(0,
|
|
2191
|
+
(0, import_sequelize_typescript21.HasMany)(() => mdDownload, {
|
|
2076
2192
|
sourceKey: "id"
|
|
2077
2193
|
})
|
|
2078
2194
|
], mdDownloadGroup.prototype, "mdDownloads", 2);
|
|
2079
2195
|
mdDownloadGroup = __decorateClass([
|
|
2080
|
-
(0,
|
|
2196
|
+
(0, import_sequelize_typescript21.Table)({
|
|
2081
2197
|
tableName: "md_download_group",
|
|
2082
2198
|
timestamps: false
|
|
2083
2199
|
})
|
|
2084
2200
|
], mdDownloadGroup);
|
|
2085
2201
|
|
|
2086
2202
|
// src/databases/tables/mdDownload.ts
|
|
2087
|
-
var mdDownload = class extends
|
|
2203
|
+
var mdDownload = class extends import_sequelize_typescript22.Model {
|
|
2088
2204
|
};
|
|
2089
2205
|
__decorateClass([
|
|
2090
|
-
(0,
|
|
2206
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2091
2207
|
primaryKey: true,
|
|
2092
2208
|
autoIncrement: true,
|
|
2093
|
-
type:
|
|
2209
|
+
type: import_sequelize_typescript22.DataType.INTEGER
|
|
2094
2210
|
})
|
|
2095
2211
|
], mdDownload.prototype, "id", 2);
|
|
2096
2212
|
__decorateClass([
|
|
2097
|
-
(0,
|
|
2098
|
-
type:
|
|
2213
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2214
|
+
type: import_sequelize_typescript22.DataType.STRING(60)
|
|
2099
2215
|
})
|
|
2100
2216
|
], mdDownload.prototype, "uuid", 2);
|
|
2101
2217
|
__decorateClass([
|
|
2102
|
-
(0,
|
|
2218
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2103
2219
|
field: "key_name",
|
|
2104
2220
|
allowNull: true,
|
|
2105
|
-
type:
|
|
2221
|
+
type: import_sequelize_typescript22.DataType.STRING(100)
|
|
2106
2222
|
})
|
|
2107
2223
|
], mdDownload.prototype, "keyName", 2);
|
|
2108
2224
|
__decorateClass([
|
|
2109
|
-
(0,
|
|
2110
|
-
(0,
|
|
2225
|
+
(0, import_sequelize_typescript22.ForeignKey)(() => mdDownloadGroup),
|
|
2226
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2111
2227
|
field: "group_id",
|
|
2112
2228
|
allowNull: true,
|
|
2113
|
-
type:
|
|
2229
|
+
type: import_sequelize_typescript22.DataType.INTEGER
|
|
2114
2230
|
})
|
|
2115
2231
|
], mdDownload.prototype, "groupId", 2);
|
|
2116
2232
|
__decorateClass([
|
|
2117
|
-
(0,
|
|
2233
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2118
2234
|
field: "user_id",
|
|
2119
|
-
type:
|
|
2235
|
+
type: import_sequelize_typescript22.DataType.INTEGER
|
|
2120
2236
|
})
|
|
2121
2237
|
], mdDownload.prototype, "userId", 2);
|
|
2122
2238
|
__decorateClass([
|
|
2123
|
-
(0,
|
|
2239
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2124
2240
|
allowNull: true,
|
|
2125
|
-
type:
|
|
2241
|
+
type: import_sequelize_typescript22.DataType.STRING(500)
|
|
2126
2242
|
})
|
|
2127
2243
|
], mdDownload.prototype, "title", 2);
|
|
2128
2244
|
__decorateClass([
|
|
2129
|
-
(0,
|
|
2245
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2130
2246
|
allowNull: true,
|
|
2131
|
-
type:
|
|
2247
|
+
type: import_sequelize_typescript22.DataType.STRING
|
|
2132
2248
|
})
|
|
2133
2249
|
], mdDownload.prototype, "description", 2);
|
|
2134
2250
|
__decorateClass([
|
|
2135
|
-
(0,
|
|
2251
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2136
2252
|
allowNull: true,
|
|
2137
|
-
type:
|
|
2253
|
+
type: import_sequelize_typescript22.DataType.STRING
|
|
2138
2254
|
})
|
|
2139
2255
|
], mdDownload.prototype, "detail", 2);
|
|
2140
2256
|
__decorateClass([
|
|
2141
|
-
(0,
|
|
2257
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2142
2258
|
field: "meta_title",
|
|
2143
2259
|
allowNull: true,
|
|
2144
|
-
type:
|
|
2260
|
+
type: import_sequelize_typescript22.DataType.STRING(500)
|
|
2145
2261
|
})
|
|
2146
2262
|
], mdDownload.prototype, "metaTitle", 2);
|
|
2147
2263
|
__decorateClass([
|
|
2148
|
-
(0,
|
|
2264
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2149
2265
|
field: "meta_keyword",
|
|
2150
2266
|
allowNull: true,
|
|
2151
|
-
type:
|
|
2267
|
+
type: import_sequelize_typescript22.DataType.STRING(500)
|
|
2152
2268
|
})
|
|
2153
2269
|
], mdDownload.prototype, "metaKeyword", 2);
|
|
2154
2270
|
__decorateClass([
|
|
2155
|
-
(0,
|
|
2271
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2156
2272
|
field: "meta_description",
|
|
2157
2273
|
allowNull: true,
|
|
2158
|
-
type:
|
|
2274
|
+
type: import_sequelize_typescript22.DataType.STRING(500)
|
|
2159
2275
|
})
|
|
2160
2276
|
], mdDownload.prototype, "metaDescription", 2);
|
|
2161
2277
|
__decorateClass([
|
|
2162
|
-
(0,
|
|
2278
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2163
2279
|
field: "image_cover",
|
|
2164
2280
|
allowNull: true,
|
|
2165
|
-
type:
|
|
2281
|
+
type: import_sequelize_typescript22.DataType.STRING(60)
|
|
2166
2282
|
})
|
|
2167
2283
|
], mdDownload.prototype, "imageCover", 2);
|
|
2168
2284
|
__decorateClass([
|
|
2169
|
-
(0,
|
|
2285
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2170
2286
|
allowNull: true,
|
|
2171
|
-
type:
|
|
2287
|
+
type: import_sequelize_typescript22.DataType.STRING(60)
|
|
2172
2288
|
})
|
|
2173
2289
|
], mdDownload.prototype, "video", 2);
|
|
2174
2290
|
__decorateClass([
|
|
2175
|
-
(0,
|
|
2291
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2176
2292
|
field: "image_gallery",
|
|
2177
2293
|
allowNull: true,
|
|
2178
|
-
type:
|
|
2294
|
+
type: import_sequelize_typescript22.DataType.JSON
|
|
2179
2295
|
})
|
|
2180
2296
|
], mdDownload.prototype, "imageGallery", 2);
|
|
2181
2297
|
__decorateClass([
|
|
2182
|
-
(0,
|
|
2298
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2183
2299
|
allowNull: true,
|
|
2184
|
-
type:
|
|
2300
|
+
type: import_sequelize_typescript22.DataType.JSON
|
|
2185
2301
|
})
|
|
2186
2302
|
], mdDownload.prototype, "attachments", 2);
|
|
2187
2303
|
__decorateClass([
|
|
2188
|
-
(0,
|
|
2304
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2189
2305
|
allowNull: true,
|
|
2190
|
-
type:
|
|
2306
|
+
type: import_sequelize_typescript22.DataType.INTEGER
|
|
2191
2307
|
})
|
|
2192
2308
|
], mdDownload.prototype, "highlight", 2);
|
|
2193
2309
|
__decorateClass([
|
|
2194
|
-
(0,
|
|
2310
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2195
2311
|
allowNull: true,
|
|
2196
|
-
type:
|
|
2312
|
+
type: import_sequelize_typescript22.DataType.INTEGER
|
|
2197
2313
|
})
|
|
2198
2314
|
], mdDownload.prototype, "sort", 2);
|
|
2199
2315
|
__decorateClass([
|
|
2200
|
-
(0,
|
|
2316
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2201
2317
|
allowNull: true,
|
|
2202
|
-
type:
|
|
2318
|
+
type: import_sequelize_typescript22.DataType.INTEGER
|
|
2203
2319
|
})
|
|
2204
2320
|
], mdDownload.prototype, "status", 2);
|
|
2205
2321
|
__decorateClass([
|
|
2206
|
-
(0,
|
|
2322
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2207
2323
|
allowNull: true,
|
|
2208
|
-
type:
|
|
2324
|
+
type: import_sequelize_typescript22.DataType.INTEGER
|
|
2209
2325
|
})
|
|
2210
2326
|
], mdDownload.prototype, "publish", 2);
|
|
2211
2327
|
__decorateClass([
|
|
2212
|
-
(0,
|
|
2328
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2213
2329
|
field: "has_expire",
|
|
2214
|
-
type:
|
|
2330
|
+
type: import_sequelize_typescript22.DataType.INTEGER
|
|
2215
2331
|
})
|
|
2216
2332
|
], mdDownload.prototype, "hasExpire", 2);
|
|
2217
2333
|
__decorateClass([
|
|
2218
|
-
(0,
|
|
2334
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2219
2335
|
field: "start_date",
|
|
2220
2336
|
allowNull: true,
|
|
2221
|
-
type:
|
|
2337
|
+
type: import_sequelize_typescript22.DataType.DATE
|
|
2222
2338
|
})
|
|
2223
2339
|
], mdDownload.prototype, "startDate", 2);
|
|
2224
2340
|
__decorateClass([
|
|
2225
|
-
(0,
|
|
2341
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2226
2342
|
field: "expire_date",
|
|
2227
2343
|
allowNull: true,
|
|
2228
|
-
type:
|
|
2344
|
+
type: import_sequelize_typescript22.DataType.DATE
|
|
2229
2345
|
})
|
|
2230
2346
|
], mdDownload.prototype, "expireDate", 2);
|
|
2231
2347
|
__decorateClass([
|
|
2232
|
-
(0,
|
|
2348
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2233
2349
|
field: "created_by",
|
|
2234
2350
|
allowNull: true,
|
|
2235
|
-
type:
|
|
2351
|
+
type: import_sequelize_typescript22.DataType.STRING(60)
|
|
2236
2352
|
})
|
|
2237
2353
|
], mdDownload.prototype, "createdBy", 2);
|
|
2238
2354
|
__decorateClass([
|
|
2239
|
-
(0,
|
|
2355
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2240
2356
|
field: "created_date",
|
|
2241
2357
|
allowNull: true,
|
|
2242
|
-
type:
|
|
2358
|
+
type: import_sequelize_typescript22.DataType.DATE
|
|
2243
2359
|
})
|
|
2244
2360
|
], mdDownload.prototype, "createdDate", 2);
|
|
2245
2361
|
__decorateClass([
|
|
2246
|
-
(0,
|
|
2362
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2247
2363
|
field: "updated_by",
|
|
2248
2364
|
allowNull: true,
|
|
2249
|
-
type:
|
|
2365
|
+
type: import_sequelize_typescript22.DataType.STRING(60)
|
|
2250
2366
|
})
|
|
2251
2367
|
], mdDownload.prototype, "updatedBy", 2);
|
|
2252
2368
|
__decorateClass([
|
|
2253
|
-
(0,
|
|
2369
|
+
(0, import_sequelize_typescript22.Column)({
|
|
2254
2370
|
field: "updated_date",
|
|
2255
2371
|
allowNull: true,
|
|
2256
|
-
type:
|
|
2372
|
+
type: import_sequelize_typescript22.DataType.DATE
|
|
2257
2373
|
})
|
|
2258
2374
|
], mdDownload.prototype, "updatedDate", 2);
|
|
2259
2375
|
__decorateClass([
|
|
2260
|
-
(0,
|
|
2376
|
+
(0, import_sequelize_typescript22.BelongsTo)(() => mdDownloadGroup)
|
|
2261
2377
|
], mdDownload.prototype, "mdDownloadGroup", 2);
|
|
2262
2378
|
mdDownload = __decorateClass([
|
|
2263
|
-
(0,
|
|
2379
|
+
(0, import_sequelize_typescript22.Table)({
|
|
2264
2380
|
tableName: "md_download",
|
|
2265
2381
|
timestamps: false
|
|
2266
2382
|
})
|
|
2267
2383
|
], mdDownload);
|
|
2268
2384
|
|
|
2269
2385
|
// src/databases/tables/mdEbook.ts
|
|
2270
|
-
var
|
|
2386
|
+
var import_sequelize_typescript24 = require("sequelize-typescript");
|
|
2271
2387
|
|
|
2272
2388
|
// src/databases/tables/mdEbookGroup.ts
|
|
2273
|
-
var
|
|
2274
|
-
var mdEbookGroup = class extends
|
|
2389
|
+
var import_sequelize_typescript23 = require("sequelize-typescript");
|
|
2390
|
+
var mdEbookGroup = class extends import_sequelize_typescript23.Model {
|
|
2275
2391
|
};
|
|
2276
2392
|
__decorateClass([
|
|
2277
|
-
(0,
|
|
2393
|
+
(0, import_sequelize_typescript23.Column)({
|
|
2278
2394
|
primaryKey: true,
|
|
2279
2395
|
autoIncrement: true,
|
|
2280
|
-
type:
|
|
2396
|
+
type: import_sequelize_typescript23.DataType.INTEGER
|
|
2281
2397
|
})
|
|
2282
2398
|
], mdEbookGroup.prototype, "id", 2);
|
|
2283
2399
|
__decorateClass([
|
|
2284
|
-
(0,
|
|
2400
|
+
(0, import_sequelize_typescript23.Column)({
|
|
2285
2401
|
allowNull: true,
|
|
2286
|
-
type:
|
|
2402
|
+
type: import_sequelize_typescript23.DataType.STRING(60)
|
|
2287
2403
|
})
|
|
2288
2404
|
], mdEbookGroup.prototype, "uuid", 2);
|
|
2289
2405
|
__decorateClass([
|
|
2290
|
-
(0,
|
|
2406
|
+
(0, import_sequelize_typescript23.Column)({
|
|
2291
2407
|
field: "key_name",
|
|
2292
2408
|
allowNull: true,
|
|
2293
|
-
type:
|
|
2409
|
+
type: import_sequelize_typescript23.DataType.STRING(100)
|
|
2294
2410
|
})
|
|
2295
2411
|
], mdEbookGroup.prototype, "keyName", 2);
|
|
2296
2412
|
__decorateClass([
|
|
2297
|
-
(0,
|
|
2413
|
+
(0, import_sequelize_typescript23.Column)({
|
|
2298
2414
|
field: "user_id",
|
|
2299
2415
|
allowNull: true,
|
|
2300
|
-
type:
|
|
2416
|
+
type: import_sequelize_typescript23.DataType.INTEGER
|
|
2301
2417
|
})
|
|
2302
2418
|
], mdEbookGroup.prototype, "userId", 2);
|
|
2303
2419
|
__decorateClass([
|
|
2304
|
-
(0,
|
|
2305
|
-
type:
|
|
2420
|
+
(0, import_sequelize_typescript23.Column)({
|
|
2421
|
+
type: import_sequelize_typescript23.DataType.STRING(255)
|
|
2306
2422
|
})
|
|
2307
2423
|
], mdEbookGroup.prototype, "name", 2);
|
|
2308
2424
|
__decorateClass([
|
|
2309
|
-
(0,
|
|
2425
|
+
(0, import_sequelize_typescript23.Column)({
|
|
2310
2426
|
allowNull: true,
|
|
2311
|
-
type:
|
|
2427
|
+
type: import_sequelize_typescript23.DataType.STRING(255)
|
|
2312
2428
|
})
|
|
2313
2429
|
], mdEbookGroup.prototype, "description", 2);
|
|
2314
2430
|
__decorateClass([
|
|
2315
|
-
(0,
|
|
2431
|
+
(0, import_sequelize_typescript23.Column)({
|
|
2316
2432
|
allowNull: true,
|
|
2317
|
-
type:
|
|
2433
|
+
type: import_sequelize_typescript23.DataType.INTEGER
|
|
2318
2434
|
})
|
|
2319
2435
|
], mdEbookGroup.prototype, "status", 2);
|
|
2320
2436
|
__decorateClass([
|
|
2321
|
-
(0,
|
|
2437
|
+
(0, import_sequelize_typescript23.Column)({
|
|
2322
2438
|
field: "created_by",
|
|
2323
2439
|
allowNull: true,
|
|
2324
|
-
type:
|
|
2440
|
+
type: import_sequelize_typescript23.DataType.STRING(60)
|
|
2325
2441
|
})
|
|
2326
2442
|
], mdEbookGroup.prototype, "createdBy", 2);
|
|
2327
2443
|
__decorateClass([
|
|
2328
|
-
(0,
|
|
2444
|
+
(0, import_sequelize_typescript23.Column)({
|
|
2329
2445
|
field: "created_date",
|
|
2330
2446
|
allowNull: true,
|
|
2331
|
-
type:
|
|
2447
|
+
type: import_sequelize_typescript23.DataType.DATE
|
|
2332
2448
|
})
|
|
2333
2449
|
], mdEbookGroup.prototype, "createdDate", 2);
|
|
2334
2450
|
__decorateClass([
|
|
2335
|
-
(0,
|
|
2451
|
+
(0, import_sequelize_typescript23.Column)({
|
|
2336
2452
|
field: "updated_by",
|
|
2337
2453
|
allowNull: true,
|
|
2338
|
-
type:
|
|
2454
|
+
type: import_sequelize_typescript23.DataType.STRING(60)
|
|
2339
2455
|
})
|
|
2340
2456
|
], mdEbookGroup.prototype, "updatedBy", 2);
|
|
2341
2457
|
__decorateClass([
|
|
2342
|
-
(0,
|
|
2458
|
+
(0, import_sequelize_typescript23.Column)({
|
|
2343
2459
|
field: "updated_date",
|
|
2344
2460
|
allowNull: true,
|
|
2345
|
-
type:
|
|
2461
|
+
type: import_sequelize_typescript23.DataType.DATE
|
|
2346
2462
|
})
|
|
2347
2463
|
], mdEbookGroup.prototype, "updatedDate", 2);
|
|
2348
2464
|
__decorateClass([
|
|
2349
|
-
(0,
|
|
2465
|
+
(0, import_sequelize_typescript23.HasMany)(() => mdEbook, {
|
|
2350
2466
|
sourceKey: "id"
|
|
2351
2467
|
})
|
|
2352
2468
|
], mdEbookGroup.prototype, "mdEbooks", 2);
|
|
2353
2469
|
mdEbookGroup = __decorateClass([
|
|
2354
|
-
(0,
|
|
2470
|
+
(0, import_sequelize_typescript23.Table)({
|
|
2355
2471
|
tableName: "md_ebook_group",
|
|
2356
2472
|
timestamps: false
|
|
2357
2473
|
})
|
|
2358
2474
|
], mdEbookGroup);
|
|
2359
2475
|
|
|
2360
2476
|
// src/databases/tables/mdEbook.ts
|
|
2361
|
-
var mdEbook = class extends
|
|
2477
|
+
var mdEbook = class extends import_sequelize_typescript24.Model {
|
|
2362
2478
|
};
|
|
2363
2479
|
__decorateClass([
|
|
2364
|
-
(0,
|
|
2480
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2365
2481
|
primaryKey: true,
|
|
2366
2482
|
autoIncrement: true,
|
|
2367
|
-
type:
|
|
2483
|
+
type: import_sequelize_typescript24.DataType.INTEGER
|
|
2368
2484
|
})
|
|
2369
2485
|
], mdEbook.prototype, "id", 2);
|
|
2370
2486
|
__decorateClass([
|
|
2371
|
-
(0,
|
|
2372
|
-
type:
|
|
2487
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2488
|
+
type: import_sequelize_typescript24.DataType.STRING(60)
|
|
2373
2489
|
})
|
|
2374
2490
|
], mdEbook.prototype, "uuid", 2);
|
|
2375
2491
|
__decorateClass([
|
|
2376
|
-
(0,
|
|
2492
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2377
2493
|
field: "key_name",
|
|
2378
2494
|
allowNull: true,
|
|
2379
|
-
type:
|
|
2495
|
+
type: import_sequelize_typescript24.DataType.STRING(100)
|
|
2380
2496
|
})
|
|
2381
2497
|
], mdEbook.prototype, "keyName", 2);
|
|
2382
2498
|
__decorateClass([
|
|
2383
|
-
(0,
|
|
2384
|
-
(0,
|
|
2499
|
+
(0, import_sequelize_typescript24.ForeignKey)(() => mdEbookGroup),
|
|
2500
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2385
2501
|
field: "group_id",
|
|
2386
2502
|
allowNull: true,
|
|
2387
|
-
type:
|
|
2503
|
+
type: import_sequelize_typescript24.DataType.INTEGER
|
|
2388
2504
|
})
|
|
2389
2505
|
], mdEbook.prototype, "groupId", 2);
|
|
2390
2506
|
__decorateClass([
|
|
2391
|
-
(0,
|
|
2507
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2392
2508
|
field: "user_id",
|
|
2393
|
-
type:
|
|
2509
|
+
type: import_sequelize_typescript24.DataType.INTEGER
|
|
2394
2510
|
})
|
|
2395
2511
|
], mdEbook.prototype, "userId", 2);
|
|
2396
2512
|
__decorateClass([
|
|
2397
|
-
(0,
|
|
2513
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2398
2514
|
allowNull: true,
|
|
2399
|
-
type:
|
|
2515
|
+
type: import_sequelize_typescript24.DataType.STRING(255)
|
|
2400
2516
|
})
|
|
2401
2517
|
], mdEbook.prototype, "title", 2);
|
|
2402
2518
|
__decorateClass([
|
|
2403
|
-
(0,
|
|
2519
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2404
2520
|
allowNull: true,
|
|
2405
|
-
type:
|
|
2521
|
+
type: import_sequelize_typescript24.DataType.STRING
|
|
2406
2522
|
})
|
|
2407
2523
|
], mdEbook.prototype, "description", 2);
|
|
2408
2524
|
__decorateClass([
|
|
2409
|
-
(0,
|
|
2525
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2410
2526
|
allowNull: true,
|
|
2411
|
-
type:
|
|
2527
|
+
type: import_sequelize_typescript24.DataType.STRING
|
|
2412
2528
|
})
|
|
2413
2529
|
], mdEbook.prototype, "detail", 2);
|
|
2414
2530
|
__decorateClass([
|
|
2415
|
-
(0,
|
|
2531
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2416
2532
|
field: "meta_title",
|
|
2417
2533
|
allowNull: true,
|
|
2418
|
-
type:
|
|
2534
|
+
type: import_sequelize_typescript24.DataType.STRING(255)
|
|
2419
2535
|
})
|
|
2420
2536
|
], mdEbook.prototype, "metaTitle", 2);
|
|
2421
2537
|
__decorateClass([
|
|
2422
|
-
(0,
|
|
2538
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2423
2539
|
field: "meta_keyword",
|
|
2424
2540
|
allowNull: true,
|
|
2425
|
-
type:
|
|
2541
|
+
type: import_sequelize_typescript24.DataType.STRING(255)
|
|
2426
2542
|
})
|
|
2427
2543
|
], mdEbook.prototype, "metaKeyword", 2);
|
|
2428
2544
|
__decorateClass([
|
|
2429
|
-
(0,
|
|
2545
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2430
2546
|
field: "meta_description",
|
|
2431
2547
|
allowNull: true,
|
|
2432
|
-
type:
|
|
2548
|
+
type: import_sequelize_typescript24.DataType.STRING(255)
|
|
2433
2549
|
})
|
|
2434
2550
|
], mdEbook.prototype, "metaDescription", 2);
|
|
2435
2551
|
__decorateClass([
|
|
2436
|
-
(0,
|
|
2552
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2437
2553
|
field: "image_cover",
|
|
2438
2554
|
allowNull: true,
|
|
2439
|
-
type:
|
|
2555
|
+
type: import_sequelize_typescript24.DataType.STRING(60)
|
|
2440
2556
|
})
|
|
2441
2557
|
], mdEbook.prototype, "imageCover", 2);
|
|
2442
2558
|
__decorateClass([
|
|
2443
|
-
(0,
|
|
2559
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2444
2560
|
field: "image_gallery",
|
|
2445
2561
|
allowNull: true,
|
|
2446
|
-
type:
|
|
2562
|
+
type: import_sequelize_typescript24.DataType.JSON
|
|
2447
2563
|
})
|
|
2448
2564
|
], mdEbook.prototype, "imageGallery", 2);
|
|
2449
2565
|
__decorateClass([
|
|
2450
|
-
(0,
|
|
2566
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2451
2567
|
allowNull: true,
|
|
2452
|
-
type:
|
|
2568
|
+
type: import_sequelize_typescript24.DataType.JSON
|
|
2453
2569
|
})
|
|
2454
2570
|
], mdEbook.prototype, "attachments", 2);
|
|
2455
2571
|
__decorateClass([
|
|
2456
|
-
(0,
|
|
2572
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2457
2573
|
allowNull: true,
|
|
2458
|
-
type:
|
|
2574
|
+
type: import_sequelize_typescript24.DataType.INTEGER
|
|
2459
2575
|
})
|
|
2460
2576
|
], mdEbook.prototype, "highlight", 2);
|
|
2461
2577
|
__decorateClass([
|
|
2462
|
-
(0,
|
|
2578
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2463
2579
|
allowNull: true,
|
|
2464
|
-
type:
|
|
2580
|
+
type: import_sequelize_typescript24.DataType.INTEGER
|
|
2465
2581
|
})
|
|
2466
2582
|
], mdEbook.prototype, "sort", 2);
|
|
2467
2583
|
__decorateClass([
|
|
2468
|
-
(0,
|
|
2584
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2469
2585
|
allowNull: true,
|
|
2470
|
-
type:
|
|
2586
|
+
type: import_sequelize_typescript24.DataType.INTEGER
|
|
2471
2587
|
})
|
|
2472
2588
|
], mdEbook.prototype, "status", 2);
|
|
2473
2589
|
__decorateClass([
|
|
2474
|
-
(0,
|
|
2590
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2475
2591
|
field: "has_expire",
|
|
2476
|
-
type:
|
|
2592
|
+
type: import_sequelize_typescript24.DataType.INTEGER
|
|
2477
2593
|
})
|
|
2478
2594
|
], mdEbook.prototype, "hasExpire", 2);
|
|
2479
2595
|
__decorateClass([
|
|
2480
|
-
(0,
|
|
2596
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2481
2597
|
field: "start_date",
|
|
2482
2598
|
allowNull: true,
|
|
2483
|
-
type:
|
|
2599
|
+
type: import_sequelize_typescript24.DataType.DATE
|
|
2484
2600
|
})
|
|
2485
2601
|
], mdEbook.prototype, "startDate", 2);
|
|
2486
2602
|
__decorateClass([
|
|
2487
|
-
(0,
|
|
2603
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2488
2604
|
field: "expire_date",
|
|
2489
2605
|
allowNull: true,
|
|
2490
|
-
type:
|
|
2606
|
+
type: import_sequelize_typescript24.DataType.DATE
|
|
2491
2607
|
})
|
|
2492
2608
|
], mdEbook.prototype, "expireDate", 2);
|
|
2493
2609
|
__decorateClass([
|
|
2494
|
-
(0,
|
|
2610
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2495
2611
|
field: "created_by",
|
|
2496
2612
|
allowNull: true,
|
|
2497
|
-
type:
|
|
2613
|
+
type: import_sequelize_typescript24.DataType.STRING(60)
|
|
2498
2614
|
})
|
|
2499
2615
|
], mdEbook.prototype, "createdBy", 2);
|
|
2500
2616
|
__decorateClass([
|
|
2501
|
-
(0,
|
|
2617
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2502
2618
|
field: "created_date",
|
|
2503
2619
|
allowNull: true,
|
|
2504
|
-
type:
|
|
2620
|
+
type: import_sequelize_typescript24.DataType.DATE
|
|
2505
2621
|
})
|
|
2506
2622
|
], mdEbook.prototype, "createdDate", 2);
|
|
2507
2623
|
__decorateClass([
|
|
2508
|
-
(0,
|
|
2624
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2509
2625
|
field: "updated_by",
|
|
2510
2626
|
allowNull: true,
|
|
2511
|
-
type:
|
|
2627
|
+
type: import_sequelize_typescript24.DataType.STRING(60)
|
|
2512
2628
|
})
|
|
2513
2629
|
], mdEbook.prototype, "updatedBy", 2);
|
|
2514
2630
|
__decorateClass([
|
|
2515
|
-
(0,
|
|
2631
|
+
(0, import_sequelize_typescript24.Column)({
|
|
2516
2632
|
field: "updated_date",
|
|
2517
2633
|
allowNull: true,
|
|
2518
|
-
type:
|
|
2634
|
+
type: import_sequelize_typescript24.DataType.DATE
|
|
2519
2635
|
})
|
|
2520
2636
|
], mdEbook.prototype, "updatedDate", 2);
|
|
2521
2637
|
__decorateClass([
|
|
2522
|
-
(0,
|
|
2638
|
+
(0, import_sequelize_typescript24.BelongsTo)(() => mdEbookGroup)
|
|
2523
2639
|
], mdEbook.prototype, "mdEbookGroup", 2);
|
|
2524
2640
|
mdEbook = __decorateClass([
|
|
2525
|
-
(0,
|
|
2641
|
+
(0, import_sequelize_typescript24.Table)({
|
|
2526
2642
|
tableName: "md_ebook",
|
|
2527
2643
|
timestamps: false
|
|
2528
2644
|
})
|
|
2529
2645
|
], mdEbook);
|
|
2530
2646
|
|
|
2531
2647
|
// src/databases/tables/mdFaq.ts
|
|
2532
|
-
var
|
|
2648
|
+
var import_sequelize_typescript26 = require("sequelize-typescript");
|
|
2533
2649
|
|
|
2534
2650
|
// src/databases/tables/mdFaqGroup.ts
|
|
2535
|
-
var
|
|
2536
|
-
var mdFaqGroup = class extends
|
|
2651
|
+
var import_sequelize_typescript25 = require("sequelize-typescript");
|
|
2652
|
+
var mdFaqGroup = class extends import_sequelize_typescript25.Model {
|
|
2537
2653
|
};
|
|
2538
2654
|
__decorateClass([
|
|
2539
|
-
(0,
|
|
2655
|
+
(0, import_sequelize_typescript25.Column)({
|
|
2540
2656
|
primaryKey: true,
|
|
2541
2657
|
autoIncrement: true,
|
|
2542
|
-
type:
|
|
2658
|
+
type: import_sequelize_typescript25.DataType.INTEGER
|
|
2543
2659
|
})
|
|
2544
2660
|
], mdFaqGroup.prototype, "id", 2);
|
|
2545
2661
|
__decorateClass([
|
|
2546
|
-
(0,
|
|
2662
|
+
(0, import_sequelize_typescript25.Column)({
|
|
2547
2663
|
allowNull: true,
|
|
2548
|
-
type:
|
|
2664
|
+
type: import_sequelize_typescript25.DataType.STRING(60)
|
|
2549
2665
|
})
|
|
2550
2666
|
], mdFaqGroup.prototype, "uuid", 2);
|
|
2551
2667
|
__decorateClass([
|
|
2552
|
-
(0,
|
|
2668
|
+
(0, import_sequelize_typescript25.Column)({
|
|
2553
2669
|
field: "key_name",
|
|
2554
2670
|
allowNull: true,
|
|
2555
|
-
type:
|
|
2671
|
+
type: import_sequelize_typescript25.DataType.STRING(100)
|
|
2556
2672
|
})
|
|
2557
2673
|
], mdFaqGroup.prototype, "keyName", 2);
|
|
2558
2674
|
__decorateClass([
|
|
2559
|
-
(0,
|
|
2675
|
+
(0, import_sequelize_typescript25.Column)({
|
|
2560
2676
|
field: "user_id",
|
|
2561
2677
|
allowNull: true,
|
|
2562
|
-
type:
|
|
2678
|
+
type: import_sequelize_typescript25.DataType.INTEGER
|
|
2563
2679
|
})
|
|
2564
2680
|
], mdFaqGroup.prototype, "userId", 2);
|
|
2565
2681
|
__decorateClass([
|
|
2566
|
-
(0,
|
|
2567
|
-
type:
|
|
2682
|
+
(0, import_sequelize_typescript25.Column)({
|
|
2683
|
+
type: import_sequelize_typescript25.DataType.STRING(255)
|
|
2568
2684
|
})
|
|
2569
2685
|
], mdFaqGroup.prototype, "name", 2);
|
|
2570
2686
|
__decorateClass([
|
|
2571
|
-
(0,
|
|
2687
|
+
(0, import_sequelize_typescript25.Column)({
|
|
2572
2688
|
allowNull: true,
|
|
2573
|
-
type:
|
|
2689
|
+
type: import_sequelize_typescript25.DataType.STRING(255)
|
|
2574
2690
|
})
|
|
2575
2691
|
], mdFaqGroup.prototype, "description", 2);
|
|
2576
2692
|
__decorateClass([
|
|
2577
|
-
(0,
|
|
2693
|
+
(0, import_sequelize_typescript25.Column)({
|
|
2578
2694
|
allowNull: true,
|
|
2579
|
-
type:
|
|
2695
|
+
type: import_sequelize_typescript25.DataType.INTEGER
|
|
2580
2696
|
})
|
|
2581
2697
|
], mdFaqGroup.prototype, "status", 2);
|
|
2582
2698
|
__decorateClass([
|
|
2583
|
-
(0,
|
|
2699
|
+
(0, import_sequelize_typescript25.Column)({
|
|
2584
2700
|
field: "created_by",
|
|
2585
2701
|
allowNull: true,
|
|
2586
|
-
type:
|
|
2702
|
+
type: import_sequelize_typescript25.DataType.STRING(60)
|
|
2587
2703
|
})
|
|
2588
2704
|
], mdFaqGroup.prototype, "createdBy", 2);
|
|
2589
2705
|
__decorateClass([
|
|
2590
|
-
(0,
|
|
2706
|
+
(0, import_sequelize_typescript25.Column)({
|
|
2591
2707
|
field: "created_date",
|
|
2592
2708
|
allowNull: true,
|
|
2593
|
-
type:
|
|
2709
|
+
type: import_sequelize_typescript25.DataType.DATE
|
|
2594
2710
|
})
|
|
2595
2711
|
], mdFaqGroup.prototype, "createdDate", 2);
|
|
2596
2712
|
__decorateClass([
|
|
2597
|
-
(0,
|
|
2713
|
+
(0, import_sequelize_typescript25.Column)({
|
|
2598
2714
|
field: "updated_by",
|
|
2599
2715
|
allowNull: true,
|
|
2600
|
-
type:
|
|
2716
|
+
type: import_sequelize_typescript25.DataType.STRING(60)
|
|
2601
2717
|
})
|
|
2602
2718
|
], mdFaqGroup.prototype, "updatedBy", 2);
|
|
2603
2719
|
__decorateClass([
|
|
2604
|
-
(0,
|
|
2720
|
+
(0, import_sequelize_typescript25.Column)({
|
|
2605
2721
|
field: "updated_date",
|
|
2606
2722
|
allowNull: true,
|
|
2607
|
-
type:
|
|
2723
|
+
type: import_sequelize_typescript25.DataType.DATE
|
|
2608
2724
|
})
|
|
2609
2725
|
], mdFaqGroup.prototype, "updatedDate", 2);
|
|
2610
2726
|
__decorateClass([
|
|
2611
|
-
(0,
|
|
2727
|
+
(0, import_sequelize_typescript25.HasMany)(() => mdFaq, {
|
|
2612
2728
|
sourceKey: "id"
|
|
2613
2729
|
})
|
|
2614
2730
|
], mdFaqGroup.prototype, "mdFaqs", 2);
|
|
2615
2731
|
mdFaqGroup = __decorateClass([
|
|
2616
|
-
(0,
|
|
2732
|
+
(0, import_sequelize_typescript25.Table)({
|
|
2617
2733
|
tableName: "md_faq_group",
|
|
2618
2734
|
timestamps: false
|
|
2619
2735
|
})
|
|
2620
2736
|
], mdFaqGroup);
|
|
2621
2737
|
|
|
2622
2738
|
// src/databases/tables/mdFaq.ts
|
|
2623
|
-
var mdFaq = class extends
|
|
2739
|
+
var mdFaq = class extends import_sequelize_typescript26.Model {
|
|
2624
2740
|
};
|
|
2625
2741
|
__decorateClass([
|
|
2626
|
-
(0,
|
|
2742
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2627
2743
|
primaryKey: true,
|
|
2628
2744
|
autoIncrement: true,
|
|
2629
|
-
type:
|
|
2745
|
+
type: import_sequelize_typescript26.DataType.INTEGER
|
|
2630
2746
|
})
|
|
2631
2747
|
], mdFaq.prototype, "id", 2);
|
|
2632
2748
|
__decorateClass([
|
|
2633
|
-
(0,
|
|
2749
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2634
2750
|
allowNull: true,
|
|
2635
|
-
type:
|
|
2751
|
+
type: import_sequelize_typescript26.DataType.STRING(60)
|
|
2636
2752
|
})
|
|
2637
2753
|
], mdFaq.prototype, "uuid", 2);
|
|
2638
2754
|
__decorateClass([
|
|
2639
|
-
(0,
|
|
2755
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2640
2756
|
field: "key_name",
|
|
2641
2757
|
allowNull: true,
|
|
2642
|
-
type:
|
|
2758
|
+
type: import_sequelize_typescript26.DataType.STRING(100)
|
|
2643
2759
|
})
|
|
2644
2760
|
], mdFaq.prototype, "keyName", 2);
|
|
2645
2761
|
__decorateClass([
|
|
2646
|
-
(0,
|
|
2762
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2647
2763
|
field: "user_id",
|
|
2648
2764
|
allowNull: true,
|
|
2649
|
-
type:
|
|
2765
|
+
type: import_sequelize_typescript26.DataType.INTEGER
|
|
2650
2766
|
})
|
|
2651
2767
|
], mdFaq.prototype, "userId", 2);
|
|
2652
2768
|
__decorateClass([
|
|
2653
|
-
(0,
|
|
2654
|
-
(0,
|
|
2769
|
+
(0, import_sequelize_typescript26.ForeignKey)(() => mdFaqGroup),
|
|
2770
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2655
2771
|
field: "group_id",
|
|
2656
2772
|
allowNull: true,
|
|
2657
|
-
type:
|
|
2773
|
+
type: import_sequelize_typescript26.DataType.INTEGER
|
|
2658
2774
|
})
|
|
2659
2775
|
], mdFaq.prototype, "groupId", 2);
|
|
2660
2776
|
__decorateClass([
|
|
2661
|
-
(0,
|
|
2777
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2662
2778
|
allowNull: true,
|
|
2663
|
-
type:
|
|
2779
|
+
type: import_sequelize_typescript26.DataType.STRING(255)
|
|
2664
2780
|
})
|
|
2665
2781
|
], mdFaq.prototype, "title", 2);
|
|
2666
2782
|
__decorateClass([
|
|
2667
|
-
(0,
|
|
2783
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2668
2784
|
allowNull: true,
|
|
2669
|
-
type:
|
|
2785
|
+
type: import_sequelize_typescript26.DataType.STRING(255)
|
|
2670
2786
|
})
|
|
2671
2787
|
], mdFaq.prototype, "description", 2);
|
|
2672
2788
|
__decorateClass([
|
|
2673
|
-
(0,
|
|
2789
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2674
2790
|
allowNull: true,
|
|
2675
|
-
type:
|
|
2791
|
+
type: import_sequelize_typescript26.DataType.STRING
|
|
2676
2792
|
})
|
|
2677
2793
|
], mdFaq.prototype, "detail", 2);
|
|
2678
2794
|
__decorateClass([
|
|
2679
|
-
(0,
|
|
2795
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2680
2796
|
allowNull: true,
|
|
2681
|
-
type:
|
|
2797
|
+
type: import_sequelize_typescript26.DataType.JSON
|
|
2682
2798
|
})
|
|
2683
2799
|
], mdFaq.prototype, "attachments", 2);
|
|
2684
2800
|
__decorateClass([
|
|
2685
|
-
(0,
|
|
2801
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2686
2802
|
allowNull: true,
|
|
2687
|
-
type:
|
|
2803
|
+
type: import_sequelize_typescript26.DataType.INTEGER
|
|
2688
2804
|
})
|
|
2689
2805
|
], mdFaq.prototype, "sort", 2);
|
|
2690
2806
|
__decorateClass([
|
|
2691
|
-
(0,
|
|
2807
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2692
2808
|
allowNull: true,
|
|
2693
|
-
type:
|
|
2809
|
+
type: import_sequelize_typescript26.DataType.INTEGER
|
|
2694
2810
|
})
|
|
2695
2811
|
], mdFaq.prototype, "status", 2);
|
|
2696
2812
|
__decorateClass([
|
|
2697
|
-
(0,
|
|
2813
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2698
2814
|
field: "has_expire",
|
|
2699
2815
|
allowNull: true,
|
|
2700
|
-
type:
|
|
2816
|
+
type: import_sequelize_typescript26.DataType.INTEGER
|
|
2701
2817
|
})
|
|
2702
2818
|
], mdFaq.prototype, "hasExpire", 2);
|
|
2703
2819
|
__decorateClass([
|
|
2704
|
-
(0,
|
|
2820
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2705
2821
|
field: "start_date",
|
|
2706
2822
|
allowNull: true,
|
|
2707
|
-
type:
|
|
2823
|
+
type: import_sequelize_typescript26.DataType.DATE
|
|
2708
2824
|
})
|
|
2709
2825
|
], mdFaq.prototype, "startDate", 2);
|
|
2710
2826
|
__decorateClass([
|
|
2711
|
-
(0,
|
|
2827
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2712
2828
|
field: "expire_date",
|
|
2713
2829
|
allowNull: true,
|
|
2714
|
-
type:
|
|
2830
|
+
type: import_sequelize_typescript26.DataType.DATE
|
|
2715
2831
|
})
|
|
2716
2832
|
], mdFaq.prototype, "expireDate", 2);
|
|
2717
2833
|
__decorateClass([
|
|
2718
|
-
(0,
|
|
2834
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2719
2835
|
field: "created_by",
|
|
2720
2836
|
allowNull: true,
|
|
2721
|
-
type:
|
|
2837
|
+
type: import_sequelize_typescript26.DataType.STRING(60)
|
|
2722
2838
|
})
|
|
2723
2839
|
], mdFaq.prototype, "createdBy", 2);
|
|
2724
2840
|
__decorateClass([
|
|
2725
|
-
(0,
|
|
2841
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2726
2842
|
field: "created_date",
|
|
2727
2843
|
allowNull: true,
|
|
2728
|
-
type:
|
|
2844
|
+
type: import_sequelize_typescript26.DataType.DATE
|
|
2729
2845
|
})
|
|
2730
2846
|
], mdFaq.prototype, "createdDate", 2);
|
|
2731
2847
|
__decorateClass([
|
|
2732
|
-
(0,
|
|
2848
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2733
2849
|
field: "updated_by",
|
|
2734
2850
|
allowNull: true,
|
|
2735
|
-
type:
|
|
2851
|
+
type: import_sequelize_typescript26.DataType.STRING(60)
|
|
2736
2852
|
})
|
|
2737
2853
|
], mdFaq.prototype, "updatedBy", 2);
|
|
2738
2854
|
__decorateClass([
|
|
2739
|
-
(0,
|
|
2855
|
+
(0, import_sequelize_typescript26.Column)({
|
|
2740
2856
|
field: "updated_date",
|
|
2741
2857
|
allowNull: true,
|
|
2742
|
-
type:
|
|
2858
|
+
type: import_sequelize_typescript26.DataType.DATE
|
|
2743
2859
|
})
|
|
2744
2860
|
], mdFaq.prototype, "updatedDate", 2);
|
|
2745
2861
|
__decorateClass([
|
|
2746
|
-
(0,
|
|
2862
|
+
(0, import_sequelize_typescript26.BelongsTo)(() => mdFaqGroup)
|
|
2747
2863
|
], mdFaq.prototype, "mdFaqGroup", 2);
|
|
2748
2864
|
mdFaq = __decorateClass([
|
|
2749
|
-
(0,
|
|
2865
|
+
(0, import_sequelize_typescript26.Table)({
|
|
2750
2866
|
tableName: "md_faq",
|
|
2751
2867
|
timestamps: false
|
|
2752
2868
|
})
|
|
2753
2869
|
], mdFaq);
|
|
2754
2870
|
|
|
2755
2871
|
// src/databases/tables/mdFormAdvance_1.ts
|
|
2756
|
-
var
|
|
2757
|
-
var mdFormAdvance_1 = class extends
|
|
2872
|
+
var import_sequelize_typescript27 = require("sequelize-typescript");
|
|
2873
|
+
var mdFormAdvance_1 = class extends import_sequelize_typescript27.Model {
|
|
2758
2874
|
};
|
|
2759
2875
|
__decorateClass([
|
|
2760
|
-
(0,
|
|
2876
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2761
2877
|
primaryKey: true,
|
|
2762
2878
|
autoIncrement: true,
|
|
2763
|
-
type:
|
|
2879
|
+
type: import_sequelize_typescript27.DataType.INTEGER
|
|
2764
2880
|
})
|
|
2765
2881
|
], mdFormAdvance_1.prototype, "id", 2);
|
|
2766
2882
|
__decorateClass([
|
|
2767
|
-
(0,
|
|
2883
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2768
2884
|
allowNull: true,
|
|
2769
|
-
type:
|
|
2885
|
+
type: import_sequelize_typescript27.DataType.STRING(60)
|
|
2770
2886
|
})
|
|
2771
2887
|
], mdFormAdvance_1.prototype, "uuid", 2);
|
|
2772
2888
|
__decorateClass([
|
|
2773
|
-
(0,
|
|
2889
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2774
2890
|
field: "key_name",
|
|
2775
2891
|
allowNull: true,
|
|
2776
|
-
type:
|
|
2892
|
+
type: import_sequelize_typescript27.DataType.STRING(100)
|
|
2777
2893
|
})
|
|
2778
2894
|
], mdFormAdvance_1.prototype, "keyName", 2);
|
|
2779
2895
|
__decorateClass([
|
|
2780
|
-
(0,
|
|
2896
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2781
2897
|
allowNull: true,
|
|
2782
|
-
type:
|
|
2898
|
+
type: import_sequelize_typescript27.DataType.STRING(255)
|
|
2783
2899
|
})
|
|
2784
2900
|
], mdFormAdvance_1.prototype, "title", 2);
|
|
2785
2901
|
__decorateClass([
|
|
2786
|
-
(0,
|
|
2902
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2787
2903
|
allowNull: true,
|
|
2788
|
-
type:
|
|
2904
|
+
type: import_sequelize_typescript27.DataType.STRING
|
|
2789
2905
|
})
|
|
2790
2906
|
], mdFormAdvance_1.prototype, "detail", 2);
|
|
2791
2907
|
__decorateClass([
|
|
2792
|
-
(0,
|
|
2908
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2793
2909
|
allowNull: true,
|
|
2794
|
-
type:
|
|
2910
|
+
type: import_sequelize_typescript27.DataType.INTEGER
|
|
2795
2911
|
})
|
|
2796
2912
|
], mdFormAdvance_1.prototype, "status", 2);
|
|
2797
2913
|
__decorateClass([
|
|
2798
|
-
(0,
|
|
2914
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2799
2915
|
field: "created_by",
|
|
2800
2916
|
allowNull: true,
|
|
2801
|
-
type:
|
|
2917
|
+
type: import_sequelize_typescript27.DataType.STRING(60)
|
|
2802
2918
|
})
|
|
2803
2919
|
], mdFormAdvance_1.prototype, "createdBy", 2);
|
|
2804
2920
|
__decorateClass([
|
|
2805
|
-
(0,
|
|
2921
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2806
2922
|
field: "created_date",
|
|
2807
2923
|
allowNull: true,
|
|
2808
|
-
type:
|
|
2924
|
+
type: import_sequelize_typescript27.DataType.DATE
|
|
2809
2925
|
})
|
|
2810
2926
|
], mdFormAdvance_1.prototype, "createdDate", 2);
|
|
2811
2927
|
__decorateClass([
|
|
2812
|
-
(0,
|
|
2928
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2813
2929
|
field: "updated_by",
|
|
2814
2930
|
allowNull: true,
|
|
2815
|
-
type:
|
|
2931
|
+
type: import_sequelize_typescript27.DataType.STRING(60)
|
|
2816
2932
|
})
|
|
2817
2933
|
], mdFormAdvance_1.prototype, "updatedBy", 2);
|
|
2818
2934
|
__decorateClass([
|
|
2819
|
-
(0,
|
|
2935
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2820
2936
|
field: "updated_date",
|
|
2821
2937
|
allowNull: true,
|
|
2822
|
-
type:
|
|
2938
|
+
type: import_sequelize_typescript27.DataType.DATE
|
|
2823
2939
|
})
|
|
2824
2940
|
], mdFormAdvance_1.prototype, "updatedDate", 2);
|
|
2825
2941
|
mdFormAdvance_1 = __decorateClass([
|
|
2826
|
-
(0,
|
|
2942
|
+
(0, import_sequelize_typescript27.Table)({
|
|
2827
2943
|
tableName: "md_form_advance_1",
|
|
2828
2944
|
timestamps: false
|
|
2829
2945
|
})
|
|
2830
2946
|
], mdFormAdvance_1);
|
|
2831
2947
|
|
|
2832
2948
|
// src/databases/tables/mdFormAdvance_2.ts
|
|
2833
|
-
var
|
|
2834
|
-
var mdFormAdvance_2 = class extends
|
|
2949
|
+
var import_sequelize_typescript28 = require("sequelize-typescript");
|
|
2950
|
+
var mdFormAdvance_2 = class extends import_sequelize_typescript28.Model {
|
|
2835
2951
|
};
|
|
2836
2952
|
__decorateClass([
|
|
2837
|
-
(0,
|
|
2953
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2838
2954
|
primaryKey: true,
|
|
2839
2955
|
autoIncrement: true,
|
|
2840
|
-
type:
|
|
2956
|
+
type: import_sequelize_typescript28.DataType.INTEGER
|
|
2841
2957
|
})
|
|
2842
2958
|
], mdFormAdvance_2.prototype, "id", 2);
|
|
2843
2959
|
__decorateClass([
|
|
2844
|
-
(0,
|
|
2960
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2845
2961
|
allowNull: true,
|
|
2846
|
-
type:
|
|
2962
|
+
type: import_sequelize_typescript28.DataType.STRING(60)
|
|
2847
2963
|
})
|
|
2848
2964
|
], mdFormAdvance_2.prototype, "uuid", 2);
|
|
2849
2965
|
__decorateClass([
|
|
2850
|
-
(0,
|
|
2966
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2851
2967
|
field: "key_name",
|
|
2852
2968
|
allowNull: true,
|
|
2853
|
-
type:
|
|
2969
|
+
type: import_sequelize_typescript28.DataType.STRING(100)
|
|
2854
2970
|
})
|
|
2855
2971
|
], mdFormAdvance_2.prototype, "keyName", 2);
|
|
2856
2972
|
__decorateClass([
|
|
2857
|
-
(0,
|
|
2973
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2858
2974
|
allowNull: true,
|
|
2859
|
-
type:
|
|
2975
|
+
type: import_sequelize_typescript28.DataType.STRING(255)
|
|
2860
2976
|
})
|
|
2861
2977
|
], mdFormAdvance_2.prototype, "name", 2);
|
|
2862
2978
|
__decorateClass([
|
|
2863
|
-
(0,
|
|
2979
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2864
2980
|
allowNull: true,
|
|
2865
|
-
type:
|
|
2981
|
+
type: import_sequelize_typescript28.DataType.STRING
|
|
2866
2982
|
})
|
|
2867
2983
|
], mdFormAdvance_2.prototype, "words", 2);
|
|
2868
2984
|
__decorateClass([
|
|
2869
|
-
(0,
|
|
2985
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2870
2986
|
allowNull: true,
|
|
2871
|
-
type:
|
|
2987
|
+
type: import_sequelize_typescript28.DataType.INTEGER
|
|
2872
2988
|
})
|
|
2873
2989
|
], mdFormAdvance_2.prototype, "status", 2);
|
|
2874
2990
|
__decorateClass([
|
|
2875
|
-
(0,
|
|
2991
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2876
2992
|
field: "ip_address",
|
|
2877
2993
|
allowNull: true,
|
|
2878
|
-
type:
|
|
2994
|
+
type: import_sequelize_typescript28.DataType.STRING(15)
|
|
2879
2995
|
})
|
|
2880
2996
|
], mdFormAdvance_2.prototype, "ipAddress", 2);
|
|
2881
2997
|
__decorateClass([
|
|
2882
|
-
(0,
|
|
2998
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2883
2999
|
field: "created_by",
|
|
2884
3000
|
allowNull: true,
|
|
2885
|
-
type:
|
|
3001
|
+
type: import_sequelize_typescript28.DataType.STRING(60)
|
|
2886
3002
|
})
|
|
2887
3003
|
], mdFormAdvance_2.prototype, "createdBy", 2);
|
|
2888
3004
|
__decorateClass([
|
|
2889
|
-
(0,
|
|
3005
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2890
3006
|
field: "created_date",
|
|
2891
3007
|
allowNull: true,
|
|
2892
|
-
type:
|
|
3008
|
+
type: import_sequelize_typescript28.DataType.DATE
|
|
2893
3009
|
})
|
|
2894
3010
|
], mdFormAdvance_2.prototype, "createdDate", 2);
|
|
2895
3011
|
__decorateClass([
|
|
2896
|
-
(0,
|
|
3012
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2897
3013
|
field: "updated_by",
|
|
2898
3014
|
allowNull: true,
|
|
2899
|
-
type:
|
|
3015
|
+
type: import_sequelize_typescript28.DataType.STRING(60)
|
|
2900
3016
|
})
|
|
2901
3017
|
], mdFormAdvance_2.prototype, "updatedBy", 2);
|
|
2902
3018
|
__decorateClass([
|
|
2903
|
-
(0,
|
|
3019
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2904
3020
|
field: "updated_date",
|
|
2905
3021
|
allowNull: true,
|
|
2906
|
-
type:
|
|
3022
|
+
type: import_sequelize_typescript28.DataType.DATE
|
|
2907
3023
|
})
|
|
2908
3024
|
], mdFormAdvance_2.prototype, "updatedDate", 2);
|
|
2909
3025
|
mdFormAdvance_2 = __decorateClass([
|
|
2910
|
-
(0,
|
|
3026
|
+
(0, import_sequelize_typescript28.Table)({
|
|
2911
3027
|
tableName: "md_form_advance_2",
|
|
2912
3028
|
timestamps: false
|
|
2913
3029
|
})
|
|
2914
3030
|
], mdFormAdvance_2);
|
|
2915
3031
|
|
|
2916
3032
|
// src/databases/tables/mdLink.ts
|
|
2917
|
-
var
|
|
3033
|
+
var import_sequelize_typescript30 = require("sequelize-typescript");
|
|
2918
3034
|
|
|
2919
3035
|
// src/databases/tables/mdLinkGroup.ts
|
|
2920
|
-
var
|
|
2921
|
-
var mdLinkGroup = class extends
|
|
3036
|
+
var import_sequelize_typescript29 = require("sequelize-typescript");
|
|
3037
|
+
var mdLinkGroup = class extends import_sequelize_typescript29.Model {
|
|
2922
3038
|
};
|
|
2923
3039
|
__decorateClass([
|
|
2924
|
-
(0,
|
|
3040
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2925
3041
|
primaryKey: true,
|
|
2926
3042
|
autoIncrement: true,
|
|
2927
|
-
type:
|
|
3043
|
+
type: import_sequelize_typescript29.DataType.INTEGER
|
|
2928
3044
|
})
|
|
2929
3045
|
], mdLinkGroup.prototype, "id", 2);
|
|
2930
3046
|
__decorateClass([
|
|
2931
|
-
(0,
|
|
3047
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2932
3048
|
allowNull: true,
|
|
2933
|
-
type:
|
|
3049
|
+
type: import_sequelize_typescript29.DataType.STRING(60)
|
|
2934
3050
|
})
|
|
2935
3051
|
], mdLinkGroup.prototype, "uuid", 2);
|
|
2936
3052
|
__decorateClass([
|
|
2937
|
-
(0,
|
|
3053
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2938
3054
|
field: "key_name",
|
|
2939
3055
|
allowNull: true,
|
|
2940
|
-
type:
|
|
3056
|
+
type: import_sequelize_typescript29.DataType.STRING(100)
|
|
2941
3057
|
})
|
|
2942
3058
|
], mdLinkGroup.prototype, "keyName", 2);
|
|
2943
3059
|
__decorateClass([
|
|
2944
|
-
(0,
|
|
3060
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2945
3061
|
field: "user_id",
|
|
2946
3062
|
allowNull: true,
|
|
2947
|
-
type:
|
|
3063
|
+
type: import_sequelize_typescript29.DataType.INTEGER
|
|
2948
3064
|
})
|
|
2949
3065
|
], mdLinkGroup.prototype, "userId", 2);
|
|
2950
3066
|
__decorateClass([
|
|
2951
|
-
(0,
|
|
2952
|
-
type:
|
|
3067
|
+
(0, import_sequelize_typescript29.Column)({
|
|
3068
|
+
type: import_sequelize_typescript29.DataType.STRING(255)
|
|
2953
3069
|
})
|
|
2954
3070
|
], mdLinkGroup.prototype, "name", 2);
|
|
2955
3071
|
__decorateClass([
|
|
2956
|
-
(0,
|
|
3072
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2957
3073
|
allowNull: true,
|
|
2958
|
-
type:
|
|
3074
|
+
type: import_sequelize_typescript29.DataType.STRING(255)
|
|
2959
3075
|
})
|
|
2960
3076
|
], mdLinkGroup.prototype, "description", 2);
|
|
2961
3077
|
__decorateClass([
|
|
2962
|
-
(0,
|
|
3078
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2963
3079
|
allowNull: true,
|
|
2964
|
-
type:
|
|
3080
|
+
type: import_sequelize_typescript29.DataType.INTEGER
|
|
2965
3081
|
})
|
|
2966
3082
|
], mdLinkGroup.prototype, "sort", 2);
|
|
2967
3083
|
__decorateClass([
|
|
2968
|
-
(0,
|
|
3084
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2969
3085
|
allowNull: true,
|
|
2970
|
-
type:
|
|
3086
|
+
type: import_sequelize_typescript29.DataType.INTEGER
|
|
2971
3087
|
})
|
|
2972
3088
|
], mdLinkGroup.prototype, "status", 2);
|
|
2973
3089
|
__decorateClass([
|
|
2974
|
-
(0,
|
|
3090
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2975
3091
|
field: "created_by",
|
|
2976
3092
|
allowNull: true,
|
|
2977
|
-
type:
|
|
3093
|
+
type: import_sequelize_typescript29.DataType.STRING(60)
|
|
2978
3094
|
})
|
|
2979
3095
|
], mdLinkGroup.prototype, "createdBy", 2);
|
|
2980
3096
|
__decorateClass([
|
|
2981
|
-
(0,
|
|
3097
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2982
3098
|
field: "created_date",
|
|
2983
3099
|
allowNull: true,
|
|
2984
|
-
type:
|
|
3100
|
+
type: import_sequelize_typescript29.DataType.DATE
|
|
2985
3101
|
})
|
|
2986
3102
|
], mdLinkGroup.prototype, "createdDate", 2);
|
|
2987
3103
|
__decorateClass([
|
|
2988
|
-
(0,
|
|
3104
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2989
3105
|
field: "updated_by",
|
|
2990
3106
|
allowNull: true,
|
|
2991
|
-
type:
|
|
3107
|
+
type: import_sequelize_typescript29.DataType.STRING(60)
|
|
2992
3108
|
})
|
|
2993
3109
|
], mdLinkGroup.prototype, "updatedBy", 2);
|
|
2994
3110
|
__decorateClass([
|
|
2995
|
-
(0,
|
|
3111
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2996
3112
|
field: "updated_date",
|
|
2997
3113
|
allowNull: true,
|
|
2998
|
-
type:
|
|
3114
|
+
type: import_sequelize_typescript29.DataType.DATE
|
|
2999
3115
|
})
|
|
3000
3116
|
], mdLinkGroup.prototype, "updatedDate", 2);
|
|
3001
3117
|
__decorateClass([
|
|
3002
|
-
(0,
|
|
3118
|
+
(0, import_sequelize_typescript29.HasMany)(() => mdLink, {
|
|
3003
3119
|
sourceKey: "id"
|
|
3004
3120
|
})
|
|
3005
3121
|
], mdLinkGroup.prototype, "mdLinks", 2);
|
|
3006
3122
|
mdLinkGroup = __decorateClass([
|
|
3007
|
-
(0,
|
|
3123
|
+
(0, import_sequelize_typescript29.Table)({
|
|
3008
3124
|
tableName: "md_link_group",
|
|
3009
3125
|
timestamps: false
|
|
3010
3126
|
})
|
|
3011
3127
|
], mdLinkGroup);
|
|
3012
3128
|
|
|
3013
3129
|
// src/databases/tables/mdLink.ts
|
|
3014
|
-
var mdLink = class extends
|
|
3130
|
+
var mdLink = class extends import_sequelize_typescript30.Model {
|
|
3015
3131
|
};
|
|
3016
3132
|
__decorateClass([
|
|
3017
|
-
(0,
|
|
3133
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3018
3134
|
primaryKey: true,
|
|
3019
3135
|
autoIncrement: true,
|
|
3020
|
-
type:
|
|
3136
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3021
3137
|
})
|
|
3022
3138
|
], mdLink.prototype, "id", 2);
|
|
3023
3139
|
__decorateClass([
|
|
3024
|
-
(0,
|
|
3025
|
-
type:
|
|
3140
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3141
|
+
type: import_sequelize_typescript30.DataType.STRING(60)
|
|
3026
3142
|
})
|
|
3027
3143
|
], mdLink.prototype, "uuid", 2);
|
|
3028
3144
|
__decorateClass([
|
|
3029
|
-
(0,
|
|
3145
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3030
3146
|
field: "key_name",
|
|
3031
3147
|
allowNull: true,
|
|
3032
|
-
type:
|
|
3148
|
+
type: import_sequelize_typescript30.DataType.STRING(100)
|
|
3033
3149
|
})
|
|
3034
3150
|
], mdLink.prototype, "keyName", 2);
|
|
3035
3151
|
__decorateClass([
|
|
3036
|
-
(0,
|
|
3037
|
-
(0,
|
|
3152
|
+
(0, import_sequelize_typescript30.ForeignKey)(() => mdLinkGroup),
|
|
3153
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3038
3154
|
field: "group_id",
|
|
3039
3155
|
allowNull: true,
|
|
3040
|
-
type:
|
|
3156
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3041
3157
|
})
|
|
3042
3158
|
], mdLink.prototype, "groupId", 2);
|
|
3043
3159
|
__decorateClass([
|
|
3044
|
-
(0,
|
|
3160
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3045
3161
|
field: "user_id",
|
|
3046
3162
|
allowNull: true,
|
|
3047
|
-
type:
|
|
3163
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3048
3164
|
})
|
|
3049
3165
|
], mdLink.prototype, "userId", 2);
|
|
3050
3166
|
__decorateClass([
|
|
3051
|
-
(0,
|
|
3167
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3052
3168
|
allowNull: true,
|
|
3053
|
-
type:
|
|
3169
|
+
type: import_sequelize_typescript30.DataType.STRING(255)
|
|
3054
3170
|
})
|
|
3055
3171
|
], mdLink.prototype, "title", 2);
|
|
3056
3172
|
__decorateClass([
|
|
3057
|
-
(0,
|
|
3173
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3058
3174
|
allowNull: true,
|
|
3059
|
-
type:
|
|
3175
|
+
type: import_sequelize_typescript30.DataType.STRING(255)
|
|
3060
3176
|
})
|
|
3061
3177
|
], mdLink.prototype, "url", 2);
|
|
3062
3178
|
__decorateClass([
|
|
3063
|
-
(0,
|
|
3179
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3064
3180
|
allowNull: true,
|
|
3065
|
-
type:
|
|
3181
|
+
type: import_sequelize_typescript30.DataType.STRING(10)
|
|
3066
3182
|
})
|
|
3067
3183
|
], mdLink.prototype, "target", 2);
|
|
3068
3184
|
__decorateClass([
|
|
3069
|
-
(0,
|
|
3185
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3070
3186
|
allowNull: true,
|
|
3071
|
-
type:
|
|
3187
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3072
3188
|
})
|
|
3073
3189
|
], mdLink.prototype, "sort", 2);
|
|
3074
3190
|
__decorateClass([
|
|
3075
|
-
(0,
|
|
3191
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3076
3192
|
allowNull: true,
|
|
3077
|
-
type:
|
|
3193
|
+
type: import_sequelize_typescript30.DataType.INTEGER,
|
|
3078
3194
|
defaultValue: "1"
|
|
3079
3195
|
})
|
|
3080
3196
|
], mdLink.prototype, "status", 2);
|
|
3081
3197
|
__decorateClass([
|
|
3082
|
-
(0,
|
|
3198
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3083
3199
|
field: "has_expire",
|
|
3084
3200
|
allowNull: true,
|
|
3085
|
-
type:
|
|
3201
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3086
3202
|
})
|
|
3087
3203
|
], mdLink.prototype, "hasExpire", 2);
|
|
3088
3204
|
__decorateClass([
|
|
3089
|
-
(0,
|
|
3205
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3090
3206
|
field: "start_date",
|
|
3091
3207
|
allowNull: true,
|
|
3092
|
-
type:
|
|
3208
|
+
type: import_sequelize_typescript30.DataType.DATE
|
|
3093
3209
|
})
|
|
3094
3210
|
], mdLink.prototype, "startDate", 2);
|
|
3095
3211
|
__decorateClass([
|
|
3096
|
-
(0,
|
|
3212
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3097
3213
|
field: "expire_date",
|
|
3098
3214
|
allowNull: true,
|
|
3099
|
-
type:
|
|
3215
|
+
type: import_sequelize_typescript30.DataType.DATE
|
|
3100
3216
|
})
|
|
3101
3217
|
], mdLink.prototype, "expireDate", 2);
|
|
3102
3218
|
__decorateClass([
|
|
3103
|
-
(0,
|
|
3219
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3104
3220
|
field: "created_by",
|
|
3105
3221
|
allowNull: true,
|
|
3106
|
-
type:
|
|
3222
|
+
type: import_sequelize_typescript30.DataType.STRING(60)
|
|
3107
3223
|
})
|
|
3108
3224
|
], mdLink.prototype, "createdBy", 2);
|
|
3109
3225
|
__decorateClass([
|
|
3110
|
-
(0,
|
|
3226
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3111
3227
|
field: "created_date",
|
|
3112
3228
|
allowNull: true,
|
|
3113
|
-
type:
|
|
3229
|
+
type: import_sequelize_typescript30.DataType.DATE
|
|
3114
3230
|
})
|
|
3115
3231
|
], mdLink.prototype, "createdDate", 2);
|
|
3116
3232
|
__decorateClass([
|
|
3117
|
-
(0,
|
|
3233
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3118
3234
|
field: "updated_by",
|
|
3119
3235
|
allowNull: true,
|
|
3120
|
-
type:
|
|
3236
|
+
type: import_sequelize_typescript30.DataType.STRING(60)
|
|
3121
3237
|
})
|
|
3122
3238
|
], mdLink.prototype, "updatedBy", 2);
|
|
3123
3239
|
__decorateClass([
|
|
3124
|
-
(0,
|
|
3240
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3125
3241
|
field: "updated_date",
|
|
3126
3242
|
allowNull: true,
|
|
3127
|
-
type:
|
|
3243
|
+
type: import_sequelize_typescript30.DataType.DATE
|
|
3128
3244
|
})
|
|
3129
3245
|
], mdLink.prototype, "updatedDate", 2);
|
|
3130
3246
|
__decorateClass([
|
|
3131
|
-
(0,
|
|
3247
|
+
(0, import_sequelize_typescript30.BelongsTo)(() => mdLinkGroup)
|
|
3132
3248
|
], mdLink.prototype, "mdLinkGroup", 2);
|
|
3133
3249
|
mdLink = __decorateClass([
|
|
3134
|
-
(0,
|
|
3250
|
+
(0, import_sequelize_typescript30.Table)({
|
|
3135
3251
|
tableName: "md_link",
|
|
3136
3252
|
timestamps: false
|
|
3137
3253
|
})
|
|
3138
3254
|
], mdLink);
|
|
3139
3255
|
|
|
3140
3256
|
// src/databases/tables/mdNews.ts
|
|
3141
|
-
var
|
|
3257
|
+
var import_sequelize_typescript32 = require("sequelize-typescript");
|
|
3142
3258
|
|
|
3143
3259
|
// src/databases/tables/mdNewsGroup.ts
|
|
3144
|
-
var
|
|
3145
|
-
var mdNewsGroup = class extends
|
|
3260
|
+
var import_sequelize_typescript31 = require("sequelize-typescript");
|
|
3261
|
+
var mdNewsGroup = class extends import_sequelize_typescript31.Model {
|
|
3146
3262
|
};
|
|
3147
3263
|
__decorateClass([
|
|
3148
|
-
(0,
|
|
3264
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3149
3265
|
primaryKey: true,
|
|
3150
3266
|
autoIncrement: true,
|
|
3151
|
-
type:
|
|
3267
|
+
type: import_sequelize_typescript31.DataType.INTEGER
|
|
3152
3268
|
})
|
|
3153
3269
|
], mdNewsGroup.prototype, "id", 2);
|
|
3154
3270
|
__decorateClass([
|
|
3155
|
-
(0,
|
|
3271
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3156
3272
|
allowNull: true,
|
|
3157
|
-
type:
|
|
3273
|
+
type: import_sequelize_typescript31.DataType.STRING(60)
|
|
3158
3274
|
})
|
|
3159
3275
|
], mdNewsGroup.prototype, "uuid", 2);
|
|
3160
3276
|
__decorateClass([
|
|
3161
|
-
(0,
|
|
3277
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3162
3278
|
field: "key_name",
|
|
3163
3279
|
allowNull: true,
|
|
3164
|
-
type:
|
|
3280
|
+
type: import_sequelize_typescript31.DataType.STRING(100)
|
|
3165
3281
|
})
|
|
3166
3282
|
], mdNewsGroup.prototype, "keyName", 2);
|
|
3167
3283
|
__decorateClass([
|
|
3168
|
-
(0,
|
|
3284
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3169
3285
|
field: "user_id",
|
|
3170
3286
|
allowNull: true,
|
|
3171
|
-
type:
|
|
3287
|
+
type: import_sequelize_typescript31.DataType.INTEGER
|
|
3172
3288
|
})
|
|
3173
3289
|
], mdNewsGroup.prototype, "userId", 2);
|
|
3174
3290
|
__decorateClass([
|
|
3175
|
-
(0,
|
|
3176
|
-
type:
|
|
3291
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3292
|
+
type: import_sequelize_typescript31.DataType.STRING(255)
|
|
3177
3293
|
})
|
|
3178
3294
|
], mdNewsGroup.prototype, "name", 2);
|
|
3179
3295
|
__decorateClass([
|
|
3180
|
-
(0,
|
|
3296
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3181
3297
|
allowNull: true,
|
|
3182
|
-
type:
|
|
3298
|
+
type: import_sequelize_typescript31.DataType.STRING(255)
|
|
3183
3299
|
})
|
|
3184
3300
|
], mdNewsGroup.prototype, "description", 2);
|
|
3185
3301
|
__decorateClass([
|
|
3186
|
-
(0,
|
|
3302
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3187
3303
|
allowNull: true,
|
|
3188
|
-
type:
|
|
3304
|
+
type: import_sequelize_typescript31.DataType.INTEGER
|
|
3189
3305
|
})
|
|
3190
3306
|
], mdNewsGroup.prototype, "status", 2);
|
|
3191
3307
|
__decorateClass([
|
|
3192
|
-
(0,
|
|
3308
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3193
3309
|
field: "created_by",
|
|
3194
3310
|
allowNull: true,
|
|
3195
|
-
type:
|
|
3311
|
+
type: import_sequelize_typescript31.DataType.STRING(60)
|
|
3196
3312
|
})
|
|
3197
3313
|
], mdNewsGroup.prototype, "createdBy", 2);
|
|
3198
3314
|
__decorateClass([
|
|
3199
|
-
(0,
|
|
3315
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3200
3316
|
field: "created_date",
|
|
3201
3317
|
allowNull: true,
|
|
3202
|
-
type:
|
|
3318
|
+
type: import_sequelize_typescript31.DataType.DATE
|
|
3203
3319
|
})
|
|
3204
3320
|
], mdNewsGroup.prototype, "createdDate", 2);
|
|
3205
3321
|
__decorateClass([
|
|
3206
|
-
(0,
|
|
3322
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3207
3323
|
field: "updated_by",
|
|
3208
3324
|
allowNull: true,
|
|
3209
|
-
type:
|
|
3325
|
+
type: import_sequelize_typescript31.DataType.STRING(60)
|
|
3210
3326
|
})
|
|
3211
3327
|
], mdNewsGroup.prototype, "updatedBy", 2);
|
|
3212
3328
|
__decorateClass([
|
|
3213
|
-
(0,
|
|
3329
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3214
3330
|
field: "updated_date",
|
|
3215
3331
|
allowNull: true,
|
|
3216
|
-
type:
|
|
3332
|
+
type: import_sequelize_typescript31.DataType.DATE
|
|
3217
3333
|
})
|
|
3218
3334
|
], mdNewsGroup.prototype, "updatedDate", 2);
|
|
3219
3335
|
__decorateClass([
|
|
3220
|
-
(0,
|
|
3336
|
+
(0, import_sequelize_typescript31.HasMany)(() => mdNews, {
|
|
3221
3337
|
sourceKey: "id"
|
|
3222
3338
|
})
|
|
3223
3339
|
], mdNewsGroup.prototype, "mdNews", 2);
|
|
3224
3340
|
mdNewsGroup = __decorateClass([
|
|
3225
|
-
(0,
|
|
3341
|
+
(0, import_sequelize_typescript31.Table)({
|
|
3226
3342
|
tableName: "md_news_group",
|
|
3227
3343
|
timestamps: false
|
|
3228
3344
|
})
|
|
3229
3345
|
], mdNewsGroup);
|
|
3230
3346
|
|
|
3231
3347
|
// src/databases/tables/mdNews.ts
|
|
3232
|
-
var mdNews = class extends
|
|
3348
|
+
var mdNews = class extends import_sequelize_typescript32.Model {
|
|
3233
3349
|
};
|
|
3234
3350
|
__decorateClass([
|
|
3235
|
-
(0,
|
|
3351
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3236
3352
|
primaryKey: true,
|
|
3237
3353
|
autoIncrement: true,
|
|
3238
|
-
type:
|
|
3354
|
+
type: import_sequelize_typescript32.DataType.INTEGER
|
|
3239
3355
|
})
|
|
3240
3356
|
], mdNews.prototype, "id", 2);
|
|
3241
|
-
__decorateClass([
|
|
3242
|
-
(0,
|
|
3243
|
-
type:
|
|
3357
|
+
__decorateClass([
|
|
3358
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3359
|
+
type: import_sequelize_typescript32.DataType.STRING(60)
|
|
3244
3360
|
})
|
|
3245
3361
|
], mdNews.prototype, "uuid", 2);
|
|
3246
3362
|
__decorateClass([
|
|
3247
|
-
(0,
|
|
3363
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3248
3364
|
field: "key_name",
|
|
3249
3365
|
allowNull: true,
|
|
3250
|
-
type:
|
|
3366
|
+
type: import_sequelize_typescript32.DataType.STRING(100)
|
|
3251
3367
|
})
|
|
3252
3368
|
], mdNews.prototype, "keyName", 2);
|
|
3253
3369
|
__decorateClass([
|
|
3254
|
-
(0,
|
|
3255
|
-
(0,
|
|
3370
|
+
(0, import_sequelize_typescript32.ForeignKey)(() => mdNewsGroup),
|
|
3371
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3256
3372
|
field: "group_id",
|
|
3257
3373
|
allowNull: true,
|
|
3258
|
-
type:
|
|
3374
|
+
type: import_sequelize_typescript32.DataType.INTEGER
|
|
3259
3375
|
})
|
|
3260
3376
|
], mdNews.prototype, "groupId", 2);
|
|
3261
3377
|
__decorateClass([
|
|
3262
|
-
(0,
|
|
3378
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3263
3379
|
field: "user_id",
|
|
3264
|
-
type:
|
|
3380
|
+
type: import_sequelize_typescript32.DataType.INTEGER
|
|
3265
3381
|
})
|
|
3266
3382
|
], mdNews.prototype, "userId", 2);
|
|
3267
3383
|
__decorateClass([
|
|
3268
|
-
(0,
|
|
3384
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3269
3385
|
allowNull: true,
|
|
3270
|
-
type:
|
|
3386
|
+
type: import_sequelize_typescript32.DataType.STRING(500)
|
|
3271
3387
|
})
|
|
3272
3388
|
], mdNews.prototype, "title", 2);
|
|
3273
3389
|
__decorateClass([
|
|
3274
|
-
(0,
|
|
3390
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3275
3391
|
allowNull: true,
|
|
3276
|
-
type:
|
|
3392
|
+
type: import_sequelize_typescript32.DataType.STRING
|
|
3277
3393
|
})
|
|
3278
3394
|
], mdNews.prototype, "description", 2);
|
|
3279
3395
|
__decorateClass([
|
|
3280
|
-
(0,
|
|
3396
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3281
3397
|
allowNull: true,
|
|
3282
|
-
type:
|
|
3398
|
+
type: import_sequelize_typescript32.DataType.STRING
|
|
3283
3399
|
})
|
|
3284
3400
|
], mdNews.prototype, "detail", 2);
|
|
3285
3401
|
__decorateClass([
|
|
3286
|
-
(0,
|
|
3402
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3287
3403
|
field: "meta_title",
|
|
3288
3404
|
allowNull: true,
|
|
3289
|
-
type:
|
|
3405
|
+
type: import_sequelize_typescript32.DataType.STRING(500)
|
|
3290
3406
|
})
|
|
3291
3407
|
], mdNews.prototype, "metaTitle", 2);
|
|
3292
3408
|
__decorateClass([
|
|
3293
|
-
(0,
|
|
3409
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3294
3410
|
field: "meta_keyword",
|
|
3295
3411
|
allowNull: true,
|
|
3296
|
-
type:
|
|
3412
|
+
type: import_sequelize_typescript32.DataType.STRING(500)
|
|
3297
3413
|
})
|
|
3298
3414
|
], mdNews.prototype, "metaKeyword", 2);
|
|
3299
3415
|
__decorateClass([
|
|
3300
|
-
(0,
|
|
3416
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3301
3417
|
field: "meta_description",
|
|
3302
3418
|
allowNull: true,
|
|
3303
|
-
type:
|
|
3419
|
+
type: import_sequelize_typescript32.DataType.STRING(500)
|
|
3304
3420
|
})
|
|
3305
3421
|
], mdNews.prototype, "metaDescription", 2);
|
|
3306
3422
|
__decorateClass([
|
|
3307
|
-
(0,
|
|
3423
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3308
3424
|
field: "image_cover",
|
|
3309
3425
|
allowNull: true,
|
|
3310
|
-
type:
|
|
3426
|
+
type: import_sequelize_typescript32.DataType.STRING(60)
|
|
3311
3427
|
})
|
|
3312
3428
|
], mdNews.prototype, "imageCover", 2);
|
|
3313
3429
|
__decorateClass([
|
|
3314
|
-
(0,
|
|
3430
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3315
3431
|
allowNull: true,
|
|
3316
|
-
type:
|
|
3432
|
+
type: import_sequelize_typescript32.DataType.STRING(60)
|
|
3317
3433
|
})
|
|
3318
3434
|
], mdNews.prototype, "video", 2);
|
|
3319
3435
|
__decorateClass([
|
|
3320
|
-
(0,
|
|
3436
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3321
3437
|
field: "image_gallery",
|
|
3322
3438
|
allowNull: true,
|
|
3323
|
-
type:
|
|
3439
|
+
type: import_sequelize_typescript32.DataType.JSON
|
|
3324
3440
|
})
|
|
3325
3441
|
], mdNews.prototype, "imageGallery", 2);
|
|
3326
3442
|
__decorateClass([
|
|
3327
|
-
(0,
|
|
3443
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3328
3444
|
allowNull: true,
|
|
3329
|
-
type:
|
|
3445
|
+
type: import_sequelize_typescript32.DataType.JSON
|
|
3330
3446
|
})
|
|
3331
3447
|
], mdNews.prototype, "attachments", 2);
|
|
3332
3448
|
__decorateClass([
|
|
3333
|
-
(0,
|
|
3449
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3334
3450
|
allowNull: true,
|
|
3335
|
-
type:
|
|
3451
|
+
type: import_sequelize_typescript32.DataType.INTEGER
|
|
3336
3452
|
})
|
|
3337
3453
|
], mdNews.prototype, "highlight", 2);
|
|
3338
3454
|
__decorateClass([
|
|
3339
|
-
(0,
|
|
3455
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3340
3456
|
allowNull: true,
|
|
3341
|
-
type:
|
|
3457
|
+
type: import_sequelize_typescript32.DataType.INTEGER
|
|
3342
3458
|
})
|
|
3343
3459
|
], mdNews.prototype, "sort", 2);
|
|
3344
3460
|
__decorateClass([
|
|
3345
|
-
(0,
|
|
3461
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3346
3462
|
allowNull: true,
|
|
3347
|
-
type:
|
|
3463
|
+
type: import_sequelize_typescript32.DataType.INTEGER
|
|
3348
3464
|
})
|
|
3349
3465
|
], mdNews.prototype, "status", 2);
|
|
3350
3466
|
__decorateClass([
|
|
3351
|
-
(0,
|
|
3467
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3352
3468
|
allowNull: true,
|
|
3353
|
-
type:
|
|
3469
|
+
type: import_sequelize_typescript32.DataType.INTEGER
|
|
3354
3470
|
})
|
|
3355
3471
|
], mdNews.prototype, "publish", 2);
|
|
3356
3472
|
__decorateClass([
|
|
3357
|
-
(0,
|
|
3473
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3358
3474
|
field: "has_expire",
|
|
3359
|
-
type:
|
|
3475
|
+
type: import_sequelize_typescript32.DataType.INTEGER
|
|
3360
3476
|
})
|
|
3361
3477
|
], mdNews.prototype, "hasExpire", 2);
|
|
3362
3478
|
__decorateClass([
|
|
3363
|
-
(0,
|
|
3479
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3364
3480
|
field: "start_date",
|
|
3365
3481
|
allowNull: true,
|
|
3366
|
-
type:
|
|
3482
|
+
type: import_sequelize_typescript32.DataType.DATE
|
|
3367
3483
|
})
|
|
3368
3484
|
], mdNews.prototype, "startDate", 2);
|
|
3369
3485
|
__decorateClass([
|
|
3370
|
-
(0,
|
|
3486
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3371
3487
|
field: "expire_date",
|
|
3372
3488
|
allowNull: true,
|
|
3373
|
-
type:
|
|
3489
|
+
type: import_sequelize_typescript32.DataType.DATE
|
|
3374
3490
|
})
|
|
3375
3491
|
], mdNews.prototype, "expireDate", 2);
|
|
3376
3492
|
__decorateClass([
|
|
3377
|
-
(0,
|
|
3493
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3378
3494
|
field: "created_by",
|
|
3379
3495
|
allowNull: true,
|
|
3380
|
-
type:
|
|
3496
|
+
type: import_sequelize_typescript32.DataType.STRING(60)
|
|
3381
3497
|
})
|
|
3382
3498
|
], mdNews.prototype, "createdBy", 2);
|
|
3383
3499
|
__decorateClass([
|
|
3384
|
-
(0,
|
|
3500
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3385
3501
|
field: "created_date",
|
|
3386
3502
|
allowNull: true,
|
|
3387
|
-
type:
|
|
3503
|
+
type: import_sequelize_typescript32.DataType.DATE
|
|
3388
3504
|
})
|
|
3389
3505
|
], mdNews.prototype, "createdDate", 2);
|
|
3390
3506
|
__decorateClass([
|
|
3391
|
-
(0,
|
|
3507
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3392
3508
|
field: "updated_by",
|
|
3393
3509
|
allowNull: true,
|
|
3394
|
-
type:
|
|
3510
|
+
type: import_sequelize_typescript32.DataType.STRING(60)
|
|
3395
3511
|
})
|
|
3396
3512
|
], mdNews.prototype, "updatedBy", 2);
|
|
3397
3513
|
__decorateClass([
|
|
3398
|
-
(0,
|
|
3514
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3399
3515
|
field: "updated_date",
|
|
3400
3516
|
allowNull: true,
|
|
3401
|
-
type:
|
|
3517
|
+
type: import_sequelize_typescript32.DataType.DATE
|
|
3402
3518
|
})
|
|
3403
3519
|
], mdNews.prototype, "updatedDate", 2);
|
|
3404
3520
|
__decorateClass([
|
|
3405
|
-
(0,
|
|
3521
|
+
(0, import_sequelize_typescript32.BelongsTo)(() => mdNewsGroup)
|
|
3406
3522
|
], mdNews.prototype, "mdNewsGroup", 2);
|
|
3407
3523
|
mdNews = __decorateClass([
|
|
3408
|
-
(0,
|
|
3524
|
+
(0, import_sequelize_typescript32.Table)({
|
|
3409
3525
|
tableName: "md_news",
|
|
3410
3526
|
timestamps: false
|
|
3411
3527
|
})
|
|
3412
3528
|
], mdNews);
|
|
3413
3529
|
|
|
3414
3530
|
// src/databases/tables/mdPopup.ts
|
|
3415
|
-
var
|
|
3416
|
-
var mdPopup = class extends
|
|
3531
|
+
var import_sequelize_typescript33 = require("sequelize-typescript");
|
|
3532
|
+
var mdPopup = class extends import_sequelize_typescript33.Model {
|
|
3417
3533
|
};
|
|
3418
3534
|
__decorateClass([
|
|
3419
|
-
(0,
|
|
3535
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3420
3536
|
primaryKey: true,
|
|
3421
3537
|
autoIncrement: true,
|
|
3422
|
-
type:
|
|
3538
|
+
type: import_sequelize_typescript33.DataType.INTEGER
|
|
3423
3539
|
})
|
|
3424
3540
|
], mdPopup.prototype, "id", 2);
|
|
3425
3541
|
__decorateClass([
|
|
3426
|
-
(0,
|
|
3427
|
-
type:
|
|
3542
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3543
|
+
type: import_sequelize_typescript33.DataType.STRING(60)
|
|
3428
3544
|
})
|
|
3429
3545
|
], mdPopup.prototype, "uuid", 2);
|
|
3430
3546
|
__decorateClass([
|
|
3431
|
-
(0,
|
|
3547
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3432
3548
|
field: "key_name",
|
|
3433
3549
|
allowNull: true,
|
|
3434
|
-
type:
|
|
3550
|
+
type: import_sequelize_typescript33.DataType.STRING(100)
|
|
3435
3551
|
})
|
|
3436
3552
|
], mdPopup.prototype, "keyName", 2);
|
|
3437
3553
|
__decorateClass([
|
|
3438
|
-
(0,
|
|
3554
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3439
3555
|
field: "user_id",
|
|
3440
|
-
type:
|
|
3556
|
+
type: import_sequelize_typescript33.DataType.INTEGER
|
|
3441
3557
|
})
|
|
3442
3558
|
], mdPopup.prototype, "userId", 2);
|
|
3443
3559
|
__decorateClass([
|
|
3444
|
-
(0,
|
|
3560
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3445
3561
|
allowNull: true,
|
|
3446
|
-
type:
|
|
3562
|
+
type: import_sequelize_typescript33.DataType.STRING(255)
|
|
3447
3563
|
})
|
|
3448
3564
|
], mdPopup.prototype, "title", 2);
|
|
3449
3565
|
__decorateClass([
|
|
3450
|
-
(0,
|
|
3566
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3451
3567
|
allowNull: true,
|
|
3452
|
-
type:
|
|
3568
|
+
type: import_sequelize_typescript33.DataType.STRING
|
|
3453
3569
|
})
|
|
3454
3570
|
], mdPopup.prototype, "description", 2);
|
|
3455
3571
|
__decorateClass([
|
|
3456
|
-
(0,
|
|
3572
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3457
3573
|
allowNull: true,
|
|
3458
|
-
type:
|
|
3574
|
+
type: import_sequelize_typescript33.DataType.STRING
|
|
3459
3575
|
})
|
|
3460
3576
|
], mdPopup.prototype, "detail", 2);
|
|
3461
3577
|
__decorateClass([
|
|
3462
|
-
(0,
|
|
3578
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3463
3579
|
field: "image_cover",
|
|
3464
3580
|
allowNull: true,
|
|
3465
|
-
type:
|
|
3581
|
+
type: import_sequelize_typescript33.DataType.STRING(60)
|
|
3466
3582
|
})
|
|
3467
3583
|
], mdPopup.prototype, "imageCover", 2);
|
|
3468
3584
|
__decorateClass([
|
|
3469
|
-
(0,
|
|
3585
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3470
3586
|
allowNull: true,
|
|
3471
|
-
type:
|
|
3587
|
+
type: import_sequelize_typescript33.DataType.STRING(255)
|
|
3472
3588
|
})
|
|
3473
3589
|
], mdPopup.prototype, "url", 2);
|
|
3474
3590
|
__decorateClass([
|
|
3475
|
-
(0,
|
|
3591
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3476
3592
|
allowNull: true,
|
|
3477
|
-
type:
|
|
3593
|
+
type: import_sequelize_typescript33.DataType.INTEGER
|
|
3478
3594
|
})
|
|
3479
3595
|
], mdPopup.prototype, "sort", 2);
|
|
3480
3596
|
__decorateClass([
|
|
3481
|
-
(0,
|
|
3597
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3482
3598
|
allowNull: true,
|
|
3483
|
-
type:
|
|
3599
|
+
type: import_sequelize_typescript33.DataType.INTEGER
|
|
3484
3600
|
})
|
|
3485
3601
|
], mdPopup.prototype, "status", 2);
|
|
3486
3602
|
__decorateClass([
|
|
3487
|
-
(0,
|
|
3603
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3488
3604
|
field: "has_expire",
|
|
3489
|
-
type:
|
|
3605
|
+
type: import_sequelize_typescript33.DataType.INTEGER
|
|
3490
3606
|
})
|
|
3491
3607
|
], mdPopup.prototype, "hasExpire", 2);
|
|
3492
3608
|
__decorateClass([
|
|
3493
|
-
(0,
|
|
3609
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3494
3610
|
field: "start_date",
|
|
3495
3611
|
allowNull: true,
|
|
3496
|
-
type:
|
|
3612
|
+
type: import_sequelize_typescript33.DataType.DATE
|
|
3497
3613
|
})
|
|
3498
3614
|
], mdPopup.prototype, "startDate", 2);
|
|
3499
3615
|
__decorateClass([
|
|
3500
|
-
(0,
|
|
3616
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3501
3617
|
field: "expire_date",
|
|
3502
3618
|
allowNull: true,
|
|
3503
|
-
type:
|
|
3619
|
+
type: import_sequelize_typescript33.DataType.DATE
|
|
3504
3620
|
})
|
|
3505
3621
|
], mdPopup.prototype, "expireDate", 2);
|
|
3506
3622
|
__decorateClass([
|
|
3507
|
-
(0,
|
|
3623
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3508
3624
|
field: "created_by",
|
|
3509
3625
|
allowNull: true,
|
|
3510
|
-
type:
|
|
3626
|
+
type: import_sequelize_typescript33.DataType.STRING(60)
|
|
3511
3627
|
})
|
|
3512
3628
|
], mdPopup.prototype, "createdBy", 2);
|
|
3513
3629
|
__decorateClass([
|
|
3514
|
-
(0,
|
|
3630
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3515
3631
|
field: "created_date",
|
|
3516
3632
|
allowNull: true,
|
|
3517
|
-
type:
|
|
3633
|
+
type: import_sequelize_typescript33.DataType.DATE
|
|
3518
3634
|
})
|
|
3519
3635
|
], mdPopup.prototype, "createdDate", 2);
|
|
3520
3636
|
__decorateClass([
|
|
3521
|
-
(0,
|
|
3637
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3522
3638
|
field: "updated_by",
|
|
3523
3639
|
allowNull: true,
|
|
3524
|
-
type:
|
|
3640
|
+
type: import_sequelize_typescript33.DataType.STRING(60)
|
|
3525
3641
|
})
|
|
3526
3642
|
], mdPopup.prototype, "updatedBy", 2);
|
|
3527
3643
|
__decorateClass([
|
|
3528
|
-
(0,
|
|
3644
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3529
3645
|
field: "updated_date",
|
|
3530
3646
|
allowNull: true,
|
|
3531
|
-
type:
|
|
3647
|
+
type: import_sequelize_typescript33.DataType.DATE
|
|
3532
3648
|
})
|
|
3533
3649
|
], mdPopup.prototype, "updatedDate", 2);
|
|
3534
3650
|
mdPopup = __decorateClass([
|
|
3535
|
-
(0,
|
|
3651
|
+
(0, import_sequelize_typescript33.Table)({
|
|
3536
3652
|
tableName: "md_popup",
|
|
3537
3653
|
timestamps: false
|
|
3538
3654
|
})
|
|
3539
3655
|
], mdPopup);
|
|
3540
3656
|
|
|
3541
3657
|
// src/databases/tables/mdSetting.ts
|
|
3542
|
-
var
|
|
3543
|
-
var mdSetting = class extends
|
|
3658
|
+
var import_sequelize_typescript34 = require("sequelize-typescript");
|
|
3659
|
+
var mdSetting = class extends import_sequelize_typescript34.Model {
|
|
3544
3660
|
};
|
|
3545
3661
|
__decorateClass([
|
|
3546
|
-
(0,
|
|
3662
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3547
3663
|
primaryKey: true,
|
|
3548
3664
|
autoIncrement: true,
|
|
3549
|
-
type:
|
|
3665
|
+
type: import_sequelize_typescript34.DataType.INTEGER
|
|
3550
3666
|
})
|
|
3551
3667
|
], mdSetting.prototype, "id", 2);
|
|
3552
3668
|
__decorateClass([
|
|
3553
|
-
(0,
|
|
3669
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3554
3670
|
allowNull: true,
|
|
3555
|
-
type:
|
|
3671
|
+
type: import_sequelize_typescript34.DataType.STRING(60)
|
|
3556
3672
|
})
|
|
3557
3673
|
], mdSetting.prototype, "uuid", 2);
|
|
3558
3674
|
__decorateClass([
|
|
3559
|
-
(0,
|
|
3675
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3560
3676
|
field: "key_name",
|
|
3561
3677
|
allowNull: true,
|
|
3562
|
-
type:
|
|
3678
|
+
type: import_sequelize_typescript34.DataType.STRING(100)
|
|
3563
3679
|
})
|
|
3564
3680
|
], mdSetting.prototype, "keyName", 2);
|
|
3565
3681
|
__decorateClass([
|
|
3566
|
-
(0,
|
|
3682
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3567
3683
|
allowNull: true,
|
|
3568
|
-
type:
|
|
3684
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3569
3685
|
})
|
|
3570
3686
|
], mdSetting.prototype, "name", 2);
|
|
3571
3687
|
__decorateClass([
|
|
3572
|
-
(0,
|
|
3688
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3573
3689
|
allowNull: true,
|
|
3574
|
-
type:
|
|
3690
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3575
3691
|
})
|
|
3576
3692
|
], mdSetting.prototype, "description", 2);
|
|
3577
3693
|
__decorateClass([
|
|
3578
|
-
(0,
|
|
3694
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3579
3695
|
allowNull: true,
|
|
3580
|
-
type:
|
|
3696
|
+
type: import_sequelize_typescript34.DataType.STRING
|
|
3581
3697
|
})
|
|
3582
3698
|
], mdSetting.prototype, "value", 2);
|
|
3583
3699
|
__decorateClass([
|
|
3584
|
-
(0,
|
|
3700
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3585
3701
|
allowNull: true,
|
|
3586
|
-
type:
|
|
3702
|
+
type: import_sequelize_typescript34.DataType.INTEGER
|
|
3587
3703
|
})
|
|
3588
3704
|
], mdSetting.prototype, "status", 2);
|
|
3589
3705
|
__decorateClass([
|
|
3590
|
-
(0,
|
|
3706
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3591
3707
|
field: "created_by",
|
|
3592
3708
|
allowNull: true,
|
|
3593
|
-
type:
|
|
3709
|
+
type: import_sequelize_typescript34.DataType.STRING(60)
|
|
3594
3710
|
})
|
|
3595
3711
|
], mdSetting.prototype, "createdBy", 2);
|
|
3596
3712
|
__decorateClass([
|
|
3597
|
-
(0,
|
|
3713
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3598
3714
|
field: "created_date",
|
|
3599
3715
|
allowNull: true,
|
|
3600
|
-
type:
|
|
3716
|
+
type: import_sequelize_typescript34.DataType.DATE
|
|
3601
3717
|
})
|
|
3602
3718
|
], mdSetting.prototype, "createdDate", 2);
|
|
3603
3719
|
__decorateClass([
|
|
3604
|
-
(0,
|
|
3720
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3605
3721
|
field: "updated_by",
|
|
3606
3722
|
allowNull: true,
|
|
3607
|
-
type:
|
|
3723
|
+
type: import_sequelize_typescript34.DataType.STRING(60)
|
|
3608
3724
|
})
|
|
3609
3725
|
], mdSetting.prototype, "updatedBy", 2);
|
|
3610
3726
|
__decorateClass([
|
|
3611
|
-
(0,
|
|
3727
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3612
3728
|
field: "updated_date",
|
|
3613
3729
|
allowNull: true,
|
|
3614
|
-
type:
|
|
3730
|
+
type: import_sequelize_typescript34.DataType.DATE
|
|
3615
3731
|
})
|
|
3616
3732
|
], mdSetting.prototype, "updatedDate", 2);
|
|
3617
3733
|
mdSetting = __decorateClass([
|
|
3618
|
-
(0,
|
|
3734
|
+
(0, import_sequelize_typescript34.Table)({
|
|
3619
3735
|
tableName: "md_setting",
|
|
3620
3736
|
timestamps: false
|
|
3621
3737
|
})
|
|
3622
3738
|
], mdSetting);
|
|
3623
3739
|
|
|
3624
3740
|
// src/databases/tables/mdWords.ts
|
|
3625
|
-
var
|
|
3626
|
-
var mdWords = class extends
|
|
3741
|
+
var import_sequelize_typescript35 = require("sequelize-typescript");
|
|
3742
|
+
var mdWords = class extends import_sequelize_typescript35.Model {
|
|
3627
3743
|
};
|
|
3628
3744
|
__decorateClass([
|
|
3629
|
-
(0,
|
|
3745
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3630
3746
|
primaryKey: true,
|
|
3631
3747
|
autoIncrement: true,
|
|
3632
|
-
type:
|
|
3748
|
+
type: import_sequelize_typescript35.DataType.INTEGER
|
|
3633
3749
|
})
|
|
3634
3750
|
], mdWords.prototype, "id", 2);
|
|
3635
3751
|
__decorateClass([
|
|
3636
|
-
(0,
|
|
3752
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3637
3753
|
allowNull: true,
|
|
3638
|
-
type:
|
|
3754
|
+
type: import_sequelize_typescript35.DataType.STRING(60)
|
|
3639
3755
|
})
|
|
3640
3756
|
], mdWords.prototype, "uuid", 2);
|
|
3641
3757
|
__decorateClass([
|
|
3642
|
-
(0,
|
|
3758
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3643
3759
|
field: "key_name",
|
|
3644
3760
|
allowNull: true,
|
|
3645
|
-
type:
|
|
3761
|
+
type: import_sequelize_typescript35.DataType.STRING(100)
|
|
3646
3762
|
})
|
|
3647
3763
|
], mdWords.prototype, "keyName", 2);
|
|
3648
3764
|
__decorateClass([
|
|
3649
|
-
(0,
|
|
3765
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3650
3766
|
allowNull: true,
|
|
3651
|
-
type:
|
|
3767
|
+
type: import_sequelize_typescript35.DataType.STRING(255)
|
|
3652
3768
|
})
|
|
3653
3769
|
], mdWords.prototype, "name", 2);
|
|
3654
3770
|
__decorateClass([
|
|
3655
|
-
(0,
|
|
3771
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3656
3772
|
allowNull: true,
|
|
3657
|
-
type:
|
|
3773
|
+
type: import_sequelize_typescript35.DataType.STRING
|
|
3658
3774
|
})
|
|
3659
3775
|
], mdWords.prototype, "value", 2);
|
|
3660
3776
|
__decorateClass([
|
|
3661
|
-
(0,
|
|
3777
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3662
3778
|
allowNull: true,
|
|
3663
|
-
type:
|
|
3779
|
+
type: import_sequelize_typescript35.DataType.INTEGER
|
|
3664
3780
|
})
|
|
3665
3781
|
], mdWords.prototype, "status", 2);
|
|
3666
3782
|
__decorateClass([
|
|
3667
|
-
(0,
|
|
3783
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3668
3784
|
allowNull: true,
|
|
3669
|
-
type:
|
|
3785
|
+
type: import_sequelize_typescript35.DataType.INTEGER
|
|
3670
3786
|
})
|
|
3671
3787
|
], mdWords.prototype, "total", 2);
|
|
3672
3788
|
__decorateClass([
|
|
3673
|
-
(0,
|
|
3789
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3674
3790
|
field: "created_by",
|
|
3675
3791
|
allowNull: true,
|
|
3676
|
-
type:
|
|
3792
|
+
type: import_sequelize_typescript35.DataType.STRING(60)
|
|
3677
3793
|
})
|
|
3678
3794
|
], mdWords.prototype, "createdBy", 2);
|
|
3679
3795
|
__decorateClass([
|
|
3680
|
-
(0,
|
|
3796
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3681
3797
|
field: "created_date",
|
|
3682
3798
|
allowNull: true,
|
|
3683
|
-
type:
|
|
3799
|
+
type: import_sequelize_typescript35.DataType.DATE
|
|
3684
3800
|
})
|
|
3685
3801
|
], mdWords.prototype, "createdDate", 2);
|
|
3686
3802
|
__decorateClass([
|
|
3687
|
-
(0,
|
|
3803
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3688
3804
|
field: "updated_by",
|
|
3689
3805
|
allowNull: true,
|
|
3690
|
-
type:
|
|
3806
|
+
type: import_sequelize_typescript35.DataType.STRING(60)
|
|
3691
3807
|
})
|
|
3692
3808
|
], mdWords.prototype, "updatedBy", 2);
|
|
3693
3809
|
__decorateClass([
|
|
3694
|
-
(0,
|
|
3810
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3695
3811
|
field: "updated_date",
|
|
3696
3812
|
allowNull: true,
|
|
3697
|
-
type:
|
|
3813
|
+
type: import_sequelize_typescript35.DataType.DATE
|
|
3698
3814
|
})
|
|
3699
3815
|
], mdWords.prototype, "updatedDate", 2);
|
|
3700
3816
|
mdWords = __decorateClass([
|
|
3701
|
-
(0,
|
|
3817
|
+
(0, import_sequelize_typescript35.Table)({
|
|
3702
3818
|
tableName: "md_words",
|
|
3703
3819
|
timestamps: false
|
|
3704
3820
|
})
|
|
3705
3821
|
], mdWords);
|
|
3706
3822
|
|
|
3707
3823
|
// src/databases/tables/member.ts
|
|
3708
|
-
var
|
|
3709
|
-
var member = class extends
|
|
3824
|
+
var import_sequelize_typescript36 = require("sequelize-typescript");
|
|
3825
|
+
var member = class extends import_sequelize_typescript36.Model {
|
|
3710
3826
|
};
|
|
3711
3827
|
__decorateClass([
|
|
3712
|
-
(0,
|
|
3828
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3713
3829
|
primaryKey: true,
|
|
3714
3830
|
autoIncrement: true,
|
|
3715
|
-
type:
|
|
3831
|
+
type: import_sequelize_typescript36.DataType.INTEGER
|
|
3716
3832
|
})
|
|
3717
3833
|
], member.prototype, "id", 2);
|
|
3718
3834
|
__decorateClass([
|
|
3719
|
-
(0,
|
|
3835
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3720
3836
|
allowNull: true,
|
|
3721
|
-
type:
|
|
3837
|
+
type: import_sequelize_typescript36.DataType.STRING(60)
|
|
3722
3838
|
})
|
|
3723
3839
|
], member.prototype, "uuid", 2);
|
|
3724
3840
|
__decorateClass([
|
|
3725
|
-
(0,
|
|
3841
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3726
3842
|
allowNull: true,
|
|
3727
|
-
type:
|
|
3843
|
+
type: import_sequelize_typescript36.DataType.STRING(255)
|
|
3728
3844
|
})
|
|
3729
3845
|
], member.prototype, "username", 2);
|
|
3730
3846
|
__decorateClass([
|
|
3731
|
-
(0,
|
|
3847
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3732
3848
|
field: "password_hash",
|
|
3733
3849
|
allowNull: true,
|
|
3734
|
-
type:
|
|
3850
|
+
type: import_sequelize_typescript36.DataType.STRING(255)
|
|
3735
3851
|
})
|
|
3736
3852
|
], member.prototype, "passwordHash", 2);
|
|
3737
3853
|
__decorateClass([
|
|
3738
|
-
(0,
|
|
3854
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3739
3855
|
field: "password_reset_token",
|
|
3740
3856
|
allowNull: true,
|
|
3741
|
-
type:
|
|
3857
|
+
type: import_sequelize_typescript36.DataType.STRING(255)
|
|
3742
3858
|
})
|
|
3743
3859
|
], member.prototype, "passwordResetToken", 2);
|
|
3744
3860
|
__decorateClass([
|
|
3745
|
-
(0,
|
|
3861
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3746
3862
|
field: "verification_token",
|
|
3747
3863
|
allowNull: true,
|
|
3748
|
-
type:
|
|
3864
|
+
type: import_sequelize_typescript36.DataType.STRING(255)
|
|
3749
3865
|
})
|
|
3750
3866
|
], member.prototype, "verificationToken", 2);
|
|
3751
3867
|
__decorateClass([
|
|
3752
|
-
(0,
|
|
3868
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3753
3869
|
field: "auth_key",
|
|
3754
3870
|
allowNull: true,
|
|
3755
|
-
type:
|
|
3871
|
+
type: import_sequelize_typescript36.DataType.STRING(32)
|
|
3756
3872
|
})
|
|
3757
3873
|
], member.prototype, "authKey", 2);
|
|
3758
3874
|
__decorateClass([
|
|
3759
|
-
(0,
|
|
3875
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3760
3876
|
field: "user_type",
|
|
3761
3877
|
allowNull: true,
|
|
3762
|
-
type:
|
|
3878
|
+
type: import_sequelize_typescript36.DataType.INTEGER
|
|
3763
3879
|
})
|
|
3764
3880
|
], member.prototype, "userType", 2);
|
|
3765
3881
|
__decorateClass([
|
|
3766
|
-
(0,
|
|
3882
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3767
3883
|
allowNull: true,
|
|
3768
|
-
type:
|
|
3884
|
+
type: import_sequelize_typescript36.DataType.STRING(255)
|
|
3769
3885
|
})
|
|
3770
3886
|
], member.prototype, "email", 2);
|
|
3771
3887
|
__decorateClass([
|
|
3772
|
-
(0,
|
|
3888
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3773
3889
|
allowNull: true,
|
|
3774
|
-
type:
|
|
3890
|
+
type: import_sequelize_typescript36.DataType.STRING(10)
|
|
3775
3891
|
})
|
|
3776
3892
|
], member.prototype, "prefix", 2);
|
|
3777
3893
|
__decorateClass([
|
|
3778
|
-
(0,
|
|
3894
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3779
3895
|
field: "first_name",
|
|
3780
3896
|
allowNull: true,
|
|
3781
|
-
type:
|
|
3897
|
+
type: import_sequelize_typescript36.DataType.STRING(100)
|
|
3782
3898
|
})
|
|
3783
3899
|
], member.prototype, "firstName", 2);
|
|
3784
3900
|
__decorateClass([
|
|
3785
|
-
(0,
|
|
3901
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3786
3902
|
field: "last_name",
|
|
3787
3903
|
allowNull: true,
|
|
3788
|
-
type:
|
|
3904
|
+
type: import_sequelize_typescript36.DataType.STRING(100)
|
|
3789
3905
|
})
|
|
3790
3906
|
], member.prototype, "lastName", 2);
|
|
3791
3907
|
__decorateClass([
|
|
3792
|
-
(0,
|
|
3908
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3793
3909
|
field: "id_card",
|
|
3794
3910
|
allowNull: true,
|
|
3795
|
-
type:
|
|
3911
|
+
type: import_sequelize_typescript36.DataType.STRING(20)
|
|
3796
3912
|
})
|
|
3797
3913
|
], member.prototype, "idCard", 2);
|
|
3798
3914
|
__decorateClass([
|
|
3799
|
-
(0,
|
|
3915
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3800
3916
|
allowNull: true,
|
|
3801
|
-
type:
|
|
3917
|
+
type: import_sequelize_typescript36.DataType.STRING
|
|
3802
3918
|
})
|
|
3803
3919
|
], member.prototype, "address", 2);
|
|
3804
3920
|
__decorateClass([
|
|
3805
|
-
(0,
|
|
3921
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3806
3922
|
allowNull: true,
|
|
3807
|
-
type:
|
|
3923
|
+
type: import_sequelize_typescript36.DataType.STRING(20)
|
|
3808
3924
|
})
|
|
3809
3925
|
], member.prototype, "phone", 2);
|
|
3810
3926
|
__decorateClass([
|
|
3811
|
-
(0,
|
|
3927
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3812
3928
|
allowNull: true,
|
|
3813
|
-
type:
|
|
3929
|
+
type: import_sequelize_typescript36.DataType.STRING(255)
|
|
3814
3930
|
})
|
|
3815
3931
|
], member.prototype, "job", 2);
|
|
3816
3932
|
__decorateClass([
|
|
3817
|
-
(0,
|
|
3933
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3818
3934
|
allowNull: true,
|
|
3819
|
-
type:
|
|
3935
|
+
type: import_sequelize_typescript36.DataType.STRING(255)
|
|
3820
3936
|
})
|
|
3821
3937
|
], member.prototype, "agency", 2);
|
|
3822
3938
|
__decorateClass([
|
|
3823
|
-
(0,
|
|
3939
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3824
3940
|
allowNull: true,
|
|
3825
|
-
type:
|
|
3941
|
+
type: import_sequelize_typescript36.DataType.STRING(255)
|
|
3826
3942
|
})
|
|
3827
3943
|
], member.prototype, "position", 2);
|
|
3828
3944
|
__decorateClass([
|
|
3829
|
-
(0,
|
|
3945
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3830
3946
|
allowNull: true,
|
|
3831
|
-
type:
|
|
3947
|
+
type: import_sequelize_typescript36.DataType.STRING(1)
|
|
3832
3948
|
})
|
|
3833
3949
|
], member.prototype, "gender", 2);
|
|
3834
3950
|
__decorateClass([
|
|
3835
|
-
(0,
|
|
3951
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3836
3952
|
allowNull: true,
|
|
3837
|
-
type:
|
|
3953
|
+
type: import_sequelize_typescript36.DataType.SMALLINT
|
|
3838
3954
|
})
|
|
3839
3955
|
], member.prototype, "status", 2);
|
|
3840
3956
|
__decorateClass([
|
|
3841
|
-
(0,
|
|
3957
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3842
3958
|
allowNull: true,
|
|
3843
|
-
type:
|
|
3959
|
+
type: import_sequelize_typescript36.DataType.INTEGER
|
|
3844
3960
|
})
|
|
3845
3961
|
], member.prototype, "is_2fa", 2);
|
|
3846
3962
|
__decorateClass([
|
|
3847
|
-
(0,
|
|
3963
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3964
|
+
field: "security_info",
|
|
3965
|
+
allowNull: true,
|
|
3966
|
+
type: import_sequelize_typescript36.DataType.JSON
|
|
3967
|
+
})
|
|
3968
|
+
], member.prototype, "securityInfo", 2);
|
|
3969
|
+
__decorateClass([
|
|
3970
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3848
3971
|
field: "line_id",
|
|
3849
3972
|
allowNull: true,
|
|
3850
|
-
type:
|
|
3973
|
+
type: import_sequelize_typescript36.DataType.STRING(255)
|
|
3851
3974
|
})
|
|
3852
3975
|
], member.prototype, "lineId", 2);
|
|
3853
3976
|
__decorateClass([
|
|
3854
|
-
(0,
|
|
3977
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3855
3978
|
field: "facebook_id",
|
|
3856
3979
|
allowNull: true,
|
|
3857
|
-
type:
|
|
3980
|
+
type: import_sequelize_typescript36.DataType.STRING(255)
|
|
3858
3981
|
})
|
|
3859
3982
|
], member.prototype, "facebookId", 2);
|
|
3860
3983
|
__decorateClass([
|
|
3861
|
-
(0,
|
|
3984
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3862
3985
|
allowNull: true,
|
|
3863
|
-
type:
|
|
3986
|
+
type: import_sequelize_typescript36.DataType.INTEGER
|
|
3864
3987
|
})
|
|
3865
3988
|
], member.prototype, "policy", 2);
|
|
3866
3989
|
__decorateClass([
|
|
3867
|
-
(0,
|
|
3990
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3868
3991
|
allowNull: true,
|
|
3869
|
-
type:
|
|
3992
|
+
type: import_sequelize_typescript36.DataType.INTEGER
|
|
3870
3993
|
})
|
|
3871
3994
|
], member.prototype, "terms", 2);
|
|
3872
3995
|
__decorateClass([
|
|
3873
|
-
(0,
|
|
3996
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3874
3997
|
allowNull: true,
|
|
3875
|
-
type:
|
|
3998
|
+
type: import_sequelize_typescript36.DataType.STRING(10)
|
|
3876
3999
|
})
|
|
3877
4000
|
], member.prototype, "otp", 2);
|
|
3878
4001
|
__decorateClass([
|
|
3879
|
-
(0,
|
|
4002
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3880
4003
|
field: "otp_date",
|
|
3881
4004
|
allowNull: true,
|
|
3882
|
-
type:
|
|
4005
|
+
type: import_sequelize_typescript36.DataType.DATE
|
|
3883
4006
|
})
|
|
3884
4007
|
], member.prototype, "otpDate", 2);
|
|
3885
4008
|
__decorateClass([
|
|
3886
|
-
(0,
|
|
4009
|
+
(0, import_sequelize_typescript36.Column)({
|
|
4010
|
+
allowNull: true,
|
|
4011
|
+
type: import_sequelize_typescript36.DataType.STRING(60)
|
|
4012
|
+
})
|
|
4013
|
+
], member.prototype, "avatar", 2);
|
|
4014
|
+
__decorateClass([
|
|
4015
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3887
4016
|
field: "created_by",
|
|
3888
4017
|
allowNull: true,
|
|
3889
|
-
type:
|
|
4018
|
+
type: import_sequelize_typescript36.DataType.STRING(60)
|
|
3890
4019
|
})
|
|
3891
4020
|
], member.prototype, "createdBy", 2);
|
|
3892
4021
|
__decorateClass([
|
|
3893
|
-
(0,
|
|
4022
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3894
4023
|
field: "created_date",
|
|
3895
4024
|
allowNull: true,
|
|
3896
|
-
type:
|
|
4025
|
+
type: import_sequelize_typescript36.DataType.DATE
|
|
3897
4026
|
})
|
|
3898
4027
|
], member.prototype, "createdDate", 2);
|
|
3899
4028
|
__decorateClass([
|
|
3900
|
-
(0,
|
|
4029
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3901
4030
|
field: "updated_by",
|
|
3902
4031
|
allowNull: true,
|
|
3903
|
-
type:
|
|
4032
|
+
type: import_sequelize_typescript36.DataType.STRING(60)
|
|
3904
4033
|
})
|
|
3905
4034
|
], member.prototype, "updatedBy", 2);
|
|
3906
4035
|
__decorateClass([
|
|
3907
|
-
(0,
|
|
4036
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3908
4037
|
field: "updated_date",
|
|
3909
4038
|
allowNull: true,
|
|
3910
|
-
type:
|
|
4039
|
+
type: import_sequelize_typescript36.DataType.DATE
|
|
3911
4040
|
})
|
|
3912
4041
|
], member.prototype, "updatedDate", 2);
|
|
3913
4042
|
member = __decorateClass([
|
|
3914
|
-
(0,
|
|
4043
|
+
(0, import_sequelize_typescript36.Table)({
|
|
3915
4044
|
tableName: "member",
|
|
3916
4045
|
timestamps: false
|
|
3917
4046
|
})
|
|
3918
4047
|
], member);
|
|
3919
4048
|
|
|
3920
4049
|
// src/databases/tables/oauthAccessToken.ts
|
|
3921
|
-
var
|
|
3922
|
-
var oauthAccessToken = class extends
|
|
4050
|
+
var import_sequelize_typescript37 = require("sequelize-typescript");
|
|
4051
|
+
var oauthAccessToken = class extends import_sequelize_typescript37.Model {
|
|
3923
4052
|
};
|
|
3924
4053
|
__decorateClass([
|
|
3925
|
-
(0,
|
|
4054
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3926
4055
|
primaryKey: true,
|
|
3927
4056
|
autoIncrement: true,
|
|
3928
|
-
type:
|
|
4057
|
+
type: import_sequelize_typescript37.DataType.INTEGER
|
|
3929
4058
|
})
|
|
3930
4059
|
], oauthAccessToken.prototype, "id", 2);
|
|
3931
4060
|
__decorateClass([
|
|
3932
|
-
(0,
|
|
4061
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3933
4062
|
field: "access_token",
|
|
3934
|
-
type:
|
|
4063
|
+
type: import_sequelize_typescript37.DataType.STRING
|
|
3935
4064
|
})
|
|
3936
4065
|
], oauthAccessToken.prototype, "accessToken", 2);
|
|
3937
4066
|
__decorateClass([
|
|
3938
|
-
(0,
|
|
4067
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3939
4068
|
field: "client_id",
|
|
3940
|
-
type:
|
|
4069
|
+
type: import_sequelize_typescript37.DataType.STRING(32)
|
|
3941
4070
|
})
|
|
3942
4071
|
], oauthAccessToken.prototype, "clientId", 2);
|
|
3943
4072
|
__decorateClass([
|
|
3944
|
-
(0,
|
|
4073
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3945
4074
|
field: "user_id",
|
|
3946
4075
|
allowNull: true,
|
|
3947
|
-
type:
|
|
4076
|
+
type: import_sequelize_typescript37.DataType.INTEGER
|
|
3948
4077
|
})
|
|
3949
4078
|
], oauthAccessToken.prototype, "userId", 2);
|
|
3950
4079
|
__decorateClass([
|
|
3951
|
-
(0,
|
|
3952
|
-
type:
|
|
3953
|
-
defaultValue:
|
|
4080
|
+
(0, import_sequelize_typescript37.Column)({
|
|
4081
|
+
type: import_sequelize_typescript37.DataType.DATE,
|
|
4082
|
+
defaultValue: import_sequelize_typescript37.DataType.NOW
|
|
3954
4083
|
})
|
|
3955
4084
|
], oauthAccessToken.prototype, "expires", 2);
|
|
3956
4085
|
__decorateClass([
|
|
3957
|
-
(0,
|
|
4086
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3958
4087
|
allowNull: true,
|
|
3959
|
-
type:
|
|
4088
|
+
type: import_sequelize_typescript37.DataType.STRING(2e3)
|
|
3960
4089
|
})
|
|
3961
4090
|
], oauthAccessToken.prototype, "scope", 2);
|
|
3962
4091
|
__decorateClass([
|
|
3963
|
-
(0,
|
|
4092
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3964
4093
|
field: "created_date",
|
|
3965
|
-
type:
|
|
3966
|
-
defaultValue:
|
|
4094
|
+
type: import_sequelize_typescript37.DataType.DATE,
|
|
4095
|
+
defaultValue: import_sequelize_typescript37.DataType.NOW
|
|
3967
4096
|
})
|
|
3968
4097
|
], oauthAccessToken.prototype, "createdDate", 2);
|
|
3969
4098
|
oauthAccessToken = __decorateClass([
|
|
3970
|
-
(0,
|
|
4099
|
+
(0, import_sequelize_typescript37.Table)({
|
|
3971
4100
|
tableName: "oauth_access_token",
|
|
3972
4101
|
timestamps: false
|
|
3973
4102
|
})
|
|
3974
4103
|
], oauthAccessToken);
|
|
3975
4104
|
|
|
3976
4105
|
// src/databases/tables/oauthRefreshToken.ts
|
|
3977
|
-
var
|
|
3978
|
-
var oauthRefreshToken = class extends
|
|
4106
|
+
var import_sequelize_typescript38 = require("sequelize-typescript");
|
|
4107
|
+
var oauthRefreshToken = class extends import_sequelize_typescript38.Model {
|
|
3979
4108
|
};
|
|
3980
4109
|
__decorateClass([
|
|
3981
|
-
(0,
|
|
4110
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3982
4111
|
primaryKey: true,
|
|
3983
4112
|
autoIncrement: true,
|
|
3984
|
-
type:
|
|
4113
|
+
type: import_sequelize_typescript38.DataType.INTEGER
|
|
3985
4114
|
})
|
|
3986
4115
|
], oauthRefreshToken.prototype, "id", 2);
|
|
3987
4116
|
__decorateClass([
|
|
3988
|
-
(0,
|
|
4117
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3989
4118
|
field: "refresh_token",
|
|
3990
|
-
type:
|
|
4119
|
+
type: import_sequelize_typescript38.DataType.STRING(1e3)
|
|
3991
4120
|
})
|
|
3992
4121
|
], oauthRefreshToken.prototype, "refreshToken", 2);
|
|
3993
4122
|
__decorateClass([
|
|
3994
|
-
(0,
|
|
4123
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3995
4124
|
field: "client_id",
|
|
3996
|
-
type:
|
|
4125
|
+
type: import_sequelize_typescript38.DataType.STRING(32)
|
|
3997
4126
|
})
|
|
3998
4127
|
], oauthRefreshToken.prototype, "clientId", 2);
|
|
3999
4128
|
__decorateClass([
|
|
4000
|
-
(0,
|
|
4129
|
+
(0, import_sequelize_typescript38.Column)({
|
|
4001
4130
|
field: "user_id",
|
|
4002
4131
|
allowNull: true,
|
|
4003
|
-
type:
|
|
4132
|
+
type: import_sequelize_typescript38.DataType.INTEGER
|
|
4004
4133
|
})
|
|
4005
4134
|
], oauthRefreshToken.prototype, "userId", 2);
|
|
4006
4135
|
__decorateClass([
|
|
4007
|
-
(0,
|
|
4008
|
-
type:
|
|
4009
|
-
defaultValue:
|
|
4136
|
+
(0, import_sequelize_typescript38.Column)({
|
|
4137
|
+
type: import_sequelize_typescript38.DataType.DATE,
|
|
4138
|
+
defaultValue: import_sequelize_typescript38.DataType.NOW
|
|
4010
4139
|
})
|
|
4011
4140
|
], oauthRefreshToken.prototype, "expires", 2);
|
|
4012
4141
|
__decorateClass([
|
|
4013
|
-
(0,
|
|
4142
|
+
(0, import_sequelize_typescript38.Column)({
|
|
4014
4143
|
allowNull: true,
|
|
4015
|
-
type:
|
|
4144
|
+
type: import_sequelize_typescript38.DataType.STRING(1e3)
|
|
4016
4145
|
})
|
|
4017
4146
|
], oauthRefreshToken.prototype, "scope", 2);
|
|
4018
4147
|
__decorateClass([
|
|
4019
|
-
(0,
|
|
4148
|
+
(0, import_sequelize_typescript38.Column)({
|
|
4020
4149
|
field: "created_date",
|
|
4021
|
-
type:
|
|
4022
|
-
defaultValue:
|
|
4150
|
+
type: import_sequelize_typescript38.DataType.DATE,
|
|
4151
|
+
defaultValue: import_sequelize_typescript38.DataType.NOW
|
|
4023
4152
|
})
|
|
4024
4153
|
], oauthRefreshToken.prototype, "createdDate", 2);
|
|
4025
4154
|
oauthRefreshToken = __decorateClass([
|
|
4026
|
-
(0,
|
|
4155
|
+
(0, import_sequelize_typescript38.Table)({
|
|
4027
4156
|
tableName: "oauth_refresh_token",
|
|
4028
4157
|
timestamps: false
|
|
4029
4158
|
})
|
|
4030
4159
|
], oauthRefreshToken);
|
|
4031
4160
|
|
|
4032
4161
|
// src/databases/tables/settings.ts
|
|
4033
|
-
var
|
|
4034
|
-
var settings = class extends
|
|
4162
|
+
var import_sequelize_typescript39 = require("sequelize-typescript");
|
|
4163
|
+
var settings = class extends import_sequelize_typescript39.Model {
|
|
4035
4164
|
};
|
|
4036
4165
|
__decorateClass([
|
|
4037
|
-
(0,
|
|
4166
|
+
(0, import_sequelize_typescript39.Column)({
|
|
4038
4167
|
primaryKey: true,
|
|
4039
4168
|
autoIncrement: true,
|
|
4040
|
-
type:
|
|
4169
|
+
type: import_sequelize_typescript39.DataType.INTEGER
|
|
4041
4170
|
})
|
|
4042
4171
|
], settings.prototype, "id", 2);
|
|
4043
4172
|
__decorateClass([
|
|
4044
|
-
(0,
|
|
4173
|
+
(0, import_sequelize_typescript39.Column)({
|
|
4045
4174
|
allowNull: true,
|
|
4046
|
-
type:
|
|
4175
|
+
type: import_sequelize_typescript39.DataType.STRING(255)
|
|
4047
4176
|
})
|
|
4048
4177
|
], settings.prototype, "key", 2);
|
|
4049
4178
|
__decorateClass([
|
|
4050
|
-
(0,
|
|
4179
|
+
(0, import_sequelize_typescript39.Column)({
|
|
4051
4180
|
allowNull: true,
|
|
4052
|
-
type:
|
|
4181
|
+
type: import_sequelize_typescript39.DataType.STRING
|
|
4053
4182
|
})
|
|
4054
4183
|
], settings.prototype, "value", 2);
|
|
4055
4184
|
__decorateClass([
|
|
4056
|
-
(0,
|
|
4185
|
+
(0, import_sequelize_typescript39.Column)({
|
|
4057
4186
|
allowNull: true,
|
|
4058
|
-
type:
|
|
4187
|
+
type: import_sequelize_typescript39.DataType.JSON
|
|
4059
4188
|
})
|
|
4060
4189
|
], settings.prototype, "data", 2);
|
|
4061
4190
|
__decorateClass([
|
|
4062
|
-
(0,
|
|
4191
|
+
(0, import_sequelize_typescript39.Column)({
|
|
4063
4192
|
field: "updated_by",
|
|
4064
4193
|
allowNull: true,
|
|
4065
|
-
type:
|
|
4194
|
+
type: import_sequelize_typescript39.DataType.STRING(60)
|
|
4066
4195
|
})
|
|
4067
4196
|
], settings.prototype, "updatedBy", 2);
|
|
4068
4197
|
__decorateClass([
|
|
4069
|
-
(0,
|
|
4198
|
+
(0, import_sequelize_typescript39.Column)({
|
|
4070
4199
|
field: "updated_date",
|
|
4071
4200
|
allowNull: true,
|
|
4072
|
-
type:
|
|
4201
|
+
type: import_sequelize_typescript39.DataType.DATE
|
|
4073
4202
|
})
|
|
4074
4203
|
], settings.prototype, "updatedDate", 2);
|
|
4075
4204
|
settings = __decorateClass([
|
|
4076
|
-
(0,
|
|
4205
|
+
(0, import_sequelize_typescript39.Table)({
|
|
4077
4206
|
tableName: "settings",
|
|
4078
4207
|
timestamps: false
|
|
4079
4208
|
})
|
|
4080
4209
|
], settings);
|
|
4081
4210
|
|
|
4082
4211
|
// src/databases/tables/userCenterV.ts
|
|
4083
|
-
var
|
|
4084
|
-
var userCenterV = class extends
|
|
4212
|
+
var import_sequelize_typescript40 = require("sequelize-typescript");
|
|
4213
|
+
var userCenterV = class extends import_sequelize_typescript40.Model {
|
|
4085
4214
|
};
|
|
4086
4215
|
__decorateClass([
|
|
4087
|
-
(0,
|
|
4088
|
-
type:
|
|
4216
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4217
|
+
type: import_sequelize_typescript40.DataType.INTEGER,
|
|
4089
4218
|
defaultValue: "0"
|
|
4090
4219
|
})
|
|
4091
4220
|
], userCenterV.prototype, "id", 2);
|
|
4092
4221
|
__decorateClass([
|
|
4093
|
-
(0,
|
|
4094
|
-
type:
|
|
4222
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4223
|
+
type: import_sequelize_typescript40.DataType.STRING(60)
|
|
4095
4224
|
})
|
|
4096
4225
|
], userCenterV.prototype, "uuid", 2);
|
|
4097
4226
|
__decorateClass([
|
|
4098
|
-
(0,
|
|
4099
|
-
type:
|
|
4227
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4228
|
+
type: import_sequelize_typescript40.DataType.STRING(100)
|
|
4100
4229
|
})
|
|
4101
4230
|
], userCenterV.prototype, "username", 2);
|
|
4102
4231
|
__decorateClass([
|
|
4103
|
-
(0,
|
|
4232
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4104
4233
|
field: "password_hash",
|
|
4105
4234
|
allowNull: true,
|
|
4106
|
-
type:
|
|
4235
|
+
type: import_sequelize_typescript40.DataType.STRING(255)
|
|
4107
4236
|
})
|
|
4108
4237
|
], userCenterV.prototype, "passwordHash", 2);
|
|
4109
4238
|
__decorateClass([
|
|
4110
|
-
(0,
|
|
4239
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4111
4240
|
field: "password_reset_token",
|
|
4112
4241
|
allowNull: true,
|
|
4113
|
-
type:
|
|
4242
|
+
type: import_sequelize_typescript40.DataType.STRING(255)
|
|
4114
4243
|
})
|
|
4115
4244
|
], userCenterV.prototype, "passwordResetToken", 2);
|
|
4116
4245
|
__decorateClass([
|
|
4117
|
-
(0,
|
|
4246
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4118
4247
|
field: "verification_token",
|
|
4119
4248
|
allowNull: true,
|
|
4120
|
-
type:
|
|
4249
|
+
type: import_sequelize_typescript40.DataType.STRING(255)
|
|
4121
4250
|
})
|
|
4122
4251
|
], userCenterV.prototype, "verificationToken", 2);
|
|
4123
4252
|
__decorateClass([
|
|
4124
|
-
(0,
|
|
4253
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4125
4254
|
allowNull: true,
|
|
4126
|
-
type:
|
|
4255
|
+
type: import_sequelize_typescript40.DataType.STRING(255)
|
|
4127
4256
|
})
|
|
4128
4257
|
], userCenterV.prototype, "email", 2);
|
|
4129
4258
|
__decorateClass([
|
|
4130
|
-
(0,
|
|
4259
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4131
4260
|
field: "auth_key",
|
|
4132
4261
|
allowNull: true,
|
|
4133
|
-
type:
|
|
4262
|
+
type: import_sequelize_typescript40.DataType.STRING(32)
|
|
4134
4263
|
})
|
|
4135
4264
|
], userCenterV.prototype, "authKey", 2);
|
|
4136
4265
|
__decorateClass([
|
|
4137
|
-
(0,
|
|
4266
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4138
4267
|
field: "access_token",
|
|
4139
4268
|
allowNull: true,
|
|
4140
|
-
type:
|
|
4269
|
+
type: import_sequelize_typescript40.DataType.STRING
|
|
4141
4270
|
})
|
|
4142
4271
|
], userCenterV.prototype, "accessToken", 2);
|
|
4143
4272
|
__decorateClass([
|
|
4144
|
-
(0,
|
|
4273
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4145
4274
|
field: "user_level",
|
|
4146
4275
|
allowNull: true,
|
|
4147
|
-
type:
|
|
4276
|
+
type: import_sequelize_typescript40.DataType.INTEGER
|
|
4148
4277
|
})
|
|
4149
4278
|
], userCenterV.prototype, "userLevel", 2);
|
|
4150
4279
|
__decorateClass([
|
|
4151
|
-
(0,
|
|
4280
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4152
4281
|
field: "user_authen",
|
|
4153
4282
|
allowNull: true,
|
|
4154
|
-
type:
|
|
4283
|
+
type: import_sequelize_typescript40.DataType.STRING(64)
|
|
4155
4284
|
})
|
|
4156
4285
|
], userCenterV.prototype, "userAuthen", 2);
|
|
4157
4286
|
__decorateClass([
|
|
4158
|
-
(0,
|
|
4287
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4159
4288
|
field: "user_type",
|
|
4160
4289
|
allowNull: true,
|
|
4161
|
-
type:
|
|
4290
|
+
type: import_sequelize_typescript40.DataType.INTEGER
|
|
4162
4291
|
})
|
|
4163
4292
|
], userCenterV.prototype, "userType", 2);
|
|
4164
4293
|
__decorateClass([
|
|
4165
|
-
(0,
|
|
4294
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4166
4295
|
allowNull: true,
|
|
4167
|
-
type:
|
|
4296
|
+
type: import_sequelize_typescript40.DataType.STRING(10)
|
|
4168
4297
|
})
|
|
4169
4298
|
], userCenterV.prototype, "prefix", 2);
|
|
4170
4299
|
__decorateClass([
|
|
4171
|
-
(0,
|
|
4300
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4172
4301
|
field: "first_name",
|
|
4173
4302
|
allowNull: true,
|
|
4174
|
-
type:
|
|
4303
|
+
type: import_sequelize_typescript40.DataType.STRING(100)
|
|
4175
4304
|
})
|
|
4176
4305
|
], userCenterV.prototype, "firstName", 2);
|
|
4177
4306
|
__decorateClass([
|
|
4178
|
-
(0,
|
|
4307
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4179
4308
|
field: "last_name",
|
|
4180
4309
|
allowNull: true,
|
|
4181
|
-
type:
|
|
4310
|
+
type: import_sequelize_typescript40.DataType.STRING(100)
|
|
4182
4311
|
})
|
|
4183
4312
|
], userCenterV.prototype, "lastName", 2);
|
|
4184
4313
|
__decorateClass([
|
|
4185
|
-
(0,
|
|
4314
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4186
4315
|
allowNull: true,
|
|
4187
|
-
type:
|
|
4316
|
+
type: import_sequelize_typescript40.DataType.STRING(20)
|
|
4188
4317
|
})
|
|
4189
4318
|
], userCenterV.prototype, "phone", 2);
|
|
4190
4319
|
__decorateClass([
|
|
4191
|
-
(0,
|
|
4320
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4192
4321
|
allowNull: true,
|
|
4193
|
-
type:
|
|
4322
|
+
type: import_sequelize_typescript40.DataType.SMALLINT
|
|
4194
4323
|
})
|
|
4195
4324
|
], userCenterV.prototype, "status", 2);
|
|
4196
4325
|
__decorateClass([
|
|
4197
|
-
(0,
|
|
4326
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4198
4327
|
field: "created_by",
|
|
4199
4328
|
allowNull: true,
|
|
4200
|
-
type:
|
|
4329
|
+
type: import_sequelize_typescript40.DataType.STRING(60)
|
|
4201
4330
|
})
|
|
4202
4331
|
], userCenterV.prototype, "createdBy", 2);
|
|
4203
4332
|
__decorateClass([
|
|
4204
|
-
(0,
|
|
4333
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4205
4334
|
field: "created_date",
|
|
4206
4335
|
allowNull: true,
|
|
4207
|
-
type:
|
|
4336
|
+
type: import_sequelize_typescript40.DataType.DATE
|
|
4208
4337
|
})
|
|
4209
4338
|
], userCenterV.prototype, "createdDate", 2);
|
|
4210
4339
|
__decorateClass([
|
|
4211
|
-
(0,
|
|
4340
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4212
4341
|
field: "updated_by",
|
|
4213
4342
|
allowNull: true,
|
|
4214
|
-
type:
|
|
4343
|
+
type: import_sequelize_typescript40.DataType.STRING(60)
|
|
4215
4344
|
})
|
|
4216
4345
|
], userCenterV.prototype, "updatedBy", 2);
|
|
4217
4346
|
__decorateClass([
|
|
4218
|
-
(0,
|
|
4347
|
+
(0, import_sequelize_typescript40.Column)({
|
|
4219
4348
|
field: "updated_date",
|
|
4220
4349
|
allowNull: true,
|
|
4221
|
-
type:
|
|
4350
|
+
type: import_sequelize_typescript40.DataType.DATE
|
|
4222
4351
|
})
|
|
4223
4352
|
], userCenterV.prototype, "updatedDate", 2);
|
|
4224
4353
|
userCenterV = __decorateClass([
|
|
4225
|
-
(0,
|
|
4354
|
+
(0, import_sequelize_typescript40.Table)({
|
|
4226
4355
|
tableName: "user_center_v",
|
|
4227
4356
|
timestamps: false,
|
|
4228
4357
|
comment: "VIEW"
|
|
@@ -4230,38 +4359,38 @@ userCenterV = __decorateClass([
|
|
|
4230
4359
|
], userCenterV);
|
|
4231
4360
|
|
|
4232
4361
|
// src/databases/tables/userRoleV.ts
|
|
4233
|
-
var
|
|
4234
|
-
var userRoleV = class extends
|
|
4362
|
+
var import_sequelize_typescript41 = require("sequelize-typescript");
|
|
4363
|
+
var userRoleV = class extends import_sequelize_typescript41.Model {
|
|
4235
4364
|
};
|
|
4236
4365
|
__decorateClass([
|
|
4237
|
-
(0,
|
|
4238
|
-
type:
|
|
4366
|
+
(0, import_sequelize_typescript41.Column)({
|
|
4367
|
+
type: import_sequelize_typescript41.DataType.INTEGER,
|
|
4239
4368
|
defaultValue: "0"
|
|
4240
4369
|
})
|
|
4241
4370
|
], userRoleV.prototype, "id", 2);
|
|
4242
4371
|
__decorateClass([
|
|
4243
|
-
(0,
|
|
4372
|
+
(0, import_sequelize_typescript41.Column)({
|
|
4244
4373
|
field: "website_th",
|
|
4245
4374
|
allowNull: true,
|
|
4246
|
-
type:
|
|
4375
|
+
type: import_sequelize_typescript41.DataType.STRING(60)
|
|
4247
4376
|
})
|
|
4248
4377
|
], userRoleV.prototype, "websiteTh", 2);
|
|
4249
4378
|
__decorateClass([
|
|
4250
|
-
(0,
|
|
4379
|
+
(0, import_sequelize_typescript41.Column)({
|
|
4251
4380
|
field: "website_en",
|
|
4252
4381
|
allowNull: true,
|
|
4253
|
-
type:
|
|
4382
|
+
type: import_sequelize_typescript41.DataType.STRING(60)
|
|
4254
4383
|
})
|
|
4255
4384
|
], userRoleV.prototype, "websiteEn", 2);
|
|
4256
4385
|
__decorateClass([
|
|
4257
|
-
(0,
|
|
4386
|
+
(0, import_sequelize_typescript41.Column)({
|
|
4258
4387
|
field: "website_fr",
|
|
4259
4388
|
allowNull: true,
|
|
4260
|
-
type:
|
|
4389
|
+
type: import_sequelize_typescript41.DataType.STRING(60)
|
|
4261
4390
|
})
|
|
4262
4391
|
], userRoleV.prototype, "websiteFr", 2);
|
|
4263
4392
|
userRoleV = __decorateClass([
|
|
4264
|
-
(0,
|
|
4393
|
+
(0, import_sequelize_typescript41.Table)({
|
|
4265
4394
|
tableName: "user_role_v",
|
|
4266
4395
|
timestamps: false,
|
|
4267
4396
|
comment: "VIEW"
|
|
@@ -4275,6 +4404,7 @@ userRoleV = __decorateClass([
|
|
|
4275
4404
|
authRole,
|
|
4276
4405
|
authRoleChild,
|
|
4277
4406
|
files,
|
|
4407
|
+
formFaq,
|
|
4278
4408
|
helper,
|
|
4279
4409
|
logs,
|
|
4280
4410
|
mdBanner,
|