From baf4c67cfb9212b2cac96bf345d38137fa9f9678 Mon Sep 17 00:00:00 2001 From: gogacoder Date: Sun, 9 Mar 2025 21:51:16 +0700 Subject: [PATCH] feat: entities --- .../bindings/app/internal/models/models.ts | 105 ++- .../app/internal/services/authorservice.ts | 8 +- .../app/internal/services/commentservice.ts | 65 ++ .../bindings/app/internal/services/index.ts | 6 +- .../bindings/app/internal/services/models.ts | 6 + .../app/internal/services/postservice.ts | 8 +- .../app/internal/services/posttypeservice.ts | 65 ++ internal/dal/authors.gen.go | 136 +++- internal/dal/comments.gen.go | 622 ++++++++++++++++++ internal/dal/comments.gen_test.go | 145 ++++ internal/dal/gen.go | 52 +- internal/dal/gen_test.go | 2 + internal/dal/post_types.gen.go | 383 +++++++++++ internal/dal/post_types.gen_test.go | 145 ++++ internal/dal/posts.gen.go | 236 ++++++- internal/models/models.go | 34 +- internal/services/comment.go | 66 ++ internal/services/default_data.go | 69 +- internal/services/post.go | 17 + internal/services/posttype.go | 61 ++ internal/services/services.go | 2 + 21 files changed, 2171 insertions(+), 62 deletions(-) create mode 100644 frontend/bindings/app/internal/services/commentservice.ts create mode 100644 frontend/bindings/app/internal/services/posttypeservice.ts create mode 100644 internal/dal/comments.gen.go create mode 100644 internal/dal/comments.gen_test.go create mode 100644 internal/dal/post_types.gen.go create mode 100644 internal/dal/post_types.gen_test.go create mode 100644 internal/services/comment.go create mode 100644 internal/services/posttype.go diff --git a/frontend/bindings/app/internal/models/models.ts b/frontend/bindings/app/internal/models/models.ts index b3174ba..97c7442 100644 --- a/frontend/bindings/app/internal/models/models.ts +++ b/frontend/bindings/app/internal/models/models.ts @@ -9,6 +9,7 @@ export class Author { "Id": number; "Name": string; "Posts": Post[]; + "Comments": Comment[]; /** Creates a new Author instance. */ constructor($$source: Partial = {}) { @@ -21,6 +22,9 @@ export class Author { if (!("Posts" in $$source)) { this["Posts"] = []; } + if (!("Comments" in $$source)) { + this["Comments"] = []; + } Object.assign(this, $$source); } @@ -30,14 +34,63 @@ export class Author { */ static createFrom($$source: any = {}): Author { const $$createField2_0 = $$createType1; + const $$createField3_0 = $$createType3; let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source; if ("Posts" in $$parsedSource) { $$parsedSource["Posts"] = $$createField2_0($$parsedSource["Posts"]); } + if ("Comments" in $$parsedSource) { + $$parsedSource["Comments"] = $$createField3_0($$parsedSource["Comments"]); + } return new Author($$parsedSource as Partial); } } +export class Comment { + "Id": number; + "Text": string; + "AuthorId": number; + "Author": Author; + "Posts": Post[]; + + /** Creates a new Comment instance. */ + constructor($$source: Partial = {}) { + if (!("Id" in $$source)) { + this["Id"] = 0; + } + if (!("Text" in $$source)) { + this["Text"] = ""; + } + if (!("AuthorId" in $$source)) { + this["AuthorId"] = 0; + } + if (!("Author" in $$source)) { + this["Author"] = (new Author()); + } + if (!("Posts" in $$source)) { + this["Posts"] = []; + } + + Object.assign(this, $$source); + } + + /** + * Creates a new Comment instance from a string or object. + */ + static createFrom($$source: any = {}): Comment { + const $$createField3_0 = $$createType4; + const $$createField4_0 = $$createType1; + let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source; + if ("Author" in $$parsedSource) { + $$parsedSource["Author"] = $$createField3_0($$parsedSource["Author"]); + } + if ("Posts" in $$parsedSource) { + $$parsedSource["Posts"] = $$createField4_0($$parsedSource["Posts"]); + } + return new Comment($$parsedSource as Partial); + } +} + export class Post { "Id": number; "Text": string; @@ -45,6 +98,9 @@ export class Post { "CreatedAt": number; "AuthorId": number; "Author": Author; + "PostTypeId": number; + "PostType": PostType; + "Comments": Comment[]; /** Creates a new Post instance. */ constructor($$source: Partial = {}) { @@ -66,6 +122,15 @@ export class Post { if (!("Author" in $$source)) { this["Author"] = (new Author()); } + if (!("PostTypeId" in $$source)) { + this["PostTypeId"] = 0; + } + if (!("PostType" in $$source)) { + this["PostType"] = (new PostType()); + } + if (!("Comments" in $$source)) { + this["Comments"] = []; + } Object.assign(this, $$source); } @@ -74,16 +139,52 @@ export class Post { * Creates a new Post instance from a string or object. */ static createFrom($$source: any = {}): Post { - const $$createField5_0 = $$createType2; + const $$createField5_0 = $$createType4; + const $$createField7_0 = $$createType5; + const $$createField8_0 = $$createType3; let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source; if ("Author" in $$parsedSource) { $$parsedSource["Author"] = $$createField5_0($$parsedSource["Author"]); } + if ("PostType" in $$parsedSource) { + $$parsedSource["PostType"] = $$createField7_0($$parsedSource["PostType"]); + } + if ("Comments" in $$parsedSource) { + $$parsedSource["Comments"] = $$createField8_0($$parsedSource["Comments"]); + } return new Post($$parsedSource as Partial); } } +export class PostType { + "Id": number; + "Name": string; + + /** Creates a new PostType instance. */ + constructor($$source: Partial = {}) { + if (!("Id" in $$source)) { + this["Id"] = 0; + } + if (!("Name" in $$source)) { + this["Name"] = ""; + } + + Object.assign(this, $$source); + } + + /** + * Creates a new PostType instance from a string or object. + */ + static createFrom($$source: any = {}): PostType { + let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source; + return new PostType($$parsedSource as Partial); + } +} + // Private type creation functions const $$createType0 = Post.createFrom; const $$createType1 = $Create.Array($$createType0); -const $$createType2 = Author.createFrom; +const $$createType2 = Comment.createFrom; +const $$createType3 = $Create.Array($$createType2); +const $$createType4 = Author.createFrom; +const $$createType5 = PostType.createFrom; diff --git a/frontend/bindings/app/internal/services/authorservice.ts b/frontend/bindings/app/internal/services/authorservice.ts index b6380f1..6ec3d81 100644 --- a/frontend/bindings/app/internal/services/authorservice.ts +++ b/frontend/bindings/app/internal/services/authorservice.ts @@ -20,7 +20,7 @@ export function Count(): Promise & { cancel(): void } { export function Create(item: $models.Author): Promise<$models.Author> & { cancel(): void } { let $resultPromise = $Call.ByID(3684602449, item) as any; - let $typingPromise = $resultPromise.then(($result: any) => { + let $typingPromise = $resultPromise.then(($result) => { return $$createType0($result); }) as any; $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); @@ -34,7 +34,7 @@ export function Delete(id: number): Promise & { cancel(): void } { export function GetAll(): Promise<($models.Author | null)[]> & { cancel(): void } { let $resultPromise = $Call.ByID(3248293926) as any; - let $typingPromise = $resultPromise.then(($result: any) => { + let $typingPromise = $resultPromise.then(($result) => { return $$createType2($result); }) as any; $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); @@ -43,7 +43,7 @@ export function GetAll(): Promise<($models.Author | null)[]> & { cancel(): void export function GetById(id: number): Promise<$models.Author | null> & { cancel(): void } { let $resultPromise = $Call.ByID(1703016211, id) as any; - let $typingPromise = $resultPromise.then(($result: any) => { + let $typingPromise = $resultPromise.then(($result) => { return $$createType1($result); }) as any; $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); @@ -52,7 +52,7 @@ export function GetById(id: number): Promise<$models.Author | null> & { cancel() export function Update(item: $models.Author): Promise<$models.Author> & { cancel(): void } { let $resultPromise = $Call.ByID(2240704960, item) as any; - let $typingPromise = $resultPromise.then(($result: any) => { + let $typingPromise = $resultPromise.then(($result) => { return $$createType0($result); }) as any; $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); diff --git a/frontend/bindings/app/internal/services/commentservice.ts b/frontend/bindings/app/internal/services/commentservice.ts new file mode 100644 index 0000000..cce718b --- /dev/null +++ b/frontend/bindings/app/internal/services/commentservice.ts @@ -0,0 +1,65 @@ +// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL +// This file is automatically generated. DO NOT EDIT + +// eslint-disable-next-line @typescript-eslint/ban-ts-comment +// @ts-ignore: Unused imports +import {Call as $Call, Create as $Create} from "@wailsio/runtime"; + +// eslint-disable-next-line @typescript-eslint/ban-ts-comment +// @ts-ignore: Unused imports +import * as models$0 from "../models/models.js"; + +// eslint-disable-next-line @typescript-eslint/ban-ts-comment +// @ts-ignore: Unused imports +import * as $models from "./models.js"; + +export function Count(): Promise & { cancel(): void } { + let $resultPromise = $Call.ByID(3225397984) as any; + return $resultPromise; +} + +export function Create(item: $models.Comment): Promise<$models.Comment> & { cancel(): void } { + let $resultPromise = $Call.ByID(4239106089, item) as any; + let $typingPromise = $resultPromise.then(($result) => { + return $$createType0($result); + }) as any; + $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); + return $typingPromise; +} + +export function Delete(id: number): Promise & { cancel(): void } { + let $resultPromise = $Call.ByID(2553503582, id) as any; + return $resultPromise; +} + +export function GetAll(): Promise<($models.Comment | null)[]> & { cancel(): void } { + let $resultPromise = $Call.ByID(1805763390) as any; + let $typingPromise = $resultPromise.then(($result) => { + return $$createType2($result); + }) as any; + $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); + return $typingPromise; +} + +export function GetById(id: number): Promise<$models.Comment | null> & { cancel(): void } { + let $resultPromise = $Call.ByID(3217823099, id) as any; + let $typingPromise = $resultPromise.then(($result) => { + return $$createType1($result); + }) as any; + $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); + return $typingPromise; +} + +export function Update(item: $models.Comment): Promise<$models.Comment> & { cancel(): void } { + let $resultPromise = $Call.ByID(3080970936, item) as any; + let $typingPromise = $resultPromise.then(($result) => { + return $$createType0($result); + }) as any; + $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); + return $typingPromise; +} + +// Private type creation functions +const $$createType0 = models$0.Comment.createFrom; +const $$createType1 = $Create.Nullable($$createType0); +const $$createType2 = $Create.Array($$createType1); diff --git a/frontend/bindings/app/internal/services/index.ts b/frontend/bindings/app/internal/services/index.ts index 5344665..50666ce 100644 --- a/frontend/bindings/app/internal/services/index.ts +++ b/frontend/bindings/app/internal/services/index.ts @@ -2,10 +2,14 @@ // This file is automatically generated. DO NOT EDIT import * as AuthorService from "./authorservice.js"; +import * as CommentService from "./commentservice.js"; import * as PostService from "./postservice.js"; +import * as PostTypeService from "./posttypeservice.js"; export { AuthorService, - PostService + CommentService, + PostService, + PostTypeService }; export * from "./models.js"; diff --git a/frontend/bindings/app/internal/services/models.ts b/frontend/bindings/app/internal/services/models.ts index 14711ab..41eba10 100644 --- a/frontend/bindings/app/internal/services/models.ts +++ b/frontend/bindings/app/internal/services/models.ts @@ -12,5 +12,11 @@ import * as models$0 from "../models/models.js"; export const Author = models$0.Author; export type Author = models$0.Author; +export const Comment = models$0.Comment; +export type Comment = models$0.Comment; + export const Post = models$0.Post; export type Post = models$0.Post; + +export const PostType = models$0.PostType; +export type PostType = models$0.PostType; diff --git a/frontend/bindings/app/internal/services/postservice.ts b/frontend/bindings/app/internal/services/postservice.ts index 72d6196..04dec58 100644 --- a/frontend/bindings/app/internal/services/postservice.ts +++ b/frontend/bindings/app/internal/services/postservice.ts @@ -20,7 +20,7 @@ export function Count(): Promise & { cancel(): void } { export function Create(item: $models.Post): Promise<$models.Post> & { cancel(): void } { let $resultPromise = $Call.ByID(1443399856, item) as any; - let $typingPromise = $resultPromise.then(($result: any) => { + let $typingPromise = $resultPromise.then(($result) => { return $$createType0($result); }) as any; $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); @@ -39,7 +39,7 @@ export function ExportToExcel(): Promise & { cancel(): void } { export function GetAll(): Promise<($models.Post | null)[]> & { cancel(): void } { let $resultPromise = $Call.ByID(65691059) as any; - let $typingPromise = $resultPromise.then(($result: any) => { + let $typingPromise = $resultPromise.then(($result) => { return $$createType2($result); }) as any; $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); @@ -48,7 +48,7 @@ export function GetAll(): Promise<($models.Post | null)[]> & { cancel(): void } export function GetById(id: number): Promise<$models.Post | null> & { cancel(): void } { let $resultPromise = $Call.ByID(4074736792, id) as any; - let $typingPromise = $resultPromise.then(($result: any) => { + let $typingPromise = $resultPromise.then(($result) => { return $$createType1($result); }) as any; $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); @@ -57,7 +57,7 @@ export function GetById(id: number): Promise<$models.Post | null> & { cancel(): export function Update(item: $models.Post): Promise<$models.Post> & { cancel(): void } { let $resultPromise = $Call.ByID(137798821, item) as any; - let $typingPromise = $resultPromise.then(($result: any) => { + let $typingPromise = $resultPromise.then(($result) => { return $$createType0($result); }) as any; $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); diff --git a/frontend/bindings/app/internal/services/posttypeservice.ts b/frontend/bindings/app/internal/services/posttypeservice.ts new file mode 100644 index 0000000..a01bd15 --- /dev/null +++ b/frontend/bindings/app/internal/services/posttypeservice.ts @@ -0,0 +1,65 @@ +// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL +// This file is automatically generated. DO NOT EDIT + +// eslint-disable-next-line @typescript-eslint/ban-ts-comment +// @ts-ignore: Unused imports +import {Call as $Call, Create as $Create} from "@wailsio/runtime"; + +// eslint-disable-next-line @typescript-eslint/ban-ts-comment +// @ts-ignore: Unused imports +import * as models$0 from "../models/models.js"; + +// eslint-disable-next-line @typescript-eslint/ban-ts-comment +// @ts-ignore: Unused imports +import * as $models from "./models.js"; + +export function Count(): Promise & { cancel(): void } { + let $resultPromise = $Call.ByID(554487955) as any; + return $resultPromise; +} + +export function Create(item: $models.PostType): Promise<$models.PostType> & { cancel(): void } { + let $resultPromise = $Call.ByID(1092898136, item) as any; + let $typingPromise = $resultPromise.then(($result) => { + return $$createType0($result); + }) as any; + $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); + return $typingPromise; +} + +export function Delete(id: number): Promise & { cancel(): void } { + let $resultPromise = $Call.ByID(2114913543, id) as any; + return $resultPromise; +} + +export function GetAll(): Promise<($models.PostType | null)[]> & { cancel(): void } { + let $resultPromise = $Call.ByID(416231387) as any; + let $typingPromise = $resultPromise.then(($result) => { + return $$createType2($result); + }) as any; + $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); + return $typingPromise; +} + +export function GetById(id: number): Promise<$models.PostType | null> & { cancel(): void } { + let $resultPromise = $Call.ByID(3237123344, id) as any; + let $typingPromise = $resultPromise.then(($result) => { + return $$createType1($result); + }) as any; + $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); + return $typingPromise; +} + +export function Update(item: $models.PostType): Promise<$models.PostType> & { cancel(): void } { + let $resultPromise = $Call.ByID(2773888269, item) as any; + let $typingPromise = $resultPromise.then(($result) => { + return $$createType0($result); + }) as any; + $typingPromise.cancel = $resultPromise.cancel.bind($resultPromise); + return $typingPromise; +} + +// Private type creation functions +const $$createType0 = models$0.PostType.createFrom; +const $$createType1 = $Create.Nullable($$createType0); +const $$createType2 = $Create.Array($$createType1); diff --git a/internal/dal/authors.gen.go b/internal/dal/authors.gen.go index 7425d78..3037c5e 100644 --- a/internal/dal/authors.gen.go +++ b/internal/dal/authors.gen.go @@ -37,6 +37,15 @@ func newAuthor(db *gorm.DB, opts ...gen.DOOption) author { Posts struct { field.RelationField } + Comments struct { + field.RelationField + Author struct { + field.RelationField + } + Posts struct { + field.RelationField + } + } }{ RelationField: field.NewRelation("Posts.Author", "models.Author"), Posts: struct { @@ -44,7 +53,44 @@ func newAuthor(db *gorm.DB, opts ...gen.DOOption) author { }{ RelationField: field.NewRelation("Posts.Author.Posts", "models.Post"), }, + Comments: struct { + field.RelationField + Author struct { + field.RelationField + } + Posts struct { + field.RelationField + } + }{ + RelationField: field.NewRelation("Posts.Author.Comments", "models.Comment"), + Author: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Posts.Author.Comments.Author", "models.Author"), + }, + Posts: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Posts.Author.Comments.Posts", "models.Post"), + }, + }, }, + PostType: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Posts.PostType", "models.PostType"), + }, + Comments: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Posts.Comments", "models.Comment"), + }, + } + + _author.Comments = authorHasManyComments{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Comments", "models.Comment"), } _author.fillFieldMap() @@ -60,6 +106,8 @@ type author struct { Name field.String Posts authorHasManyPosts + Comments authorHasManyComments + fieldMap map[string]field.Expr } @@ -93,7 +141,7 @@ func (a *author) GetFieldByName(fieldName string) (field.OrderExpr, bool) { } func (a *author) fillFieldMap() { - a.fieldMap = make(map[string]field.Expr, 3) + a.fieldMap = make(map[string]field.Expr, 4) a.fieldMap["id"] = a.Id a.fieldMap["name"] = a.Name @@ -119,6 +167,21 @@ type authorHasManyPosts struct { Posts struct { field.RelationField } + Comments struct { + field.RelationField + Author struct { + field.RelationField + } + Posts struct { + field.RelationField + } + } + } + PostType struct { + field.RelationField + } + Comments struct { + field.RelationField } } @@ -187,6 +250,77 @@ func (a authorHasManyPostsTx) Count() int64 { return a.tx.Count() } +type authorHasManyComments struct { + db *gorm.DB + + field.RelationField +} + +func (a authorHasManyComments) Where(conds ...field.Expr) *authorHasManyComments { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a authorHasManyComments) WithContext(ctx context.Context) *authorHasManyComments { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a authorHasManyComments) Session(session *gorm.Session) *authorHasManyComments { + a.db = a.db.Session(session) + return &a +} + +func (a authorHasManyComments) Model(m *models.Author) *authorHasManyCommentsTx { + return &authorHasManyCommentsTx{a.db.Model(m).Association(a.Name())} +} + +type authorHasManyCommentsTx struct{ tx *gorm.Association } + +func (a authorHasManyCommentsTx) Find() (result []*models.Comment, err error) { + return result, a.tx.Find(&result) +} + +func (a authorHasManyCommentsTx) Append(values ...*models.Comment) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a authorHasManyCommentsTx) Replace(values ...*models.Comment) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a authorHasManyCommentsTx) Delete(values ...*models.Comment) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a authorHasManyCommentsTx) Clear() error { + return a.tx.Clear() +} + +func (a authorHasManyCommentsTx) Count() int64 { + return a.tx.Count() +} + type authorDo struct{ gen.DO } type IAuthorDo interface { diff --git a/internal/dal/comments.gen.go b/internal/dal/comments.gen.go new file mode 100644 index 0000000..b6c41df --- /dev/null +++ b/internal/dal/comments.gen.go @@ -0,0 +1,622 @@ +// 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 dal + +import ( + "app/internal/models" + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newComment(db *gorm.DB, opts ...gen.DOOption) comment { + _comment := comment{} + + _comment.commentDo.UseDB(db, opts...) + _comment.commentDo.UseModel(&models.Comment{}) + + tableName := _comment.commentDo.TableName() + _comment.ALL = field.NewAsterisk(tableName) + _comment.Id = field.NewUint(tableName, "id") + _comment.Text = field.NewString(tableName, "text") + _comment.AuthorId = field.NewUint(tableName, "author_id") + _comment.Author = commentHasOneAuthor{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Author", "models.Author"), + Posts: struct { + field.RelationField + Author struct { + field.RelationField + } + PostType struct { + field.RelationField + } + Comments struct { + field.RelationField + Author struct { + field.RelationField + } + Posts struct { + field.RelationField + } + } + }{ + RelationField: field.NewRelation("Author.Posts", "models.Post"), + Author: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Author.Posts.Author", "models.Author"), + }, + PostType: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Author.Posts.PostType", "models.PostType"), + }, + Comments: struct { + field.RelationField + Author struct { + field.RelationField + } + Posts struct { + field.RelationField + } + }{ + RelationField: field.NewRelation("Author.Posts.Comments", "models.Comment"), + Author: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Author.Posts.Comments.Author", "models.Author"), + }, + Posts: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Author.Posts.Comments.Posts", "models.Post"), + }, + }, + }, + Comments: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Author.Comments", "models.Comment"), + }, + } + + _comment.Posts = commentManyToManyPosts{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Posts", "models.Post"), + } + + _comment.fillFieldMap() + + return _comment +} + +type comment struct { + commentDo + + ALL field.Asterisk + Id field.Uint + Text field.String + AuthorId field.Uint + Author commentHasOneAuthor + + Posts commentManyToManyPosts + + fieldMap map[string]field.Expr +} + +func (c comment) Table(newTableName string) *comment { + c.commentDo.UseTable(newTableName) + return c.updateTableName(newTableName) +} + +func (c comment) As(alias string) *comment { + c.commentDo.DO = *(c.commentDo.As(alias).(*gen.DO)) + return c.updateTableName(alias) +} + +func (c *comment) updateTableName(table string) *comment { + c.ALL = field.NewAsterisk(table) + c.Id = field.NewUint(table, "id") + c.Text = field.NewString(table, "text") + c.AuthorId = field.NewUint(table, "author_id") + + c.fillFieldMap() + + return c +} + +func (c *comment) 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 *comment) fillFieldMap() { + c.fieldMap = make(map[string]field.Expr, 5) + c.fieldMap["id"] = c.Id + c.fieldMap["text"] = c.Text + c.fieldMap["author_id"] = c.AuthorId + +} + +func (c comment) clone(db *gorm.DB) comment { + c.commentDo.ReplaceConnPool(db.Statement.ConnPool) + return c +} + +func (c comment) replaceDB(db *gorm.DB) comment { + c.commentDo.ReplaceDB(db) + return c +} + +type commentHasOneAuthor struct { + db *gorm.DB + + field.RelationField + + Posts struct { + field.RelationField + Author struct { + field.RelationField + } + PostType struct { + field.RelationField + } + Comments struct { + field.RelationField + Author struct { + field.RelationField + } + Posts struct { + field.RelationField + } + } + } + Comments struct { + field.RelationField + } +} + +func (a commentHasOneAuthor) Where(conds ...field.Expr) *commentHasOneAuthor { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a commentHasOneAuthor) WithContext(ctx context.Context) *commentHasOneAuthor { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a commentHasOneAuthor) Session(session *gorm.Session) *commentHasOneAuthor { + a.db = a.db.Session(session) + return &a +} + +func (a commentHasOneAuthor) Model(m *models.Comment) *commentHasOneAuthorTx { + return &commentHasOneAuthorTx{a.db.Model(m).Association(a.Name())} +} + +type commentHasOneAuthorTx struct{ tx *gorm.Association } + +func (a commentHasOneAuthorTx) Find() (result *models.Author, err error) { + return result, a.tx.Find(&result) +} + +func (a commentHasOneAuthorTx) Append(values ...*models.Author) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a commentHasOneAuthorTx) Replace(values ...*models.Author) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a commentHasOneAuthorTx) Delete(values ...*models.Author) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a commentHasOneAuthorTx) Clear() error { + return a.tx.Clear() +} + +func (a commentHasOneAuthorTx) Count() int64 { + return a.tx.Count() +} + +type commentManyToManyPosts struct { + db *gorm.DB + + field.RelationField +} + +func (a commentManyToManyPosts) Where(conds ...field.Expr) *commentManyToManyPosts { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a commentManyToManyPosts) WithContext(ctx context.Context) *commentManyToManyPosts { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a commentManyToManyPosts) Session(session *gorm.Session) *commentManyToManyPosts { + a.db = a.db.Session(session) + return &a +} + +func (a commentManyToManyPosts) Model(m *models.Comment) *commentManyToManyPostsTx { + return &commentManyToManyPostsTx{a.db.Model(m).Association(a.Name())} +} + +type commentManyToManyPostsTx struct{ tx *gorm.Association } + +func (a commentManyToManyPostsTx) Find() (result []*models.Post, err error) { + return result, a.tx.Find(&result) +} + +func (a commentManyToManyPostsTx) Append(values ...*models.Post) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a commentManyToManyPostsTx) Replace(values ...*models.Post) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a commentManyToManyPostsTx) Delete(values ...*models.Post) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a commentManyToManyPostsTx) Clear() error { + return a.tx.Clear() +} + +func (a commentManyToManyPostsTx) Count() int64 { + return a.tx.Count() +} + +type commentDo struct{ gen.DO } + +type ICommentDo interface { + gen.SubQuery + Debug() ICommentDo + WithContext(ctx context.Context) ICommentDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() ICommentDo + WriteDB() ICommentDo + As(alias string) gen.Dao + Session(config *gorm.Session) ICommentDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) ICommentDo + Not(conds ...gen.Condition) ICommentDo + Or(conds ...gen.Condition) ICommentDo + Select(conds ...field.Expr) ICommentDo + Where(conds ...gen.Condition) ICommentDo + Order(conds ...field.Expr) ICommentDo + Distinct(cols ...field.Expr) ICommentDo + Omit(cols ...field.Expr) ICommentDo + Join(table schema.Tabler, on ...field.Expr) ICommentDo + LeftJoin(table schema.Tabler, on ...field.Expr) ICommentDo + RightJoin(table schema.Tabler, on ...field.Expr) ICommentDo + Group(cols ...field.Expr) ICommentDo + Having(conds ...gen.Condition) ICommentDo + Limit(limit int) ICommentDo + Offset(offset int) ICommentDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) ICommentDo + Unscoped() ICommentDo + Create(values ...*models.Comment) error + CreateInBatches(values []*models.Comment, batchSize int) error + Save(values ...*models.Comment) error + First() (*models.Comment, error) + Take() (*models.Comment, error) + Last() (*models.Comment, error) + Find() ([]*models.Comment, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.Comment, err error) + FindInBatches(result *[]*models.Comment, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*models.Comment) (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) ICommentDo + Assign(attrs ...field.AssignExpr) ICommentDo + Joins(fields ...field.RelationField) ICommentDo + Preload(fields ...field.RelationField) ICommentDo + FirstOrInit() (*models.Comment, error) + FirstOrCreate() (*models.Comment, error) + FindByPage(offset int, limit int) (result []*models.Comment, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) ICommentDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (c commentDo) Debug() ICommentDo { + return c.withDO(c.DO.Debug()) +} + +func (c commentDo) WithContext(ctx context.Context) ICommentDo { + return c.withDO(c.DO.WithContext(ctx)) +} + +func (c commentDo) ReadDB() ICommentDo { + return c.Clauses(dbresolver.Read) +} + +func (c commentDo) WriteDB() ICommentDo { + return c.Clauses(dbresolver.Write) +} + +func (c commentDo) Session(config *gorm.Session) ICommentDo { + return c.withDO(c.DO.Session(config)) +} + +func (c commentDo) Clauses(conds ...clause.Expression) ICommentDo { + return c.withDO(c.DO.Clauses(conds...)) +} + +func (c commentDo) Returning(value interface{}, columns ...string) ICommentDo { + return c.withDO(c.DO.Returning(value, columns...)) +} + +func (c commentDo) Not(conds ...gen.Condition) ICommentDo { + return c.withDO(c.DO.Not(conds...)) +} + +func (c commentDo) Or(conds ...gen.Condition) ICommentDo { + return c.withDO(c.DO.Or(conds...)) +} + +func (c commentDo) Select(conds ...field.Expr) ICommentDo { + return c.withDO(c.DO.Select(conds...)) +} + +func (c commentDo) Where(conds ...gen.Condition) ICommentDo { + return c.withDO(c.DO.Where(conds...)) +} + +func (c commentDo) Order(conds ...field.Expr) ICommentDo { + return c.withDO(c.DO.Order(conds...)) +} + +func (c commentDo) Distinct(cols ...field.Expr) ICommentDo { + return c.withDO(c.DO.Distinct(cols...)) +} + +func (c commentDo) Omit(cols ...field.Expr) ICommentDo { + return c.withDO(c.DO.Omit(cols...)) +} + +func (c commentDo) Join(table schema.Tabler, on ...field.Expr) ICommentDo { + return c.withDO(c.DO.Join(table, on...)) +} + +func (c commentDo) LeftJoin(table schema.Tabler, on ...field.Expr) ICommentDo { + return c.withDO(c.DO.LeftJoin(table, on...)) +} + +func (c commentDo) RightJoin(table schema.Tabler, on ...field.Expr) ICommentDo { + return c.withDO(c.DO.RightJoin(table, on...)) +} + +func (c commentDo) Group(cols ...field.Expr) ICommentDo { + return c.withDO(c.DO.Group(cols...)) +} + +func (c commentDo) Having(conds ...gen.Condition) ICommentDo { + return c.withDO(c.DO.Having(conds...)) +} + +func (c commentDo) Limit(limit int) ICommentDo { + return c.withDO(c.DO.Limit(limit)) +} + +func (c commentDo) Offset(offset int) ICommentDo { + return c.withDO(c.DO.Offset(offset)) +} + +func (c commentDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ICommentDo { + return c.withDO(c.DO.Scopes(funcs...)) +} + +func (c commentDo) Unscoped() ICommentDo { + return c.withDO(c.DO.Unscoped()) +} + +func (c commentDo) Create(values ...*models.Comment) error { + if len(values) == 0 { + return nil + } + return c.DO.Create(values) +} + +func (c commentDo) CreateInBatches(values []*models.Comment, 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 commentDo) Save(values ...*models.Comment) error { + if len(values) == 0 { + return nil + } + return c.DO.Save(values) +} + +func (c commentDo) First() (*models.Comment, error) { + if result, err := c.DO.First(); err != nil { + return nil, err + } else { + return result.(*models.Comment), nil + } +} + +func (c commentDo) Take() (*models.Comment, error) { + if result, err := c.DO.Take(); err != nil { + return nil, err + } else { + return result.(*models.Comment), nil + } +} + +func (c commentDo) Last() (*models.Comment, error) { + if result, err := c.DO.Last(); err != nil { + return nil, err + } else { + return result.(*models.Comment), nil + } +} + +func (c commentDo) Find() ([]*models.Comment, error) { + result, err := c.DO.Find() + return result.([]*models.Comment), err +} + +func (c commentDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.Comment, err error) { + buf := make([]*models.Comment, 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 commentDo) FindInBatches(result *[]*models.Comment, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return c.DO.FindInBatches(result, batchSize, fc) +} + +func (c commentDo) Attrs(attrs ...field.AssignExpr) ICommentDo { + return c.withDO(c.DO.Attrs(attrs...)) +} + +func (c commentDo) Assign(attrs ...field.AssignExpr) ICommentDo { + return c.withDO(c.DO.Assign(attrs...)) +} + +func (c commentDo) Joins(fields ...field.RelationField) ICommentDo { + for _, _f := range fields { + c = *c.withDO(c.DO.Joins(_f)) + } + return &c +} + +func (c commentDo) Preload(fields ...field.RelationField) ICommentDo { + for _, _f := range fields { + c = *c.withDO(c.DO.Preload(_f)) + } + return &c +} + +func (c commentDo) FirstOrInit() (*models.Comment, error) { + if result, err := c.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*models.Comment), nil + } +} + +func (c commentDo) FirstOrCreate() (*models.Comment, error) { + if result, err := c.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*models.Comment), nil + } +} + +func (c commentDo) FindByPage(offset int, limit int) (result []*models.Comment, 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 commentDo) 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 commentDo) Scan(result interface{}) (err error) { + return c.DO.Scan(result) +} + +func (c commentDo) Delete(models ...*models.Comment) (result gen.ResultInfo, err error) { + return c.DO.Delete(models) +} + +func (c *commentDo) withDO(do gen.Dao) *commentDo { + c.DO = *do.(*gen.DO) + return c +} diff --git a/internal/dal/comments.gen_test.go b/internal/dal/comments.gen_test.go new file mode 100644 index 0000000..f008f02 --- /dev/null +++ b/internal/dal/comments.gen_test.go @@ -0,0 +1,145 @@ +// 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 dal + +import ( + "app/internal/models" + "context" + "fmt" + "testing" + + "gorm.io/gen" + "gorm.io/gen/field" + "gorm.io/gorm/clause" +) + +func init() { + InitializeDB() + err := _gen_test_db.AutoMigrate(&models.Comment{}) + if err != nil { + fmt.Printf("Error: AutoMigrate(&models.Comment{}) fail: %s", err) + } +} + +func Test_commentQuery(t *testing.T) { + comment := newComment(_gen_test_db) + comment = *comment.As(comment.TableName()) + _do := comment.WithContext(context.Background()).Debug() + + primaryKey := field.NewString(comment.TableName(), clause.PrimaryKey) + _, err := _do.Unscoped().Where(primaryKey.IsNotNull()).Delete() + if err != nil { + t.Error("clean table fail:", err) + return + } + + _, ok := comment.GetFieldByName("") + if ok { + t.Error("GetFieldByName(\"\") from comment success") + } + + err = _do.Create(&models.Comment{}) + if err != nil { + t.Error("create item in table fail:", err) + } + + err = _do.Save(&models.Comment{}) + if err != nil { + t.Error("create item in table fail:", err) + } + + err = _do.CreateInBatches([]*models.Comment{{}, {}}, 10) + if err != nil { + t.Error("create item in table fail:", err) + } + + _, err = _do.Select(comment.ALL).Take() + if err != nil { + t.Error("Take() on table fail:", err) + } + + _, err = _do.First() + if err != nil { + t.Error("First() on table fail:", err) + } + + _, err = _do.Last() + if err != nil { + t.Error("First() on table fail:", err) + } + + _, err = _do.Where(primaryKey.IsNotNull()).FindInBatch(10, func(tx gen.Dao, batch int) error { return nil }) + if err != nil { + t.Error("FindInBatch() on table fail:", err) + } + + err = _do.Where(primaryKey.IsNotNull()).FindInBatches(&[]*models.Comment{}, 10, func(tx gen.Dao, batch int) error { return nil }) + if err != nil { + t.Error("FindInBatches() on table fail:", err) + } + + _, err = _do.Select(comment.ALL).Where(primaryKey.IsNotNull()).Order(primaryKey.Desc()).Find() + if err != nil { + t.Error("Find() on table fail:", err) + } + + _, err = _do.Distinct(primaryKey).Take() + if err != nil { + t.Error("select Distinct() on table fail:", err) + } + + _, err = _do.Select(comment.ALL).Omit(primaryKey).Take() + if err != nil { + t.Error("Omit() on table fail:", err) + } + + _, err = _do.Group(primaryKey).Find() + if err != nil { + t.Error("Group() on table fail:", err) + } + + _, err = _do.Scopes(func(dao gen.Dao) gen.Dao { return dao.Where(primaryKey.IsNotNull()) }).Find() + if err != nil { + t.Error("Scopes() on table fail:", err) + } + + _, _, err = _do.FindByPage(0, 1) + if err != nil { + t.Error("FindByPage() on table fail:", err) + } + + _, err = _do.ScanByPage(&models.Comment{}, 0, 1) + if err != nil { + t.Error("ScanByPage() on table fail:", err) + } + + _, err = _do.Attrs(primaryKey).Assign(primaryKey).FirstOrInit() + if err != nil { + t.Error("FirstOrInit() on table fail:", err) + } + + _, err = _do.Attrs(primaryKey).Assign(primaryKey).FirstOrCreate() + if err != nil { + t.Error("FirstOrCreate() on table fail:", err) + } + + var _a _another + var _aPK = field.NewString(_a.TableName(), "id") + + err = _do.Join(&_a, primaryKey.EqCol(_aPK)).Scan(map[string]interface{}{}) + if err != nil { + t.Error("Join() on table fail:", err) + } + + err = _do.LeftJoin(&_a, primaryKey.EqCol(_aPK)).Scan(map[string]interface{}{}) + if err != nil { + t.Error("LeftJoin() on table fail:", err) + } + + _, err = _do.Not().Or().Clauses().Take() + if err != nil { + t.Error("Not/Or/Clauses on table fail:", err) + } +} diff --git a/internal/dal/gen.go b/internal/dal/gen.go index 5435601..e69fc7e 100644 --- a/internal/dal/gen.go +++ b/internal/dal/gen.go @@ -16,39 +16,49 @@ import ( ) var ( - Q = new(Query) - Author *author - Post *post + Q = new(Query) + Author *author + Comment *comment + Post *post + PostType *postType ) func SetDefault(db *gorm.DB, opts ...gen.DOOption) { *Q = *Use(db, opts...) Author = &Q.Author + Comment = &Q.Comment Post = &Q.Post + PostType = &Q.PostType } func Use(db *gorm.DB, opts ...gen.DOOption) *Query { return &Query{ - db: db, - Author: newAuthor(db, opts...), - Post: newPost(db, opts...), + db: db, + Author: newAuthor(db, opts...), + Comment: newComment(db, opts...), + Post: newPost(db, opts...), + PostType: newPostType(db, opts...), } } type Query struct { db *gorm.DB - Author author - Post post + Author author + Comment comment + Post post + PostType postType } func (q *Query) Available() bool { return q.db != nil } func (q *Query) clone(db *gorm.DB) *Query { return &Query{ - db: db, - Author: q.Author.clone(db), - Post: q.Post.clone(db), + db: db, + Author: q.Author.clone(db), + Comment: q.Comment.clone(db), + Post: q.Post.clone(db), + PostType: q.PostType.clone(db), } } @@ -62,21 +72,27 @@ func (q *Query) WriteDB() *Query { func (q *Query) ReplaceDB(db *gorm.DB) *Query { return &Query{ - db: db, - Author: q.Author.replaceDB(db), - Post: q.Post.replaceDB(db), + db: db, + Author: q.Author.replaceDB(db), + Comment: q.Comment.replaceDB(db), + Post: q.Post.replaceDB(db), + PostType: q.PostType.replaceDB(db), } } type queryCtx struct { - Author IAuthorDo - Post IPostDo + Author IAuthorDo + Comment ICommentDo + Post IPostDo + PostType IPostTypeDo } func (q *Query) WithContext(ctx context.Context) *queryCtx { return &queryCtx{ - Author: q.Author.WithContext(ctx), - Post: q.Post.WithContext(ctx), + Author: q.Author.WithContext(ctx), + Comment: q.Comment.WithContext(ctx), + Post: q.Post.WithContext(ctx), + PostType: q.PostType.WithContext(ctx), } } diff --git a/internal/dal/gen_test.go b/internal/dal/gen_test.go index 6c0fc8b..dab9256 100644 --- a/internal/dal/gen_test.go +++ b/internal/dal/gen_test.go @@ -78,7 +78,9 @@ func Test_WithContext(t *testing.T) { for _, ctx := range []context.Context{ qCtx.Author.UnderlyingDB().Statement.Context, + qCtx.Comment.UnderlyingDB().Statement.Context, qCtx.Post.UnderlyingDB().Statement.Context, + qCtx.PostType.UnderlyingDB().Statement.Context, } { if v := ctx.Value(key); v != value { t.Errorf("get value from context fail, expect %q, got %q", value, v) diff --git a/internal/dal/post_types.gen.go b/internal/dal/post_types.gen.go new file mode 100644 index 0000000..65f71b4 --- /dev/null +++ b/internal/dal/post_types.gen.go @@ -0,0 +1,383 @@ +// 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 dal + +import ( + "app/internal/models" + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newPostType(db *gorm.DB, opts ...gen.DOOption) postType { + _postType := postType{} + + _postType.postTypeDo.UseDB(db, opts...) + _postType.postTypeDo.UseModel(&models.PostType{}) + + tableName := _postType.postTypeDo.TableName() + _postType.ALL = field.NewAsterisk(tableName) + _postType.Id = field.NewUint(tableName, "id") + _postType.Name = field.NewString(tableName, "name") + + _postType.fillFieldMap() + + return _postType +} + +type postType struct { + postTypeDo + + ALL field.Asterisk + Id field.Uint + Name field.String + + fieldMap map[string]field.Expr +} + +func (p postType) Table(newTableName string) *postType { + p.postTypeDo.UseTable(newTableName) + return p.updateTableName(newTableName) +} + +func (p postType) As(alias string) *postType { + p.postTypeDo.DO = *(p.postTypeDo.As(alias).(*gen.DO)) + return p.updateTableName(alias) +} + +func (p *postType) updateTableName(table string) *postType { + p.ALL = field.NewAsterisk(table) + p.Id = field.NewUint(table, "id") + p.Name = field.NewString(table, "name") + + p.fillFieldMap() + + return p +} + +func (p *postType) 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 *postType) fillFieldMap() { + p.fieldMap = make(map[string]field.Expr, 2) + p.fieldMap["id"] = p.Id + p.fieldMap["name"] = p.Name +} + +func (p postType) clone(db *gorm.DB) postType { + p.postTypeDo.ReplaceConnPool(db.Statement.ConnPool) + return p +} + +func (p postType) replaceDB(db *gorm.DB) postType { + p.postTypeDo.ReplaceDB(db) + return p +} + +type postTypeDo struct{ gen.DO } + +type IPostTypeDo interface { + gen.SubQuery + Debug() IPostTypeDo + WithContext(ctx context.Context) IPostTypeDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IPostTypeDo + WriteDB() IPostTypeDo + As(alias string) gen.Dao + Session(config *gorm.Session) IPostTypeDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IPostTypeDo + Not(conds ...gen.Condition) IPostTypeDo + Or(conds ...gen.Condition) IPostTypeDo + Select(conds ...field.Expr) IPostTypeDo + Where(conds ...gen.Condition) IPostTypeDo + Order(conds ...field.Expr) IPostTypeDo + Distinct(cols ...field.Expr) IPostTypeDo + Omit(cols ...field.Expr) IPostTypeDo + Join(table schema.Tabler, on ...field.Expr) IPostTypeDo + LeftJoin(table schema.Tabler, on ...field.Expr) IPostTypeDo + RightJoin(table schema.Tabler, on ...field.Expr) IPostTypeDo + Group(cols ...field.Expr) IPostTypeDo + Having(conds ...gen.Condition) IPostTypeDo + Limit(limit int) IPostTypeDo + Offset(offset int) IPostTypeDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IPostTypeDo + Unscoped() IPostTypeDo + Create(values ...*models.PostType) error + CreateInBatches(values []*models.PostType, batchSize int) error + Save(values ...*models.PostType) error + First() (*models.PostType, error) + Take() (*models.PostType, error) + Last() (*models.PostType, error) + Find() ([]*models.PostType, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.PostType, err error) + FindInBatches(result *[]*models.PostType, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*models.PostType) (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) IPostTypeDo + Assign(attrs ...field.AssignExpr) IPostTypeDo + Joins(fields ...field.RelationField) IPostTypeDo + Preload(fields ...field.RelationField) IPostTypeDo + FirstOrInit() (*models.PostType, error) + FirstOrCreate() (*models.PostType, error) + FindByPage(offset int, limit int) (result []*models.PostType, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IPostTypeDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (p postTypeDo) Debug() IPostTypeDo { + return p.withDO(p.DO.Debug()) +} + +func (p postTypeDo) WithContext(ctx context.Context) IPostTypeDo { + return p.withDO(p.DO.WithContext(ctx)) +} + +func (p postTypeDo) ReadDB() IPostTypeDo { + return p.Clauses(dbresolver.Read) +} + +func (p postTypeDo) WriteDB() IPostTypeDo { + return p.Clauses(dbresolver.Write) +} + +func (p postTypeDo) Session(config *gorm.Session) IPostTypeDo { + return p.withDO(p.DO.Session(config)) +} + +func (p postTypeDo) Clauses(conds ...clause.Expression) IPostTypeDo { + return p.withDO(p.DO.Clauses(conds...)) +} + +func (p postTypeDo) Returning(value interface{}, columns ...string) IPostTypeDo { + return p.withDO(p.DO.Returning(value, columns...)) +} + +func (p postTypeDo) Not(conds ...gen.Condition) IPostTypeDo { + return p.withDO(p.DO.Not(conds...)) +} + +func (p postTypeDo) Or(conds ...gen.Condition) IPostTypeDo { + return p.withDO(p.DO.Or(conds...)) +} + +func (p postTypeDo) Select(conds ...field.Expr) IPostTypeDo { + return p.withDO(p.DO.Select(conds...)) +} + +func (p postTypeDo) Where(conds ...gen.Condition) IPostTypeDo { + return p.withDO(p.DO.Where(conds...)) +} + +func (p postTypeDo) Order(conds ...field.Expr) IPostTypeDo { + return p.withDO(p.DO.Order(conds...)) +} + +func (p postTypeDo) Distinct(cols ...field.Expr) IPostTypeDo { + return p.withDO(p.DO.Distinct(cols...)) +} + +func (p postTypeDo) Omit(cols ...field.Expr) IPostTypeDo { + return p.withDO(p.DO.Omit(cols...)) +} + +func (p postTypeDo) Join(table schema.Tabler, on ...field.Expr) IPostTypeDo { + return p.withDO(p.DO.Join(table, on...)) +} + +func (p postTypeDo) LeftJoin(table schema.Tabler, on ...field.Expr) IPostTypeDo { + return p.withDO(p.DO.LeftJoin(table, on...)) +} + +func (p postTypeDo) RightJoin(table schema.Tabler, on ...field.Expr) IPostTypeDo { + return p.withDO(p.DO.RightJoin(table, on...)) +} + +func (p postTypeDo) Group(cols ...field.Expr) IPostTypeDo { + return p.withDO(p.DO.Group(cols...)) +} + +func (p postTypeDo) Having(conds ...gen.Condition) IPostTypeDo { + return p.withDO(p.DO.Having(conds...)) +} + +func (p postTypeDo) Limit(limit int) IPostTypeDo { + return p.withDO(p.DO.Limit(limit)) +} + +func (p postTypeDo) Offset(offset int) IPostTypeDo { + return p.withDO(p.DO.Offset(offset)) +} + +func (p postTypeDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IPostTypeDo { + return p.withDO(p.DO.Scopes(funcs...)) +} + +func (p postTypeDo) Unscoped() IPostTypeDo { + return p.withDO(p.DO.Unscoped()) +} + +func (p postTypeDo) Create(values ...*models.PostType) error { + if len(values) == 0 { + return nil + } + return p.DO.Create(values) +} + +func (p postTypeDo) CreateInBatches(values []*models.PostType, 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 postTypeDo) Save(values ...*models.PostType) error { + if len(values) == 0 { + return nil + } + return p.DO.Save(values) +} + +func (p postTypeDo) First() (*models.PostType, error) { + if result, err := p.DO.First(); err != nil { + return nil, err + } else { + return result.(*models.PostType), nil + } +} + +func (p postTypeDo) Take() (*models.PostType, error) { + if result, err := p.DO.Take(); err != nil { + return nil, err + } else { + return result.(*models.PostType), nil + } +} + +func (p postTypeDo) Last() (*models.PostType, error) { + if result, err := p.DO.Last(); err != nil { + return nil, err + } else { + return result.(*models.PostType), nil + } +} + +func (p postTypeDo) Find() ([]*models.PostType, error) { + result, err := p.DO.Find() + return result.([]*models.PostType), err +} + +func (p postTypeDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.PostType, err error) { + buf := make([]*models.PostType, 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 postTypeDo) FindInBatches(result *[]*models.PostType, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return p.DO.FindInBatches(result, batchSize, fc) +} + +func (p postTypeDo) Attrs(attrs ...field.AssignExpr) IPostTypeDo { + return p.withDO(p.DO.Attrs(attrs...)) +} + +func (p postTypeDo) Assign(attrs ...field.AssignExpr) IPostTypeDo { + return p.withDO(p.DO.Assign(attrs...)) +} + +func (p postTypeDo) Joins(fields ...field.RelationField) IPostTypeDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Joins(_f)) + } + return &p +} + +func (p postTypeDo) Preload(fields ...field.RelationField) IPostTypeDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Preload(_f)) + } + return &p +} + +func (p postTypeDo) FirstOrInit() (*models.PostType, error) { + if result, err := p.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*models.PostType), nil + } +} + +func (p postTypeDo) FirstOrCreate() (*models.PostType, error) { + if result, err := p.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*models.PostType), nil + } +} + +func (p postTypeDo) FindByPage(offset int, limit int) (result []*models.PostType, 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 postTypeDo) 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 postTypeDo) Scan(result interface{}) (err error) { + return p.DO.Scan(result) +} + +func (p postTypeDo) Delete(models ...*models.PostType) (result gen.ResultInfo, err error) { + return p.DO.Delete(models) +} + +func (p *postTypeDo) withDO(do gen.Dao) *postTypeDo { + p.DO = *do.(*gen.DO) + return p +} diff --git a/internal/dal/post_types.gen_test.go b/internal/dal/post_types.gen_test.go new file mode 100644 index 0000000..df0dd22 --- /dev/null +++ b/internal/dal/post_types.gen_test.go @@ -0,0 +1,145 @@ +// 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 dal + +import ( + "app/internal/models" + "context" + "fmt" + "testing" + + "gorm.io/gen" + "gorm.io/gen/field" + "gorm.io/gorm/clause" +) + +func init() { + InitializeDB() + err := _gen_test_db.AutoMigrate(&models.PostType{}) + if err != nil { + fmt.Printf("Error: AutoMigrate(&models.PostType{}) fail: %s", err) + } +} + +func Test_postTypeQuery(t *testing.T) { + postType := newPostType(_gen_test_db) + postType = *postType.As(postType.TableName()) + _do := postType.WithContext(context.Background()).Debug() + + primaryKey := field.NewString(postType.TableName(), clause.PrimaryKey) + _, err := _do.Unscoped().Where(primaryKey.IsNotNull()).Delete() + if err != nil { + t.Error("clean table fail:", err) + return + } + + _, ok := postType.GetFieldByName("") + if ok { + t.Error("GetFieldByName(\"\") from postType success") + } + + err = _do.Create(&models.PostType{}) + if err != nil { + t.Error("create item in table fail:", err) + } + + err = _do.Save(&models.PostType{}) + if err != nil { + t.Error("create item in table fail:", err) + } + + err = _do.CreateInBatches([]*models.PostType{{}, {}}, 10) + if err != nil { + t.Error("create item in table fail:", err) + } + + _, err = _do.Select(postType.ALL).Take() + if err != nil { + t.Error("Take() on table fail:", err) + } + + _, err = _do.First() + if err != nil { + t.Error("First() on table fail:", err) + } + + _, err = _do.Last() + if err != nil { + t.Error("First() on table fail:", err) + } + + _, err = _do.Where(primaryKey.IsNotNull()).FindInBatch(10, func(tx gen.Dao, batch int) error { return nil }) + if err != nil { + t.Error("FindInBatch() on table fail:", err) + } + + err = _do.Where(primaryKey.IsNotNull()).FindInBatches(&[]*models.PostType{}, 10, func(tx gen.Dao, batch int) error { return nil }) + if err != nil { + t.Error("FindInBatches() on table fail:", err) + } + + _, err = _do.Select(postType.ALL).Where(primaryKey.IsNotNull()).Order(primaryKey.Desc()).Find() + if err != nil { + t.Error("Find() on table fail:", err) + } + + _, err = _do.Distinct(primaryKey).Take() + if err != nil { + t.Error("select Distinct() on table fail:", err) + } + + _, err = _do.Select(postType.ALL).Omit(primaryKey).Take() + if err != nil { + t.Error("Omit() on table fail:", err) + } + + _, err = _do.Group(primaryKey).Find() + if err != nil { + t.Error("Group() on table fail:", err) + } + + _, err = _do.Scopes(func(dao gen.Dao) gen.Dao { return dao.Where(primaryKey.IsNotNull()) }).Find() + if err != nil { + t.Error("Scopes() on table fail:", err) + } + + _, _, err = _do.FindByPage(0, 1) + if err != nil { + t.Error("FindByPage() on table fail:", err) + } + + _, err = _do.ScanByPage(&models.PostType{}, 0, 1) + if err != nil { + t.Error("ScanByPage() on table fail:", err) + } + + _, err = _do.Attrs(primaryKey).Assign(primaryKey).FirstOrInit() + if err != nil { + t.Error("FirstOrInit() on table fail:", err) + } + + _, err = _do.Attrs(primaryKey).Assign(primaryKey).FirstOrCreate() + if err != nil { + t.Error("FirstOrCreate() on table fail:", err) + } + + var _a _another + var _aPK = field.NewString(_a.TableName(), "id") + + err = _do.Join(&_a, primaryKey.EqCol(_aPK)).Scan(map[string]interface{}{}) + if err != nil { + t.Error("Join() on table fail:", err) + } + + err = _do.LeftJoin(&_a, primaryKey.EqCol(_aPK)).Scan(map[string]interface{}{}) + if err != nil { + t.Error("LeftJoin() on table fail:", err) + } + + _, err = _do.Not().Or().Clauses().Take() + if err != nil { + t.Error("Not/Or/Clauses on table fail:", err) + } +} diff --git a/internal/dal/posts.gen.go b/internal/dal/posts.gen.go index cf6c303..cd6295d 100644 --- a/internal/dal/posts.gen.go +++ b/internal/dal/posts.gen.go @@ -31,6 +31,7 @@ func newPost(db *gorm.DB, opts ...gen.DOOption) post { _post.Deadline = field.NewInt64(tableName, "deadline") _post.CreatedAt = field.NewInt64(tableName, "created_at") _post.AuthorId = field.NewUint(tableName, "author_id") + _post.PostTypeId = field.NewUint(tableName, "post_type_id") _post.Author = postBelongsToAuthor{ db: db.Session(&gorm.Session{}), @@ -40,6 +41,18 @@ func newPost(db *gorm.DB, opts ...gen.DOOption) post { Author struct { field.RelationField } + PostType struct { + field.RelationField + } + Comments struct { + field.RelationField + Author struct { + field.RelationField + } + Posts struct { + field.RelationField + } + } }{ RelationField: field.NewRelation("Author.Posts", "models.Post"), Author: struct { @@ -47,7 +60,50 @@ func newPost(db *gorm.DB, opts ...gen.DOOption) post { }{ RelationField: field.NewRelation("Author.Posts.Author", "models.Author"), }, + PostType: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Author.Posts.PostType", "models.PostType"), + }, + Comments: struct { + field.RelationField + Author struct { + field.RelationField + } + Posts struct { + field.RelationField + } + }{ + RelationField: field.NewRelation("Author.Posts.Comments", "models.Comment"), + Author: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Author.Posts.Comments.Author", "models.Author"), + }, + Posts: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Author.Posts.Comments.Posts", "models.Post"), + }, + }, }, + Comments: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Author.Comments", "models.Comment"), + }, + } + + _post.PostType = postBelongsToPostType{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("PostType", "models.PostType"), + } + + _post.Comments = postManyToManyComments{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Comments", "models.Comment"), } _post.fillFieldMap() @@ -58,13 +114,18 @@ func newPost(db *gorm.DB, opts ...gen.DOOption) post { type post struct { postDo - ALL field.Asterisk - Id field.Uint - Text field.String - Deadline field.Int64 - CreatedAt field.Int64 - AuthorId field.Uint - Author postBelongsToAuthor + ALL field.Asterisk + Id field.Uint + Text field.String + Deadline field.Int64 + CreatedAt field.Int64 + AuthorId field.Uint + PostTypeId field.Uint + Author postBelongsToAuthor + + PostType postBelongsToPostType + + Comments postManyToManyComments fieldMap map[string]field.Expr } @@ -86,6 +147,7 @@ func (p *post) updateTableName(table string) *post { p.Deadline = field.NewInt64(table, "deadline") p.CreatedAt = field.NewInt64(table, "created_at") p.AuthorId = field.NewUint(table, "author_id") + p.PostTypeId = field.NewUint(table, "post_type_id") p.fillFieldMap() @@ -102,12 +164,13 @@ func (p *post) GetFieldByName(fieldName string) (field.OrderExpr, bool) { } func (p *post) fillFieldMap() { - p.fieldMap = make(map[string]field.Expr, 6) + p.fieldMap = make(map[string]field.Expr, 9) p.fieldMap["id"] = p.Id p.fieldMap["text"] = p.Text p.fieldMap["deadline"] = p.Deadline p.fieldMap["created_at"] = p.CreatedAt p.fieldMap["author_id"] = p.AuthorId + p.fieldMap["post_type_id"] = p.PostTypeId } @@ -131,6 +194,21 @@ type postBelongsToAuthor struct { Author struct { field.RelationField } + PostType struct { + field.RelationField + } + Comments struct { + field.RelationField + Author struct { + field.RelationField + } + Posts struct { + field.RelationField + } + } + } + Comments struct { + field.RelationField } } @@ -199,6 +277,148 @@ func (a postBelongsToAuthorTx) Count() int64 { return a.tx.Count() } +type postBelongsToPostType struct { + db *gorm.DB + + field.RelationField +} + +func (a postBelongsToPostType) Where(conds ...field.Expr) *postBelongsToPostType { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a postBelongsToPostType) WithContext(ctx context.Context) *postBelongsToPostType { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a postBelongsToPostType) Session(session *gorm.Session) *postBelongsToPostType { + a.db = a.db.Session(session) + return &a +} + +func (a postBelongsToPostType) Model(m *models.Post) *postBelongsToPostTypeTx { + return &postBelongsToPostTypeTx{a.db.Model(m).Association(a.Name())} +} + +type postBelongsToPostTypeTx struct{ tx *gorm.Association } + +func (a postBelongsToPostTypeTx) Find() (result *models.PostType, err error) { + return result, a.tx.Find(&result) +} + +func (a postBelongsToPostTypeTx) Append(values ...*models.PostType) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a postBelongsToPostTypeTx) Replace(values ...*models.PostType) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a postBelongsToPostTypeTx) Delete(values ...*models.PostType) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a postBelongsToPostTypeTx) Clear() error { + return a.tx.Clear() +} + +func (a postBelongsToPostTypeTx) Count() int64 { + return a.tx.Count() +} + +type postManyToManyComments struct { + db *gorm.DB + + field.RelationField +} + +func (a postManyToManyComments) Where(conds ...field.Expr) *postManyToManyComments { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a postManyToManyComments) WithContext(ctx context.Context) *postManyToManyComments { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a postManyToManyComments) Session(session *gorm.Session) *postManyToManyComments { + a.db = a.db.Session(session) + return &a +} + +func (a postManyToManyComments) Model(m *models.Post) *postManyToManyCommentsTx { + return &postManyToManyCommentsTx{a.db.Model(m).Association(a.Name())} +} + +type postManyToManyCommentsTx struct{ tx *gorm.Association } + +func (a postManyToManyCommentsTx) Find() (result []*models.Comment, err error) { + return result, a.tx.Find(&result) +} + +func (a postManyToManyCommentsTx) Append(values ...*models.Comment) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a postManyToManyCommentsTx) Replace(values ...*models.Comment) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a postManyToManyCommentsTx) Delete(values ...*models.Comment) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a postManyToManyCommentsTx) Clear() error { + return a.tx.Clear() +} + +func (a postManyToManyCommentsTx) Count() int64 { + return a.tx.Count() +} + type postDo struct{ gen.DO } type IPostDo interface { diff --git a/internal/models/models.go b/internal/models/models.go index 7204a70..f6e7859 100644 --- a/internal/models/models.go +++ b/internal/models/models.go @@ -1,7 +1,7 @@ package models var Entities = []any{ - &Post{}, &Author{}, &PostType{}, + &Post{}, &Author{}, &PostType{}, &Comment{}, } type PostType struct { @@ -10,18 +10,28 @@ type PostType struct { } type Post struct { - Id uint `gorm:"primaryKey" ui:"hidden"` - Text string `displayName:"Текст" ui:"label:Текст"` - Deadline int64 `ui:"label:Дедлайн;datatype:datetime;"` - CreatedAt int64 `gorm:"autoCreateTime" ui:"readonly;datatype:datetime;"` - AuthorId uint `ui:"hidden" gorm:"foreignKey:Id;references:AuthorId;constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"` - Author Author `ui:"label:Автор; field:Name;"` - TypeId uint `ui:"hidden"` - PostType PostType `ui:"label:Тип; field:Name;" gorm:"foreignKey:Id;references:TypeId;constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"` + Id uint `gorm:"primaryKey" ui:"hidden"` + Text string `ui:"label:Текст"` + Deadline int64 `ui:"label:Дедлайн;datatype:datetime;"` + CreatedAt int64 `gorm:"autoCreateTime" ui:"readonly;datatype:datetime;"` + AuthorId uint `ui:"hidden" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"` + Author Author `ui:"label:Автор; field:Name;"` + PostTypeId uint `ui:"hidden"` + PostType PostType `ui:"label:Тип; field:Name;" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"` + Comments []Comment `ui:"label:Комментарии; field:Text;" gorm:"many2many:comments_post;constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"` } type Author struct { - Id uint `gorm:"primaryKey" ui:"hidden"` - Name string `ui:"label:Имя;"` - Posts []Post `ui:"label:Посты; field:Text;" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"` + Id uint `gorm:"primaryKey" ui:"hidden"` + Name string `ui:"label:Имя;"` + Posts []Post `ui:"label:Посты; field:Text;" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"` + Comments []Comment `ui:"label:Комментарии; field:Text;" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"` +} + +type Comment struct { + Id uint `gorm:"primaryKey" ui:"hidden"` + Text string `ui:"label:Текст;"` + AuthorId uint `ui:"hidden"` + Author Author `ui:"label:Автор; field:Name;" gorm:"foreignKey:Id;references:AuthorId;constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"` + Posts []Post `ui:"label:Посты; field:Text;" gorm:"many2many:comments_post;constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"` } diff --git a/internal/services/comment.go b/internal/services/comment.go new file mode 100644 index 0000000..a2a7573 --- /dev/null +++ b/internal/services/comment.go @@ -0,0 +1,66 @@ +package services + +import ( + "app/internal/dal" + "app/internal/database" + "app/internal/models" + "errors" + + "gorm.io/gen/field" + "gorm.io/gorm" +) + +type CommentService struct { +} +type Comment = models.Comment + +func (service *CommentService) Create(item Comment) (Comment, error) { + ReplaceEmptySlicesWithNil(&item) + err := dal.Comment.Preload(field.Associations).Create(&item) + if err != nil { + return item, err + } + err = AppendAssociations(database.GetInstance(), &item) + return item, err +} + +func (service *CommentService) GetAll() ([]*Comment, error) { + var comments []*Comment + comments, err := dal.Comment.Preload(field.Associations).Find() + return comments, err +} +func (service *CommentService) GetById(id uint) (*Comment, error) { + item, err := dal.Comment.Preload(field.Associations).Where(dal.Comment.Id.Eq(id)).First() + if err != nil { + if errors.Is(err, gorm.ErrRecordNotFound) { + return nil, nil + } else { + return nil, err + } + } + return item, nil +} +func (service *CommentService) Update(item Comment) (Comment, error) { + ReplaceEmptySlicesWithNil(&item) + err := dal.Comment.Preload(field.Associations).Save(&item) + if err != nil { + return item, err + } + + err = UpdateAssociations(database.GetInstance(), &item) + + if err != nil { + return item, err + } + + return item, err +} +func (service *CommentService) Delete(id uint) error { + _, err := dal.Comment.Unscoped().Where(dal.Comment.Id.Eq(id)).Delete() + return err +} + +func (service *CommentService) Count() (int64, error) { + amount, err := dal.Comment.Count() + return amount, err +} diff --git a/internal/services/default_data.go b/internal/services/default_data.go index e0c26d1..2bd477c 100644 --- a/internal/services/default_data.go +++ b/internal/services/default_data.go @@ -7,8 +7,10 @@ import ( ) func InsertDefaultData() { + insertPostTypes() insertAuthors() insertPosts() + insertComments() } func InsertDefaultEntityData[T any](service Service[T], entities []T) { @@ -23,22 +25,25 @@ func InsertDefaultEntityData[T any](service Service[T], entities []T) { func insertPosts() { InsertDefaultEntityData(&PostService{}, []Post{ { - Id: 1, - Text: "Жителям Кузбасса запретили болеть.", - Deadline: time.Now().Unix(), - AuthorId: 1, + Id: 1, + Text: "Жителям Кузбасса запретили болеть.", + Deadline: time.Now().Unix(), + AuthorId: 1, + PostTypeId: 1, }, { - Id: 2, - Deadline: time.Now().Add(time.Hour * 24 * 5).Unix(), - Text: "⚡️⚡️⚡️Дома будут летать.", - AuthorId: 2, + Id: 2, + Deadline: time.Now().Add(time.Hour * 24 * 5).Unix(), + Text: "⚡️⚡️⚡️Дома будут летать.", + AuthorId: 2, + PostTypeId: 2, }, { - Id: 3, - Deadline: time.Now().Add(time.Hour * 24 * 6).Unix(), - Text: "В Кузбассе начали строить дома выше, чтобы жители были ближе к богу и солнцу.", - AuthorId: 3, + Id: 3, + Deadline: time.Now().Add(time.Hour * 24 * 6).Unix(), + Text: "В Кузбассе начали строить дома выше, чтобы жители были ближе к богу и солнцу.", + AuthorId: 3, + PostTypeId: 3, }, }) } @@ -59,3 +64,43 @@ func insertAuthors() { }, }) } + +func insertComments() { + InsertDefaultEntityData(&CommentService{}, []Comment{ + { + Id: 1, + Text: "Это просто замечательно!", + AuthorId: 1, + Posts: []Post{{Id: 1}}, + }, + { + Id: 2, + Text: "Я тоже думаю, что это замечательно!", + AuthorId: 2, + Posts: []Post{{Id: 2}}, + }, + { + Id: 3, + Text: "Я тоже думаю, что это замечательно!", + AuthorId: 3, + Posts: []Post{{Id: 3}}, + }, + }) +} + +func insertPostTypes() { + InsertDefaultEntityData(&PostTypeService{}, []PostType{ + { + Id: 1, + Name: "Общество", + }, + { + Id: 2, + Name: "Политика", + }, + { + Id: 3, + Name: "Экономика", + }, + }) +} diff --git a/internal/services/post.go b/internal/services/post.go index ae70b1d..9820779 100644 --- a/internal/services/post.go +++ b/internal/services/post.go @@ -2,11 +2,13 @@ package services import ( "app/internal/dal" + "app/internal/database" "app/internal/dialogs" excel "app/internal/extras/excel" "app/internal/models" "errors" "fmt" + "gorm.io/gen/field" "gorm.io/gorm" ) @@ -15,7 +17,12 @@ type PostService struct{} type Post = models.Post func (service *PostService) Create(item Post) (Post, error) { + ReplaceEmptySlicesWithNil(&item) err := dal.Post.Preload(field.Associations).Create(&item) + if err != nil { + return item, err + } + err = AppendAssociations(database.GetInstance(), &item) return item, err } func (service *PostService) GetAll() ([]*Post, error) { @@ -34,10 +41,20 @@ func (service *PostService) GetById(id uint) (*Post, error) { } return item, nil } + func (service *PostService) Update(item Post) (Post, error) { + ReplaceEmptySlicesWithNil(&item) err := dal.Post.Preload(field.Associations).Save(&item) + if err != nil { + return item, err + } + err = UpdateAssociations(database.GetInstance(), &item) + if err != nil { + return item, err + } return item, err } + func (service *PostService) Delete(id uint) error { _, err := dal.Post.Unscoped().Where(dal.Post.Id.Eq(id)).Delete() return err diff --git a/internal/services/posttype.go b/internal/services/posttype.go new file mode 100644 index 0000000..2a1a07a --- /dev/null +++ b/internal/services/posttype.go @@ -0,0 +1,61 @@ +package services + +import ( + "app/internal/dal" + "app/internal/database" + "app/internal/models" + "errors" + + "gorm.io/gen/field" + "gorm.io/gorm" +) + +type PostTypeService struct { +} +type PostType = models.PostType + +func (service *PostTypeService) Create(item PostType) (PostType, error) { + ReplaceEmptySlicesWithNil(&item) + err := dal.PostType.Preload(field.Associations).Create(&item) + if err != nil { + return item, err + } + err = AppendAssociations(database.GetInstance(), &item) + return item, err +} +func (service *PostTypeService) GetAll() ([]*PostType, error) { + var posttypes []*PostType + posttypes, err := dal.PostType.Preload(field.Associations).Find() + return posttypes, err +} +func (service *PostTypeService) GetById(id uint) (*PostType, error) { + item, err := dal.PostType.Preload(field.Associations).Where(dal.PostType.Id.Eq(id)).First() + if err != nil { + if errors.Is(err, gorm.ErrRecordNotFound) { + return nil, nil + } else { + return nil, err + } + } + return item, nil +} +func (service *PostTypeService) Update(item PostType) (PostType, error) { + ReplaceEmptySlicesWithNil(&item) + err := dal.PostType.Preload(field.Associations).Save(&item) + if err != nil { + return item, err + } + err = UpdateAssociations(database.GetInstance(), &item) + if err != nil { + return item, err + } + return item, err +} +func (service *PostTypeService) Delete(id uint) error { + _, err := dal.PostType.Unscoped().Where(dal.PostType.Id.Eq(id)).Delete() + return err +} +func (service *PostTypeService) Count() (int64, error) { + amount, err := dal.PostType.Count() + return amount, err +} diff --git a/internal/services/services.go b/internal/services/services.go index 03f23f6..547cf2b 100644 --- a/internal/services/services.go +++ b/internal/services/services.go @@ -5,4 +5,6 @@ import "github.com/wailsapp/wails/v3/pkg/application" var ExportedServices = []application.Service{ application.NewService(&PostService{}), application.NewService(&AuthorService{}), + application.NewService(&CommentService{}), + application.NewService(&PostTypeService{}), }