From dfd813bfdd5fc5f61ce8b42f1376f631a52bab74 Mon Sep 17 00:00:00 2001 From: lzh <1625167628@qq.com> Date: Mon, 16 Jun 2025 16:46:46 +0800 Subject: [PATCH] add gen --- go.mod | 19 +- go.sum | 70 ++- internal/app/logic/es.go | 4 +- internal/app/logic/process_base.go | 4 +- internal/app/logic/process_logic.go | 2 +- internal/app/logic/push.go | 2 +- internal/app/model/es.go | 4 +- internal/app/model/process.go | 2 +- internal/app/repository/config.go | 8 +- internal/app/repository/db.go | 9 + internal/app/repository/log.go | 33 +- internal/app/repository/permission.go | 1 + internal/app/repository/process.go | 25 +- internal/app/repository/push.go | 5 +- internal/app/repository/query/config.gen.go | 390 ++++++++++++++++ internal/app/repository/query/gen.go | 159 +++++++ .../app/repository/query/permission.gen.go | 414 +++++++++++++++++ internal/app/repository/query/process.gen.go | 426 ++++++++++++++++++ .../app/repository/query/process_log.gen.go | 398 ++++++++++++++++ internal/app/repository/query/push.gen.go | 402 +++++++++++++++++ internal/app/repository/query/task.gen.go | 426 ++++++++++++++++++ internal/app/repository/query/users.gen.go | 398 ++++++++++++++++ .../app/repository/query/ws_shares.gen.go | 402 +++++++++++++++++ internal/app/repository/task.go | 10 +- internal/app/repository/ws_share.go | 9 +- 25 files changed, 3542 insertions(+), 80 deletions(-) create mode 100644 internal/app/repository/query/config.gen.go create mode 100644 internal/app/repository/query/gen.go create mode 100644 internal/app/repository/query/permission.gen.go create mode 100644 internal/app/repository/query/process.gen.go create mode 100644 internal/app/repository/query/process_log.gen.go create mode 100644 internal/app/repository/query/push.gen.go create mode 100644 internal/app/repository/query/task.gen.go create mode 100644 internal/app/repository/query/users.gen.go create mode 100644 internal/app/repository/query/ws_shares.gen.go diff --git a/go.mod b/go.mod index c98286b..bf8502f 100644 --- a/go.mod +++ b/go.mod @@ -9,11 +9,13 @@ require ( ) require ( + filippo.io/edwards25519 v1.1.0 // indirect github.com/cilium/ebpf v0.16.0 // indirect github.com/containerd/log v0.1.0 // indirect github.com/coreos/go-systemd/v22 v22.5.0 // indirect github.com/docker/go-units v0.5.0 // indirect github.com/go-ole/go-ole v1.2.6 // indirect + github.com/go-sql-driver/mysql v1.8.1 // indirect github.com/godbus/dbus/v5 v5.1.0 // indirect github.com/iamacarpet/go-winpty v1.0.2 // indirect github.com/josharian/intern v1.0.0 // indirect @@ -25,13 +27,19 @@ require ( github.com/tklauser/numcpus v0.7.0 // indirect github.com/yusufpapurcu/wmi v1.2.4 // indirect golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f // indirect + golang.org/x/mod v0.22.0 // indirect golang.org/x/sync v0.9.0 // indirect + golang.org/x/tools v0.27.0 // indirect + gorm.io/datatypes v1.2.4 // indirect + gorm.io/driver/mysql v1.5.6 // indirect + gorm.io/hints v1.1.0 // indirect + gorm.io/plugin/dbresolver v1.5.0 // indirect ) require ( github.com/jinzhu/inflection v1.0.0 // indirect github.com/jinzhu/now v1.1.5 // indirect - gorm.io/gorm v1.25.7 + gorm.io/gorm v1.25.11 ) require ( @@ -46,7 +54,7 @@ require ( github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/rivo/tview v0.0.0-20241016194538-c5e4fb24af13 github.com/rivo/uniseg v0.4.7 // indirect - golang.org/x/term v0.19.0 // indirect + golang.org/x/term v0.26.0 // indirect gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect modernc.org/libc v1.22.5 // indirect modernc.org/mathutil v1.5.0 // indirect @@ -77,9 +85,9 @@ require ( github.com/ugorji/go/codec v1.2.12 // indirect go.uber.org/multierr v1.10.0 // indirect golang.org/x/arch v0.8.0 // indirect - golang.org/x/crypto v0.22.0 // indirect + golang.org/x/crypto v0.29.0 // indirect golang.org/x/sys v0.27.0 // indirect - golang.org/x/text v0.15.0 // indirect + golang.org/x/text v0.20.0 // indirect google.golang.org/protobuf v1.35.2 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) @@ -96,5 +104,6 @@ require ( github.com/shirou/gopsutil v3.21.11+incompatible github.com/timandy/routine v1.1.4 go.uber.org/zap v1.26.0 - golang.org/x/net v0.24.0 // indirect + golang.org/x/net v0.31.0 // indirect + gorm.io/gen v0.3.27 ) diff --git a/go.sum b/go.sum index 530229d..fdfdccf 100644 --- a/go.sum +++ b/go.sum @@ -1,3 +1,5 @@ +filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA= +filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0= github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4= github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM= @@ -55,6 +57,10 @@ github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBEx github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM= github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI= github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow= +github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= +github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI= +github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y= +github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg= github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= @@ -62,6 +68,10 @@ github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk= github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= +github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA= +github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0= +github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A= +github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI= github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= @@ -73,8 +83,18 @@ github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/ github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= github.com/iamacarpet/go-winpty v1.0.2 h1:jwPVTYrjAHZx6Mcm6K5i9G4opMp5TblEHH5EQCl/Gzw= github.com/iamacarpet/go-winpty v1.0.2/go.mod h1:/GHKJicG/EVRQIK1IQikMYBakBkhj/3hTjLgdzYsmpI= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9 h1:L0QtFUgDarD7Fpv9jeVMgy/+Ec0mtnmYuImjTz6dtDA= +github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.5.5 h1:amBjrZVmksIdNjxGW/IiIMzxMKZFelXbUoPNb+8sjQw= +github.com/jackc/pgx/v5 v5.5.5/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A= +github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk= +github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= +github.com/jinzhu/now v1.1.2/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= @@ -103,10 +123,15 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U= github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mattn/go-sqlite3 v1.14.8/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= +github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y= +github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= github.com/mdlayher/netlink v1.7.2 h1:/UtM3ofJap7Vl4QWCPDGXY8d3GIY2UGSDbK+QWmY8/g= github.com/mdlayher/netlink v1.7.2/go.mod h1:xraEF7uJbxLhc5fpHL4cPe221LI2bdttWlU+ZGLfQSw= github.com/mdlayher/socket v0.4.1 h1:eM9y2/jlbs1M615oshPQOHZzj6R6wMT7bX5NPiQvn2U= github.com/mdlayher/socket v0.4.1/go.mod h1:cAqeGjoufqdxWkD7DkpyS+wcefOtmu5OQ8KuoJGIReA= +github.com/microsoft/go-mssqldb v0.17.0 h1:Fto83dMZPnYv1Zwx5vHHxpNraeEaUlQ/hhHLgZiaenE= +github.com/microsoft/go-mssqldb v0.17.0/go.mod h1:OkoNGhGEs8EZqchVTtochlXruEhEOaO4S0d2sB5aeGQ= github.com/moby/sys/userns v0.1.0 h1:tVLXkFOxVu9A64/yh59slHVv9ahO9UIev4JZusOLG/g= github.com/moby/sys/userns v0.1.0/go.mod h1:IHUYgu/kao6N8YZlp9Cf444ySSvCmDlmzUcYfDHOl28= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= @@ -182,18 +207,20 @@ golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc= golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.22.0 h1:g1v0xeRhjcugydODzvb3mEM9SQ0HGp9s/nh3COQ/C30= -golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M= +golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ= +golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg= golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f h1:XdNn9LlyWAhLVp6P/i8QYBW+hlyhrhei9uErw2B5GJo= golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f/go.mod h1:D5SMRVC3C2/4+F/DB1wZsLRnSNimn2Sp/NPsCrsv8ak= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4= +golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.24.0 h1:1PcaxkF854Fu3+lvBIx5SYn9wRlBzzcnHZSiaFFAb0w= -golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8= +golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo= +golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -216,19 +243,21 @@ golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9sn golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= -golang.org/x/term v0.19.0 h1:+ThwsDv+tYfnJFhF4L8jITxu1tdTWRTZpdsWgEgjL6Q= -golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk= +golang.org/x/term v0.26.0 h1:WEQa6V3Gja/BhNxg540hBip/kkaYtRg3cxg4oXSw4AU= +golang.org/x/term v0.26.0/go.mod h1:Si5m1o57C5nBNQo5z1iq+XDijt21BDBDp2bK0QI8e3E= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk= -golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug= +golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.27.0 h1:qEKojBykQkQ4EynWy4S8Weg69NumxKdn40Fce3uc/8o= +golang.org/x/tools v0.27.0/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/protobuf v1.35.2 h1:8Ar7bF+apOIoThw1EdZl0p1oWvMqTHmpA2fRTyZO8io= google.golang.org/protobuf v1.35.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= @@ -238,8 +267,31 @@ gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gorm.io/gorm v1.25.7 h1:VsD6acwRjz2zFxGO50gPO6AkNs7KKnvfzUjHQhZDz/A= +gorm.io/datatypes v1.2.4 h1:uZmGAcK/QZ0uyfCuVg0VQY1ZmV9h1fuG0tMwKByO1z4= +gorm.io/datatypes v1.2.4/go.mod h1:f4BsLcFAX67szSv8svwLRjklArSHAvHLeE3pXAS5DZI= +gorm.io/driver/mysql v1.4.3/go.mod h1:sSIebwZAVPiT+27jK9HIwvsqOGKx3YMPmrA3mBJR10c= +gorm.io/driver/mysql v1.5.6 h1:Ld4mkIickM+EliaQZQx3uOJDJHtrd70MxAUqWqlx3Y8= +gorm.io/driver/mysql v1.5.6/go.mod h1:sEtPWMiqiN1N1cMXoXmBbd8C6/l+TESwriotuRRpkDM= +gorm.io/driver/postgres v1.5.0 h1:u2FXTy14l45qc3UeCJ7QaAXZmZfDDv0YrthvmRq1l0U= +gorm.io/driver/postgres v1.5.0/go.mod h1:FUZXzO+5Uqg5zzwzv4KK49R8lvGIyscBOqYrtI1Ce9A= +gorm.io/driver/sqlite v1.1.6/go.mod h1:W8LmC/6UvVbHKah0+QOC7Ja66EaZXHwUTjgXY8YNWX8= +gorm.io/driver/sqlite v1.4.3 h1:HBBcZSDnWi5BW3B3rwvVTc510KGkBkexlOg0QrmLUuU= +gorm.io/driver/sqlite v1.4.3/go.mod h1:0Aq3iPO+v9ZKbcdiz8gLWRw5VOPcBOPUQJFLq5e2ecI= +gorm.io/driver/sqlserver v1.4.1 h1:t4r4r6Jam5E6ejqP7N82qAJIJAht27EGT41HyPfXRw0= +gorm.io/driver/sqlserver v1.4.1/go.mod h1:DJ4P+MeZbc5rvY58PnmN1Lnyvb5gw5NPzGshHDnJLig= +gorm.io/gen v0.3.27 h1:ziocAFLpE7e0g4Rum69pGfB9S6DweTxK8gAun7cU8as= +gorm.io/gen v0.3.27/go.mod h1:9zquz2xD1f3Eb/eHq4oLn2z6vDVvQlCY5S3uMBLv4EA= +gorm.io/gorm v1.21.15/go.mod h1:F+OptMscr0P2F2qU97WT1WimdH9GaQPoDW7AYd5i2Y0= +gorm.io/gorm v1.22.2/go.mod h1:F+OptMscr0P2F2qU97WT1WimdH9GaQPoDW7AYd5i2Y0= +gorm.io/gorm v1.23.8/go.mod h1:l2lP/RyAtc1ynaTjFksBde/O8v9oOGIApu2/xRitmZk= +gorm.io/gorm v1.25.2/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k= gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8= +gorm.io/gorm v1.25.11 h1:/Wfyg1B/je1hnDx3sMkX+gAlxrlZpn6X0BXRlwXlvHg= +gorm.io/gorm v1.25.11/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ= +gorm.io/hints v1.1.0 h1:Lp4z3rxREufSdxn4qmkK3TLDltrM10FLTHiuqwDPvXw= +gorm.io/hints v1.1.0/go.mod h1:lKQ0JjySsPBj3uslFzY3JhYDtqEwzm+G1hv8rWujB6Y= +gorm.io/plugin/dbresolver v1.5.0 h1:XVHLxh775eP0CqVh3vcfJtYqja3uFl5Wr3cKlY8jgDY= +gorm.io/plugin/dbresolver v1.5.0/go.mod h1:l4Cn87EHLEYuqUncpEeTC2tTJQkjngPSD+lo8hIvcT0= modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE= modernc.org/libc v1.22.5/go.mod h1:jj+Z7dTNX8fBScMVNRAYZ/jF91K8fdT2hYMThc3YjBY= modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ= diff --git a/internal/app/logic/es.go b/internal/app/logic/es.go index 7f0a675..b52f264 100644 --- a/internal/app/logic/es.go +++ b/internal/app/logic/es.go @@ -88,7 +88,7 @@ func (e *esLogic) Search(req model.GetLogReq, filterProcessName ...string) model // 检查 req 是否为 nil if req.Page.From < 0 || req.Page.Size <= 0 { log.Logger.Error("无效的分页请求参数") - return model.LogResp{Total: 0, Data: []model.ProcessLog{}} + return model.LogResp{Total: 0, Data: []*model.ProcessLog{}} } search := e.esClient.Search(config.CF.EsIndex).From(req.Page.From).Size(req.Page.Size).TrackScores(true) @@ -140,7 +140,7 @@ func (e *esLogic) Search(req model.GetLogReq, filterProcessName ...string) model if v.Source != nil { var data model.ProcessLog if err := json.Unmarshal(v.Source, &data); err == nil { - result.Data = append(result.Data, data) + result.Data = append(result.Data, &data) } else { log.Logger.Errorw("JSON 解码失败", "err", err) } diff --git a/internal/app/logic/process_base.go b/internal/app/logic/process_base.go index 904fee4..9ca4c98 100644 --- a/internal/app/logic/process_base.go +++ b/internal/app/logic/process_base.go @@ -49,7 +49,7 @@ type ProcessBase struct { Config struct { AutoRestart bool compulsoryRestart bool - PushIds []int + PushIds []int64 logReport bool cgroupEnable bool memoryLimit *float32 @@ -218,7 +218,7 @@ func (p *ProcessBase) VerifyControl() bool { func (p *ProcessBase) setProcessConfig(pconfig model.Process) { p.Config.AutoRestart = pconfig.AutoRestart p.Config.logReport = pconfig.LogReport - p.Config.PushIds = utils.JsonStrToStruct[[]int](pconfig.PushIds) + p.Config.PushIds = utils.JsonStrToStruct[[]int64](pconfig.PushIds) p.Config.compulsoryRestart = pconfig.CompulsoryRestart p.Config.cgroupEnable = pconfig.CgroupEnable p.Config.memoryLimit = pconfig.MemoryLimit diff --git a/internal/app/logic/process_logic.go b/internal/app/logic/process_logic.go index 292e98a..2f60e5f 100644 --- a/internal/app/logic/process_logic.go +++ b/internal/app/logic/process_logic.go @@ -209,7 +209,7 @@ func (p *processCtlLogic) UpdateProcessConfig(config model.Process) error { } defer result.Lock.Unlock() result.Config.logReport = config.LogReport - result.Config.PushIds = utils.JsonStrToStruct[[]int](config.PushIds) + result.Config.PushIds = utils.JsonStrToStruct[[]int64](config.PushIds) result.Config.cgroupEnable = config.CgroupEnable result.Config.memoryLimit = config.MemoryLimit result.Config.cpuLimit = config.CpuLimit diff --git a/internal/app/logic/push.go b/internal/app/logic/push.go index b3537eb..71621b9 100644 --- a/internal/app/logic/push.go +++ b/internal/app/logic/push.go @@ -19,7 +19,7 @@ var PushLogic = &pushLogic{ }, } -func (p *pushLogic) Push(ids []int, placeholders map[string]string) { +func (p *pushLogic) Push(ids []int64, placeholders map[string]string) { pl := repository.PushRepository.GetPushConfigByIds(ids) for _, v := range pl { if v.Enable { diff --git a/internal/app/model/es.go b/internal/app/model/es.go index 1cee770..178a6b4 100644 --- a/internal/app/model/es.go +++ b/internal/app/model/es.go @@ -83,8 +83,8 @@ type EsResp struct { } type LogResp struct { - Total int64 `json:"total"` - Data []ProcessLog `json:"data"` + Total int64 `json:"total"` + Data []*ProcessLog `json:"data"` } type ProcessLog struct { diff --git a/internal/app/model/process.go b/internal/app/model/process.go index d853d01..0726736 100644 --- a/internal/app/model/process.go +++ b/internal/app/model/process.go @@ -4,7 +4,7 @@ import "github.com/lzh-1625/go_process_manager/internal/app/constants" type Process struct { Uuid int `gorm:"primaryKey;autoIncrement;column:uuid" json:"uuid"` - Name string `gorm:"column:name" json:"name"` + Name string `gorm:"column:name;uniqueIndex;type:text" json:"name"` Cmd string `gorm:"column:args" json:"cmd"` Cwd string `gorm:"column:cwd" json:"cwd"` AutoRestart bool `gorm:"column:auto_restart" json:"autoRestart"` diff --git a/internal/app/repository/config.go b/internal/app/repository/config.go index 4eafeb3..4af80a5 100644 --- a/internal/app/repository/config.go +++ b/internal/app/repository/config.go @@ -2,6 +2,7 @@ package repository import ( "github.com/lzh-1625/go_process_manager/internal/app/model" + "github.com/lzh-1625/go_process_manager/internal/app/repository/query" ) type configRepository struct{} @@ -9,11 +10,8 @@ type configRepository struct{} var ConfigRepository = new(configRepository) func (c *configRepository) GetConfigValue(key string) (string, error) { - var result string - if err := db.Model(&model.Config{}).Select("value").Where(&model.Config{Key: key}).First(&result).Error; err != nil { - return "", err - } - return result, nil + data, err := query.Config.Select(query.Config.Value).Where(query.Config.Key.Eq(key)).First() + return *data.Value, err } func (c *configRepository) SetConfigValue(key, value string) error { diff --git a/internal/app/repository/db.go b/internal/app/repository/db.go index ba5d411..f15f650 100644 --- a/internal/app/repository/db.go +++ b/internal/app/repository/db.go @@ -8,6 +8,7 @@ import ( "github.com/lzh-1625/go_process_manager/internal/app/model" "github.com/glebarez/sqlite" + "gorm.io/gen" "gorm.io/gorm" "gorm.io/gorm/logger" ) @@ -42,4 +43,12 @@ func InitDb() { db = gdb.Session(&defaultConfig) // db = gdb.Session(&defaultConfig).Debug() db.AutoMigrate(&model.Process{}, &model.User{}, &model.Permission{}, &model.Push{}, &model.Config{}, &model.ProcessLog{}, &model.Task{}, &model.WsShare{}) + + g := gen.NewGenerator(gen.Config{ + OutPath: "internal/app/repository/query", + Mode: gen.WithoutContext | gen.WithDefaultQuery | gen.WithQueryInterface, // generate mode + }) + g.UseDB(db) + g.ApplyBasic(&model.Process{}, &model.User{}, &model.Permission{}, &model.Push{}, &model.Config{}, &model.ProcessLog{}, &model.Task{}, &model.WsShare{}) + g.Execute() } diff --git a/internal/app/repository/log.go b/internal/app/repository/log.go index 8a36f0a..d107b69 100644 --- a/internal/app/repository/log.go +++ b/internal/app/repository/log.go @@ -2,6 +2,7 @@ package repository import ( "github.com/lzh-1625/go_process_manager/internal/app/model" + "github.com/lzh-1625/go_process_manager/internal/app/repository/query" "github.com/lzh-1625/go_process_manager/log" ) @@ -15,29 +16,23 @@ func (l *logRepository) InsertLog(data model.ProcessLog) { } } -func (l *logRepository) SearchLog(query model.GetLogReq) (result []model.ProcessLog, total int64) { - tx := db.Model(&model.ProcessLog{}).Where(&model.ProcessLog{ - Name: query.Match.Name, - Using: query.Match.Using, - }) - if query.Match.Log != "" { - tx.Where("log like ?", "%"+query.Match.Log+"%") +func (l *logRepository) SearchLog(req model.GetLogReq) (result []*model.ProcessLog, total int64) { + q := query.ProcessLog.Where(query.ProcessLog.Name.Eq(req.Match.Name)).Where(query.ProcessLog.Using.Eq(req.Match.Using)) + if req.Match.Log != "" { + q.Where(query.ProcessLog.Log.Like("%" + req.Match.Log + "%")) } - if query.Sort == "desc" { - tx.Order("time desc") + if req.Sort == "desc" { + q.Order(query.ProcessLog.Time.Desc()) } - if query.TimeRange.StartTime != 0 { - tx.Where("time > ?", query.TimeRange.StartTime) + if req.TimeRange.StartTime != 0 { + q.Where(query.ProcessLog.Time.Gte(req.TimeRange.StartTime)) } - if query.TimeRange.EndTime != 0 { - tx.Where("time < ?", query.TimeRange.EndTime) + if req.TimeRange.EndTime != 0 { + q.Where(query.ProcessLog.Time.Lte(req.TimeRange.EndTime)) } - if len(query.FilterName) != 0 { - tx.Where("name in ?", query.FilterName) + if len(req.FilterName) != 0 { + q.Where(query.ProcessLog.Name.In(req.FilterName...)) } - tx.Count(&total) - tx.Limit(query.Page.Size) - tx.Offset(query.Page.From) - tx.Find(&result) + result, total, _ = q.FindByPage(req.Page.From, req.Page.Size) return } diff --git a/internal/app/repository/permission.go b/internal/app/repository/permission.go index a54343b..fbcd5ef 100644 --- a/internal/app/repository/permission.go +++ b/internal/app/repository/permission.go @@ -40,6 +40,7 @@ func (p *permissionRepository) EditPermssion(data model.Permission) error { "log": data.Log, "write": data.Write, }).Error + } func (p *permissionRepository) GetPermission(user string, pid int) (result model.Permission) { diff --git a/internal/app/repository/process.go b/internal/app/repository/process.go index c84ae75..432fb3e 100644 --- a/internal/app/repository/process.go +++ b/internal/app/repository/process.go @@ -1,12 +1,9 @@ package repository import ( - "errors" - "github.com/lzh-1625/go_process_manager/internal/app/model" + "github.com/lzh-1625/go_process_manager/internal/app/repository/query" "github.com/lzh-1625/go_process_manager/log" - - "gorm.io/gorm" ) type processRepository struct{} @@ -26,9 +23,9 @@ func (p *processRepository) GetAllProcessConfig() []model.Process { func (p *processRepository) GetProcessConfigByUser(username string) []model.Process { result := []model.Process{} - tx := db.Raw(`SELECT p.* FROM permission left join process p where pid =p.uuid and owned = 1 and account = ?`, username).Scan(&result) - if tx.Error != nil { - log.Logger.Error(tx.Error) + err := query.Permission.LeftJoin(query.Process, query.Process.Uuid.EqCol(query.Permission.Pid)).Where(query.Permission.Owned.Is(true)).Where(query.Permission.Account.Eq(username)).Scan(&result) + if err != nil { + log.Logger.Error(err) return []model.Process{} } return result @@ -40,25 +37,11 @@ func (p *processRepository) UpdateProcessConfig(process model.Process) error { } func (p *processRepository) AddProcessConfig(process model.Process) (int, error) { - var existingProcess model.Process - err := db.Model(&model.Process{}).Where("name = ?", process.Name).First(&existingProcess).Error - - if err != nil && err != gorm.ErrRecordNotFound { - log.Logger.Error(err) - return 0, err - } - - if err == nil { - - return 0, errors.New("process name already exists") - } - tx := db.Create(&process) if tx.Error != nil { log.Logger.Error(tx.Error) return 0, tx.Error } - return process.Uuid, nil } diff --git a/internal/app/repository/push.go b/internal/app/repository/push.go index 34d8d6f..a2560c2 100644 --- a/internal/app/repository/push.go +++ b/internal/app/repository/push.go @@ -2,6 +2,7 @@ package repository import ( "github.com/lzh-1625/go_process_manager/internal/app/model" + "github.com/lzh-1625/go_process_manager/internal/app/repository/query" ) type pushRepository struct{} @@ -32,7 +33,7 @@ func (p *pushRepository) DeletePushConfig(id int) error { }).Error } -func (p *pushRepository) GetPushConfigByIds(ids []int) (result []model.Push) { - db.Model(&model.Push{}).Where("id in ?", ids).Find(&result) +func (p *pushRepository) GetPushConfigByIds(ids []int64) (result []*model.Push) { + result, _ = query.Push.Where(query.Push.Id.In(ids...)).Find() return } diff --git a/internal/app/repository/query/config.gen.go b/internal/app/repository/query/config.gen.go new file mode 100644 index 0000000..aa948f8 --- /dev/null +++ b/internal/app/repository/query/config.gen.go @@ -0,0 +1,390 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "github.com/lzh-1625/go_process_manager/internal/app/model" + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newConfig(db *gorm.DB, opts ...gen.DOOption) config { + _config := config{} + + _config.configDo.UseDB(db, opts...) + _config.configDo.UseModel(&model.Config{}) + + tableName := _config.configDo.TableName() + _config.ALL = field.NewAsterisk(tableName) + _config.Id = field.NewInt(tableName, "id") + _config.Key = field.NewString(tableName, "key") + _config.Value = field.NewString(tableName, "value") + + _config.fillFieldMap() + + return _config +} + +type config struct { + configDo + + ALL field.Asterisk + Id field.Int + Key field.String + Value field.String + + fieldMap map[string]field.Expr +} + +func (c config) Table(newTableName string) *config { + c.configDo.UseTable(newTableName) + return c.updateTableName(newTableName) +} + +func (c config) As(alias string) *config { + c.configDo.DO = *(c.configDo.As(alias).(*gen.DO)) + return c.updateTableName(alias) +} + +func (c *config) updateTableName(table string) *config { + c.ALL = field.NewAsterisk(table) + c.Id = field.NewInt(table, "id") + c.Key = field.NewString(table, "key") + c.Value = field.NewString(table, "value") + + c.fillFieldMap() + + return c +} + +func (c *config) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := c.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (c *config) fillFieldMap() { + c.fieldMap = make(map[string]field.Expr, 3) + c.fieldMap["id"] = c.Id + c.fieldMap["key"] = c.Key + c.fieldMap["value"] = c.Value +} + +func (c config) clone(db *gorm.DB) config { + c.configDo.ReplaceConnPool(db.Statement.ConnPool) + return c +} + +func (c config) replaceDB(db *gorm.DB) config { + c.configDo.ReplaceDB(db) + return c +} + +type configDo struct{ gen.DO } + +type IConfigDo interface { + gen.SubQuery + Debug() IConfigDo + WithContext(ctx context.Context) IConfigDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IConfigDo + WriteDB() IConfigDo + As(alias string) gen.Dao + Session(config *gorm.Session) IConfigDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IConfigDo + Not(conds ...gen.Condition) IConfigDo + Or(conds ...gen.Condition) IConfigDo + Select(conds ...field.Expr) IConfigDo + Where(conds ...gen.Condition) IConfigDo + Order(conds ...field.Expr) IConfigDo + Distinct(cols ...field.Expr) IConfigDo + Omit(cols ...field.Expr) IConfigDo + Join(table schema.Tabler, on ...field.Expr) IConfigDo + LeftJoin(table schema.Tabler, on ...field.Expr) IConfigDo + RightJoin(table schema.Tabler, on ...field.Expr) IConfigDo + Group(cols ...field.Expr) IConfigDo + Having(conds ...gen.Condition) IConfigDo + Limit(limit int) IConfigDo + Offset(offset int) IConfigDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IConfigDo + Unscoped() IConfigDo + Create(values ...*model.Config) error + CreateInBatches(values []*model.Config, batchSize int) error + Save(values ...*model.Config) error + First() (*model.Config, error) + Take() (*model.Config, error) + Last() (*model.Config, error) + Find() ([]*model.Config, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Config, err error) + FindInBatches(result *[]*model.Config, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Config) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IConfigDo + Assign(attrs ...field.AssignExpr) IConfigDo + Joins(fields ...field.RelationField) IConfigDo + Preload(fields ...field.RelationField) IConfigDo + FirstOrInit() (*model.Config, error) + FirstOrCreate() (*model.Config, error) + FindByPage(offset int, limit int) (result []*model.Config, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IConfigDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (c configDo) Debug() IConfigDo { + return c.withDO(c.DO.Debug()) +} + +func (c configDo) WithContext(ctx context.Context) IConfigDo { + return c.withDO(c.DO.WithContext(ctx)) +} + +func (c configDo) ReadDB() IConfigDo { + return c.Clauses(dbresolver.Read) +} + +func (c configDo) WriteDB() IConfigDo { + return c.Clauses(dbresolver.Write) +} + +func (c configDo) Session(config *gorm.Session) IConfigDo { + return c.withDO(c.DO.Session(config)) +} + +func (c configDo) Clauses(conds ...clause.Expression) IConfigDo { + return c.withDO(c.DO.Clauses(conds...)) +} + +func (c configDo) Returning(value interface{}, columns ...string) IConfigDo { + return c.withDO(c.DO.Returning(value, columns...)) +} + +func (c configDo) Not(conds ...gen.Condition) IConfigDo { + return c.withDO(c.DO.Not(conds...)) +} + +func (c configDo) Or(conds ...gen.Condition) IConfigDo { + return c.withDO(c.DO.Or(conds...)) +} + +func (c configDo) Select(conds ...field.Expr) IConfigDo { + return c.withDO(c.DO.Select(conds...)) +} + +func (c configDo) Where(conds ...gen.Condition) IConfigDo { + return c.withDO(c.DO.Where(conds...)) +} + +func (c configDo) Order(conds ...field.Expr) IConfigDo { + return c.withDO(c.DO.Order(conds...)) +} + +func (c configDo) Distinct(cols ...field.Expr) IConfigDo { + return c.withDO(c.DO.Distinct(cols...)) +} + +func (c configDo) Omit(cols ...field.Expr) IConfigDo { + return c.withDO(c.DO.Omit(cols...)) +} + +func (c configDo) Join(table schema.Tabler, on ...field.Expr) IConfigDo { + return c.withDO(c.DO.Join(table, on...)) +} + +func (c configDo) LeftJoin(table schema.Tabler, on ...field.Expr) IConfigDo { + return c.withDO(c.DO.LeftJoin(table, on...)) +} + +func (c configDo) RightJoin(table schema.Tabler, on ...field.Expr) IConfigDo { + return c.withDO(c.DO.RightJoin(table, on...)) +} + +func (c configDo) Group(cols ...field.Expr) IConfigDo { + return c.withDO(c.DO.Group(cols...)) +} + +func (c configDo) Having(conds ...gen.Condition) IConfigDo { + return c.withDO(c.DO.Having(conds...)) +} + +func (c configDo) Limit(limit int) IConfigDo { + return c.withDO(c.DO.Limit(limit)) +} + +func (c configDo) Offset(offset int) IConfigDo { + return c.withDO(c.DO.Offset(offset)) +} + +func (c configDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IConfigDo { + return c.withDO(c.DO.Scopes(funcs...)) +} + +func (c configDo) Unscoped() IConfigDo { + return c.withDO(c.DO.Unscoped()) +} + +func (c configDo) Create(values ...*model.Config) error { + if len(values) == 0 { + return nil + } + return c.DO.Create(values) +} + +func (c configDo) CreateInBatches(values []*model.Config, batchSize int) error { + return c.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (c configDo) Save(values ...*model.Config) error { + if len(values) == 0 { + return nil + } + return c.DO.Save(values) +} + +func (c configDo) First() (*model.Config, error) { + if result, err := c.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Config), nil + } +} + +func (c configDo) Take() (*model.Config, error) { + if result, err := c.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Config), nil + } +} + +func (c configDo) Last() (*model.Config, error) { + if result, err := c.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Config), nil + } +} + +func (c configDo) Find() ([]*model.Config, error) { + result, err := c.DO.Find() + return result.([]*model.Config), err +} + +func (c configDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Config, err error) { + buf := make([]*model.Config, 0, batchSize) + err = c.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (c configDo) FindInBatches(result *[]*model.Config, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return c.DO.FindInBatches(result, batchSize, fc) +} + +func (c configDo) Attrs(attrs ...field.AssignExpr) IConfigDo { + return c.withDO(c.DO.Attrs(attrs...)) +} + +func (c configDo) Assign(attrs ...field.AssignExpr) IConfigDo { + return c.withDO(c.DO.Assign(attrs...)) +} + +func (c configDo) Joins(fields ...field.RelationField) IConfigDo { + for _, _f := range fields { + c = *c.withDO(c.DO.Joins(_f)) + } + return &c +} + +func (c configDo) Preload(fields ...field.RelationField) IConfigDo { + for _, _f := range fields { + c = *c.withDO(c.DO.Preload(_f)) + } + return &c +} + +func (c configDo) FirstOrInit() (*model.Config, error) { + if result, err := c.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Config), nil + } +} + +func (c configDo) FirstOrCreate() (*model.Config, error) { + if result, err := c.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Config), nil + } +} + +func (c configDo) FindByPage(offset int, limit int) (result []*model.Config, count int64, err error) { + result, err = c.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = c.Offset(-1).Limit(-1).Count() + return +} + +func (c configDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = c.Count() + if err != nil { + return + } + + err = c.Offset(offset).Limit(limit).Scan(result) + return +} + +func (c configDo) Scan(result interface{}) (err error) { + return c.DO.Scan(result) +} + +func (c configDo) Delete(models ...*model.Config) (result gen.ResultInfo, err error) { + return c.DO.Delete(models) +} + +func (c *configDo) withDO(do gen.Dao) *configDo { + c.DO = *do.(*gen.DO) + return c +} diff --git a/internal/app/repository/query/gen.go b/internal/app/repository/query/gen.go new file mode 100644 index 0000000..f3e81e7 --- /dev/null +++ b/internal/app/repository/query/gen.go @@ -0,0 +1,159 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + + "gorm.io/gen" + + "gorm.io/plugin/dbresolver" +) + +var ( + Q = new(Query) + Config *config + Permission *permission + Process *process + ProcessLog *processLog + Push *push + Task *task + User *user + WsShare *wsShare +) + +func SetDefault(db *gorm.DB, opts ...gen.DOOption) { + *Q = *Use(db, opts...) + Config = &Q.Config + Permission = &Q.Permission + Process = &Q.Process + ProcessLog = &Q.ProcessLog + Push = &Q.Push + Task = &Q.Task + User = &Q.User + WsShare = &Q.WsShare +} + +func Use(db *gorm.DB, opts ...gen.DOOption) *Query { + return &Query{ + db: db, + Config: newConfig(db, opts...), + Permission: newPermission(db, opts...), + Process: newProcess(db, opts...), + ProcessLog: newProcessLog(db, opts...), + Push: newPush(db, opts...), + Task: newTask(db, opts...), + User: newUser(db, opts...), + WsShare: newWsShare(db, opts...), + } +} + +type Query struct { + db *gorm.DB + + Config config + Permission permission + Process process + ProcessLog processLog + Push push + Task task + User user + WsShare wsShare +} + +func (q *Query) Available() bool { return q.db != nil } + +func (q *Query) clone(db *gorm.DB) *Query { + return &Query{ + db: db, + Config: q.Config.clone(db), + Permission: q.Permission.clone(db), + Process: q.Process.clone(db), + ProcessLog: q.ProcessLog.clone(db), + Push: q.Push.clone(db), + Task: q.Task.clone(db), + User: q.User.clone(db), + WsShare: q.WsShare.clone(db), + } +} + +func (q *Query) ReadDB() *Query { + return q.ReplaceDB(q.db.Clauses(dbresolver.Read)) +} + +func (q *Query) WriteDB() *Query { + return q.ReplaceDB(q.db.Clauses(dbresolver.Write)) +} + +func (q *Query) ReplaceDB(db *gorm.DB) *Query { + return &Query{ + db: db, + Config: q.Config.replaceDB(db), + Permission: q.Permission.replaceDB(db), + Process: q.Process.replaceDB(db), + ProcessLog: q.ProcessLog.replaceDB(db), + Push: q.Push.replaceDB(db), + Task: q.Task.replaceDB(db), + User: q.User.replaceDB(db), + WsShare: q.WsShare.replaceDB(db), + } +} + +type queryCtx struct { + Config IConfigDo + Permission IPermissionDo + Process IProcessDo + ProcessLog IProcessLogDo + Push IPushDo + Task ITaskDo + User IUserDo + WsShare IWsShareDo +} + +func (q *Query) WithContext(ctx context.Context) *queryCtx { + return &queryCtx{ + Config: q.Config.WithContext(ctx), + Permission: q.Permission.WithContext(ctx), + Process: q.Process.WithContext(ctx), + ProcessLog: q.ProcessLog.WithContext(ctx), + Push: q.Push.WithContext(ctx), + Task: q.Task.WithContext(ctx), + User: q.User.WithContext(ctx), + WsShare: q.WsShare.WithContext(ctx), + } +} + +func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error { + return q.db.Transaction(func(tx *gorm.DB) error { return fc(q.clone(tx)) }, opts...) +} + +func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx { + tx := q.db.Begin(opts...) + return &QueryTx{Query: q.clone(tx), Error: tx.Error} +} + +type QueryTx struct { + *Query + Error error +} + +func (q *QueryTx) Commit() error { + return q.db.Commit().Error +} + +func (q *QueryTx) Rollback() error { + return q.db.Rollback().Error +} + +func (q *QueryTx) SavePoint(name string) error { + return q.db.SavePoint(name).Error +} + +func (q *QueryTx) RollbackTo(name string) error { + return q.db.RollbackTo(name).Error +} diff --git a/internal/app/repository/query/permission.gen.go b/internal/app/repository/query/permission.gen.go new file mode 100644 index 0000000..f6da702 --- /dev/null +++ b/internal/app/repository/query/permission.gen.go @@ -0,0 +1,414 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "github.com/lzh-1625/go_process_manager/internal/app/model" + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newPermission(db *gorm.DB, opts ...gen.DOOption) permission { + _permission := permission{} + + _permission.permissionDo.UseDB(db, opts...) + _permission.permissionDo.UseModel(&model.Permission{}) + + tableName := _permission.permissionDo.TableName() + _permission.ALL = field.NewAsterisk(tableName) + _permission.Id = field.NewInt64(tableName, "id") + _permission.Account = field.NewString(tableName, "account") + _permission.Pid = field.NewInt32(tableName, "pid") + _permission.Owned = field.NewBool(tableName, "owned") + _permission.Start = field.NewBool(tableName, "start") + _permission.Stop = field.NewBool(tableName, "stop") + _permission.Terminal = field.NewBool(tableName, "terminal") + _permission.Write = field.NewBool(tableName, "write") + _permission.Log = field.NewBool(tableName, "log") + + _permission.fillFieldMap() + + return _permission +} + +type permission struct { + permissionDo + + ALL field.Asterisk + Id field.Int64 + Account field.String + Pid field.Int32 + Owned field.Bool + Start field.Bool + Stop field.Bool + Terminal field.Bool + Write field.Bool + Log field.Bool + + fieldMap map[string]field.Expr +} + +func (p permission) Table(newTableName string) *permission { + p.permissionDo.UseTable(newTableName) + return p.updateTableName(newTableName) +} + +func (p permission) As(alias string) *permission { + p.permissionDo.DO = *(p.permissionDo.As(alias).(*gen.DO)) + return p.updateTableName(alias) +} + +func (p *permission) updateTableName(table string) *permission { + p.ALL = field.NewAsterisk(table) + p.Id = field.NewInt64(table, "id") + p.Account = field.NewString(table, "account") + p.Pid = field.NewInt32(table, "pid") + p.Owned = field.NewBool(table, "owned") + p.Start = field.NewBool(table, "start") + p.Stop = field.NewBool(table, "stop") + p.Terminal = field.NewBool(table, "terminal") + p.Write = field.NewBool(table, "write") + p.Log = field.NewBool(table, "log") + + p.fillFieldMap() + + return p +} + +func (p *permission) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := p.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (p *permission) fillFieldMap() { + p.fieldMap = make(map[string]field.Expr, 9) + p.fieldMap["id"] = p.Id + p.fieldMap["account"] = p.Account + p.fieldMap["pid"] = p.Pid + p.fieldMap["owned"] = p.Owned + p.fieldMap["start"] = p.Start + p.fieldMap["stop"] = p.Stop + p.fieldMap["terminal"] = p.Terminal + p.fieldMap["write"] = p.Write + p.fieldMap["log"] = p.Log +} + +func (p permission) clone(db *gorm.DB) permission { + p.permissionDo.ReplaceConnPool(db.Statement.ConnPool) + return p +} + +func (p permission) replaceDB(db *gorm.DB) permission { + p.permissionDo.ReplaceDB(db) + return p +} + +type permissionDo struct{ gen.DO } + +type IPermissionDo interface { + gen.SubQuery + Debug() IPermissionDo + WithContext(ctx context.Context) IPermissionDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IPermissionDo + WriteDB() IPermissionDo + As(alias string) gen.Dao + Session(config *gorm.Session) IPermissionDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IPermissionDo + Not(conds ...gen.Condition) IPermissionDo + Or(conds ...gen.Condition) IPermissionDo + Select(conds ...field.Expr) IPermissionDo + Where(conds ...gen.Condition) IPermissionDo + Order(conds ...field.Expr) IPermissionDo + Distinct(cols ...field.Expr) IPermissionDo + Omit(cols ...field.Expr) IPermissionDo + Join(table schema.Tabler, on ...field.Expr) IPermissionDo + LeftJoin(table schema.Tabler, on ...field.Expr) IPermissionDo + RightJoin(table schema.Tabler, on ...field.Expr) IPermissionDo + Group(cols ...field.Expr) IPermissionDo + Having(conds ...gen.Condition) IPermissionDo + Limit(limit int) IPermissionDo + Offset(offset int) IPermissionDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IPermissionDo + Unscoped() IPermissionDo + Create(values ...*model.Permission) error + CreateInBatches(values []*model.Permission, batchSize int) error + Save(values ...*model.Permission) error + First() (*model.Permission, error) + Take() (*model.Permission, error) + Last() (*model.Permission, error) + Find() ([]*model.Permission, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Permission, err error) + FindInBatches(result *[]*model.Permission, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Permission) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IPermissionDo + Assign(attrs ...field.AssignExpr) IPermissionDo + Joins(fields ...field.RelationField) IPermissionDo + Preload(fields ...field.RelationField) IPermissionDo + FirstOrInit() (*model.Permission, error) + FirstOrCreate() (*model.Permission, error) + FindByPage(offset int, limit int) (result []*model.Permission, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IPermissionDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (p permissionDo) Debug() IPermissionDo { + return p.withDO(p.DO.Debug()) +} + +func (p permissionDo) WithContext(ctx context.Context) IPermissionDo { + return p.withDO(p.DO.WithContext(ctx)) +} + +func (p permissionDo) ReadDB() IPermissionDo { + return p.Clauses(dbresolver.Read) +} + +func (p permissionDo) WriteDB() IPermissionDo { + return p.Clauses(dbresolver.Write) +} + +func (p permissionDo) Session(config *gorm.Session) IPermissionDo { + return p.withDO(p.DO.Session(config)) +} + +func (p permissionDo) Clauses(conds ...clause.Expression) IPermissionDo { + return p.withDO(p.DO.Clauses(conds...)) +} + +func (p permissionDo) Returning(value interface{}, columns ...string) IPermissionDo { + return p.withDO(p.DO.Returning(value, columns...)) +} + +func (p permissionDo) Not(conds ...gen.Condition) IPermissionDo { + return p.withDO(p.DO.Not(conds...)) +} + +func (p permissionDo) Or(conds ...gen.Condition) IPermissionDo { + return p.withDO(p.DO.Or(conds...)) +} + +func (p permissionDo) Select(conds ...field.Expr) IPermissionDo { + return p.withDO(p.DO.Select(conds...)) +} + +func (p permissionDo) Where(conds ...gen.Condition) IPermissionDo { + return p.withDO(p.DO.Where(conds...)) +} + +func (p permissionDo) Order(conds ...field.Expr) IPermissionDo { + return p.withDO(p.DO.Order(conds...)) +} + +func (p permissionDo) Distinct(cols ...field.Expr) IPermissionDo { + return p.withDO(p.DO.Distinct(cols...)) +} + +func (p permissionDo) Omit(cols ...field.Expr) IPermissionDo { + return p.withDO(p.DO.Omit(cols...)) +} + +func (p permissionDo) Join(table schema.Tabler, on ...field.Expr) IPermissionDo { + return p.withDO(p.DO.Join(table, on...)) +} + +func (p permissionDo) LeftJoin(table schema.Tabler, on ...field.Expr) IPermissionDo { + return p.withDO(p.DO.LeftJoin(table, on...)) +} + +func (p permissionDo) RightJoin(table schema.Tabler, on ...field.Expr) IPermissionDo { + return p.withDO(p.DO.RightJoin(table, on...)) +} + +func (p permissionDo) Group(cols ...field.Expr) IPermissionDo { + return p.withDO(p.DO.Group(cols...)) +} + +func (p permissionDo) Having(conds ...gen.Condition) IPermissionDo { + return p.withDO(p.DO.Having(conds...)) +} + +func (p permissionDo) Limit(limit int) IPermissionDo { + return p.withDO(p.DO.Limit(limit)) +} + +func (p permissionDo) Offset(offset int) IPermissionDo { + return p.withDO(p.DO.Offset(offset)) +} + +func (p permissionDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IPermissionDo { + return p.withDO(p.DO.Scopes(funcs...)) +} + +func (p permissionDo) Unscoped() IPermissionDo { + return p.withDO(p.DO.Unscoped()) +} + +func (p permissionDo) Create(values ...*model.Permission) error { + if len(values) == 0 { + return nil + } + return p.DO.Create(values) +} + +func (p permissionDo) CreateInBatches(values []*model.Permission, batchSize int) error { + return p.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (p permissionDo) Save(values ...*model.Permission) error { + if len(values) == 0 { + return nil + } + return p.DO.Save(values) +} + +func (p permissionDo) First() (*model.Permission, error) { + if result, err := p.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Permission), nil + } +} + +func (p permissionDo) Take() (*model.Permission, error) { + if result, err := p.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Permission), nil + } +} + +func (p permissionDo) Last() (*model.Permission, error) { + if result, err := p.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Permission), nil + } +} + +func (p permissionDo) Find() ([]*model.Permission, error) { + result, err := p.DO.Find() + return result.([]*model.Permission), err +} + +func (p permissionDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Permission, err error) { + buf := make([]*model.Permission, 0, batchSize) + err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (p permissionDo) FindInBatches(result *[]*model.Permission, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return p.DO.FindInBatches(result, batchSize, fc) +} + +func (p permissionDo) Attrs(attrs ...field.AssignExpr) IPermissionDo { + return p.withDO(p.DO.Attrs(attrs...)) +} + +func (p permissionDo) Assign(attrs ...field.AssignExpr) IPermissionDo { + return p.withDO(p.DO.Assign(attrs...)) +} + +func (p permissionDo) Joins(fields ...field.RelationField) IPermissionDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Joins(_f)) + } + return &p +} + +func (p permissionDo) Preload(fields ...field.RelationField) IPermissionDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Preload(_f)) + } + return &p +} + +func (p permissionDo) FirstOrInit() (*model.Permission, error) { + if result, err := p.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Permission), nil + } +} + +func (p permissionDo) FirstOrCreate() (*model.Permission, error) { + if result, err := p.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Permission), nil + } +} + +func (p permissionDo) FindByPage(offset int, limit int) (result []*model.Permission, count int64, err error) { + result, err = p.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = p.Offset(-1).Limit(-1).Count() + return +} + +func (p permissionDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = p.Count() + if err != nil { + return + } + + err = p.Offset(offset).Limit(limit).Scan(result) + return +} + +func (p permissionDo) Scan(result interface{}) (err error) { + return p.DO.Scan(result) +} + +func (p permissionDo) Delete(models ...*model.Permission) (result gen.ResultInfo, err error) { + return p.DO.Delete(models) +} + +func (p *permissionDo) withDO(do gen.Dao) *permissionDo { + p.DO = *do.(*gen.DO) + return p +} diff --git a/internal/app/repository/query/process.gen.go b/internal/app/repository/query/process.gen.go new file mode 100644 index 0000000..e9189f4 --- /dev/null +++ b/internal/app/repository/query/process.gen.go @@ -0,0 +1,426 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "github.com/lzh-1625/go_process_manager/internal/app/model" + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newProcess(db *gorm.DB, opts ...gen.DOOption) process { + _process := process{} + + _process.processDo.UseDB(db, opts...) + _process.processDo.UseModel(&model.Process{}) + + tableName := _process.processDo.TableName() + _process.ALL = field.NewAsterisk(tableName) + _process.Uuid = field.NewInt(tableName, "uuid") + _process.Name = field.NewString(tableName, "name") + _process.Cmd = field.NewString(tableName, "args") + _process.Cwd = field.NewString(tableName, "cwd") + _process.AutoRestart = field.NewBool(tableName, "auto_restart") + _process.CompulsoryRestart = field.NewBool(tableName, "compulsory_restart") + _process.PushIds = field.NewString(tableName, "push_ids") + _process.LogReport = field.NewBool(tableName, "log_report") + _process.TermType = field.NewString(tableName, "term_type") + _process.CgroupEnable = field.NewBool(tableName, "cgroup_enable") + _process.MemoryLimit = field.NewFloat32(tableName, "memory_limit") + _process.CpuLimit = field.NewFloat32(tableName, "cpu_limit") + + _process.fillFieldMap() + + return _process +} + +type process struct { + processDo + + ALL field.Asterisk + Uuid field.Int + Name field.String + Cmd field.String + Cwd field.String + AutoRestart field.Bool + CompulsoryRestart field.Bool + PushIds field.String + LogReport field.Bool + TermType field.String + CgroupEnable field.Bool + MemoryLimit field.Float32 + CpuLimit field.Float32 + + fieldMap map[string]field.Expr +} + +func (p process) Table(newTableName string) *process { + p.processDo.UseTable(newTableName) + return p.updateTableName(newTableName) +} + +func (p process) As(alias string) *process { + p.processDo.DO = *(p.processDo.As(alias).(*gen.DO)) + return p.updateTableName(alias) +} + +func (p *process) updateTableName(table string) *process { + p.ALL = field.NewAsterisk(table) + p.Uuid = field.NewInt(table, "uuid") + p.Name = field.NewString(table, "name") + p.Cmd = field.NewString(table, "args") + p.Cwd = field.NewString(table, "cwd") + p.AutoRestart = field.NewBool(table, "auto_restart") + p.CompulsoryRestart = field.NewBool(table, "compulsory_restart") + p.PushIds = field.NewString(table, "push_ids") + p.LogReport = field.NewBool(table, "log_report") + p.TermType = field.NewString(table, "term_type") + p.CgroupEnable = field.NewBool(table, "cgroup_enable") + p.MemoryLimit = field.NewFloat32(table, "memory_limit") + p.CpuLimit = field.NewFloat32(table, "cpu_limit") + + p.fillFieldMap() + + return p +} + +func (p *process) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := p.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (p *process) fillFieldMap() { + p.fieldMap = make(map[string]field.Expr, 12) + p.fieldMap["uuid"] = p.Uuid + p.fieldMap["name"] = p.Name + p.fieldMap["args"] = p.Cmd + p.fieldMap["cwd"] = p.Cwd + p.fieldMap["auto_restart"] = p.AutoRestart + p.fieldMap["compulsory_restart"] = p.CompulsoryRestart + p.fieldMap["push_ids"] = p.PushIds + p.fieldMap["log_report"] = p.LogReport + p.fieldMap["term_type"] = p.TermType + p.fieldMap["cgroup_enable"] = p.CgroupEnable + p.fieldMap["memory_limit"] = p.MemoryLimit + p.fieldMap["cpu_limit"] = p.CpuLimit +} + +func (p process) clone(db *gorm.DB) process { + p.processDo.ReplaceConnPool(db.Statement.ConnPool) + return p +} + +func (p process) replaceDB(db *gorm.DB) process { + p.processDo.ReplaceDB(db) + return p +} + +type processDo struct{ gen.DO } + +type IProcessDo interface { + gen.SubQuery + Debug() IProcessDo + WithContext(ctx context.Context) IProcessDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IProcessDo + WriteDB() IProcessDo + As(alias string) gen.Dao + Session(config *gorm.Session) IProcessDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IProcessDo + Not(conds ...gen.Condition) IProcessDo + Or(conds ...gen.Condition) IProcessDo + Select(conds ...field.Expr) IProcessDo + Where(conds ...gen.Condition) IProcessDo + Order(conds ...field.Expr) IProcessDo + Distinct(cols ...field.Expr) IProcessDo + Omit(cols ...field.Expr) IProcessDo + Join(table schema.Tabler, on ...field.Expr) IProcessDo + LeftJoin(table schema.Tabler, on ...field.Expr) IProcessDo + RightJoin(table schema.Tabler, on ...field.Expr) IProcessDo + Group(cols ...field.Expr) IProcessDo + Having(conds ...gen.Condition) IProcessDo + Limit(limit int) IProcessDo + Offset(offset int) IProcessDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IProcessDo + Unscoped() IProcessDo + Create(values ...*model.Process) error + CreateInBatches(values []*model.Process, batchSize int) error + Save(values ...*model.Process) error + First() (*model.Process, error) + Take() (*model.Process, error) + Last() (*model.Process, error) + Find() ([]*model.Process, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Process, err error) + FindInBatches(result *[]*model.Process, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Process) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IProcessDo + Assign(attrs ...field.AssignExpr) IProcessDo + Joins(fields ...field.RelationField) IProcessDo + Preload(fields ...field.RelationField) IProcessDo + FirstOrInit() (*model.Process, error) + FirstOrCreate() (*model.Process, error) + FindByPage(offset int, limit int) (result []*model.Process, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IProcessDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (p processDo) Debug() IProcessDo { + return p.withDO(p.DO.Debug()) +} + +func (p processDo) WithContext(ctx context.Context) IProcessDo { + return p.withDO(p.DO.WithContext(ctx)) +} + +func (p processDo) ReadDB() IProcessDo { + return p.Clauses(dbresolver.Read) +} + +func (p processDo) WriteDB() IProcessDo { + return p.Clauses(dbresolver.Write) +} + +func (p processDo) Session(config *gorm.Session) IProcessDo { + return p.withDO(p.DO.Session(config)) +} + +func (p processDo) Clauses(conds ...clause.Expression) IProcessDo { + return p.withDO(p.DO.Clauses(conds...)) +} + +func (p processDo) Returning(value interface{}, columns ...string) IProcessDo { + return p.withDO(p.DO.Returning(value, columns...)) +} + +func (p processDo) Not(conds ...gen.Condition) IProcessDo { + return p.withDO(p.DO.Not(conds...)) +} + +func (p processDo) Or(conds ...gen.Condition) IProcessDo { + return p.withDO(p.DO.Or(conds...)) +} + +func (p processDo) Select(conds ...field.Expr) IProcessDo { + return p.withDO(p.DO.Select(conds...)) +} + +func (p processDo) Where(conds ...gen.Condition) IProcessDo { + return p.withDO(p.DO.Where(conds...)) +} + +func (p processDo) Order(conds ...field.Expr) IProcessDo { + return p.withDO(p.DO.Order(conds...)) +} + +func (p processDo) Distinct(cols ...field.Expr) IProcessDo { + return p.withDO(p.DO.Distinct(cols...)) +} + +func (p processDo) Omit(cols ...field.Expr) IProcessDo { + return p.withDO(p.DO.Omit(cols...)) +} + +func (p processDo) Join(table schema.Tabler, on ...field.Expr) IProcessDo { + return p.withDO(p.DO.Join(table, on...)) +} + +func (p processDo) LeftJoin(table schema.Tabler, on ...field.Expr) IProcessDo { + return p.withDO(p.DO.LeftJoin(table, on...)) +} + +func (p processDo) RightJoin(table schema.Tabler, on ...field.Expr) IProcessDo { + return p.withDO(p.DO.RightJoin(table, on...)) +} + +func (p processDo) Group(cols ...field.Expr) IProcessDo { + return p.withDO(p.DO.Group(cols...)) +} + +func (p processDo) Having(conds ...gen.Condition) IProcessDo { + return p.withDO(p.DO.Having(conds...)) +} + +func (p processDo) Limit(limit int) IProcessDo { + return p.withDO(p.DO.Limit(limit)) +} + +func (p processDo) Offset(offset int) IProcessDo { + return p.withDO(p.DO.Offset(offset)) +} + +func (p processDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IProcessDo { + return p.withDO(p.DO.Scopes(funcs...)) +} + +func (p processDo) Unscoped() IProcessDo { + return p.withDO(p.DO.Unscoped()) +} + +func (p processDo) Create(values ...*model.Process) error { + if len(values) == 0 { + return nil + } + return p.DO.Create(values) +} + +func (p processDo) CreateInBatches(values []*model.Process, batchSize int) error { + return p.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (p processDo) Save(values ...*model.Process) error { + if len(values) == 0 { + return nil + } + return p.DO.Save(values) +} + +func (p processDo) First() (*model.Process, error) { + if result, err := p.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Process), nil + } +} + +func (p processDo) Take() (*model.Process, error) { + if result, err := p.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Process), nil + } +} + +func (p processDo) Last() (*model.Process, error) { + if result, err := p.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Process), nil + } +} + +func (p processDo) Find() ([]*model.Process, error) { + result, err := p.DO.Find() + return result.([]*model.Process), err +} + +func (p processDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Process, err error) { + buf := make([]*model.Process, 0, batchSize) + err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (p processDo) FindInBatches(result *[]*model.Process, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return p.DO.FindInBatches(result, batchSize, fc) +} + +func (p processDo) Attrs(attrs ...field.AssignExpr) IProcessDo { + return p.withDO(p.DO.Attrs(attrs...)) +} + +func (p processDo) Assign(attrs ...field.AssignExpr) IProcessDo { + return p.withDO(p.DO.Assign(attrs...)) +} + +func (p processDo) Joins(fields ...field.RelationField) IProcessDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Joins(_f)) + } + return &p +} + +func (p processDo) Preload(fields ...field.RelationField) IProcessDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Preload(_f)) + } + return &p +} + +func (p processDo) FirstOrInit() (*model.Process, error) { + if result, err := p.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Process), nil + } +} + +func (p processDo) FirstOrCreate() (*model.Process, error) { + if result, err := p.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Process), nil + } +} + +func (p processDo) FindByPage(offset int, limit int) (result []*model.Process, count int64, err error) { + result, err = p.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = p.Offset(-1).Limit(-1).Count() + return +} + +func (p processDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = p.Count() + if err != nil { + return + } + + err = p.Offset(offset).Limit(limit).Scan(result) + return +} + +func (p processDo) Scan(result interface{}) (err error) { + return p.DO.Scan(result) +} + +func (p processDo) Delete(models ...*model.Process) (result gen.ResultInfo, err error) { + return p.DO.Delete(models) +} + +func (p *processDo) withDO(do gen.Dao) *processDo { + p.DO = *do.(*gen.DO) + return p +} diff --git a/internal/app/repository/query/process_log.gen.go b/internal/app/repository/query/process_log.gen.go new file mode 100644 index 0000000..45fedd0 --- /dev/null +++ b/internal/app/repository/query/process_log.gen.go @@ -0,0 +1,398 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "github.com/lzh-1625/go_process_manager/internal/app/model" + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newProcessLog(db *gorm.DB, opts ...gen.DOOption) processLog { + _processLog := processLog{} + + _processLog.processLogDo.UseDB(db, opts...) + _processLog.processLogDo.UseModel(&model.ProcessLog{}) + + tableName := _processLog.processLogDo.TableName() + _processLog.ALL = field.NewAsterisk(tableName) + _processLog.Id = field.NewInt(tableName, "id") + _processLog.Log = field.NewString(tableName, "log") + _processLog.Time = field.NewInt64(tableName, "time") + _processLog.Name = field.NewString(tableName, "name") + _processLog.Using = field.NewString(tableName, "using") + + _processLog.fillFieldMap() + + return _processLog +} + +type processLog struct { + processLogDo + + ALL field.Asterisk + Id field.Int + Log field.String + Time field.Int64 + Name field.String + Using field.String + + fieldMap map[string]field.Expr +} + +func (p processLog) Table(newTableName string) *processLog { + p.processLogDo.UseTable(newTableName) + return p.updateTableName(newTableName) +} + +func (p processLog) As(alias string) *processLog { + p.processLogDo.DO = *(p.processLogDo.As(alias).(*gen.DO)) + return p.updateTableName(alias) +} + +func (p *processLog) updateTableName(table string) *processLog { + p.ALL = field.NewAsterisk(table) + p.Id = field.NewInt(table, "id") + p.Log = field.NewString(table, "log") + p.Time = field.NewInt64(table, "time") + p.Name = field.NewString(table, "name") + p.Using = field.NewString(table, "using") + + p.fillFieldMap() + + return p +} + +func (p *processLog) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := p.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (p *processLog) fillFieldMap() { + p.fieldMap = make(map[string]field.Expr, 5) + p.fieldMap["id"] = p.Id + p.fieldMap["log"] = p.Log + p.fieldMap["time"] = p.Time + p.fieldMap["name"] = p.Name + p.fieldMap["using"] = p.Using +} + +func (p processLog) clone(db *gorm.DB) processLog { + p.processLogDo.ReplaceConnPool(db.Statement.ConnPool) + return p +} + +func (p processLog) replaceDB(db *gorm.DB) processLog { + p.processLogDo.ReplaceDB(db) + return p +} + +type processLogDo struct{ gen.DO } + +type IProcessLogDo interface { + gen.SubQuery + Debug() IProcessLogDo + WithContext(ctx context.Context) IProcessLogDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IProcessLogDo + WriteDB() IProcessLogDo + As(alias string) gen.Dao + Session(config *gorm.Session) IProcessLogDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IProcessLogDo + Not(conds ...gen.Condition) IProcessLogDo + Or(conds ...gen.Condition) IProcessLogDo + Select(conds ...field.Expr) IProcessLogDo + Where(conds ...gen.Condition) IProcessLogDo + Order(conds ...field.Expr) IProcessLogDo + Distinct(cols ...field.Expr) IProcessLogDo + Omit(cols ...field.Expr) IProcessLogDo + Join(table schema.Tabler, on ...field.Expr) IProcessLogDo + LeftJoin(table schema.Tabler, on ...field.Expr) IProcessLogDo + RightJoin(table schema.Tabler, on ...field.Expr) IProcessLogDo + Group(cols ...field.Expr) IProcessLogDo + Having(conds ...gen.Condition) IProcessLogDo + Limit(limit int) IProcessLogDo + Offset(offset int) IProcessLogDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IProcessLogDo + Unscoped() IProcessLogDo + Create(values ...*model.ProcessLog) error + CreateInBatches(values []*model.ProcessLog, batchSize int) error + Save(values ...*model.ProcessLog) error + First() (*model.ProcessLog, error) + Take() (*model.ProcessLog, error) + Last() (*model.ProcessLog, error) + Find() ([]*model.ProcessLog, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ProcessLog, err error) + FindInBatches(result *[]*model.ProcessLog, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.ProcessLog) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IProcessLogDo + Assign(attrs ...field.AssignExpr) IProcessLogDo + Joins(fields ...field.RelationField) IProcessLogDo + Preload(fields ...field.RelationField) IProcessLogDo + FirstOrInit() (*model.ProcessLog, error) + FirstOrCreate() (*model.ProcessLog, error) + FindByPage(offset int, limit int) (result []*model.ProcessLog, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IProcessLogDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (p processLogDo) Debug() IProcessLogDo { + return p.withDO(p.DO.Debug()) +} + +func (p processLogDo) WithContext(ctx context.Context) IProcessLogDo { + return p.withDO(p.DO.WithContext(ctx)) +} + +func (p processLogDo) ReadDB() IProcessLogDo { + return p.Clauses(dbresolver.Read) +} + +func (p processLogDo) WriteDB() IProcessLogDo { + return p.Clauses(dbresolver.Write) +} + +func (p processLogDo) Session(config *gorm.Session) IProcessLogDo { + return p.withDO(p.DO.Session(config)) +} + +func (p processLogDo) Clauses(conds ...clause.Expression) IProcessLogDo { + return p.withDO(p.DO.Clauses(conds...)) +} + +func (p processLogDo) Returning(value interface{}, columns ...string) IProcessLogDo { + return p.withDO(p.DO.Returning(value, columns...)) +} + +func (p processLogDo) Not(conds ...gen.Condition) IProcessLogDo { + return p.withDO(p.DO.Not(conds...)) +} + +func (p processLogDo) Or(conds ...gen.Condition) IProcessLogDo { + return p.withDO(p.DO.Or(conds...)) +} + +func (p processLogDo) Select(conds ...field.Expr) IProcessLogDo { + return p.withDO(p.DO.Select(conds...)) +} + +func (p processLogDo) Where(conds ...gen.Condition) IProcessLogDo { + return p.withDO(p.DO.Where(conds...)) +} + +func (p processLogDo) Order(conds ...field.Expr) IProcessLogDo { + return p.withDO(p.DO.Order(conds...)) +} + +func (p processLogDo) Distinct(cols ...field.Expr) IProcessLogDo { + return p.withDO(p.DO.Distinct(cols...)) +} + +func (p processLogDo) Omit(cols ...field.Expr) IProcessLogDo { + return p.withDO(p.DO.Omit(cols...)) +} + +func (p processLogDo) Join(table schema.Tabler, on ...field.Expr) IProcessLogDo { + return p.withDO(p.DO.Join(table, on...)) +} + +func (p processLogDo) LeftJoin(table schema.Tabler, on ...field.Expr) IProcessLogDo { + return p.withDO(p.DO.LeftJoin(table, on...)) +} + +func (p processLogDo) RightJoin(table schema.Tabler, on ...field.Expr) IProcessLogDo { + return p.withDO(p.DO.RightJoin(table, on...)) +} + +func (p processLogDo) Group(cols ...field.Expr) IProcessLogDo { + return p.withDO(p.DO.Group(cols...)) +} + +func (p processLogDo) Having(conds ...gen.Condition) IProcessLogDo { + return p.withDO(p.DO.Having(conds...)) +} + +func (p processLogDo) Limit(limit int) IProcessLogDo { + return p.withDO(p.DO.Limit(limit)) +} + +func (p processLogDo) Offset(offset int) IProcessLogDo { + return p.withDO(p.DO.Offset(offset)) +} + +func (p processLogDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IProcessLogDo { + return p.withDO(p.DO.Scopes(funcs...)) +} + +func (p processLogDo) Unscoped() IProcessLogDo { + return p.withDO(p.DO.Unscoped()) +} + +func (p processLogDo) Create(values ...*model.ProcessLog) error { + if len(values) == 0 { + return nil + } + return p.DO.Create(values) +} + +func (p processLogDo) CreateInBatches(values []*model.ProcessLog, batchSize int) error { + return p.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (p processLogDo) Save(values ...*model.ProcessLog) error { + if len(values) == 0 { + return nil + } + return p.DO.Save(values) +} + +func (p processLogDo) First() (*model.ProcessLog, error) { + if result, err := p.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.ProcessLog), nil + } +} + +func (p processLogDo) Take() (*model.ProcessLog, error) { + if result, err := p.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.ProcessLog), nil + } +} + +func (p processLogDo) Last() (*model.ProcessLog, error) { + if result, err := p.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.ProcessLog), nil + } +} + +func (p processLogDo) Find() ([]*model.ProcessLog, error) { + result, err := p.DO.Find() + return result.([]*model.ProcessLog), err +} + +func (p processLogDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ProcessLog, err error) { + buf := make([]*model.ProcessLog, 0, batchSize) + err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (p processLogDo) FindInBatches(result *[]*model.ProcessLog, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return p.DO.FindInBatches(result, batchSize, fc) +} + +func (p processLogDo) Attrs(attrs ...field.AssignExpr) IProcessLogDo { + return p.withDO(p.DO.Attrs(attrs...)) +} + +func (p processLogDo) Assign(attrs ...field.AssignExpr) IProcessLogDo { + return p.withDO(p.DO.Assign(attrs...)) +} + +func (p processLogDo) Joins(fields ...field.RelationField) IProcessLogDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Joins(_f)) + } + return &p +} + +func (p processLogDo) Preload(fields ...field.RelationField) IProcessLogDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Preload(_f)) + } + return &p +} + +func (p processLogDo) FirstOrInit() (*model.ProcessLog, error) { + if result, err := p.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.ProcessLog), nil + } +} + +func (p processLogDo) FirstOrCreate() (*model.ProcessLog, error) { + if result, err := p.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.ProcessLog), nil + } +} + +func (p processLogDo) FindByPage(offset int, limit int) (result []*model.ProcessLog, count int64, err error) { + result, err = p.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = p.Offset(-1).Limit(-1).Count() + return +} + +func (p processLogDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = p.Count() + if err != nil { + return + } + + err = p.Offset(offset).Limit(limit).Scan(result) + return +} + +func (p processLogDo) Scan(result interface{}) (err error) { + return p.DO.Scan(result) +} + +func (p processLogDo) Delete(models ...*model.ProcessLog) (result gen.ResultInfo, err error) { + return p.DO.Delete(models) +} + +func (p *processLogDo) withDO(do gen.Dao) *processLogDo { + p.DO = *do.(*gen.DO) + return p +} diff --git a/internal/app/repository/query/push.gen.go b/internal/app/repository/query/push.gen.go new file mode 100644 index 0000000..2261833 --- /dev/null +++ b/internal/app/repository/query/push.gen.go @@ -0,0 +1,402 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "github.com/lzh-1625/go_process_manager/internal/app/model" + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newPush(db *gorm.DB, opts ...gen.DOOption) push { + _push := push{} + + _push.pushDo.UseDB(db, opts...) + _push.pushDo.UseModel(&model.Push{}) + + tableName := _push.pushDo.TableName() + _push.ALL = field.NewAsterisk(tableName) + _push.Id = field.NewInt64(tableName, "id") + _push.Method = field.NewString(tableName, "method") + _push.Url = field.NewString(tableName, "url") + _push.Body = field.NewString(tableName, "body") + _push.Remark = field.NewString(tableName, "remark") + _push.Enable = field.NewBool(tableName, "enable") + + _push.fillFieldMap() + + return _push +} + +type push struct { + pushDo + + ALL field.Asterisk + Id field.Int64 + Method field.String + Url field.String + Body field.String + Remark field.String + Enable field.Bool + + fieldMap map[string]field.Expr +} + +func (p push) Table(newTableName string) *push { + p.pushDo.UseTable(newTableName) + return p.updateTableName(newTableName) +} + +func (p push) As(alias string) *push { + p.pushDo.DO = *(p.pushDo.As(alias).(*gen.DO)) + return p.updateTableName(alias) +} + +func (p *push) updateTableName(table string) *push { + p.ALL = field.NewAsterisk(table) + p.Id = field.NewInt64(table, "id") + p.Method = field.NewString(table, "method") + p.Url = field.NewString(table, "url") + p.Body = field.NewString(table, "body") + p.Remark = field.NewString(table, "remark") + p.Enable = field.NewBool(table, "enable") + + p.fillFieldMap() + + return p +} + +func (p *push) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := p.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (p *push) fillFieldMap() { + p.fieldMap = make(map[string]field.Expr, 6) + p.fieldMap["id"] = p.Id + p.fieldMap["method"] = p.Method + p.fieldMap["url"] = p.Url + p.fieldMap["body"] = p.Body + p.fieldMap["remark"] = p.Remark + p.fieldMap["enable"] = p.Enable +} + +func (p push) clone(db *gorm.DB) push { + p.pushDo.ReplaceConnPool(db.Statement.ConnPool) + return p +} + +func (p push) replaceDB(db *gorm.DB) push { + p.pushDo.ReplaceDB(db) + return p +} + +type pushDo struct{ gen.DO } + +type IPushDo interface { + gen.SubQuery + Debug() IPushDo + WithContext(ctx context.Context) IPushDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IPushDo + WriteDB() IPushDo + As(alias string) gen.Dao + Session(config *gorm.Session) IPushDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IPushDo + Not(conds ...gen.Condition) IPushDo + Or(conds ...gen.Condition) IPushDo + Select(conds ...field.Expr) IPushDo + Where(conds ...gen.Condition) IPushDo + Order(conds ...field.Expr) IPushDo + Distinct(cols ...field.Expr) IPushDo + Omit(cols ...field.Expr) IPushDo + Join(table schema.Tabler, on ...field.Expr) IPushDo + LeftJoin(table schema.Tabler, on ...field.Expr) IPushDo + RightJoin(table schema.Tabler, on ...field.Expr) IPushDo + Group(cols ...field.Expr) IPushDo + Having(conds ...gen.Condition) IPushDo + Limit(limit int) IPushDo + Offset(offset int) IPushDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IPushDo + Unscoped() IPushDo + Create(values ...*model.Push) error + CreateInBatches(values []*model.Push, batchSize int) error + Save(values ...*model.Push) error + First() (*model.Push, error) + Take() (*model.Push, error) + Last() (*model.Push, error) + Find() ([]*model.Push, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Push, err error) + FindInBatches(result *[]*model.Push, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Push) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IPushDo + Assign(attrs ...field.AssignExpr) IPushDo + Joins(fields ...field.RelationField) IPushDo + Preload(fields ...field.RelationField) IPushDo + FirstOrInit() (*model.Push, error) + FirstOrCreate() (*model.Push, error) + FindByPage(offset int, limit int) (result []*model.Push, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IPushDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (p pushDo) Debug() IPushDo { + return p.withDO(p.DO.Debug()) +} + +func (p pushDo) WithContext(ctx context.Context) IPushDo { + return p.withDO(p.DO.WithContext(ctx)) +} + +func (p pushDo) ReadDB() IPushDo { + return p.Clauses(dbresolver.Read) +} + +func (p pushDo) WriteDB() IPushDo { + return p.Clauses(dbresolver.Write) +} + +func (p pushDo) Session(config *gorm.Session) IPushDo { + return p.withDO(p.DO.Session(config)) +} + +func (p pushDo) Clauses(conds ...clause.Expression) IPushDo { + return p.withDO(p.DO.Clauses(conds...)) +} + +func (p pushDo) Returning(value interface{}, columns ...string) IPushDo { + return p.withDO(p.DO.Returning(value, columns...)) +} + +func (p pushDo) Not(conds ...gen.Condition) IPushDo { + return p.withDO(p.DO.Not(conds...)) +} + +func (p pushDo) Or(conds ...gen.Condition) IPushDo { + return p.withDO(p.DO.Or(conds...)) +} + +func (p pushDo) Select(conds ...field.Expr) IPushDo { + return p.withDO(p.DO.Select(conds...)) +} + +func (p pushDo) Where(conds ...gen.Condition) IPushDo { + return p.withDO(p.DO.Where(conds...)) +} + +func (p pushDo) Order(conds ...field.Expr) IPushDo { + return p.withDO(p.DO.Order(conds...)) +} + +func (p pushDo) Distinct(cols ...field.Expr) IPushDo { + return p.withDO(p.DO.Distinct(cols...)) +} + +func (p pushDo) Omit(cols ...field.Expr) IPushDo { + return p.withDO(p.DO.Omit(cols...)) +} + +func (p pushDo) Join(table schema.Tabler, on ...field.Expr) IPushDo { + return p.withDO(p.DO.Join(table, on...)) +} + +func (p pushDo) LeftJoin(table schema.Tabler, on ...field.Expr) IPushDo { + return p.withDO(p.DO.LeftJoin(table, on...)) +} + +func (p pushDo) RightJoin(table schema.Tabler, on ...field.Expr) IPushDo { + return p.withDO(p.DO.RightJoin(table, on...)) +} + +func (p pushDo) Group(cols ...field.Expr) IPushDo { + return p.withDO(p.DO.Group(cols...)) +} + +func (p pushDo) Having(conds ...gen.Condition) IPushDo { + return p.withDO(p.DO.Having(conds...)) +} + +func (p pushDo) Limit(limit int) IPushDo { + return p.withDO(p.DO.Limit(limit)) +} + +func (p pushDo) Offset(offset int) IPushDo { + return p.withDO(p.DO.Offset(offset)) +} + +func (p pushDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IPushDo { + return p.withDO(p.DO.Scopes(funcs...)) +} + +func (p pushDo) Unscoped() IPushDo { + return p.withDO(p.DO.Unscoped()) +} + +func (p pushDo) Create(values ...*model.Push) error { + if len(values) == 0 { + return nil + } + return p.DO.Create(values) +} + +func (p pushDo) CreateInBatches(values []*model.Push, batchSize int) error { + return p.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (p pushDo) Save(values ...*model.Push) error { + if len(values) == 0 { + return nil + } + return p.DO.Save(values) +} + +func (p pushDo) First() (*model.Push, error) { + if result, err := p.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Push), nil + } +} + +func (p pushDo) Take() (*model.Push, error) { + if result, err := p.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Push), nil + } +} + +func (p pushDo) Last() (*model.Push, error) { + if result, err := p.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Push), nil + } +} + +func (p pushDo) Find() ([]*model.Push, error) { + result, err := p.DO.Find() + return result.([]*model.Push), err +} + +func (p pushDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Push, err error) { + buf := make([]*model.Push, 0, batchSize) + err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (p pushDo) FindInBatches(result *[]*model.Push, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return p.DO.FindInBatches(result, batchSize, fc) +} + +func (p pushDo) Attrs(attrs ...field.AssignExpr) IPushDo { + return p.withDO(p.DO.Attrs(attrs...)) +} + +func (p pushDo) Assign(attrs ...field.AssignExpr) IPushDo { + return p.withDO(p.DO.Assign(attrs...)) +} + +func (p pushDo) Joins(fields ...field.RelationField) IPushDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Joins(_f)) + } + return &p +} + +func (p pushDo) Preload(fields ...field.RelationField) IPushDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Preload(_f)) + } + return &p +} + +func (p pushDo) FirstOrInit() (*model.Push, error) { + if result, err := p.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Push), nil + } +} + +func (p pushDo) FirstOrCreate() (*model.Push, error) { + if result, err := p.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Push), nil + } +} + +func (p pushDo) FindByPage(offset int, limit int) (result []*model.Push, count int64, err error) { + result, err = p.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = p.Offset(-1).Limit(-1).Count() + return +} + +func (p pushDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = p.Count() + if err != nil { + return + } + + err = p.Offset(offset).Limit(limit).Scan(result) + return +} + +func (p pushDo) Scan(result interface{}) (err error) { + return p.DO.Scan(result) +} + +func (p pushDo) Delete(models ...*model.Push) (result gen.ResultInfo, err error) { + return p.DO.Delete(models) +} + +func (p *pushDo) withDO(do gen.Dao) *pushDo { + p.DO = *do.(*gen.DO) + return p +} diff --git a/internal/app/repository/query/task.gen.go b/internal/app/repository/query/task.gen.go new file mode 100644 index 0000000..50cdf18 --- /dev/null +++ b/internal/app/repository/query/task.gen.go @@ -0,0 +1,426 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "github.com/lzh-1625/go_process_manager/internal/app/model" + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newTask(db *gorm.DB, opts ...gen.DOOption) task { + _task := task{} + + _task.taskDo.UseDB(db, opts...) + _task.taskDo.UseModel(&model.Task{}) + + tableName := _task.taskDo.TableName() + _task.ALL = field.NewAsterisk(tableName) + _task.Id = field.NewInt(tableName, "id") + _task.ProcessId = field.NewInt(tableName, "process_id") + _task.Condition = field.NewInt(tableName, "condition") + _task.NextId = field.NewInt(tableName, "next_id") + _task.Operation = field.NewInt(tableName, "operation") + _task.TriggerEvent = field.NewInt32(tableName, "trigger_event") + _task.TriggerTarget = field.NewInt(tableName, "trigger_target") + _task.OperationTarget = field.NewInt(tableName, "operation_target") + _task.Cron = field.NewString(tableName, "cron") + _task.Enable = field.NewBool(tableName, "enable") + _task.ApiEnable = field.NewBool(tableName, "api_enable") + _task.Key = field.NewString(tableName, "key") + + _task.fillFieldMap() + + return _task +} + +type task struct { + taskDo + + ALL field.Asterisk + Id field.Int + ProcessId field.Int + Condition field.Int + NextId field.Int + Operation field.Int + TriggerEvent field.Int32 + TriggerTarget field.Int + OperationTarget field.Int + Cron field.String + Enable field.Bool + ApiEnable field.Bool + Key field.String + + fieldMap map[string]field.Expr +} + +func (t task) Table(newTableName string) *task { + t.taskDo.UseTable(newTableName) + return t.updateTableName(newTableName) +} + +func (t task) As(alias string) *task { + t.taskDo.DO = *(t.taskDo.As(alias).(*gen.DO)) + return t.updateTableName(alias) +} + +func (t *task) updateTableName(table string) *task { + t.ALL = field.NewAsterisk(table) + t.Id = field.NewInt(table, "id") + t.ProcessId = field.NewInt(table, "process_id") + t.Condition = field.NewInt(table, "condition") + t.NextId = field.NewInt(table, "next_id") + t.Operation = field.NewInt(table, "operation") + t.TriggerEvent = field.NewInt32(table, "trigger_event") + t.TriggerTarget = field.NewInt(table, "trigger_target") + t.OperationTarget = field.NewInt(table, "operation_target") + t.Cron = field.NewString(table, "cron") + t.Enable = field.NewBool(table, "enable") + t.ApiEnable = field.NewBool(table, "api_enable") + t.Key = field.NewString(table, "key") + + t.fillFieldMap() + + return t +} + +func (t *task) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := t.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (t *task) fillFieldMap() { + t.fieldMap = make(map[string]field.Expr, 12) + t.fieldMap["id"] = t.Id + t.fieldMap["process_id"] = t.ProcessId + t.fieldMap["condition"] = t.Condition + t.fieldMap["next_id"] = t.NextId + t.fieldMap["operation"] = t.Operation + t.fieldMap["trigger_event"] = t.TriggerEvent + t.fieldMap["trigger_target"] = t.TriggerTarget + t.fieldMap["operation_target"] = t.OperationTarget + t.fieldMap["cron"] = t.Cron + t.fieldMap["enable"] = t.Enable + t.fieldMap["api_enable"] = t.ApiEnable + t.fieldMap["key"] = t.Key +} + +func (t task) clone(db *gorm.DB) task { + t.taskDo.ReplaceConnPool(db.Statement.ConnPool) + return t +} + +func (t task) replaceDB(db *gorm.DB) task { + t.taskDo.ReplaceDB(db) + return t +} + +type taskDo struct{ gen.DO } + +type ITaskDo interface { + gen.SubQuery + Debug() ITaskDo + WithContext(ctx context.Context) ITaskDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() ITaskDo + WriteDB() ITaskDo + As(alias string) gen.Dao + Session(config *gorm.Session) ITaskDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) ITaskDo + Not(conds ...gen.Condition) ITaskDo + Or(conds ...gen.Condition) ITaskDo + Select(conds ...field.Expr) ITaskDo + Where(conds ...gen.Condition) ITaskDo + Order(conds ...field.Expr) ITaskDo + Distinct(cols ...field.Expr) ITaskDo + Omit(cols ...field.Expr) ITaskDo + Join(table schema.Tabler, on ...field.Expr) ITaskDo + LeftJoin(table schema.Tabler, on ...field.Expr) ITaskDo + RightJoin(table schema.Tabler, on ...field.Expr) ITaskDo + Group(cols ...field.Expr) ITaskDo + Having(conds ...gen.Condition) ITaskDo + Limit(limit int) ITaskDo + Offset(offset int) ITaskDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) ITaskDo + Unscoped() ITaskDo + Create(values ...*model.Task) error + CreateInBatches(values []*model.Task, batchSize int) error + Save(values ...*model.Task) error + First() (*model.Task, error) + Take() (*model.Task, error) + Last() (*model.Task, error) + Find() ([]*model.Task, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Task, err error) + FindInBatches(result *[]*model.Task, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Task) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) ITaskDo + Assign(attrs ...field.AssignExpr) ITaskDo + Joins(fields ...field.RelationField) ITaskDo + Preload(fields ...field.RelationField) ITaskDo + FirstOrInit() (*model.Task, error) + FirstOrCreate() (*model.Task, error) + FindByPage(offset int, limit int) (result []*model.Task, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) ITaskDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (t taskDo) Debug() ITaskDo { + return t.withDO(t.DO.Debug()) +} + +func (t taskDo) WithContext(ctx context.Context) ITaskDo { + return t.withDO(t.DO.WithContext(ctx)) +} + +func (t taskDo) ReadDB() ITaskDo { + return t.Clauses(dbresolver.Read) +} + +func (t taskDo) WriteDB() ITaskDo { + return t.Clauses(dbresolver.Write) +} + +func (t taskDo) Session(config *gorm.Session) ITaskDo { + return t.withDO(t.DO.Session(config)) +} + +func (t taskDo) Clauses(conds ...clause.Expression) ITaskDo { + return t.withDO(t.DO.Clauses(conds...)) +} + +func (t taskDo) Returning(value interface{}, columns ...string) ITaskDo { + return t.withDO(t.DO.Returning(value, columns...)) +} + +func (t taskDo) Not(conds ...gen.Condition) ITaskDo { + return t.withDO(t.DO.Not(conds...)) +} + +func (t taskDo) Or(conds ...gen.Condition) ITaskDo { + return t.withDO(t.DO.Or(conds...)) +} + +func (t taskDo) Select(conds ...field.Expr) ITaskDo { + return t.withDO(t.DO.Select(conds...)) +} + +func (t taskDo) Where(conds ...gen.Condition) ITaskDo { + return t.withDO(t.DO.Where(conds...)) +} + +func (t taskDo) Order(conds ...field.Expr) ITaskDo { + return t.withDO(t.DO.Order(conds...)) +} + +func (t taskDo) Distinct(cols ...field.Expr) ITaskDo { + return t.withDO(t.DO.Distinct(cols...)) +} + +func (t taskDo) Omit(cols ...field.Expr) ITaskDo { + return t.withDO(t.DO.Omit(cols...)) +} + +func (t taskDo) Join(table schema.Tabler, on ...field.Expr) ITaskDo { + return t.withDO(t.DO.Join(table, on...)) +} + +func (t taskDo) LeftJoin(table schema.Tabler, on ...field.Expr) ITaskDo { + return t.withDO(t.DO.LeftJoin(table, on...)) +} + +func (t taskDo) RightJoin(table schema.Tabler, on ...field.Expr) ITaskDo { + return t.withDO(t.DO.RightJoin(table, on...)) +} + +func (t taskDo) Group(cols ...field.Expr) ITaskDo { + return t.withDO(t.DO.Group(cols...)) +} + +func (t taskDo) Having(conds ...gen.Condition) ITaskDo { + return t.withDO(t.DO.Having(conds...)) +} + +func (t taskDo) Limit(limit int) ITaskDo { + return t.withDO(t.DO.Limit(limit)) +} + +func (t taskDo) Offset(offset int) ITaskDo { + return t.withDO(t.DO.Offset(offset)) +} + +func (t taskDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ITaskDo { + return t.withDO(t.DO.Scopes(funcs...)) +} + +func (t taskDo) Unscoped() ITaskDo { + return t.withDO(t.DO.Unscoped()) +} + +func (t taskDo) Create(values ...*model.Task) error { + if len(values) == 0 { + return nil + } + return t.DO.Create(values) +} + +func (t taskDo) CreateInBatches(values []*model.Task, batchSize int) error { + return t.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (t taskDo) Save(values ...*model.Task) error { + if len(values) == 0 { + return nil + } + return t.DO.Save(values) +} + +func (t taskDo) First() (*model.Task, error) { + if result, err := t.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Task), nil + } +} + +func (t taskDo) Take() (*model.Task, error) { + if result, err := t.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Task), nil + } +} + +func (t taskDo) Last() (*model.Task, error) { + if result, err := t.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Task), nil + } +} + +func (t taskDo) Find() ([]*model.Task, error) { + result, err := t.DO.Find() + return result.([]*model.Task), err +} + +func (t taskDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Task, err error) { + buf := make([]*model.Task, 0, batchSize) + err = t.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (t taskDo) FindInBatches(result *[]*model.Task, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return t.DO.FindInBatches(result, batchSize, fc) +} + +func (t taskDo) Attrs(attrs ...field.AssignExpr) ITaskDo { + return t.withDO(t.DO.Attrs(attrs...)) +} + +func (t taskDo) Assign(attrs ...field.AssignExpr) ITaskDo { + return t.withDO(t.DO.Assign(attrs...)) +} + +func (t taskDo) Joins(fields ...field.RelationField) ITaskDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Joins(_f)) + } + return &t +} + +func (t taskDo) Preload(fields ...field.RelationField) ITaskDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Preload(_f)) + } + return &t +} + +func (t taskDo) FirstOrInit() (*model.Task, error) { + if result, err := t.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Task), nil + } +} + +func (t taskDo) FirstOrCreate() (*model.Task, error) { + if result, err := t.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Task), nil + } +} + +func (t taskDo) FindByPage(offset int, limit int) (result []*model.Task, count int64, err error) { + result, err = t.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = t.Offset(-1).Limit(-1).Count() + return +} + +func (t taskDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = t.Count() + if err != nil { + return + } + + err = t.Offset(offset).Limit(limit).Scan(result) + return +} + +func (t taskDo) Scan(result interface{}) (err error) { + return t.DO.Scan(result) +} + +func (t taskDo) Delete(models ...*model.Task) (result gen.ResultInfo, err error) { + return t.DO.Delete(models) +} + +func (t *taskDo) withDO(do gen.Dao) *taskDo { + t.DO = *do.(*gen.DO) + return t +} diff --git a/internal/app/repository/query/users.gen.go b/internal/app/repository/query/users.gen.go new file mode 100644 index 0000000..2eeb847 --- /dev/null +++ b/internal/app/repository/query/users.gen.go @@ -0,0 +1,398 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "github.com/lzh-1625/go_process_manager/internal/app/model" + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newUser(db *gorm.DB, opts ...gen.DOOption) user { + _user := user{} + + _user.userDo.UseDB(db, opts...) + _user.userDo.UseModel(&model.User{}) + + tableName := _user.userDo.TableName() + _user.ALL = field.NewAsterisk(tableName) + _user.Account = field.NewString(tableName, "account") + _user.Password = field.NewString(tableName, "password") + _user.Role = field.NewInt(tableName, "role") + _user.CreateTime = field.NewTime(tableName, "create_time") + _user.Remark = field.NewString(tableName, "remark") + + _user.fillFieldMap() + + return _user +} + +type user struct { + userDo + + ALL field.Asterisk + Account field.String + Password field.String + Role field.Int + CreateTime field.Time + Remark field.String + + fieldMap map[string]field.Expr +} + +func (u user) Table(newTableName string) *user { + u.userDo.UseTable(newTableName) + return u.updateTableName(newTableName) +} + +func (u user) As(alias string) *user { + u.userDo.DO = *(u.userDo.As(alias).(*gen.DO)) + return u.updateTableName(alias) +} + +func (u *user) updateTableName(table string) *user { + u.ALL = field.NewAsterisk(table) + u.Account = field.NewString(table, "account") + u.Password = field.NewString(table, "password") + u.Role = field.NewInt(table, "role") + u.CreateTime = field.NewTime(table, "create_time") + u.Remark = field.NewString(table, "remark") + + u.fillFieldMap() + + return u +} + +func (u *user) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := u.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (u *user) fillFieldMap() { + u.fieldMap = make(map[string]field.Expr, 5) + u.fieldMap["account"] = u.Account + u.fieldMap["password"] = u.Password + u.fieldMap["role"] = u.Role + u.fieldMap["create_time"] = u.CreateTime + u.fieldMap["remark"] = u.Remark +} + +func (u user) clone(db *gorm.DB) user { + u.userDo.ReplaceConnPool(db.Statement.ConnPool) + return u +} + +func (u user) replaceDB(db *gorm.DB) user { + u.userDo.ReplaceDB(db) + return u +} + +type userDo struct{ gen.DO } + +type IUserDo interface { + gen.SubQuery + Debug() IUserDo + WithContext(ctx context.Context) IUserDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IUserDo + WriteDB() IUserDo + As(alias string) gen.Dao + Session(config *gorm.Session) IUserDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IUserDo + Not(conds ...gen.Condition) IUserDo + Or(conds ...gen.Condition) IUserDo + Select(conds ...field.Expr) IUserDo + Where(conds ...gen.Condition) IUserDo + Order(conds ...field.Expr) IUserDo + Distinct(cols ...field.Expr) IUserDo + Omit(cols ...field.Expr) IUserDo + Join(table schema.Tabler, on ...field.Expr) IUserDo + LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo + RightJoin(table schema.Tabler, on ...field.Expr) IUserDo + Group(cols ...field.Expr) IUserDo + Having(conds ...gen.Condition) IUserDo + Limit(limit int) IUserDo + Offset(offset int) IUserDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo + Unscoped() IUserDo + Create(values ...*model.User) error + CreateInBatches(values []*model.User, batchSize int) error + Save(values ...*model.User) error + First() (*model.User, error) + Take() (*model.User, error) + Last() (*model.User, error) + Find() ([]*model.User, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error) + FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.User) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IUserDo + Assign(attrs ...field.AssignExpr) IUserDo + Joins(fields ...field.RelationField) IUserDo + Preload(fields ...field.RelationField) IUserDo + FirstOrInit() (*model.User, error) + FirstOrCreate() (*model.User, error) + FindByPage(offset int, limit int) (result []*model.User, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IUserDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (u userDo) Debug() IUserDo { + return u.withDO(u.DO.Debug()) +} + +func (u userDo) WithContext(ctx context.Context) IUserDo { + return u.withDO(u.DO.WithContext(ctx)) +} + +func (u userDo) ReadDB() IUserDo { + return u.Clauses(dbresolver.Read) +} + +func (u userDo) WriteDB() IUserDo { + return u.Clauses(dbresolver.Write) +} + +func (u userDo) Session(config *gorm.Session) IUserDo { + return u.withDO(u.DO.Session(config)) +} + +func (u userDo) Clauses(conds ...clause.Expression) IUserDo { + return u.withDO(u.DO.Clauses(conds...)) +} + +func (u userDo) Returning(value interface{}, columns ...string) IUserDo { + return u.withDO(u.DO.Returning(value, columns...)) +} + +func (u userDo) Not(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Not(conds...)) +} + +func (u userDo) Or(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Or(conds...)) +} + +func (u userDo) Select(conds ...field.Expr) IUserDo { + return u.withDO(u.DO.Select(conds...)) +} + +func (u userDo) Where(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Where(conds...)) +} + +func (u userDo) Order(conds ...field.Expr) IUserDo { + return u.withDO(u.DO.Order(conds...)) +} + +func (u userDo) Distinct(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Distinct(cols...)) +} + +func (u userDo) Omit(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Omit(cols...)) +} + +func (u userDo) Join(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.Join(table, on...)) +} + +func (u userDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.LeftJoin(table, on...)) +} + +func (u userDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.RightJoin(table, on...)) +} + +func (u userDo) Group(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Group(cols...)) +} + +func (u userDo) Having(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Having(conds...)) +} + +func (u userDo) Limit(limit int) IUserDo { + return u.withDO(u.DO.Limit(limit)) +} + +func (u userDo) Offset(offset int) IUserDo { + return u.withDO(u.DO.Offset(offset)) +} + +func (u userDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo { + return u.withDO(u.DO.Scopes(funcs...)) +} + +func (u userDo) Unscoped() IUserDo { + return u.withDO(u.DO.Unscoped()) +} + +func (u userDo) Create(values ...*model.User) error { + if len(values) == 0 { + return nil + } + return u.DO.Create(values) +} + +func (u userDo) CreateInBatches(values []*model.User, batchSize int) error { + return u.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (u userDo) Save(values ...*model.User) error { + if len(values) == 0 { + return nil + } + return u.DO.Save(values) +} + +func (u userDo) First() (*model.User, error) { + if result, err := u.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Take() (*model.User, error) { + if result, err := u.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Last() (*model.User, error) { + if result, err := u.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Find() ([]*model.User, error) { + result, err := u.DO.Find() + return result.([]*model.User), err +} + +func (u userDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error) { + buf := make([]*model.User, 0, batchSize) + err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (u userDo) FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return u.DO.FindInBatches(result, batchSize, fc) +} + +func (u userDo) Attrs(attrs ...field.AssignExpr) IUserDo { + return u.withDO(u.DO.Attrs(attrs...)) +} + +func (u userDo) Assign(attrs ...field.AssignExpr) IUserDo { + return u.withDO(u.DO.Assign(attrs...)) +} + +func (u userDo) Joins(fields ...field.RelationField) IUserDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Joins(_f)) + } + return &u +} + +func (u userDo) Preload(fields ...field.RelationField) IUserDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Preload(_f)) + } + return &u +} + +func (u userDo) FirstOrInit() (*model.User, error) { + if result, err := u.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) FirstOrCreate() (*model.User, error) { + if result, err := u.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) FindByPage(offset int, limit int) (result []*model.User, count int64, err error) { + result, err = u.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = u.Offset(-1).Limit(-1).Count() + return +} + +func (u userDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = u.Count() + if err != nil { + return + } + + err = u.Offset(offset).Limit(limit).Scan(result) + return +} + +func (u userDo) Scan(result interface{}) (err error) { + return u.DO.Scan(result) +} + +func (u userDo) Delete(models ...*model.User) (result gen.ResultInfo, err error) { + return u.DO.Delete(models) +} + +func (u *userDo) withDO(do gen.Dao) *userDo { + u.DO = *do.(*gen.DO) + return u +} diff --git a/internal/app/repository/query/ws_shares.gen.go b/internal/app/repository/query/ws_shares.gen.go new file mode 100644 index 0000000..989e498 --- /dev/null +++ b/internal/app/repository/query/ws_shares.gen.go @@ -0,0 +1,402 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "github.com/lzh-1625/go_process_manager/internal/app/model" + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newWsShare(db *gorm.DB, opts ...gen.DOOption) wsShare { + _wsShare := wsShare{} + + _wsShare.wsShareDo.UseDB(db, opts...) + _wsShare.wsShareDo.UseModel(&model.WsShare{}) + + tableName := _wsShare.wsShareDo.TableName() + _wsShare.ALL = field.NewAsterisk(tableName) + _wsShare.Id = field.NewInt(tableName, "id") + _wsShare.Pid = field.NewInt(tableName, "pid") + _wsShare.Write = field.NewBool(tableName, "write") + _wsShare.ExpireTime = field.NewTime(tableName, "expire_time") + _wsShare.CreateBy = field.NewString(tableName, "create_by") + _wsShare.Token = field.NewString(tableName, "token") + + _wsShare.fillFieldMap() + + return _wsShare +} + +type wsShare struct { + wsShareDo + + ALL field.Asterisk + Id field.Int + Pid field.Int + Write field.Bool + ExpireTime field.Time + CreateBy field.String + Token field.String + + fieldMap map[string]field.Expr +} + +func (w wsShare) Table(newTableName string) *wsShare { + w.wsShareDo.UseTable(newTableName) + return w.updateTableName(newTableName) +} + +func (w wsShare) As(alias string) *wsShare { + w.wsShareDo.DO = *(w.wsShareDo.As(alias).(*gen.DO)) + return w.updateTableName(alias) +} + +func (w *wsShare) updateTableName(table string) *wsShare { + w.ALL = field.NewAsterisk(table) + w.Id = field.NewInt(table, "id") + w.Pid = field.NewInt(table, "pid") + w.Write = field.NewBool(table, "write") + w.ExpireTime = field.NewTime(table, "expire_time") + w.CreateBy = field.NewString(table, "create_by") + w.Token = field.NewString(table, "token") + + w.fillFieldMap() + + return w +} + +func (w *wsShare) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := w.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (w *wsShare) fillFieldMap() { + w.fieldMap = make(map[string]field.Expr, 6) + w.fieldMap["id"] = w.Id + w.fieldMap["pid"] = w.Pid + w.fieldMap["write"] = w.Write + w.fieldMap["expire_time"] = w.ExpireTime + w.fieldMap["create_by"] = w.CreateBy + w.fieldMap["token"] = w.Token +} + +func (w wsShare) clone(db *gorm.DB) wsShare { + w.wsShareDo.ReplaceConnPool(db.Statement.ConnPool) + return w +} + +func (w wsShare) replaceDB(db *gorm.DB) wsShare { + w.wsShareDo.ReplaceDB(db) + return w +} + +type wsShareDo struct{ gen.DO } + +type IWsShareDo interface { + gen.SubQuery + Debug() IWsShareDo + WithContext(ctx context.Context) IWsShareDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IWsShareDo + WriteDB() IWsShareDo + As(alias string) gen.Dao + Session(config *gorm.Session) IWsShareDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IWsShareDo + Not(conds ...gen.Condition) IWsShareDo + Or(conds ...gen.Condition) IWsShareDo + Select(conds ...field.Expr) IWsShareDo + Where(conds ...gen.Condition) IWsShareDo + Order(conds ...field.Expr) IWsShareDo + Distinct(cols ...field.Expr) IWsShareDo + Omit(cols ...field.Expr) IWsShareDo + Join(table schema.Tabler, on ...field.Expr) IWsShareDo + LeftJoin(table schema.Tabler, on ...field.Expr) IWsShareDo + RightJoin(table schema.Tabler, on ...field.Expr) IWsShareDo + Group(cols ...field.Expr) IWsShareDo + Having(conds ...gen.Condition) IWsShareDo + Limit(limit int) IWsShareDo + Offset(offset int) IWsShareDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IWsShareDo + Unscoped() IWsShareDo + Create(values ...*model.WsShare) error + CreateInBatches(values []*model.WsShare, batchSize int) error + Save(values ...*model.WsShare) error + First() (*model.WsShare, error) + Take() (*model.WsShare, error) + Last() (*model.WsShare, error) + Find() ([]*model.WsShare, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.WsShare, err error) + FindInBatches(result *[]*model.WsShare, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.WsShare) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IWsShareDo + Assign(attrs ...field.AssignExpr) IWsShareDo + Joins(fields ...field.RelationField) IWsShareDo + Preload(fields ...field.RelationField) IWsShareDo + FirstOrInit() (*model.WsShare, error) + FirstOrCreate() (*model.WsShare, error) + FindByPage(offset int, limit int) (result []*model.WsShare, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IWsShareDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (w wsShareDo) Debug() IWsShareDo { + return w.withDO(w.DO.Debug()) +} + +func (w wsShareDo) WithContext(ctx context.Context) IWsShareDo { + return w.withDO(w.DO.WithContext(ctx)) +} + +func (w wsShareDo) ReadDB() IWsShareDo { + return w.Clauses(dbresolver.Read) +} + +func (w wsShareDo) WriteDB() IWsShareDo { + return w.Clauses(dbresolver.Write) +} + +func (w wsShareDo) Session(config *gorm.Session) IWsShareDo { + return w.withDO(w.DO.Session(config)) +} + +func (w wsShareDo) Clauses(conds ...clause.Expression) IWsShareDo { + return w.withDO(w.DO.Clauses(conds...)) +} + +func (w wsShareDo) Returning(value interface{}, columns ...string) IWsShareDo { + return w.withDO(w.DO.Returning(value, columns...)) +} + +func (w wsShareDo) Not(conds ...gen.Condition) IWsShareDo { + return w.withDO(w.DO.Not(conds...)) +} + +func (w wsShareDo) Or(conds ...gen.Condition) IWsShareDo { + return w.withDO(w.DO.Or(conds...)) +} + +func (w wsShareDo) Select(conds ...field.Expr) IWsShareDo { + return w.withDO(w.DO.Select(conds...)) +} + +func (w wsShareDo) Where(conds ...gen.Condition) IWsShareDo { + return w.withDO(w.DO.Where(conds...)) +} + +func (w wsShareDo) Order(conds ...field.Expr) IWsShareDo { + return w.withDO(w.DO.Order(conds...)) +} + +func (w wsShareDo) Distinct(cols ...field.Expr) IWsShareDo { + return w.withDO(w.DO.Distinct(cols...)) +} + +func (w wsShareDo) Omit(cols ...field.Expr) IWsShareDo { + return w.withDO(w.DO.Omit(cols...)) +} + +func (w wsShareDo) Join(table schema.Tabler, on ...field.Expr) IWsShareDo { + return w.withDO(w.DO.Join(table, on...)) +} + +func (w wsShareDo) LeftJoin(table schema.Tabler, on ...field.Expr) IWsShareDo { + return w.withDO(w.DO.LeftJoin(table, on...)) +} + +func (w wsShareDo) RightJoin(table schema.Tabler, on ...field.Expr) IWsShareDo { + return w.withDO(w.DO.RightJoin(table, on...)) +} + +func (w wsShareDo) Group(cols ...field.Expr) IWsShareDo { + return w.withDO(w.DO.Group(cols...)) +} + +func (w wsShareDo) Having(conds ...gen.Condition) IWsShareDo { + return w.withDO(w.DO.Having(conds...)) +} + +func (w wsShareDo) Limit(limit int) IWsShareDo { + return w.withDO(w.DO.Limit(limit)) +} + +func (w wsShareDo) Offset(offset int) IWsShareDo { + return w.withDO(w.DO.Offset(offset)) +} + +func (w wsShareDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IWsShareDo { + return w.withDO(w.DO.Scopes(funcs...)) +} + +func (w wsShareDo) Unscoped() IWsShareDo { + return w.withDO(w.DO.Unscoped()) +} + +func (w wsShareDo) Create(values ...*model.WsShare) error { + if len(values) == 0 { + return nil + } + return w.DO.Create(values) +} + +func (w wsShareDo) CreateInBatches(values []*model.WsShare, batchSize int) error { + return w.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (w wsShareDo) Save(values ...*model.WsShare) error { + if len(values) == 0 { + return nil + } + return w.DO.Save(values) +} + +func (w wsShareDo) First() (*model.WsShare, error) { + if result, err := w.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.WsShare), nil + } +} + +func (w wsShareDo) Take() (*model.WsShare, error) { + if result, err := w.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.WsShare), nil + } +} + +func (w wsShareDo) Last() (*model.WsShare, error) { + if result, err := w.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.WsShare), nil + } +} + +func (w wsShareDo) Find() ([]*model.WsShare, error) { + result, err := w.DO.Find() + return result.([]*model.WsShare), err +} + +func (w wsShareDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.WsShare, err error) { + buf := make([]*model.WsShare, 0, batchSize) + err = w.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (w wsShareDo) FindInBatches(result *[]*model.WsShare, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return w.DO.FindInBatches(result, batchSize, fc) +} + +func (w wsShareDo) Attrs(attrs ...field.AssignExpr) IWsShareDo { + return w.withDO(w.DO.Attrs(attrs...)) +} + +func (w wsShareDo) Assign(attrs ...field.AssignExpr) IWsShareDo { + return w.withDO(w.DO.Assign(attrs...)) +} + +func (w wsShareDo) Joins(fields ...field.RelationField) IWsShareDo { + for _, _f := range fields { + w = *w.withDO(w.DO.Joins(_f)) + } + return &w +} + +func (w wsShareDo) Preload(fields ...field.RelationField) IWsShareDo { + for _, _f := range fields { + w = *w.withDO(w.DO.Preload(_f)) + } + return &w +} + +func (w wsShareDo) FirstOrInit() (*model.WsShare, error) { + if result, err := w.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.WsShare), nil + } +} + +func (w wsShareDo) FirstOrCreate() (*model.WsShare, error) { + if result, err := w.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.WsShare), nil + } +} + +func (w wsShareDo) FindByPage(offset int, limit int) (result []*model.WsShare, count int64, err error) { + result, err = w.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = w.Offset(-1).Limit(-1).Count() + return +} + +func (w wsShareDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = w.Count() + if err != nil { + return + } + + err = w.Offset(offset).Limit(limit).Scan(result) + return +} + +func (w wsShareDo) Scan(result interface{}) (err error) { + return w.DO.Scan(result) +} + +func (w wsShareDo) Delete(models ...*model.WsShare) (result gen.ResultInfo, err error) { + return w.DO.Delete(models) +} + +func (w *wsShareDo) withDO(do gen.Dao) *wsShareDo { + w.DO = *do.(*gen.DO) + return w +} diff --git a/internal/app/repository/task.go b/internal/app/repository/task.go index 94bedec..a96b42f 100644 --- a/internal/app/repository/task.go +++ b/internal/app/repository/task.go @@ -5,6 +5,7 @@ import ( "github.com/lzh-1625/go_process_manager/internal/app/constants" "github.com/lzh-1625/go_process_manager/internal/app/model" + "github.com/lzh-1625/go_process_manager/internal/app/repository/query" "gorm.io/gorm" ) @@ -50,12 +51,7 @@ func (t *taskRepository) EditTask(data model.Task) (err error) { } func (t *taskRepository) EditTaskEnable(id int, enable bool) (err error) { - err = db.Model(&model.Task{}).Where(&model.Task{Id: id}).First(&model.Task{}).Error - if errors.Is(err, gorm.ErrRecordNotFound) { - return err - } - - err = db.Model(&model.Task{}).Where(&model.Task{Id: id}).Update("enable", enable).Error + _, err = query.Task.Where(query.Task.Id.Eq(id)).Update(query.Task.Enable, enable) return } @@ -67,6 +63,6 @@ func (t *taskRepository) GetAllTaskWithProcessName() (result []model.TaskVo) { func (t *taskRepository) GetTriggerTask(processName string, event constants.ProcessState) []model.Task { result := []model.Task{} - db.Raw(`SELECT task.* FROM task left join process p on p.uuid == task.trigger_target WHERE trigger_event= ? AND p.name = ?`, event, processName).Scan(&result) + query.Task.Select(query.Task.ALL).LeftJoin(query.Process, query.Process.Uuid.EqCol(query.Task.TriggerTarget)).Where(query.Process.Name.Eq(processName)).Where(query.Task.TriggerEvent.Eq(int32(event))).Scan(result) return result } diff --git a/internal/app/repository/ws_share.go b/internal/app/repository/ws_share.go index 90cf4ac..16d8986 100644 --- a/internal/app/repository/ws_share.go +++ b/internal/app/repository/ws_share.go @@ -1,13 +1,16 @@ package repository -import "github.com/lzh-1625/go_process_manager/internal/app/model" +import ( + "github.com/lzh-1625/go_process_manager/internal/app/model" + "github.com/lzh-1625/go_process_manager/internal/app/repository/query" +) type wsShare struct{} var WsShare = new(wsShare) -func (p *wsShare) GetWsShareDataByToken(token string) (data model.WsShare, err error) { - err = db.Model(&model.WsShare{}).Where("token = ?", token).First(&data).Error +func (p *wsShare) GetWsShareDataByToken(token string) (data *model.WsShare, err error) { + data, err = query.WsShare.Where(query.WsShare.Token.Eq(token)).First() return }