@admc-go-th/admc-library 1.0.64 → 1.0.65
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.
|
@@ -48,6 +48,7 @@ __export(tables_exports, {
|
|
|
48
48
|
mdFaq: () => mdFaq,
|
|
49
49
|
mdFaqGroup: () => mdFaqGroup,
|
|
50
50
|
mdFormAdvance_1: () => mdFormAdvance_1,
|
|
51
|
+
mdFormAdvance_2: () => mdFormAdvance_2,
|
|
51
52
|
mdLink: () => mdLink,
|
|
52
53
|
mdLinkGroup: () => mdLinkGroup,
|
|
53
54
|
mdNews: () => mdNews,
|
|
@@ -55,12 +56,12 @@ __export(tables_exports, {
|
|
|
55
56
|
mdPopup: () => mdPopup,
|
|
56
57
|
mdQuestionnaire: () => mdQuestionnaire,
|
|
57
58
|
mdSetting: () => mdSetting,
|
|
59
|
+
mdWords: () => mdWords,
|
|
58
60
|
member: () => member,
|
|
59
61
|
menu: () => menu,
|
|
60
62
|
msModule: () => msModule,
|
|
61
63
|
oauthAccessToken: () => oauthAccessToken,
|
|
62
64
|
oauthRefreshToken: () => oauthRefreshToken,
|
|
63
|
-
setting: () => setting,
|
|
64
65
|
settings: () => settings,
|
|
65
66
|
userCenterV: () => userCenterV,
|
|
66
67
|
userRoleV: () => userRoleV,
|
|
@@ -2731,12 +2732,9 @@ mdFormAdvance_1 = __decorateClass([
|
|
|
2731
2732
|
})
|
|
2732
2733
|
], mdFormAdvance_1);
|
|
2733
2734
|
|
|
2734
|
-
// src/databases/tables/
|
|
2735
|
-
var import_sequelize_typescript27 = require("sequelize-typescript");
|
|
2736
|
-
|
|
2737
|
-
// src/databases/tables/mdLinkGroup.ts
|
|
2735
|
+
// src/databases/tables/mdFormAdvance_2.ts
|
|
2738
2736
|
var import_sequelize_typescript26 = require("sequelize-typescript");
|
|
2739
|
-
var
|
|
2737
|
+
var mdFormAdvance_2 = class extends import_sequelize_typescript26.Model {
|
|
2740
2738
|
};
|
|
2741
2739
|
__decorateClass([
|
|
2742
2740
|
(0, import_sequelize_typescript26.Column)({
|
|
@@ -2744,1257 +2742,1364 @@ __decorateClass([
|
|
|
2744
2742
|
autoIncrement: true,
|
|
2745
2743
|
type: import_sequelize_typescript26.DataType.INTEGER
|
|
2746
2744
|
})
|
|
2747
|
-
],
|
|
2745
|
+
], mdFormAdvance_2.prototype, "id", 2);
|
|
2748
2746
|
__decorateClass([
|
|
2749
2747
|
(0, import_sequelize_typescript26.Column)({
|
|
2750
2748
|
allowNull: true,
|
|
2751
2749
|
type: import_sequelize_typescript26.DataType.STRING(60)
|
|
2752
2750
|
})
|
|
2753
|
-
],
|
|
2751
|
+
], mdFormAdvance_2.prototype, "uuid", 2);
|
|
2754
2752
|
__decorateClass([
|
|
2755
2753
|
(0, import_sequelize_typescript26.Column)({
|
|
2756
2754
|
field: "key_name",
|
|
2757
2755
|
allowNull: true,
|
|
2758
2756
|
type: import_sequelize_typescript26.DataType.STRING(100)
|
|
2759
2757
|
})
|
|
2760
|
-
],
|
|
2758
|
+
], mdFormAdvance_2.prototype, "keyName", 2);
|
|
2761
2759
|
__decorateClass([
|
|
2762
2760
|
(0, import_sequelize_typescript26.Column)({
|
|
2763
|
-
field: "user_id",
|
|
2764
2761
|
allowNull: true,
|
|
2765
|
-
type: import_sequelize_typescript26.DataType.INTEGER
|
|
2766
|
-
})
|
|
2767
|
-
], mdLinkGroup.prototype, "userId", 2);
|
|
2768
|
-
__decorateClass([
|
|
2769
|
-
(0, import_sequelize_typescript26.Column)({
|
|
2770
2762
|
type: import_sequelize_typescript26.DataType.STRING(255)
|
|
2771
2763
|
})
|
|
2772
|
-
],
|
|
2764
|
+
], mdFormAdvance_2.prototype, "name", 2);
|
|
2773
2765
|
__decorateClass([
|
|
2774
2766
|
(0, import_sequelize_typescript26.Column)({
|
|
2775
2767
|
allowNull: true,
|
|
2776
|
-
type: import_sequelize_typescript26.DataType.STRING
|
|
2768
|
+
type: import_sequelize_typescript26.DataType.STRING
|
|
2777
2769
|
})
|
|
2778
|
-
],
|
|
2770
|
+
], mdFormAdvance_2.prototype, "words", 2);
|
|
2779
2771
|
__decorateClass([
|
|
2780
2772
|
(0, import_sequelize_typescript26.Column)({
|
|
2781
2773
|
allowNull: true,
|
|
2782
2774
|
type: import_sequelize_typescript26.DataType.INTEGER
|
|
2783
2775
|
})
|
|
2784
|
-
],
|
|
2776
|
+
], mdFormAdvance_2.prototype, "status", 2);
|
|
2785
2777
|
__decorateClass([
|
|
2786
2778
|
(0, import_sequelize_typescript26.Column)({
|
|
2779
|
+
field: "ip_address",
|
|
2787
2780
|
allowNull: true,
|
|
2788
|
-
type: import_sequelize_typescript26.DataType.
|
|
2781
|
+
type: import_sequelize_typescript26.DataType.STRING(15)
|
|
2789
2782
|
})
|
|
2790
|
-
],
|
|
2783
|
+
], mdFormAdvance_2.prototype, "ipAddress", 2);
|
|
2791
2784
|
__decorateClass([
|
|
2792
2785
|
(0, import_sequelize_typescript26.Column)({
|
|
2793
2786
|
field: "created_by",
|
|
2794
2787
|
allowNull: true,
|
|
2795
2788
|
type: import_sequelize_typescript26.DataType.STRING(60)
|
|
2796
2789
|
})
|
|
2797
|
-
],
|
|
2790
|
+
], mdFormAdvance_2.prototype, "createdBy", 2);
|
|
2798
2791
|
__decorateClass([
|
|
2799
2792
|
(0, import_sequelize_typescript26.Column)({
|
|
2800
2793
|
field: "created_date",
|
|
2801
2794
|
allowNull: true,
|
|
2802
2795
|
type: import_sequelize_typescript26.DataType.DATE
|
|
2803
2796
|
})
|
|
2804
|
-
],
|
|
2797
|
+
], mdFormAdvance_2.prototype, "createdDate", 2);
|
|
2805
2798
|
__decorateClass([
|
|
2806
2799
|
(0, import_sequelize_typescript26.Column)({
|
|
2807
2800
|
field: "updated_by",
|
|
2808
2801
|
allowNull: true,
|
|
2809
2802
|
type: import_sequelize_typescript26.DataType.STRING(60)
|
|
2810
2803
|
})
|
|
2811
|
-
],
|
|
2804
|
+
], mdFormAdvance_2.prototype, "updatedBy", 2);
|
|
2812
2805
|
__decorateClass([
|
|
2813
2806
|
(0, import_sequelize_typescript26.Column)({
|
|
2814
2807
|
field: "updated_date",
|
|
2815
2808
|
allowNull: true,
|
|
2816
2809
|
type: import_sequelize_typescript26.DataType.DATE
|
|
2817
2810
|
})
|
|
2811
|
+
], mdFormAdvance_2.prototype, "updatedDate", 2);
|
|
2812
|
+
mdFormAdvance_2 = __decorateClass([
|
|
2813
|
+
(0, import_sequelize_typescript26.Table)({
|
|
2814
|
+
tableName: "md_form_advance_2",
|
|
2815
|
+
timestamps: false
|
|
2816
|
+
})
|
|
2817
|
+
], mdFormAdvance_2);
|
|
2818
|
+
|
|
2819
|
+
// src/databases/tables/mdLink.ts
|
|
2820
|
+
var import_sequelize_typescript28 = require("sequelize-typescript");
|
|
2821
|
+
|
|
2822
|
+
// src/databases/tables/mdLinkGroup.ts
|
|
2823
|
+
var import_sequelize_typescript27 = require("sequelize-typescript");
|
|
2824
|
+
var mdLinkGroup = class extends import_sequelize_typescript27.Model {
|
|
2825
|
+
};
|
|
2826
|
+
__decorateClass([
|
|
2827
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2828
|
+
primaryKey: true,
|
|
2829
|
+
autoIncrement: true,
|
|
2830
|
+
type: import_sequelize_typescript27.DataType.INTEGER
|
|
2831
|
+
})
|
|
2832
|
+
], mdLinkGroup.prototype, "id", 2);
|
|
2833
|
+
__decorateClass([
|
|
2834
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2835
|
+
allowNull: true,
|
|
2836
|
+
type: import_sequelize_typescript27.DataType.STRING(60)
|
|
2837
|
+
})
|
|
2838
|
+
], mdLinkGroup.prototype, "uuid", 2);
|
|
2839
|
+
__decorateClass([
|
|
2840
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2841
|
+
field: "key_name",
|
|
2842
|
+
allowNull: true,
|
|
2843
|
+
type: import_sequelize_typescript27.DataType.STRING(100)
|
|
2844
|
+
})
|
|
2845
|
+
], mdLinkGroup.prototype, "keyName", 2);
|
|
2846
|
+
__decorateClass([
|
|
2847
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2848
|
+
field: "user_id",
|
|
2849
|
+
allowNull: true,
|
|
2850
|
+
type: import_sequelize_typescript27.DataType.INTEGER
|
|
2851
|
+
})
|
|
2852
|
+
], mdLinkGroup.prototype, "userId", 2);
|
|
2853
|
+
__decorateClass([
|
|
2854
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2855
|
+
type: import_sequelize_typescript27.DataType.STRING(255)
|
|
2856
|
+
})
|
|
2857
|
+
], mdLinkGroup.prototype, "name", 2);
|
|
2858
|
+
__decorateClass([
|
|
2859
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2860
|
+
allowNull: true,
|
|
2861
|
+
type: import_sequelize_typescript27.DataType.STRING(255)
|
|
2862
|
+
})
|
|
2863
|
+
], mdLinkGroup.prototype, "description", 2);
|
|
2864
|
+
__decorateClass([
|
|
2865
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2866
|
+
allowNull: true,
|
|
2867
|
+
type: import_sequelize_typescript27.DataType.INTEGER
|
|
2868
|
+
})
|
|
2869
|
+
], mdLinkGroup.prototype, "sort", 2);
|
|
2870
|
+
__decorateClass([
|
|
2871
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2872
|
+
allowNull: true,
|
|
2873
|
+
type: import_sequelize_typescript27.DataType.INTEGER
|
|
2874
|
+
})
|
|
2875
|
+
], mdLinkGroup.prototype, "status", 2);
|
|
2876
|
+
__decorateClass([
|
|
2877
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2878
|
+
field: "created_by",
|
|
2879
|
+
allowNull: true,
|
|
2880
|
+
type: import_sequelize_typescript27.DataType.STRING(60)
|
|
2881
|
+
})
|
|
2882
|
+
], mdLinkGroup.prototype, "createdBy", 2);
|
|
2883
|
+
__decorateClass([
|
|
2884
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2885
|
+
field: "created_date",
|
|
2886
|
+
allowNull: true,
|
|
2887
|
+
type: import_sequelize_typescript27.DataType.DATE
|
|
2888
|
+
})
|
|
2889
|
+
], mdLinkGroup.prototype, "createdDate", 2);
|
|
2890
|
+
__decorateClass([
|
|
2891
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2892
|
+
field: "updated_by",
|
|
2893
|
+
allowNull: true,
|
|
2894
|
+
type: import_sequelize_typescript27.DataType.STRING(60)
|
|
2895
|
+
})
|
|
2896
|
+
], mdLinkGroup.prototype, "updatedBy", 2);
|
|
2897
|
+
__decorateClass([
|
|
2898
|
+
(0, import_sequelize_typescript27.Column)({
|
|
2899
|
+
field: "updated_date",
|
|
2900
|
+
allowNull: true,
|
|
2901
|
+
type: import_sequelize_typescript27.DataType.DATE
|
|
2902
|
+
})
|
|
2818
2903
|
], mdLinkGroup.prototype, "updatedDate", 2);
|
|
2819
2904
|
__decorateClass([
|
|
2820
|
-
(0,
|
|
2905
|
+
(0, import_sequelize_typescript27.HasMany)(() => mdLink, {
|
|
2821
2906
|
sourceKey: "id"
|
|
2822
2907
|
})
|
|
2823
2908
|
], mdLinkGroup.prototype, "mdLinks", 2);
|
|
2824
2909
|
mdLinkGroup = __decorateClass([
|
|
2825
|
-
(0,
|
|
2910
|
+
(0, import_sequelize_typescript27.Table)({
|
|
2826
2911
|
tableName: "md_link_group",
|
|
2827
2912
|
timestamps: false
|
|
2828
2913
|
})
|
|
2829
2914
|
], mdLinkGroup);
|
|
2830
2915
|
|
|
2831
2916
|
// src/databases/tables/mdLink.ts
|
|
2832
|
-
var mdLink = class extends
|
|
2917
|
+
var mdLink = class extends import_sequelize_typescript28.Model {
|
|
2833
2918
|
};
|
|
2834
2919
|
__decorateClass([
|
|
2835
|
-
(0,
|
|
2920
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2836
2921
|
primaryKey: true,
|
|
2837
2922
|
autoIncrement: true,
|
|
2838
|
-
type:
|
|
2923
|
+
type: import_sequelize_typescript28.DataType.INTEGER
|
|
2839
2924
|
})
|
|
2840
2925
|
], mdLink.prototype, "id", 2);
|
|
2841
2926
|
__decorateClass([
|
|
2842
|
-
(0,
|
|
2843
|
-
type:
|
|
2927
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2928
|
+
type: import_sequelize_typescript28.DataType.STRING(60)
|
|
2844
2929
|
})
|
|
2845
2930
|
], mdLink.prototype, "uuid", 2);
|
|
2846
2931
|
__decorateClass([
|
|
2847
|
-
(0,
|
|
2932
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2848
2933
|
field: "key_name",
|
|
2849
2934
|
allowNull: true,
|
|
2850
|
-
type:
|
|
2935
|
+
type: import_sequelize_typescript28.DataType.STRING(100)
|
|
2851
2936
|
})
|
|
2852
2937
|
], mdLink.prototype, "keyName", 2);
|
|
2853
2938
|
__decorateClass([
|
|
2854
|
-
(0,
|
|
2855
|
-
(0,
|
|
2939
|
+
(0, import_sequelize_typescript28.ForeignKey)(() => mdLinkGroup),
|
|
2940
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2856
2941
|
field: "group_id",
|
|
2857
2942
|
allowNull: true,
|
|
2858
|
-
type:
|
|
2943
|
+
type: import_sequelize_typescript28.DataType.INTEGER
|
|
2859
2944
|
})
|
|
2860
2945
|
], mdLink.prototype, "groupId", 2);
|
|
2861
2946
|
__decorateClass([
|
|
2862
|
-
(0,
|
|
2947
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2863
2948
|
field: "user_id",
|
|
2864
2949
|
allowNull: true,
|
|
2865
|
-
type:
|
|
2950
|
+
type: import_sequelize_typescript28.DataType.INTEGER
|
|
2866
2951
|
})
|
|
2867
2952
|
], mdLink.prototype, "userId", 2);
|
|
2868
2953
|
__decorateClass([
|
|
2869
|
-
(0,
|
|
2954
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2870
2955
|
allowNull: true,
|
|
2871
|
-
type:
|
|
2956
|
+
type: import_sequelize_typescript28.DataType.STRING(255)
|
|
2872
2957
|
})
|
|
2873
2958
|
], mdLink.prototype, "title", 2);
|
|
2874
2959
|
__decorateClass([
|
|
2875
|
-
(0,
|
|
2960
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2876
2961
|
allowNull: true,
|
|
2877
|
-
type:
|
|
2962
|
+
type: import_sequelize_typescript28.DataType.STRING(255)
|
|
2878
2963
|
})
|
|
2879
2964
|
], mdLink.prototype, "url", 2);
|
|
2880
2965
|
__decorateClass([
|
|
2881
|
-
(0,
|
|
2966
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2882
2967
|
allowNull: true,
|
|
2883
|
-
type:
|
|
2968
|
+
type: import_sequelize_typescript28.DataType.STRING(10)
|
|
2884
2969
|
})
|
|
2885
2970
|
], mdLink.prototype, "target", 2);
|
|
2886
2971
|
__decorateClass([
|
|
2887
|
-
(0,
|
|
2972
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2888
2973
|
allowNull: true,
|
|
2889
|
-
type:
|
|
2974
|
+
type: import_sequelize_typescript28.DataType.INTEGER
|
|
2890
2975
|
})
|
|
2891
2976
|
], mdLink.prototype, "sort", 2);
|
|
2892
2977
|
__decorateClass([
|
|
2893
|
-
(0,
|
|
2978
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2894
2979
|
allowNull: true,
|
|
2895
|
-
type:
|
|
2980
|
+
type: import_sequelize_typescript28.DataType.INTEGER,
|
|
2896
2981
|
defaultValue: "1"
|
|
2897
2982
|
})
|
|
2898
2983
|
], mdLink.prototype, "status", 2);
|
|
2899
2984
|
__decorateClass([
|
|
2900
|
-
(0,
|
|
2985
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2901
2986
|
field: "has_expire",
|
|
2902
2987
|
allowNull: true,
|
|
2903
|
-
type:
|
|
2988
|
+
type: import_sequelize_typescript28.DataType.INTEGER
|
|
2904
2989
|
})
|
|
2905
2990
|
], mdLink.prototype, "hasExpire", 2);
|
|
2906
2991
|
__decorateClass([
|
|
2907
|
-
(0,
|
|
2992
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2908
2993
|
field: "start_date",
|
|
2909
2994
|
allowNull: true,
|
|
2910
|
-
type:
|
|
2995
|
+
type: import_sequelize_typescript28.DataType.DATE
|
|
2911
2996
|
})
|
|
2912
2997
|
], mdLink.prototype, "startDate", 2);
|
|
2913
2998
|
__decorateClass([
|
|
2914
|
-
(0,
|
|
2999
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2915
3000
|
field: "expire_date",
|
|
2916
3001
|
allowNull: true,
|
|
2917
|
-
type:
|
|
3002
|
+
type: import_sequelize_typescript28.DataType.DATE
|
|
2918
3003
|
})
|
|
2919
3004
|
], mdLink.prototype, "expireDate", 2);
|
|
2920
3005
|
__decorateClass([
|
|
2921
|
-
(0,
|
|
3006
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2922
3007
|
field: "created_by",
|
|
2923
3008
|
allowNull: true,
|
|
2924
|
-
type:
|
|
3009
|
+
type: import_sequelize_typescript28.DataType.STRING(60)
|
|
2925
3010
|
})
|
|
2926
3011
|
], mdLink.prototype, "createdBy", 2);
|
|
2927
3012
|
__decorateClass([
|
|
2928
|
-
(0,
|
|
3013
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2929
3014
|
field: "created_date",
|
|
2930
3015
|
allowNull: true,
|
|
2931
|
-
type:
|
|
3016
|
+
type: import_sequelize_typescript28.DataType.DATE
|
|
2932
3017
|
})
|
|
2933
3018
|
], mdLink.prototype, "createdDate", 2);
|
|
2934
3019
|
__decorateClass([
|
|
2935
|
-
(0,
|
|
3020
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2936
3021
|
field: "updated_by",
|
|
2937
3022
|
allowNull: true,
|
|
2938
|
-
type:
|
|
3023
|
+
type: import_sequelize_typescript28.DataType.STRING(60)
|
|
2939
3024
|
})
|
|
2940
3025
|
], mdLink.prototype, "updatedBy", 2);
|
|
2941
3026
|
__decorateClass([
|
|
2942
|
-
(0,
|
|
3027
|
+
(0, import_sequelize_typescript28.Column)({
|
|
2943
3028
|
field: "updated_date",
|
|
2944
3029
|
allowNull: true,
|
|
2945
|
-
type:
|
|
3030
|
+
type: import_sequelize_typescript28.DataType.DATE
|
|
2946
3031
|
})
|
|
2947
3032
|
], mdLink.prototype, "updatedDate", 2);
|
|
2948
3033
|
__decorateClass([
|
|
2949
|
-
(0,
|
|
3034
|
+
(0, import_sequelize_typescript28.BelongsTo)(() => mdLinkGroup)
|
|
2950
3035
|
], mdLink.prototype, "mdLinkGroup", 2);
|
|
2951
3036
|
mdLink = __decorateClass([
|
|
2952
|
-
(0,
|
|
3037
|
+
(0, import_sequelize_typescript28.Table)({
|
|
2953
3038
|
tableName: "md_link",
|
|
2954
3039
|
timestamps: false
|
|
2955
3040
|
})
|
|
2956
3041
|
], mdLink);
|
|
2957
3042
|
|
|
2958
3043
|
// src/databases/tables/mdNews.ts
|
|
2959
|
-
var
|
|
3044
|
+
var import_sequelize_typescript30 = require("sequelize-typescript");
|
|
2960
3045
|
|
|
2961
3046
|
// src/databases/tables/mdNewsGroup.ts
|
|
2962
|
-
var
|
|
2963
|
-
var mdNewsGroup = class extends
|
|
3047
|
+
var import_sequelize_typescript29 = require("sequelize-typescript");
|
|
3048
|
+
var mdNewsGroup = class extends import_sequelize_typescript29.Model {
|
|
2964
3049
|
};
|
|
2965
3050
|
__decorateClass([
|
|
2966
|
-
(0,
|
|
3051
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2967
3052
|
primaryKey: true,
|
|
2968
3053
|
autoIncrement: true,
|
|
2969
|
-
type:
|
|
3054
|
+
type: import_sequelize_typescript29.DataType.INTEGER
|
|
2970
3055
|
})
|
|
2971
3056
|
], mdNewsGroup.prototype, "id", 2);
|
|
2972
3057
|
__decorateClass([
|
|
2973
|
-
(0,
|
|
3058
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2974
3059
|
allowNull: true,
|
|
2975
|
-
type:
|
|
3060
|
+
type: import_sequelize_typescript29.DataType.STRING(60)
|
|
2976
3061
|
})
|
|
2977
3062
|
], mdNewsGroup.prototype, "uuid", 2);
|
|
2978
3063
|
__decorateClass([
|
|
2979
|
-
(0,
|
|
3064
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2980
3065
|
field: "key_name",
|
|
2981
3066
|
allowNull: true,
|
|
2982
|
-
type:
|
|
3067
|
+
type: import_sequelize_typescript29.DataType.STRING(100)
|
|
2983
3068
|
})
|
|
2984
3069
|
], mdNewsGroup.prototype, "keyName", 2);
|
|
2985
3070
|
__decorateClass([
|
|
2986
|
-
(0,
|
|
3071
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2987
3072
|
field: "user_id",
|
|
2988
3073
|
allowNull: true,
|
|
2989
|
-
type:
|
|
3074
|
+
type: import_sequelize_typescript29.DataType.INTEGER
|
|
2990
3075
|
})
|
|
2991
3076
|
], mdNewsGroup.prototype, "userId", 2);
|
|
2992
3077
|
__decorateClass([
|
|
2993
|
-
(0,
|
|
2994
|
-
type:
|
|
3078
|
+
(0, import_sequelize_typescript29.Column)({
|
|
3079
|
+
type: import_sequelize_typescript29.DataType.STRING(255)
|
|
2995
3080
|
})
|
|
2996
3081
|
], mdNewsGroup.prototype, "name", 2);
|
|
2997
3082
|
__decorateClass([
|
|
2998
|
-
(0,
|
|
3083
|
+
(0, import_sequelize_typescript29.Column)({
|
|
2999
3084
|
allowNull: true,
|
|
3000
|
-
type:
|
|
3085
|
+
type: import_sequelize_typescript29.DataType.STRING(255)
|
|
3001
3086
|
})
|
|
3002
3087
|
], mdNewsGroup.prototype, "description", 2);
|
|
3003
3088
|
__decorateClass([
|
|
3004
|
-
(0,
|
|
3089
|
+
(0, import_sequelize_typescript29.Column)({
|
|
3005
3090
|
allowNull: true,
|
|
3006
|
-
type:
|
|
3091
|
+
type: import_sequelize_typescript29.DataType.INTEGER
|
|
3007
3092
|
})
|
|
3008
3093
|
], mdNewsGroup.prototype, "status", 2);
|
|
3009
3094
|
__decorateClass([
|
|
3010
|
-
(0,
|
|
3095
|
+
(0, import_sequelize_typescript29.Column)({
|
|
3011
3096
|
field: "created_by",
|
|
3012
3097
|
allowNull: true,
|
|
3013
|
-
type:
|
|
3098
|
+
type: import_sequelize_typescript29.DataType.STRING(60)
|
|
3014
3099
|
})
|
|
3015
3100
|
], mdNewsGroup.prototype, "createdBy", 2);
|
|
3016
3101
|
__decorateClass([
|
|
3017
|
-
(0,
|
|
3102
|
+
(0, import_sequelize_typescript29.Column)({
|
|
3018
3103
|
field: "created_date",
|
|
3019
3104
|
allowNull: true,
|
|
3020
|
-
type:
|
|
3105
|
+
type: import_sequelize_typescript29.DataType.DATE
|
|
3021
3106
|
})
|
|
3022
3107
|
], mdNewsGroup.prototype, "createdDate", 2);
|
|
3023
3108
|
__decorateClass([
|
|
3024
|
-
(0,
|
|
3109
|
+
(0, import_sequelize_typescript29.Column)({
|
|
3025
3110
|
field: "updated_by",
|
|
3026
3111
|
allowNull: true,
|
|
3027
|
-
type:
|
|
3112
|
+
type: import_sequelize_typescript29.DataType.STRING(60)
|
|
3028
3113
|
})
|
|
3029
3114
|
], mdNewsGroup.prototype, "updatedBy", 2);
|
|
3030
3115
|
__decorateClass([
|
|
3031
|
-
(0,
|
|
3116
|
+
(0, import_sequelize_typescript29.Column)({
|
|
3032
3117
|
field: "updated_date",
|
|
3033
3118
|
allowNull: true,
|
|
3034
|
-
type:
|
|
3119
|
+
type: import_sequelize_typescript29.DataType.DATE
|
|
3035
3120
|
})
|
|
3036
3121
|
], mdNewsGroup.prototype, "updatedDate", 2);
|
|
3037
3122
|
__decorateClass([
|
|
3038
|
-
(0,
|
|
3123
|
+
(0, import_sequelize_typescript29.HasMany)(() => mdNews, {
|
|
3039
3124
|
sourceKey: "id"
|
|
3040
3125
|
})
|
|
3041
3126
|
], mdNewsGroup.prototype, "mdNews", 2);
|
|
3042
3127
|
mdNewsGroup = __decorateClass([
|
|
3043
|
-
(0,
|
|
3128
|
+
(0, import_sequelize_typescript29.Table)({
|
|
3044
3129
|
tableName: "md_news_group",
|
|
3045
3130
|
timestamps: false
|
|
3046
3131
|
})
|
|
3047
3132
|
], mdNewsGroup);
|
|
3048
3133
|
|
|
3049
3134
|
// src/databases/tables/mdNews.ts
|
|
3050
|
-
var mdNews = class extends
|
|
3135
|
+
var mdNews = class extends import_sequelize_typescript30.Model {
|
|
3051
3136
|
};
|
|
3052
3137
|
__decorateClass([
|
|
3053
|
-
(0,
|
|
3138
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3054
3139
|
primaryKey: true,
|
|
3055
3140
|
autoIncrement: true,
|
|
3056
|
-
type:
|
|
3141
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3057
3142
|
})
|
|
3058
3143
|
], mdNews.prototype, "id", 2);
|
|
3059
3144
|
__decorateClass([
|
|
3060
|
-
(0,
|
|
3061
|
-
type:
|
|
3145
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3146
|
+
type: import_sequelize_typescript30.DataType.STRING(60)
|
|
3062
3147
|
})
|
|
3063
3148
|
], mdNews.prototype, "uuid", 2);
|
|
3064
3149
|
__decorateClass([
|
|
3065
|
-
(0,
|
|
3150
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3066
3151
|
field: "key_name",
|
|
3067
3152
|
allowNull: true,
|
|
3068
|
-
type:
|
|
3153
|
+
type: import_sequelize_typescript30.DataType.STRING(100)
|
|
3069
3154
|
})
|
|
3070
3155
|
], mdNews.prototype, "keyName", 2);
|
|
3071
3156
|
__decorateClass([
|
|
3072
|
-
(0,
|
|
3073
|
-
(0,
|
|
3157
|
+
(0, import_sequelize_typescript30.ForeignKey)(() => mdNewsGroup),
|
|
3158
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3074
3159
|
field: "group_id",
|
|
3075
3160
|
allowNull: true,
|
|
3076
|
-
type:
|
|
3161
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3077
3162
|
})
|
|
3078
3163
|
], mdNews.prototype, "groupId", 2);
|
|
3079
3164
|
__decorateClass([
|
|
3080
|
-
(0,
|
|
3165
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3081
3166
|
field: "user_id",
|
|
3082
|
-
type:
|
|
3167
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3083
3168
|
})
|
|
3084
3169
|
], mdNews.prototype, "userId", 2);
|
|
3085
3170
|
__decorateClass([
|
|
3086
|
-
(0,
|
|
3171
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3087
3172
|
allowNull: true,
|
|
3088
|
-
type:
|
|
3173
|
+
type: import_sequelize_typescript30.DataType.STRING(500)
|
|
3089
3174
|
})
|
|
3090
3175
|
], mdNews.prototype, "title", 2);
|
|
3091
3176
|
__decorateClass([
|
|
3092
|
-
(0,
|
|
3177
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3093
3178
|
allowNull: true,
|
|
3094
|
-
type:
|
|
3179
|
+
type: import_sequelize_typescript30.DataType.STRING
|
|
3095
3180
|
})
|
|
3096
3181
|
], mdNews.prototype, "description", 2);
|
|
3097
3182
|
__decorateClass([
|
|
3098
|
-
(0,
|
|
3183
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3099
3184
|
allowNull: true,
|
|
3100
|
-
type:
|
|
3185
|
+
type: import_sequelize_typescript30.DataType.STRING
|
|
3101
3186
|
})
|
|
3102
3187
|
], mdNews.prototype, "detail", 2);
|
|
3103
3188
|
__decorateClass([
|
|
3104
|
-
(0,
|
|
3189
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3105
3190
|
field: "meta_title",
|
|
3106
3191
|
allowNull: true,
|
|
3107
|
-
type:
|
|
3192
|
+
type: import_sequelize_typescript30.DataType.STRING(500)
|
|
3108
3193
|
})
|
|
3109
3194
|
], mdNews.prototype, "metaTitle", 2);
|
|
3110
3195
|
__decorateClass([
|
|
3111
|
-
(0,
|
|
3196
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3112
3197
|
field: "meta_keyword",
|
|
3113
3198
|
allowNull: true,
|
|
3114
|
-
type:
|
|
3199
|
+
type: import_sequelize_typescript30.DataType.STRING(500)
|
|
3115
3200
|
})
|
|
3116
3201
|
], mdNews.prototype, "metaKeyword", 2);
|
|
3117
3202
|
__decorateClass([
|
|
3118
|
-
(0,
|
|
3203
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3119
3204
|
field: "meta_description",
|
|
3120
3205
|
allowNull: true,
|
|
3121
|
-
type:
|
|
3206
|
+
type: import_sequelize_typescript30.DataType.STRING(500)
|
|
3122
3207
|
})
|
|
3123
3208
|
], mdNews.prototype, "metaDescription", 2);
|
|
3124
3209
|
__decorateClass([
|
|
3125
|
-
(0,
|
|
3210
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3126
3211
|
field: "image_cover",
|
|
3127
3212
|
allowNull: true,
|
|
3128
|
-
type:
|
|
3213
|
+
type: import_sequelize_typescript30.DataType.STRING(60)
|
|
3129
3214
|
})
|
|
3130
3215
|
], mdNews.prototype, "imageCover", 2);
|
|
3131
3216
|
__decorateClass([
|
|
3132
|
-
(0,
|
|
3217
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3133
3218
|
allowNull: true,
|
|
3134
|
-
type:
|
|
3219
|
+
type: import_sequelize_typescript30.DataType.STRING(60)
|
|
3135
3220
|
})
|
|
3136
3221
|
], mdNews.prototype, "video", 2);
|
|
3137
3222
|
__decorateClass([
|
|
3138
|
-
(0,
|
|
3223
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3139
3224
|
field: "image_gallery",
|
|
3140
3225
|
allowNull: true,
|
|
3141
|
-
type:
|
|
3226
|
+
type: import_sequelize_typescript30.DataType.JSON
|
|
3142
3227
|
})
|
|
3143
3228
|
], mdNews.prototype, "imageGallery", 2);
|
|
3144
3229
|
__decorateClass([
|
|
3145
|
-
(0,
|
|
3230
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3146
3231
|
allowNull: true,
|
|
3147
|
-
type:
|
|
3232
|
+
type: import_sequelize_typescript30.DataType.JSON
|
|
3148
3233
|
})
|
|
3149
3234
|
], mdNews.prototype, "attachments", 2);
|
|
3150
3235
|
__decorateClass([
|
|
3151
|
-
(0,
|
|
3236
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3152
3237
|
allowNull: true,
|
|
3153
|
-
type:
|
|
3238
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3154
3239
|
})
|
|
3155
3240
|
], mdNews.prototype, "highlight", 2);
|
|
3156
3241
|
__decorateClass([
|
|
3157
|
-
(0,
|
|
3242
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3158
3243
|
allowNull: true,
|
|
3159
|
-
type:
|
|
3244
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3160
3245
|
})
|
|
3161
3246
|
], mdNews.prototype, "sort", 2);
|
|
3162
3247
|
__decorateClass([
|
|
3163
|
-
(0,
|
|
3248
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3164
3249
|
allowNull: true,
|
|
3165
|
-
type:
|
|
3250
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3166
3251
|
})
|
|
3167
3252
|
], mdNews.prototype, "status", 2);
|
|
3168
3253
|
__decorateClass([
|
|
3169
|
-
(0,
|
|
3254
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3170
3255
|
allowNull: true,
|
|
3171
|
-
type:
|
|
3256
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3172
3257
|
})
|
|
3173
3258
|
], mdNews.prototype, "publish", 2);
|
|
3174
3259
|
__decorateClass([
|
|
3175
|
-
(0,
|
|
3260
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3176
3261
|
field: "has_expire",
|
|
3177
|
-
type:
|
|
3262
|
+
type: import_sequelize_typescript30.DataType.INTEGER
|
|
3178
3263
|
})
|
|
3179
3264
|
], mdNews.prototype, "hasExpire", 2);
|
|
3180
3265
|
__decorateClass([
|
|
3181
|
-
(0,
|
|
3266
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3182
3267
|
field: "start_date",
|
|
3183
3268
|
allowNull: true,
|
|
3184
|
-
type:
|
|
3269
|
+
type: import_sequelize_typescript30.DataType.DATE
|
|
3185
3270
|
})
|
|
3186
3271
|
], mdNews.prototype, "startDate", 2);
|
|
3187
3272
|
__decorateClass([
|
|
3188
|
-
(0,
|
|
3273
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3189
3274
|
field: "expire_date",
|
|
3190
3275
|
allowNull: true,
|
|
3191
|
-
type:
|
|
3276
|
+
type: import_sequelize_typescript30.DataType.DATE
|
|
3192
3277
|
})
|
|
3193
3278
|
], mdNews.prototype, "expireDate", 2);
|
|
3194
3279
|
__decorateClass([
|
|
3195
|
-
(0,
|
|
3280
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3196
3281
|
field: "created_by",
|
|
3197
3282
|
allowNull: true,
|
|
3198
|
-
type:
|
|
3283
|
+
type: import_sequelize_typescript30.DataType.STRING(60)
|
|
3199
3284
|
})
|
|
3200
3285
|
], mdNews.prototype, "createdBy", 2);
|
|
3201
3286
|
__decorateClass([
|
|
3202
|
-
(0,
|
|
3287
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3203
3288
|
field: "created_date",
|
|
3204
3289
|
allowNull: true,
|
|
3205
|
-
type:
|
|
3290
|
+
type: import_sequelize_typescript30.DataType.DATE
|
|
3206
3291
|
})
|
|
3207
3292
|
], mdNews.prototype, "createdDate", 2);
|
|
3208
3293
|
__decorateClass([
|
|
3209
|
-
(0,
|
|
3294
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3210
3295
|
field: "updated_by",
|
|
3211
3296
|
allowNull: true,
|
|
3212
|
-
type:
|
|
3297
|
+
type: import_sequelize_typescript30.DataType.STRING(60)
|
|
3213
3298
|
})
|
|
3214
3299
|
], mdNews.prototype, "updatedBy", 2);
|
|
3215
3300
|
__decorateClass([
|
|
3216
|
-
(0,
|
|
3301
|
+
(0, import_sequelize_typescript30.Column)({
|
|
3217
3302
|
field: "updated_date",
|
|
3218
3303
|
allowNull: true,
|
|
3219
|
-
type:
|
|
3304
|
+
type: import_sequelize_typescript30.DataType.DATE
|
|
3220
3305
|
})
|
|
3221
3306
|
], mdNews.prototype, "updatedDate", 2);
|
|
3222
3307
|
__decorateClass([
|
|
3223
|
-
(0,
|
|
3308
|
+
(0, import_sequelize_typescript30.BelongsTo)(() => mdNewsGroup)
|
|
3224
3309
|
], mdNews.prototype, "mdNewsGroup", 2);
|
|
3225
3310
|
mdNews = __decorateClass([
|
|
3226
|
-
(0,
|
|
3311
|
+
(0, import_sequelize_typescript30.Table)({
|
|
3227
3312
|
tableName: "md_news",
|
|
3228
3313
|
timestamps: false
|
|
3229
3314
|
})
|
|
3230
3315
|
], mdNews);
|
|
3231
3316
|
|
|
3232
3317
|
// src/databases/tables/mdPopup.ts
|
|
3233
|
-
var
|
|
3234
|
-
var mdPopup = class extends
|
|
3318
|
+
var import_sequelize_typescript31 = require("sequelize-typescript");
|
|
3319
|
+
var mdPopup = class extends import_sequelize_typescript31.Model {
|
|
3235
3320
|
};
|
|
3236
3321
|
__decorateClass([
|
|
3237
|
-
(0,
|
|
3322
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3238
3323
|
primaryKey: true,
|
|
3239
3324
|
autoIncrement: true,
|
|
3240
|
-
type:
|
|
3325
|
+
type: import_sequelize_typescript31.DataType.INTEGER
|
|
3241
3326
|
})
|
|
3242
3327
|
], mdPopup.prototype, "id", 2);
|
|
3243
3328
|
__decorateClass([
|
|
3244
|
-
(0,
|
|
3245
|
-
type:
|
|
3329
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3330
|
+
type: import_sequelize_typescript31.DataType.STRING(60)
|
|
3246
3331
|
})
|
|
3247
3332
|
], mdPopup.prototype, "uuid", 2);
|
|
3248
3333
|
__decorateClass([
|
|
3249
|
-
(0,
|
|
3334
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3250
3335
|
field: "key_name",
|
|
3251
3336
|
allowNull: true,
|
|
3252
|
-
type:
|
|
3337
|
+
type: import_sequelize_typescript31.DataType.STRING(100)
|
|
3253
3338
|
})
|
|
3254
3339
|
], mdPopup.prototype, "keyName", 2);
|
|
3255
3340
|
__decorateClass([
|
|
3256
|
-
(0,
|
|
3341
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3257
3342
|
field: "user_id",
|
|
3258
|
-
type:
|
|
3343
|
+
type: import_sequelize_typescript31.DataType.INTEGER
|
|
3259
3344
|
})
|
|
3260
3345
|
], mdPopup.prototype, "userId", 2);
|
|
3261
3346
|
__decorateClass([
|
|
3262
|
-
(0,
|
|
3347
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3263
3348
|
allowNull: true,
|
|
3264
|
-
type:
|
|
3349
|
+
type: import_sequelize_typescript31.DataType.STRING(255)
|
|
3265
3350
|
})
|
|
3266
3351
|
], mdPopup.prototype, "title", 2);
|
|
3267
3352
|
__decorateClass([
|
|
3268
|
-
(0,
|
|
3353
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3269
3354
|
allowNull: true,
|
|
3270
|
-
type:
|
|
3355
|
+
type: import_sequelize_typescript31.DataType.STRING
|
|
3271
3356
|
})
|
|
3272
3357
|
], mdPopup.prototype, "description", 2);
|
|
3273
3358
|
__decorateClass([
|
|
3274
|
-
(0,
|
|
3359
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3275
3360
|
allowNull: true,
|
|
3276
|
-
type:
|
|
3361
|
+
type: import_sequelize_typescript31.DataType.STRING
|
|
3277
3362
|
})
|
|
3278
3363
|
], mdPopup.prototype, "detail", 2);
|
|
3279
3364
|
__decorateClass([
|
|
3280
|
-
(0,
|
|
3365
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3281
3366
|
field: "image_cover",
|
|
3282
3367
|
allowNull: true,
|
|
3283
|
-
type:
|
|
3368
|
+
type: import_sequelize_typescript31.DataType.STRING(60)
|
|
3284
3369
|
})
|
|
3285
3370
|
], mdPopup.prototype, "imageCover", 2);
|
|
3286
3371
|
__decorateClass([
|
|
3287
|
-
(0,
|
|
3372
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3288
3373
|
allowNull: true,
|
|
3289
|
-
type:
|
|
3374
|
+
type: import_sequelize_typescript31.DataType.STRING(255)
|
|
3290
3375
|
})
|
|
3291
3376
|
], mdPopup.prototype, "url", 2);
|
|
3292
3377
|
__decorateClass([
|
|
3293
|
-
(0,
|
|
3378
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3294
3379
|
allowNull: true,
|
|
3295
|
-
type:
|
|
3380
|
+
type: import_sequelize_typescript31.DataType.INTEGER
|
|
3296
3381
|
})
|
|
3297
3382
|
], mdPopup.prototype, "sort", 2);
|
|
3298
3383
|
__decorateClass([
|
|
3299
|
-
(0,
|
|
3384
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3300
3385
|
allowNull: true,
|
|
3301
|
-
type:
|
|
3386
|
+
type: import_sequelize_typescript31.DataType.INTEGER
|
|
3302
3387
|
})
|
|
3303
3388
|
], mdPopup.prototype, "status", 2);
|
|
3304
3389
|
__decorateClass([
|
|
3305
|
-
(0,
|
|
3390
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3306
3391
|
field: "has_expire",
|
|
3307
|
-
type:
|
|
3392
|
+
type: import_sequelize_typescript31.DataType.INTEGER
|
|
3308
3393
|
})
|
|
3309
3394
|
], mdPopup.prototype, "hasExpire", 2);
|
|
3310
3395
|
__decorateClass([
|
|
3311
|
-
(0,
|
|
3396
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3312
3397
|
field: "start_date",
|
|
3313
3398
|
allowNull: true,
|
|
3314
|
-
type:
|
|
3399
|
+
type: import_sequelize_typescript31.DataType.DATE
|
|
3315
3400
|
})
|
|
3316
3401
|
], mdPopup.prototype, "startDate", 2);
|
|
3317
3402
|
__decorateClass([
|
|
3318
|
-
(0,
|
|
3403
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3319
3404
|
field: "expire_date",
|
|
3320
3405
|
allowNull: true,
|
|
3321
|
-
type:
|
|
3406
|
+
type: import_sequelize_typescript31.DataType.DATE
|
|
3322
3407
|
})
|
|
3323
3408
|
], mdPopup.prototype, "expireDate", 2);
|
|
3324
3409
|
__decorateClass([
|
|
3325
|
-
(0,
|
|
3410
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3326
3411
|
field: "created_by",
|
|
3327
3412
|
allowNull: true,
|
|
3328
|
-
type:
|
|
3413
|
+
type: import_sequelize_typescript31.DataType.STRING(60)
|
|
3329
3414
|
})
|
|
3330
3415
|
], mdPopup.prototype, "createdBy", 2);
|
|
3331
3416
|
__decorateClass([
|
|
3332
|
-
(0,
|
|
3417
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3333
3418
|
field: "created_date",
|
|
3334
3419
|
allowNull: true,
|
|
3335
|
-
type:
|
|
3420
|
+
type: import_sequelize_typescript31.DataType.DATE
|
|
3336
3421
|
})
|
|
3337
3422
|
], mdPopup.prototype, "createdDate", 2);
|
|
3338
3423
|
__decorateClass([
|
|
3339
|
-
(0,
|
|
3424
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3340
3425
|
field: "updated_by",
|
|
3341
3426
|
allowNull: true,
|
|
3342
|
-
type:
|
|
3427
|
+
type: import_sequelize_typescript31.DataType.STRING(60)
|
|
3343
3428
|
})
|
|
3344
3429
|
], mdPopup.prototype, "updatedBy", 2);
|
|
3345
3430
|
__decorateClass([
|
|
3346
|
-
(0,
|
|
3431
|
+
(0, import_sequelize_typescript31.Column)({
|
|
3347
3432
|
field: "updated_date",
|
|
3348
3433
|
allowNull: true,
|
|
3349
|
-
type:
|
|
3434
|
+
type: import_sequelize_typescript31.DataType.DATE
|
|
3350
3435
|
})
|
|
3351
3436
|
], mdPopup.prototype, "updatedDate", 2);
|
|
3352
3437
|
mdPopup = __decorateClass([
|
|
3353
|
-
(0,
|
|
3438
|
+
(0, import_sequelize_typescript31.Table)({
|
|
3354
3439
|
tableName: "md_popup",
|
|
3355
3440
|
timestamps: false
|
|
3356
3441
|
})
|
|
3357
3442
|
], mdPopup);
|
|
3358
3443
|
|
|
3359
3444
|
// src/databases/tables/mdSetting.ts
|
|
3360
|
-
var
|
|
3361
|
-
var mdSetting = class extends
|
|
3445
|
+
var import_sequelize_typescript32 = require("sequelize-typescript");
|
|
3446
|
+
var mdSetting = class extends import_sequelize_typescript32.Model {
|
|
3362
3447
|
};
|
|
3363
3448
|
__decorateClass([
|
|
3364
|
-
(0,
|
|
3449
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3365
3450
|
primaryKey: true,
|
|
3366
3451
|
autoIncrement: true,
|
|
3367
|
-
type:
|
|
3452
|
+
type: import_sequelize_typescript32.DataType.INTEGER
|
|
3368
3453
|
})
|
|
3369
3454
|
], mdSetting.prototype, "id", 2);
|
|
3370
3455
|
__decorateClass([
|
|
3371
|
-
(0,
|
|
3456
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3372
3457
|
allowNull: true,
|
|
3373
|
-
type:
|
|
3458
|
+
type: import_sequelize_typescript32.DataType.STRING(60)
|
|
3374
3459
|
})
|
|
3375
3460
|
], mdSetting.prototype, "uuid", 2);
|
|
3376
3461
|
__decorateClass([
|
|
3377
|
-
(0,
|
|
3462
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3378
3463
|
field: "key_name",
|
|
3379
3464
|
allowNull: true,
|
|
3380
|
-
type:
|
|
3465
|
+
type: import_sequelize_typescript32.DataType.STRING(100)
|
|
3381
3466
|
})
|
|
3382
3467
|
], mdSetting.prototype, "keyName", 2);
|
|
3383
3468
|
__decorateClass([
|
|
3384
|
-
(0,
|
|
3469
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3385
3470
|
allowNull: true,
|
|
3386
|
-
type:
|
|
3471
|
+
type: import_sequelize_typescript32.DataType.STRING(255)
|
|
3387
3472
|
})
|
|
3388
3473
|
], mdSetting.prototype, "name", 2);
|
|
3389
3474
|
__decorateClass([
|
|
3390
|
-
(0,
|
|
3475
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3391
3476
|
allowNull: true,
|
|
3392
|
-
type:
|
|
3477
|
+
type: import_sequelize_typescript32.DataType.STRING(255)
|
|
3393
3478
|
})
|
|
3394
3479
|
], mdSetting.prototype, "description", 2);
|
|
3395
3480
|
__decorateClass([
|
|
3396
|
-
(0,
|
|
3481
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3397
3482
|
allowNull: true,
|
|
3398
|
-
type:
|
|
3483
|
+
type: import_sequelize_typescript32.DataType.STRING
|
|
3399
3484
|
})
|
|
3400
3485
|
], mdSetting.prototype, "value", 2);
|
|
3401
3486
|
__decorateClass([
|
|
3402
|
-
(0,
|
|
3487
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3403
3488
|
allowNull: true,
|
|
3404
|
-
type:
|
|
3489
|
+
type: import_sequelize_typescript32.DataType.INTEGER
|
|
3405
3490
|
})
|
|
3406
3491
|
], mdSetting.prototype, "status", 2);
|
|
3407
3492
|
__decorateClass([
|
|
3408
|
-
(0,
|
|
3493
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3409
3494
|
field: "created_by",
|
|
3410
3495
|
allowNull: true,
|
|
3411
|
-
type:
|
|
3496
|
+
type: import_sequelize_typescript32.DataType.STRING(60)
|
|
3412
3497
|
})
|
|
3413
3498
|
], mdSetting.prototype, "createdBy", 2);
|
|
3414
3499
|
__decorateClass([
|
|
3415
|
-
(0,
|
|
3500
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3416
3501
|
field: "created_date",
|
|
3417
3502
|
allowNull: true,
|
|
3418
|
-
type:
|
|
3503
|
+
type: import_sequelize_typescript32.DataType.DATE
|
|
3419
3504
|
})
|
|
3420
3505
|
], mdSetting.prototype, "createdDate", 2);
|
|
3421
3506
|
__decorateClass([
|
|
3422
|
-
(0,
|
|
3507
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3423
3508
|
field: "updated_by",
|
|
3424
3509
|
allowNull: true,
|
|
3425
|
-
type:
|
|
3510
|
+
type: import_sequelize_typescript32.DataType.STRING(60)
|
|
3426
3511
|
})
|
|
3427
3512
|
], mdSetting.prototype, "updatedBy", 2);
|
|
3428
3513
|
__decorateClass([
|
|
3429
|
-
(0,
|
|
3514
|
+
(0, import_sequelize_typescript32.Column)({
|
|
3430
3515
|
field: "updated_date",
|
|
3431
3516
|
allowNull: true,
|
|
3432
|
-
type:
|
|
3517
|
+
type: import_sequelize_typescript32.DataType.DATE
|
|
3433
3518
|
})
|
|
3434
3519
|
], mdSetting.prototype, "updatedDate", 2);
|
|
3435
3520
|
mdSetting = __decorateClass([
|
|
3436
|
-
(0,
|
|
3521
|
+
(0, import_sequelize_typescript32.Table)({
|
|
3437
3522
|
tableName: "md_setting",
|
|
3438
3523
|
timestamps: false
|
|
3439
3524
|
})
|
|
3440
3525
|
], mdSetting);
|
|
3441
3526
|
|
|
3527
|
+
// src/databases/tables/mdWords.ts
|
|
3528
|
+
var import_sequelize_typescript33 = require("sequelize-typescript");
|
|
3529
|
+
var mdWords = class extends import_sequelize_typescript33.Model {
|
|
3530
|
+
};
|
|
3531
|
+
__decorateClass([
|
|
3532
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3533
|
+
primaryKey: true,
|
|
3534
|
+
autoIncrement: true,
|
|
3535
|
+
type: import_sequelize_typescript33.DataType.INTEGER
|
|
3536
|
+
})
|
|
3537
|
+
], mdWords.prototype, "id", 2);
|
|
3538
|
+
__decorateClass([
|
|
3539
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3540
|
+
allowNull: true,
|
|
3541
|
+
type: import_sequelize_typescript33.DataType.STRING(60)
|
|
3542
|
+
})
|
|
3543
|
+
], mdWords.prototype, "uuid", 2);
|
|
3544
|
+
__decorateClass([
|
|
3545
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3546
|
+
field: "key_name",
|
|
3547
|
+
allowNull: true,
|
|
3548
|
+
type: import_sequelize_typescript33.DataType.STRING(100)
|
|
3549
|
+
})
|
|
3550
|
+
], mdWords.prototype, "keyName", 2);
|
|
3551
|
+
__decorateClass([
|
|
3552
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3553
|
+
allowNull: true,
|
|
3554
|
+
type: import_sequelize_typescript33.DataType.STRING(255)
|
|
3555
|
+
})
|
|
3556
|
+
], mdWords.prototype, "name", 2);
|
|
3557
|
+
__decorateClass([
|
|
3558
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3559
|
+
allowNull: true,
|
|
3560
|
+
type: import_sequelize_typescript33.DataType.STRING
|
|
3561
|
+
})
|
|
3562
|
+
], mdWords.prototype, "value", 2);
|
|
3563
|
+
__decorateClass([
|
|
3564
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3565
|
+
allowNull: true,
|
|
3566
|
+
type: import_sequelize_typescript33.DataType.INTEGER
|
|
3567
|
+
})
|
|
3568
|
+
], mdWords.prototype, "status", 2);
|
|
3569
|
+
__decorateClass([
|
|
3570
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3571
|
+
allowNull: true,
|
|
3572
|
+
type: import_sequelize_typescript33.DataType.INTEGER
|
|
3573
|
+
})
|
|
3574
|
+
], mdWords.prototype, "total", 2);
|
|
3575
|
+
__decorateClass([
|
|
3576
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3577
|
+
field: "created_by",
|
|
3578
|
+
allowNull: true,
|
|
3579
|
+
type: import_sequelize_typescript33.DataType.STRING(60)
|
|
3580
|
+
})
|
|
3581
|
+
], mdWords.prototype, "createdBy", 2);
|
|
3582
|
+
__decorateClass([
|
|
3583
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3584
|
+
field: "created_date",
|
|
3585
|
+
allowNull: true,
|
|
3586
|
+
type: import_sequelize_typescript33.DataType.DATE
|
|
3587
|
+
})
|
|
3588
|
+
], mdWords.prototype, "createdDate", 2);
|
|
3589
|
+
__decorateClass([
|
|
3590
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3591
|
+
field: "updated_by",
|
|
3592
|
+
allowNull: true,
|
|
3593
|
+
type: import_sequelize_typescript33.DataType.STRING(60)
|
|
3594
|
+
})
|
|
3595
|
+
], mdWords.prototype, "updatedBy", 2);
|
|
3596
|
+
__decorateClass([
|
|
3597
|
+
(0, import_sequelize_typescript33.Column)({
|
|
3598
|
+
field: "updated_date",
|
|
3599
|
+
allowNull: true,
|
|
3600
|
+
type: import_sequelize_typescript33.DataType.DATE
|
|
3601
|
+
})
|
|
3602
|
+
], mdWords.prototype, "updatedDate", 2);
|
|
3603
|
+
mdWords = __decorateClass([
|
|
3604
|
+
(0, import_sequelize_typescript33.Table)({
|
|
3605
|
+
tableName: "md_words",
|
|
3606
|
+
timestamps: false
|
|
3607
|
+
})
|
|
3608
|
+
], mdWords);
|
|
3609
|
+
|
|
3442
3610
|
// src/databases/tables/member.ts
|
|
3443
|
-
var
|
|
3444
|
-
var member = class extends
|
|
3611
|
+
var import_sequelize_typescript34 = require("sequelize-typescript");
|
|
3612
|
+
var member = class extends import_sequelize_typescript34.Model {
|
|
3445
3613
|
};
|
|
3446
3614
|
__decorateClass([
|
|
3447
|
-
(0,
|
|
3615
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3448
3616
|
primaryKey: true,
|
|
3449
3617
|
autoIncrement: true,
|
|
3450
|
-
type:
|
|
3618
|
+
type: import_sequelize_typescript34.DataType.INTEGER
|
|
3451
3619
|
})
|
|
3452
3620
|
], member.prototype, "id", 2);
|
|
3453
3621
|
__decorateClass([
|
|
3454
|
-
(0,
|
|
3622
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3455
3623
|
allowNull: true,
|
|
3456
|
-
type:
|
|
3624
|
+
type: import_sequelize_typescript34.DataType.STRING(60)
|
|
3457
3625
|
})
|
|
3458
3626
|
], member.prototype, "uuid", 2);
|
|
3459
3627
|
__decorateClass([
|
|
3460
|
-
(0,
|
|
3628
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3461
3629
|
allowNull: true,
|
|
3462
|
-
type:
|
|
3630
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3463
3631
|
})
|
|
3464
3632
|
], member.prototype, "username", 2);
|
|
3465
3633
|
__decorateClass([
|
|
3466
|
-
(0,
|
|
3634
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3467
3635
|
field: "password_hash",
|
|
3468
3636
|
allowNull: true,
|
|
3469
|
-
type:
|
|
3637
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3470
3638
|
})
|
|
3471
3639
|
], member.prototype, "passwordHash", 2);
|
|
3472
3640
|
__decorateClass([
|
|
3473
|
-
(0,
|
|
3641
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3474
3642
|
field: "password_reset_token",
|
|
3475
3643
|
allowNull: true,
|
|
3476
|
-
type:
|
|
3644
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3477
3645
|
})
|
|
3478
3646
|
], member.prototype, "passwordResetToken", 2);
|
|
3479
3647
|
__decorateClass([
|
|
3480
|
-
(0,
|
|
3648
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3481
3649
|
field: "verification_token",
|
|
3482
3650
|
allowNull: true,
|
|
3483
|
-
type:
|
|
3651
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3484
3652
|
})
|
|
3485
3653
|
], member.prototype, "verificationToken", 2);
|
|
3486
3654
|
__decorateClass([
|
|
3487
|
-
(0,
|
|
3655
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3488
3656
|
field: "auth_key",
|
|
3489
3657
|
allowNull: true,
|
|
3490
|
-
type:
|
|
3658
|
+
type: import_sequelize_typescript34.DataType.STRING(32)
|
|
3491
3659
|
})
|
|
3492
3660
|
], member.prototype, "authKey", 2);
|
|
3493
3661
|
__decorateClass([
|
|
3494
|
-
(0,
|
|
3662
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3495
3663
|
field: "user_type",
|
|
3496
3664
|
allowNull: true,
|
|
3497
|
-
type:
|
|
3665
|
+
type: import_sequelize_typescript34.DataType.INTEGER
|
|
3498
3666
|
})
|
|
3499
3667
|
], member.prototype, "userType", 2);
|
|
3500
3668
|
__decorateClass([
|
|
3501
|
-
(0,
|
|
3669
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3502
3670
|
allowNull: true,
|
|
3503
|
-
type:
|
|
3671
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3504
3672
|
})
|
|
3505
3673
|
], member.prototype, "email", 2);
|
|
3506
3674
|
__decorateClass([
|
|
3507
|
-
(0,
|
|
3675
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3508
3676
|
allowNull: true,
|
|
3509
|
-
type:
|
|
3677
|
+
type: import_sequelize_typescript34.DataType.STRING(10)
|
|
3510
3678
|
})
|
|
3511
3679
|
], member.prototype, "prefix", 2);
|
|
3512
3680
|
__decorateClass([
|
|
3513
|
-
(0,
|
|
3681
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3514
3682
|
field: "first_name",
|
|
3515
3683
|
allowNull: true,
|
|
3516
|
-
type:
|
|
3684
|
+
type: import_sequelize_typescript34.DataType.STRING(100)
|
|
3517
3685
|
})
|
|
3518
3686
|
], member.prototype, "firstName", 2);
|
|
3519
3687
|
__decorateClass([
|
|
3520
|
-
(0,
|
|
3688
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3521
3689
|
field: "last_name",
|
|
3522
3690
|
allowNull: true,
|
|
3523
|
-
type:
|
|
3691
|
+
type: import_sequelize_typescript34.DataType.STRING(100)
|
|
3524
3692
|
})
|
|
3525
3693
|
], member.prototype, "lastName", 2);
|
|
3526
3694
|
__decorateClass([
|
|
3527
|
-
(0,
|
|
3695
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3528
3696
|
allowNull: true,
|
|
3529
|
-
type:
|
|
3697
|
+
type: import_sequelize_typescript34.DataType.STRING(20)
|
|
3530
3698
|
})
|
|
3531
3699
|
], member.prototype, "phone", 2);
|
|
3532
3700
|
__decorateClass([
|
|
3533
|
-
(0,
|
|
3701
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3534
3702
|
allowNull: true,
|
|
3535
|
-
type:
|
|
3703
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3536
3704
|
})
|
|
3537
3705
|
], member.prototype, "job", 2);
|
|
3538
3706
|
__decorateClass([
|
|
3539
|
-
(0,
|
|
3707
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3540
3708
|
allowNull: true,
|
|
3541
|
-
type:
|
|
3709
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3542
3710
|
})
|
|
3543
3711
|
], member.prototype, "agency", 2);
|
|
3544
3712
|
__decorateClass([
|
|
3545
|
-
(0,
|
|
3713
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3546
3714
|
allowNull: true,
|
|
3547
|
-
type:
|
|
3715
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3548
3716
|
})
|
|
3549
3717
|
], member.prototype, "position", 2);
|
|
3550
3718
|
__decorateClass([
|
|
3551
|
-
(0,
|
|
3719
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3552
3720
|
allowNull: true,
|
|
3553
|
-
type:
|
|
3721
|
+
type: import_sequelize_typescript34.DataType.STRING(1)
|
|
3554
3722
|
})
|
|
3555
3723
|
], member.prototype, "gender", 2);
|
|
3556
3724
|
__decorateClass([
|
|
3557
|
-
(0,
|
|
3725
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3558
3726
|
allowNull: true,
|
|
3559
|
-
type:
|
|
3727
|
+
type: import_sequelize_typescript34.DataType.SMALLINT
|
|
3560
3728
|
})
|
|
3561
3729
|
], member.prototype, "status", 2);
|
|
3562
3730
|
__decorateClass([
|
|
3563
|
-
(0,
|
|
3731
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3564
3732
|
allowNull: true,
|
|
3565
|
-
type:
|
|
3733
|
+
type: import_sequelize_typescript34.DataType.INTEGER
|
|
3566
3734
|
})
|
|
3567
3735
|
], member.prototype, "is_2fa", 2);
|
|
3568
3736
|
__decorateClass([
|
|
3569
|
-
(0,
|
|
3737
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3570
3738
|
field: "line_id",
|
|
3571
3739
|
allowNull: true,
|
|
3572
|
-
type:
|
|
3740
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3573
3741
|
})
|
|
3574
3742
|
], member.prototype, "lineId", 2);
|
|
3575
3743
|
__decorateClass([
|
|
3576
|
-
(0,
|
|
3744
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3577
3745
|
field: "facebook_id",
|
|
3578
3746
|
allowNull: true,
|
|
3579
|
-
type:
|
|
3747
|
+
type: import_sequelize_typescript34.DataType.STRING(255)
|
|
3580
3748
|
})
|
|
3581
3749
|
], member.prototype, "facebookId", 2);
|
|
3582
3750
|
__decorateClass([
|
|
3583
|
-
(0,
|
|
3751
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3584
3752
|
allowNull: true,
|
|
3585
|
-
type:
|
|
3753
|
+
type: import_sequelize_typescript34.DataType.INTEGER
|
|
3586
3754
|
})
|
|
3587
3755
|
], member.prototype, "policy", 2);
|
|
3588
3756
|
__decorateClass([
|
|
3589
|
-
(0,
|
|
3757
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3590
3758
|
allowNull: true,
|
|
3591
|
-
type:
|
|
3759
|
+
type: import_sequelize_typescript34.DataType.INTEGER
|
|
3592
3760
|
})
|
|
3593
3761
|
], member.prototype, "terms", 2);
|
|
3594
3762
|
__decorateClass([
|
|
3595
|
-
(0,
|
|
3763
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3596
3764
|
field: "created_by",
|
|
3597
3765
|
allowNull: true,
|
|
3598
|
-
type:
|
|
3766
|
+
type: import_sequelize_typescript34.DataType.STRING(60)
|
|
3599
3767
|
})
|
|
3600
3768
|
], member.prototype, "createdBy", 2);
|
|
3601
3769
|
__decorateClass([
|
|
3602
|
-
(0,
|
|
3770
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3603
3771
|
field: "created_date",
|
|
3604
3772
|
allowNull: true,
|
|
3605
|
-
type:
|
|
3773
|
+
type: import_sequelize_typescript34.DataType.DATE
|
|
3606
3774
|
})
|
|
3607
3775
|
], member.prototype, "createdDate", 2);
|
|
3608
3776
|
__decorateClass([
|
|
3609
|
-
(0,
|
|
3777
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3610
3778
|
field: "updated_by",
|
|
3611
3779
|
allowNull: true,
|
|
3612
|
-
type:
|
|
3780
|
+
type: import_sequelize_typescript34.DataType.STRING(60)
|
|
3613
3781
|
})
|
|
3614
3782
|
], member.prototype, "updatedBy", 2);
|
|
3615
3783
|
__decorateClass([
|
|
3616
|
-
(0,
|
|
3784
|
+
(0, import_sequelize_typescript34.Column)({
|
|
3617
3785
|
field: "updated_date",
|
|
3618
3786
|
allowNull: true,
|
|
3619
|
-
type:
|
|
3787
|
+
type: import_sequelize_typescript34.DataType.DATE
|
|
3620
3788
|
})
|
|
3621
3789
|
], member.prototype, "updatedDate", 2);
|
|
3622
3790
|
member = __decorateClass([
|
|
3623
|
-
(0,
|
|
3791
|
+
(0, import_sequelize_typescript34.Table)({
|
|
3624
3792
|
tableName: "member",
|
|
3625
3793
|
timestamps: false
|
|
3626
3794
|
})
|
|
3627
3795
|
], member);
|
|
3628
3796
|
|
|
3629
3797
|
// src/databases/tables/oauthAccessToken.ts
|
|
3630
|
-
var
|
|
3631
|
-
var oauthAccessToken = class extends
|
|
3798
|
+
var import_sequelize_typescript35 = require("sequelize-typescript");
|
|
3799
|
+
var oauthAccessToken = class extends import_sequelize_typescript35.Model {
|
|
3632
3800
|
};
|
|
3633
3801
|
__decorateClass([
|
|
3634
|
-
(0,
|
|
3802
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3635
3803
|
primaryKey: true,
|
|
3636
3804
|
autoIncrement: true,
|
|
3637
|
-
type:
|
|
3805
|
+
type: import_sequelize_typescript35.DataType.INTEGER
|
|
3638
3806
|
})
|
|
3639
3807
|
], oauthAccessToken.prototype, "id", 2);
|
|
3640
3808
|
__decorateClass([
|
|
3641
|
-
(0,
|
|
3809
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3642
3810
|
field: "access_token",
|
|
3643
|
-
type:
|
|
3811
|
+
type: import_sequelize_typescript35.DataType.STRING
|
|
3644
3812
|
})
|
|
3645
3813
|
], oauthAccessToken.prototype, "accessToken", 2);
|
|
3646
3814
|
__decorateClass([
|
|
3647
|
-
(0,
|
|
3815
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3648
3816
|
field: "client_id",
|
|
3649
|
-
type:
|
|
3817
|
+
type: import_sequelize_typescript35.DataType.STRING(32)
|
|
3650
3818
|
})
|
|
3651
3819
|
], oauthAccessToken.prototype, "clientId", 2);
|
|
3652
3820
|
__decorateClass([
|
|
3653
|
-
(0,
|
|
3821
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3654
3822
|
field: "user_id",
|
|
3655
3823
|
allowNull: true,
|
|
3656
|
-
type:
|
|
3824
|
+
type: import_sequelize_typescript35.DataType.INTEGER
|
|
3657
3825
|
})
|
|
3658
3826
|
], oauthAccessToken.prototype, "userId", 2);
|
|
3659
3827
|
__decorateClass([
|
|
3660
|
-
(0,
|
|
3661
|
-
type:
|
|
3662
|
-
defaultValue:
|
|
3828
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3829
|
+
type: import_sequelize_typescript35.DataType.DATE,
|
|
3830
|
+
defaultValue: import_sequelize_typescript35.DataType.NOW
|
|
3663
3831
|
})
|
|
3664
3832
|
], oauthAccessToken.prototype, "expires", 2);
|
|
3665
3833
|
__decorateClass([
|
|
3666
|
-
(0,
|
|
3834
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3667
3835
|
allowNull: true,
|
|
3668
|
-
type:
|
|
3836
|
+
type: import_sequelize_typescript35.DataType.STRING(2e3)
|
|
3669
3837
|
})
|
|
3670
3838
|
], oauthAccessToken.prototype, "scope", 2);
|
|
3671
3839
|
__decorateClass([
|
|
3672
|
-
(0,
|
|
3840
|
+
(0, import_sequelize_typescript35.Column)({
|
|
3673
3841
|
field: "created_date",
|
|
3674
|
-
type:
|
|
3675
|
-
defaultValue:
|
|
3842
|
+
type: import_sequelize_typescript35.DataType.DATE,
|
|
3843
|
+
defaultValue: import_sequelize_typescript35.DataType.NOW
|
|
3676
3844
|
})
|
|
3677
3845
|
], oauthAccessToken.prototype, "createdDate", 2);
|
|
3678
3846
|
oauthAccessToken = __decorateClass([
|
|
3679
|
-
(0,
|
|
3847
|
+
(0, import_sequelize_typescript35.Table)({
|
|
3680
3848
|
tableName: "oauth_access_token",
|
|
3681
3849
|
timestamps: false
|
|
3682
3850
|
})
|
|
3683
3851
|
], oauthAccessToken);
|
|
3684
3852
|
|
|
3685
3853
|
// src/databases/tables/oauthRefreshToken.ts
|
|
3686
|
-
var
|
|
3687
|
-
var oauthRefreshToken = class extends
|
|
3854
|
+
var import_sequelize_typescript36 = require("sequelize-typescript");
|
|
3855
|
+
var oauthRefreshToken = class extends import_sequelize_typescript36.Model {
|
|
3688
3856
|
};
|
|
3689
3857
|
__decorateClass([
|
|
3690
|
-
(0,
|
|
3858
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3691
3859
|
primaryKey: true,
|
|
3692
3860
|
autoIncrement: true,
|
|
3693
|
-
type:
|
|
3861
|
+
type: import_sequelize_typescript36.DataType.INTEGER
|
|
3694
3862
|
})
|
|
3695
3863
|
], oauthRefreshToken.prototype, "id", 2);
|
|
3696
3864
|
__decorateClass([
|
|
3697
|
-
(0,
|
|
3865
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3698
3866
|
field: "refresh_token",
|
|
3699
|
-
type:
|
|
3867
|
+
type: import_sequelize_typescript36.DataType.STRING(1e3)
|
|
3700
3868
|
})
|
|
3701
3869
|
], oauthRefreshToken.prototype, "refreshToken", 2);
|
|
3702
3870
|
__decorateClass([
|
|
3703
|
-
(0,
|
|
3871
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3704
3872
|
field: "client_id",
|
|
3705
|
-
type:
|
|
3873
|
+
type: import_sequelize_typescript36.DataType.STRING(32)
|
|
3706
3874
|
})
|
|
3707
3875
|
], oauthRefreshToken.prototype, "clientId", 2);
|
|
3708
3876
|
__decorateClass([
|
|
3709
|
-
(0,
|
|
3877
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3710
3878
|
field: "user_id",
|
|
3711
3879
|
allowNull: true,
|
|
3712
|
-
type:
|
|
3880
|
+
type: import_sequelize_typescript36.DataType.INTEGER
|
|
3713
3881
|
})
|
|
3714
3882
|
], oauthRefreshToken.prototype, "userId", 2);
|
|
3715
3883
|
__decorateClass([
|
|
3716
|
-
(0,
|
|
3717
|
-
type:
|
|
3718
|
-
defaultValue:
|
|
3884
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3885
|
+
type: import_sequelize_typescript36.DataType.DATE,
|
|
3886
|
+
defaultValue: import_sequelize_typescript36.DataType.NOW
|
|
3719
3887
|
})
|
|
3720
3888
|
], oauthRefreshToken.prototype, "expires", 2);
|
|
3721
3889
|
__decorateClass([
|
|
3722
|
-
(0,
|
|
3890
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3723
3891
|
allowNull: true,
|
|
3724
|
-
type:
|
|
3892
|
+
type: import_sequelize_typescript36.DataType.STRING(1e3)
|
|
3725
3893
|
})
|
|
3726
3894
|
], oauthRefreshToken.prototype, "scope", 2);
|
|
3727
3895
|
__decorateClass([
|
|
3728
|
-
(0,
|
|
3896
|
+
(0, import_sequelize_typescript36.Column)({
|
|
3729
3897
|
field: "created_date",
|
|
3730
|
-
type:
|
|
3731
|
-
defaultValue:
|
|
3898
|
+
type: import_sequelize_typescript36.DataType.DATE,
|
|
3899
|
+
defaultValue: import_sequelize_typescript36.DataType.NOW
|
|
3732
3900
|
})
|
|
3733
3901
|
], oauthRefreshToken.prototype, "createdDate", 2);
|
|
3734
3902
|
oauthRefreshToken = __decorateClass([
|
|
3735
|
-
(0,
|
|
3903
|
+
(0, import_sequelize_typescript36.Table)({
|
|
3736
3904
|
tableName: "oauth_refresh_token",
|
|
3737
3905
|
timestamps: false
|
|
3738
3906
|
})
|
|
3739
3907
|
], oauthRefreshToken);
|
|
3740
3908
|
|
|
3741
|
-
// src/databases/tables/setting.ts
|
|
3742
|
-
var import_sequelize_typescript35 = require("sequelize-typescript");
|
|
3743
|
-
var setting = class extends import_sequelize_typescript35.Model {
|
|
3744
|
-
};
|
|
3745
|
-
__decorateClass([
|
|
3746
|
-
(0, import_sequelize_typescript35.Column)({
|
|
3747
|
-
primaryKey: true,
|
|
3748
|
-
autoIncrement: true,
|
|
3749
|
-
type: import_sequelize_typescript35.DataType.INTEGER
|
|
3750
|
-
})
|
|
3751
|
-
], setting.prototype, "id", 2);
|
|
3752
|
-
__decorateClass([
|
|
3753
|
-
(0, import_sequelize_typescript35.Column)({
|
|
3754
|
-
type: import_sequelize_typescript35.DataType.STRING(60)
|
|
3755
|
-
})
|
|
3756
|
-
], setting.prototype, "uuid", 2);
|
|
3757
|
-
__decorateClass([
|
|
3758
|
-
(0, import_sequelize_typescript35.Column)({
|
|
3759
|
-
allowNull: true,
|
|
3760
|
-
type: import_sequelize_typescript35.DataType.STRING(255)
|
|
3761
|
-
})
|
|
3762
|
-
], setting.prototype, "title", 2);
|
|
3763
|
-
__decorateClass([
|
|
3764
|
-
(0, import_sequelize_typescript35.Column)({
|
|
3765
|
-
allowNull: true,
|
|
3766
|
-
type: import_sequelize_typescript35.DataType.STRING(255)
|
|
3767
|
-
})
|
|
3768
|
-
], setting.prototype, "description", 2);
|
|
3769
|
-
__decorateClass([
|
|
3770
|
-
(0, import_sequelize_typescript35.Column)({
|
|
3771
|
-
field: "image_logo_uuid",
|
|
3772
|
-
allowNull: true,
|
|
3773
|
-
type: import_sequelize_typescript35.DataType.STRING(60)
|
|
3774
|
-
})
|
|
3775
|
-
], setting.prototype, "imageLogoUuid", 2);
|
|
3776
|
-
__decorateClass([
|
|
3777
|
-
(0, import_sequelize_typescript35.Column)({
|
|
3778
|
-
field: "image_cover_uuid",
|
|
3779
|
-
allowNull: true,
|
|
3780
|
-
type: import_sequelize_typescript35.DataType.STRING(60)
|
|
3781
|
-
})
|
|
3782
|
-
], setting.prototype, "imageCoverUuid", 2);
|
|
3783
|
-
__decorateClass([
|
|
3784
|
-
(0, import_sequelize_typescript35.Column)({
|
|
3785
|
-
field: "image_background_uuid",
|
|
3786
|
-
allowNull: true,
|
|
3787
|
-
type: import_sequelize_typescript35.DataType.STRING(60)
|
|
3788
|
-
})
|
|
3789
|
-
], setting.prototype, "imageBackgroundUuid", 2);
|
|
3790
|
-
__decorateClass([
|
|
3791
|
-
(0, import_sequelize_typescript35.Column)({
|
|
3792
|
-
field: "updated_date",
|
|
3793
|
-
allowNull: true,
|
|
3794
|
-
type: import_sequelize_typescript35.DataType.DATE
|
|
3795
|
-
})
|
|
3796
|
-
], setting.prototype, "updatedDate", 2);
|
|
3797
|
-
setting = __decorateClass([
|
|
3798
|
-
(0, import_sequelize_typescript35.Table)({
|
|
3799
|
-
tableName: "setting",
|
|
3800
|
-
timestamps: false
|
|
3801
|
-
})
|
|
3802
|
-
], setting);
|
|
3803
|
-
|
|
3804
3909
|
// src/databases/tables/settings.ts
|
|
3805
|
-
var
|
|
3806
|
-
var settings = class extends
|
|
3910
|
+
var import_sequelize_typescript37 = require("sequelize-typescript");
|
|
3911
|
+
var settings = class extends import_sequelize_typescript37.Model {
|
|
3807
3912
|
};
|
|
3808
3913
|
__decorateClass([
|
|
3809
|
-
(0,
|
|
3914
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3810
3915
|
primaryKey: true,
|
|
3811
3916
|
autoIncrement: true,
|
|
3812
|
-
type:
|
|
3917
|
+
type: import_sequelize_typescript37.DataType.INTEGER
|
|
3813
3918
|
})
|
|
3814
3919
|
], settings.prototype, "id", 2);
|
|
3815
3920
|
__decorateClass([
|
|
3816
|
-
(0,
|
|
3921
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3817
3922
|
allowNull: true,
|
|
3818
|
-
type:
|
|
3923
|
+
type: import_sequelize_typescript37.DataType.STRING(255)
|
|
3819
3924
|
})
|
|
3820
3925
|
], settings.prototype, "key", 2);
|
|
3821
3926
|
__decorateClass([
|
|
3822
|
-
(0,
|
|
3927
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3823
3928
|
allowNull: true,
|
|
3824
|
-
type:
|
|
3929
|
+
type: import_sequelize_typescript37.DataType.STRING
|
|
3825
3930
|
})
|
|
3826
3931
|
], settings.prototype, "value", 2);
|
|
3827
3932
|
__decorateClass([
|
|
3828
|
-
(0,
|
|
3933
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3829
3934
|
allowNull: true,
|
|
3830
|
-
type:
|
|
3935
|
+
type: import_sequelize_typescript37.DataType.JSON
|
|
3831
3936
|
})
|
|
3832
3937
|
], settings.prototype, "data", 2);
|
|
3833
3938
|
__decorateClass([
|
|
3834
|
-
(0,
|
|
3939
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3835
3940
|
field: "updated_by",
|
|
3836
3941
|
allowNull: true,
|
|
3837
|
-
type:
|
|
3942
|
+
type: import_sequelize_typescript37.DataType.STRING(60)
|
|
3838
3943
|
})
|
|
3839
3944
|
], settings.prototype, "updatedBy", 2);
|
|
3840
3945
|
__decorateClass([
|
|
3841
|
-
(0,
|
|
3946
|
+
(0, import_sequelize_typescript37.Column)({
|
|
3842
3947
|
field: "updated_date",
|
|
3843
3948
|
allowNull: true,
|
|
3844
|
-
type:
|
|
3949
|
+
type: import_sequelize_typescript37.DataType.DATE
|
|
3845
3950
|
})
|
|
3846
3951
|
], settings.prototype, "updatedDate", 2);
|
|
3847
3952
|
settings = __decorateClass([
|
|
3848
|
-
(0,
|
|
3953
|
+
(0, import_sequelize_typescript37.Table)({
|
|
3849
3954
|
tableName: "settings",
|
|
3850
3955
|
timestamps: false
|
|
3851
3956
|
})
|
|
3852
3957
|
], settings);
|
|
3853
3958
|
|
|
3854
3959
|
// src/databases/tables/userCenterV.ts
|
|
3855
|
-
var
|
|
3856
|
-
var userCenterV = class extends
|
|
3960
|
+
var import_sequelize_typescript38 = require("sequelize-typescript");
|
|
3961
|
+
var userCenterV = class extends import_sequelize_typescript38.Model {
|
|
3857
3962
|
};
|
|
3858
3963
|
__decorateClass([
|
|
3859
|
-
(0,
|
|
3860
|
-
type:
|
|
3964
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3965
|
+
type: import_sequelize_typescript38.DataType.INTEGER,
|
|
3861
3966
|
defaultValue: "0"
|
|
3862
3967
|
})
|
|
3863
3968
|
], userCenterV.prototype, "id", 2);
|
|
3864
3969
|
__decorateClass([
|
|
3865
|
-
(0,
|
|
3866
|
-
type:
|
|
3970
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3971
|
+
type: import_sequelize_typescript38.DataType.STRING(60)
|
|
3867
3972
|
})
|
|
3868
3973
|
], userCenterV.prototype, "uuid", 2);
|
|
3869
3974
|
__decorateClass([
|
|
3870
|
-
(0,
|
|
3871
|
-
type:
|
|
3975
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3976
|
+
type: import_sequelize_typescript38.DataType.STRING(100)
|
|
3872
3977
|
})
|
|
3873
3978
|
], userCenterV.prototype, "username", 2);
|
|
3874
3979
|
__decorateClass([
|
|
3875
|
-
(0,
|
|
3980
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3876
3981
|
field: "password_hash",
|
|
3877
3982
|
allowNull: true,
|
|
3878
|
-
type:
|
|
3983
|
+
type: import_sequelize_typescript38.DataType.STRING(255)
|
|
3879
3984
|
})
|
|
3880
3985
|
], userCenterV.prototype, "passwordHash", 2);
|
|
3881
3986
|
__decorateClass([
|
|
3882
|
-
(0,
|
|
3987
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3883
3988
|
field: "password_reset_token",
|
|
3884
3989
|
allowNull: true,
|
|
3885
|
-
type:
|
|
3990
|
+
type: import_sequelize_typescript38.DataType.STRING(255)
|
|
3886
3991
|
})
|
|
3887
3992
|
], userCenterV.prototype, "passwordResetToken", 2);
|
|
3888
3993
|
__decorateClass([
|
|
3889
|
-
(0,
|
|
3994
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3890
3995
|
field: "verification_token",
|
|
3891
3996
|
allowNull: true,
|
|
3892
|
-
type:
|
|
3997
|
+
type: import_sequelize_typescript38.DataType.STRING(255)
|
|
3893
3998
|
})
|
|
3894
3999
|
], userCenterV.prototype, "verificationToken", 2);
|
|
3895
4000
|
__decorateClass([
|
|
3896
|
-
(0,
|
|
4001
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3897
4002
|
allowNull: true,
|
|
3898
|
-
type:
|
|
4003
|
+
type: import_sequelize_typescript38.DataType.STRING(255)
|
|
3899
4004
|
})
|
|
3900
4005
|
], userCenterV.prototype, "email", 2);
|
|
3901
4006
|
__decorateClass([
|
|
3902
|
-
(0,
|
|
4007
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3903
4008
|
field: "auth_key",
|
|
3904
4009
|
allowNull: true,
|
|
3905
|
-
type:
|
|
4010
|
+
type: import_sequelize_typescript38.DataType.STRING(32)
|
|
3906
4011
|
})
|
|
3907
4012
|
], userCenterV.prototype, "authKey", 2);
|
|
3908
4013
|
__decorateClass([
|
|
3909
|
-
(0,
|
|
4014
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3910
4015
|
field: "access_token",
|
|
3911
4016
|
allowNull: true,
|
|
3912
|
-
type:
|
|
4017
|
+
type: import_sequelize_typescript38.DataType.STRING
|
|
3913
4018
|
})
|
|
3914
4019
|
], userCenterV.prototype, "accessToken", 2);
|
|
3915
4020
|
__decorateClass([
|
|
3916
|
-
(0,
|
|
4021
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3917
4022
|
field: "user_level",
|
|
3918
4023
|
allowNull: true,
|
|
3919
|
-
type:
|
|
4024
|
+
type: import_sequelize_typescript38.DataType.INTEGER
|
|
3920
4025
|
})
|
|
3921
4026
|
], userCenterV.prototype, "userLevel", 2);
|
|
3922
4027
|
__decorateClass([
|
|
3923
|
-
(0,
|
|
4028
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3924
4029
|
field: "user_authen",
|
|
3925
4030
|
allowNull: true,
|
|
3926
|
-
type:
|
|
4031
|
+
type: import_sequelize_typescript38.DataType.STRING(64)
|
|
3927
4032
|
})
|
|
3928
4033
|
], userCenterV.prototype, "userAuthen", 2);
|
|
3929
4034
|
__decorateClass([
|
|
3930
|
-
(0,
|
|
4035
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3931
4036
|
field: "user_type",
|
|
3932
4037
|
allowNull: true,
|
|
3933
|
-
type:
|
|
4038
|
+
type: import_sequelize_typescript38.DataType.INTEGER
|
|
3934
4039
|
})
|
|
3935
4040
|
], userCenterV.prototype, "userType", 2);
|
|
3936
4041
|
__decorateClass([
|
|
3937
|
-
(0,
|
|
4042
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3938
4043
|
allowNull: true,
|
|
3939
|
-
type:
|
|
4044
|
+
type: import_sequelize_typescript38.DataType.STRING(10)
|
|
3940
4045
|
})
|
|
3941
4046
|
], userCenterV.prototype, "prefix", 2);
|
|
3942
4047
|
__decorateClass([
|
|
3943
|
-
(0,
|
|
4048
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3944
4049
|
field: "first_name",
|
|
3945
4050
|
allowNull: true,
|
|
3946
|
-
type:
|
|
4051
|
+
type: import_sequelize_typescript38.DataType.STRING(100)
|
|
3947
4052
|
})
|
|
3948
4053
|
], userCenterV.prototype, "firstName", 2);
|
|
3949
4054
|
__decorateClass([
|
|
3950
|
-
(0,
|
|
4055
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3951
4056
|
field: "last_name",
|
|
3952
4057
|
allowNull: true,
|
|
3953
|
-
type:
|
|
4058
|
+
type: import_sequelize_typescript38.DataType.STRING(100)
|
|
3954
4059
|
})
|
|
3955
4060
|
], userCenterV.prototype, "lastName", 2);
|
|
3956
4061
|
__decorateClass([
|
|
3957
|
-
(0,
|
|
4062
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3958
4063
|
allowNull: true,
|
|
3959
|
-
type:
|
|
4064
|
+
type: import_sequelize_typescript38.DataType.STRING(20)
|
|
3960
4065
|
})
|
|
3961
4066
|
], userCenterV.prototype, "phone", 2);
|
|
3962
4067
|
__decorateClass([
|
|
3963
|
-
(0,
|
|
4068
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3964
4069
|
allowNull: true,
|
|
3965
|
-
type:
|
|
4070
|
+
type: import_sequelize_typescript38.DataType.SMALLINT
|
|
3966
4071
|
})
|
|
3967
4072
|
], userCenterV.prototype, "status", 2);
|
|
3968
4073
|
__decorateClass([
|
|
3969
|
-
(0,
|
|
4074
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3970
4075
|
field: "created_by",
|
|
3971
4076
|
allowNull: true,
|
|
3972
|
-
type:
|
|
4077
|
+
type: import_sequelize_typescript38.DataType.STRING(60)
|
|
3973
4078
|
})
|
|
3974
4079
|
], userCenterV.prototype, "createdBy", 2);
|
|
3975
4080
|
__decorateClass([
|
|
3976
|
-
(0,
|
|
4081
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3977
4082
|
field: "created_date",
|
|
3978
4083
|
allowNull: true,
|
|
3979
|
-
type:
|
|
4084
|
+
type: import_sequelize_typescript38.DataType.DATE
|
|
3980
4085
|
})
|
|
3981
4086
|
], userCenterV.prototype, "createdDate", 2);
|
|
3982
4087
|
__decorateClass([
|
|
3983
|
-
(0,
|
|
4088
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3984
4089
|
field: "updated_by",
|
|
3985
4090
|
allowNull: true,
|
|
3986
|
-
type:
|
|
4091
|
+
type: import_sequelize_typescript38.DataType.STRING(60)
|
|
3987
4092
|
})
|
|
3988
4093
|
], userCenterV.prototype, "updatedBy", 2);
|
|
3989
4094
|
__decorateClass([
|
|
3990
|
-
(0,
|
|
4095
|
+
(0, import_sequelize_typescript38.Column)({
|
|
3991
4096
|
field: "updated_date",
|
|
3992
4097
|
allowNull: true,
|
|
3993
|
-
type:
|
|
4098
|
+
type: import_sequelize_typescript38.DataType.DATE
|
|
3994
4099
|
})
|
|
3995
4100
|
], userCenterV.prototype, "updatedDate", 2);
|
|
3996
4101
|
userCenterV = __decorateClass([
|
|
3997
|
-
(0,
|
|
4102
|
+
(0, import_sequelize_typescript38.Table)({
|
|
3998
4103
|
tableName: "user_center_v",
|
|
3999
4104
|
timestamps: false,
|
|
4000
4105
|
comment: "VIEW"
|
|
@@ -4002,38 +4107,38 @@ userCenterV = __decorateClass([
|
|
|
4002
4107
|
], userCenterV);
|
|
4003
4108
|
|
|
4004
4109
|
// src/databases/tables/userRoleV.ts
|
|
4005
|
-
var
|
|
4006
|
-
var userRoleV = class extends
|
|
4110
|
+
var import_sequelize_typescript39 = require("sequelize-typescript");
|
|
4111
|
+
var userRoleV = class extends import_sequelize_typescript39.Model {
|
|
4007
4112
|
};
|
|
4008
4113
|
__decorateClass([
|
|
4009
|
-
(0,
|
|
4010
|
-
type:
|
|
4114
|
+
(0, import_sequelize_typescript39.Column)({
|
|
4115
|
+
type: import_sequelize_typescript39.DataType.INTEGER,
|
|
4011
4116
|
defaultValue: "0"
|
|
4012
4117
|
})
|
|
4013
4118
|
], userRoleV.prototype, "id", 2);
|
|
4014
4119
|
__decorateClass([
|
|
4015
|
-
(0,
|
|
4120
|
+
(0, import_sequelize_typescript39.Column)({
|
|
4016
4121
|
field: "website_th",
|
|
4017
4122
|
allowNull: true,
|
|
4018
|
-
type:
|
|
4123
|
+
type: import_sequelize_typescript39.DataType.STRING(60)
|
|
4019
4124
|
})
|
|
4020
4125
|
], userRoleV.prototype, "websiteTh", 2);
|
|
4021
4126
|
__decorateClass([
|
|
4022
|
-
(0,
|
|
4127
|
+
(0, import_sequelize_typescript39.Column)({
|
|
4023
4128
|
field: "website_en",
|
|
4024
4129
|
allowNull: true,
|
|
4025
|
-
type:
|
|
4130
|
+
type: import_sequelize_typescript39.DataType.STRING(60)
|
|
4026
4131
|
})
|
|
4027
4132
|
], userRoleV.prototype, "websiteEn", 2);
|
|
4028
4133
|
__decorateClass([
|
|
4029
|
-
(0,
|
|
4134
|
+
(0, import_sequelize_typescript39.Column)({
|
|
4030
4135
|
field: "website_fr",
|
|
4031
4136
|
allowNull: true,
|
|
4032
|
-
type:
|
|
4137
|
+
type: import_sequelize_typescript39.DataType.STRING(60)
|
|
4033
4138
|
})
|
|
4034
4139
|
], userRoleV.prototype, "websiteFr", 2);
|
|
4035
4140
|
userRoleV = __decorateClass([
|
|
4036
|
-
(0,
|
|
4141
|
+
(0, import_sequelize_typescript39.Table)({
|
|
4037
4142
|
tableName: "user_role_v",
|
|
4038
4143
|
timestamps: false,
|
|
4039
4144
|
comment: "VIEW"
|
|
@@ -4061,6 +4166,7 @@ userRoleV = __decorateClass([
|
|
|
4061
4166
|
mdFaq,
|
|
4062
4167
|
mdFaqGroup,
|
|
4063
4168
|
mdFormAdvance_1,
|
|
4169
|
+
mdFormAdvance_2,
|
|
4064
4170
|
mdLink,
|
|
4065
4171
|
mdLinkGroup,
|
|
4066
4172
|
mdNews,
|
|
@@ -4068,12 +4174,12 @@ userRoleV = __decorateClass([
|
|
|
4068
4174
|
mdPopup,
|
|
4069
4175
|
mdQuestionnaire,
|
|
4070
4176
|
mdSetting,
|
|
4177
|
+
mdWords,
|
|
4071
4178
|
member,
|
|
4072
4179
|
menu,
|
|
4073
4180
|
msModule,
|
|
4074
4181
|
oauthAccessToken,
|
|
4075
4182
|
oauthRefreshToken,
|
|
4076
|
-
setting,
|
|
4077
4183
|
settings,
|
|
4078
4184
|
userCenterV,
|
|
4079
4185
|
userRoleV,
|