From b7f69844e1f8eada74167848dfa8d2456792d639 Mon Sep 17 00:00:00 2001 From: ducky Date: Fri, 30 Jan 2026 16:45:04 +0800 Subject: [PATCH 1/2] feat(announcements): add admin/user announcement system Implements announcements end-to-end (admin CRUD + read status, user list + mark read) with OR-of-AND targeting. Also breaks the ent<->service import cycle by moving schema-facing constants/targeting into a new domain package. --- backend/cmd/server/wire_gen.go | 9 +- backend/ent/announcement.go | 249 +++ backend/ent/announcement/announcement.go | 164 ++ backend/ent/announcement/where.go | 624 ++++++ backend/ent/announcement_create.go | 1159 +++++++++++ backend/ent/announcement_delete.go | 88 + backend/ent/announcement_query.go | 643 ++++++ backend/ent/announcement_update.go | 824 ++++++++ backend/ent/announcementread.go | 185 ++ .../ent/announcementread/announcementread.go | 127 ++ backend/ent/announcementread/where.go | 257 +++ backend/ent/announcementread_create.go | 660 +++++++ backend/ent/announcementread_delete.go | 88 + backend/ent/announcementread_query.go | 718 +++++++ backend/ent/announcementread_update.go | 456 +++++ backend/ent/client.go | 376 +++- backend/ent/ent.go | 4 + backend/ent/hook/hook.go | 24 + backend/ent/intercept/intercept.go | 60 + backend/ent/migrate/schema.go | 102 + backend/ent/mutation.go | 1759 ++++++++++++++++- backend/ent/predicate/predicate.go | 6 + backend/ent/runtime/runtime.go | 52 + backend/ent/schema/account.go | 4 +- backend/ent/schema/announcement.go | 91 + backend/ent/schema/announcement_read.go | 66 + backend/ent/schema/api_key.go | 4 +- backend/ent/schema/group.go | 8 +- backend/ent/schema/promo_code.go | 4 +- backend/ent/schema/redeem_code.go | 6 +- backend/ent/schema/user.go | 7 +- backend/ent/schema/user_subscription.go | 4 +- backend/ent/tx.go | 6 + backend/ent/user.go | 28 +- backend/ent/user/user.go | 30 + backend/ent/user/where.go | 23 + backend/ent/user_create.go | 32 + backend/ent/user_query.go | 76 +- backend/ent/user_update.go | 163 ++ backend/internal/domain/announcement.go | 226 +++ backend/internal/domain/constants.go | 64 + .../handler/admin/announcement_handler.go | 247 +++ .../internal/handler/announcement_handler.go | 82 + backend/internal/handler/dto/announcement.go | 75 + backend/internal/handler/handler.go | 2 + backend/internal/handler/wire.go | 6 + .../repository/announcement_read_repo.go | 84 + .../internal/repository/announcement_repo.go | 195 ++ backend/internal/repository/wire.go | 2 + backend/internal/server/routes/admin.go | 15 + backend/internal/server/routes/user.go | 7 + backend/internal/service/announcement.go | 64 + .../internal/service/announcement_service.go | 378 ++++ .../service/announcement_targeting_test.go | 67 + backend/internal/service/domain_constants.go | 56 +- backend/internal/service/wire.go | 1 + backend/migrations/045_add_announcements.sql | 44 + frontend/src/api/admin/announcements.ts | 71 + frontend/src/api/admin/index.ts | 3 + frontend/src/api/announcements.ts | 26 + frontend/src/api/index.ts | 1 + .../AnnouncementReadStatusDialog.vue | 186 ++ .../AnnouncementTargetingEditor.vue | 388 ++++ frontend/src/components/layout/AppSidebar.vue | 18 + frontend/src/i18n/locales/en.ts | 83 + frontend/src/i18n/locales/zh.ts | 83 + frontend/src/router/index.ts | 24 + frontend/src/types/index.ts | 75 + .../src/views/admin/AnnouncementsView.vue | 538 +++++ frontend/src/views/user/AnnouncementsView.vue | 140 ++ 70 files changed, 12366 insertions(+), 71 deletions(-) create mode 100644 backend/ent/announcement.go create mode 100644 backend/ent/announcement/announcement.go create mode 100644 backend/ent/announcement/where.go create mode 100644 backend/ent/announcement_create.go create mode 100644 backend/ent/announcement_delete.go create mode 100644 backend/ent/announcement_query.go create mode 100644 backend/ent/announcement_update.go create mode 100644 backend/ent/announcementread.go create mode 100644 backend/ent/announcementread/announcementread.go create mode 100644 backend/ent/announcementread/where.go create mode 100644 backend/ent/announcementread_create.go create mode 100644 backend/ent/announcementread_delete.go create mode 100644 backend/ent/announcementread_query.go create mode 100644 backend/ent/announcementread_update.go create mode 100644 backend/ent/schema/announcement.go create mode 100644 backend/ent/schema/announcement_read.go create mode 100644 backend/internal/domain/announcement.go create mode 100644 backend/internal/domain/constants.go create mode 100644 backend/internal/handler/admin/announcement_handler.go create mode 100644 backend/internal/handler/announcement_handler.go create mode 100644 backend/internal/handler/dto/announcement.go create mode 100644 backend/internal/repository/announcement_read_repo.go create mode 100644 backend/internal/repository/announcement_repo.go create mode 100644 backend/internal/service/announcement.go create mode 100644 backend/internal/service/announcement_service.go create mode 100644 backend/internal/service/announcement_targeting_test.go create mode 100644 backend/migrations/045_add_announcements.sql create mode 100644 frontend/src/api/admin/announcements.ts create mode 100644 frontend/src/api/announcements.ts create mode 100644 frontend/src/components/admin/announcements/AnnouncementReadStatusDialog.vue create mode 100644 frontend/src/components/admin/announcements/AnnouncementTargetingEditor.vue create mode 100644 frontend/src/views/admin/AnnouncementsView.vue create mode 100644 frontend/src/views/user/AnnouncementsView.vue diff --git a/backend/cmd/server/wire_gen.go b/backend/cmd/server/wire_gen.go index 71624091..7d465fee 100644 --- a/backend/cmd/server/wire_gen.go +++ b/backend/cmd/server/wire_gen.go @@ -81,6 +81,10 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) { redeemService := service.NewRedeemService(redeemCodeRepository, userRepository, subscriptionService, redeemCache, billingCacheService, client, apiKeyAuthCacheInvalidator) redeemHandler := handler.NewRedeemHandler(redeemService) subscriptionHandler := handler.NewSubscriptionHandler(subscriptionService) + announcementRepository := repository.NewAnnouncementRepository(client) + announcementReadRepository := repository.NewAnnouncementReadRepository(client) + announcementService := service.NewAnnouncementService(announcementRepository, announcementReadRepository, userRepository, userSubscriptionRepository) + announcementHandler := handler.NewAnnouncementHandler(announcementService) dashboardAggregationRepository := repository.NewDashboardAggregationRepository(db) dashboardStatsCache := repository.NewDashboardCache(redisClient, configConfig) dashboardService := service.NewDashboardService(usageLogRepository, dashboardAggregationRepository, dashboardStatsCache, configConfig) @@ -128,6 +132,7 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) { crsSyncService := service.NewCRSSyncService(accountRepository, proxyRepository, oAuthService, openAIOAuthService, geminiOAuthService, configConfig) sessionLimitCache := repository.ProvideSessionLimitCache(redisClient, configConfig) accountHandler := admin.NewAccountHandler(adminService, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, rateLimitService, accountUsageService, accountTestService, concurrencyService, crsSyncService, sessionLimitCache, compositeTokenCacheInvalidator) + adminAnnouncementHandler := admin.NewAnnouncementHandler(announcementService) oAuthHandler := admin.NewOAuthHandler(oAuthService) openAIOAuthHandler := admin.NewOpenAIOAuthHandler(openAIOAuthService, adminService) geminiOAuthHandler := admin.NewGeminiOAuthHandler(geminiOAuthService) @@ -167,12 +172,12 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) { userAttributeValueRepository := repository.NewUserAttributeValueRepository(client) userAttributeService := service.NewUserAttributeService(userAttributeDefinitionRepository, userAttributeValueRepository) userAttributeHandler := admin.NewUserAttributeHandler(userAttributeService) - adminHandlers := handler.ProvideAdminHandlers(dashboardHandler, adminUserHandler, groupHandler, accountHandler, oAuthHandler, openAIOAuthHandler, geminiOAuthHandler, antigravityOAuthHandler, proxyHandler, adminRedeemHandler, promoHandler, settingHandler, opsHandler, systemHandler, adminSubscriptionHandler, adminUsageHandler, userAttributeHandler) + adminHandlers := handler.ProvideAdminHandlers(dashboardHandler, adminUserHandler, groupHandler, accountHandler, adminAnnouncementHandler, oAuthHandler, openAIOAuthHandler, geminiOAuthHandler, antigravityOAuthHandler, proxyHandler, adminRedeemHandler, promoHandler, settingHandler, opsHandler, systemHandler, adminSubscriptionHandler, adminUsageHandler, userAttributeHandler) gatewayHandler := handler.NewGatewayHandler(gatewayService, geminiMessagesCompatService, antigravityGatewayService, userService, concurrencyService, billingCacheService, configConfig) openAIGatewayHandler := handler.NewOpenAIGatewayHandler(openAIGatewayService, concurrencyService, billingCacheService, configConfig) handlerSettingHandler := handler.ProvideSettingHandler(settingService, buildInfo) totpHandler := handler.NewTotpHandler(totpService) - handlers := handler.ProvideHandlers(authHandler, userHandler, apiKeyHandler, usageHandler, redeemHandler, subscriptionHandler, adminHandlers, gatewayHandler, openAIGatewayHandler, handlerSettingHandler, totpHandler) + handlers := handler.ProvideHandlers(authHandler, userHandler, apiKeyHandler, usageHandler, redeemHandler, subscriptionHandler, announcementHandler, adminHandlers, gatewayHandler, openAIGatewayHandler, handlerSettingHandler, totpHandler) jwtAuthMiddleware := middleware.NewJWTAuthMiddleware(authService, userService) adminAuthMiddleware := middleware.NewAdminAuthMiddleware(authService, userService, settingService) apiKeyAuthMiddleware := middleware.NewAPIKeyAuthMiddleware(apiKeyService, subscriptionService, configConfig) diff --git a/backend/ent/announcement.go b/backend/ent/announcement.go new file mode 100644 index 00000000..93d7a375 --- /dev/null +++ b/backend/ent/announcement.go @@ -0,0 +1,249 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "encoding/json" + "fmt" + "strings" + "time" + + "entgo.io/ent" + "entgo.io/ent/dialect/sql" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/internal/domain" +) + +// Announcement is the model entity for the Announcement schema. +type Announcement struct { + config `json:"-"` + // ID of the ent. + ID int64 `json:"id,omitempty"` + // 公告标题 + Title string `json:"title,omitempty"` + // 公告内容（支持 Markdown） + Content string `json:"content,omitempty"` + // 状态: draft, active, archived + Status string `json:"status,omitempty"` + // 展示条件（JSON 规则） + Targeting domain.AnnouncementTargeting `json:"targeting,omitempty"` + // 开始展示时间（为空表示立即生效） + StartsAt *time.Time `json:"starts_at,omitempty"` + // 结束展示时间（为空表示永久生效） + EndsAt *time.Time `json:"ends_at,omitempty"` + // 创建人用户ID（管理员） + CreatedBy *int64 `json:"created_by,omitempty"` + // 更新人用户ID（管理员） + UpdatedBy *int64 `json:"updated_by,omitempty"` + // CreatedAt holds the value of the "created_at" field. + CreatedAt time.Time `json:"created_at,omitempty"` + // UpdatedAt holds the value of the "updated_at" field. + UpdatedAt time.Time `json:"updated_at,omitempty"` + // Edges holds the relations/edges for other nodes in the graph. + // The values are being populated by the AnnouncementQuery when eager-loading is set. + Edges AnnouncementEdges `json:"edges"` + selectValues sql.SelectValues +} + +// AnnouncementEdges holds the relations/edges for other nodes in the graph. +type AnnouncementEdges struct { + // Reads holds the value of the reads edge. + Reads []*AnnouncementRead `json:"reads,omitempty"` + // loadedTypes holds the information for reporting if a + // type was loaded (or requested) in eager-loading or not. + loadedTypes [1]bool +} + +// ReadsOrErr returns the Reads value or an error if the edge +// was not loaded in eager-loading. +func (e AnnouncementEdges) ReadsOrErr() ([]*AnnouncementRead, error) { + if e.loadedTypes[0] { + return e.Reads, nil + } + return nil, &NotLoadedError{edge: "reads"} +} + +// scanValues returns the types for scanning values from sql.Rows. +func (*Announcement) scanValues(columns []string) ([]any, error) { + values := make([]any, len(columns)) + for i := range columns { + switch columns[i] { + case announcement.FieldTargeting: + values[i] = new([]byte) + case announcement.FieldID, announcement.FieldCreatedBy, announcement.FieldUpdatedBy: + values[i] = new(sql.NullInt64) + case announcement.FieldTitle, announcement.FieldContent, announcement.FieldStatus: + values[i] = new(sql.NullString) + case announcement.FieldStartsAt, announcement.FieldEndsAt, announcement.FieldCreatedAt, announcement.FieldUpdatedAt: + values[i] = new(sql.NullTime) + default: + values[i] = new(sql.UnknownType) + } + } + return values, nil +} + +// assignValues assigns the values that were returned from sql.Rows (after scanning) +// to the Announcement fields. +func (_m *Announcement) assignValues(columns []string, values []any) error { + if m, n := len(values), len(columns); m < n { + return fmt.Errorf("mismatch number of scan values: %d != %d", m, n) + } + for i := range columns { + switch columns[i] { + case announcement.FieldID: + value, ok := values[i].(*sql.NullInt64) + if !ok { + return fmt.Errorf("unexpected type %T for field id", value) + } + _m.ID = int64(value.Int64) + case announcement.FieldTitle: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field title", values[i]) + } else if value.Valid { + _m.Title = value.String + } + case announcement.FieldContent: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field content", values[i]) + } else if value.Valid { + _m.Content = value.String + } + case announcement.FieldStatus: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field status", values[i]) + } else if value.Valid { + _m.Status = value.String + } + case announcement.FieldTargeting: + if value, ok := values[i].(*[]byte); !ok { + return fmt.Errorf("unexpected type %T for field targeting", values[i]) + } else if value != nil && len(*value) > 0 { + if err := json.Unmarshal(*value, &_m.Targeting); err != nil { + return fmt.Errorf("unmarshal field targeting: %w", err) + } + } + case announcement.FieldStartsAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field starts_at", values[i]) + } else if value.Valid { + _m.StartsAt = new(time.Time) + *_m.StartsAt = value.Time + } + case announcement.FieldEndsAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field ends_at", values[i]) + } else if value.Valid { + _m.EndsAt = new(time.Time) + *_m.EndsAt = value.Time + } + case announcement.FieldCreatedBy: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field created_by", values[i]) + } else if value.Valid { + _m.CreatedBy = new(int64) + *_m.CreatedBy = value.Int64 + } + case announcement.FieldUpdatedBy: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field updated_by", values[i]) + } else if value.Valid { + _m.UpdatedBy = new(int64) + *_m.UpdatedBy = value.Int64 + } + case announcement.FieldCreatedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field created_at", values[i]) + } else if value.Valid { + _m.CreatedAt = value.Time + } + case announcement.FieldUpdatedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field updated_at", values[i]) + } else if value.Valid { + _m.UpdatedAt = value.Time + } + default: + _m.selectValues.Set(columns[i], values[i]) + } + } + return nil +} + +// Value returns the ent.Value that was dynamically selected and assigned to the Announcement. +// This includes values selected through modifiers, order, etc. +func (_m *Announcement) Value(name string) (ent.Value, error) { + return _m.selectValues.Get(name) +} + +// QueryReads queries the "reads" edge of the Announcement entity. +func (_m *Announcement) QueryReads() *AnnouncementReadQuery { + return NewAnnouncementClient(_m.config).QueryReads(_m) +} + +// Update returns a builder for updating this Announcement. +// Note that you need to call Announcement.Unwrap() before calling this method if this Announcement +// was returned from a transaction, and the transaction was committed or rolled back. +func (_m *Announcement) Update() *AnnouncementUpdateOne { + return NewAnnouncementClient(_m.config).UpdateOne(_m) +} + +// Unwrap unwraps the Announcement entity that was returned from a transaction after it was closed, +// so that all future queries will be executed through the driver which created the transaction. +func (_m *Announcement) Unwrap() *Announcement { + _tx, ok := _m.config.driver.(*txDriver) + if !ok { + panic("ent: Announcement is not a transactional entity") + } + _m.config.driver = _tx.drv + return _m +} + +// String implements the fmt.Stringer. +func (_m *Announcement) String() string { + var builder strings.Builder + builder.WriteString("Announcement(") + builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID)) + builder.WriteString("title=") + builder.WriteString(_m.Title) + builder.WriteString(", ") + builder.WriteString("content=") + builder.WriteString(_m.Content) + builder.WriteString(", ") + builder.WriteString("status=") + builder.WriteString(_m.Status) + builder.WriteString(", ") + builder.WriteString("targeting=") + builder.WriteString(fmt.Sprintf("%v", _m.Targeting)) + builder.WriteString(", ") + if v := _m.StartsAt; v != nil { + builder.WriteString("starts_at=") + builder.WriteString(v.Format(time.ANSIC)) + } + builder.WriteString(", ") + if v := _m.EndsAt; v != nil { + builder.WriteString("ends_at=") + builder.WriteString(v.Format(time.ANSIC)) + } + builder.WriteString(", ") + if v := _m.CreatedBy; v != nil { + builder.WriteString("created_by=") + builder.WriteString(fmt.Sprintf("%v", *v)) + } + builder.WriteString(", ") + if v := _m.UpdatedBy; v != nil { + builder.WriteString("updated_by=") + builder.WriteString(fmt.Sprintf("%v", *v)) + } + builder.WriteString(", ") + builder.WriteString("created_at=") + builder.WriteString(_m.CreatedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("updated_at=") + builder.WriteString(_m.UpdatedAt.Format(time.ANSIC)) + builder.WriteByte(')') + return builder.String() +} + +// Announcements is a parsable slice of Announcement. +type Announcements []*Announcement diff --git a/backend/ent/announcement/announcement.go b/backend/ent/announcement/announcement.go new file mode 100644 index 00000000..4f34ee05 --- /dev/null +++ b/backend/ent/announcement/announcement.go @@ -0,0 +1,164 @@ +// Code generated by ent, DO NOT EDIT. + +package announcement + +import ( + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" +) + +const ( + // Label holds the string label denoting the announcement type in the database. + Label = "announcement" + // FieldID holds the string denoting the id field in the database. + FieldID = "id" + // FieldTitle holds the string denoting the title field in the database. + FieldTitle = "title" + // FieldContent holds the string denoting the content field in the database. + FieldContent = "content" + // FieldStatus holds the string denoting the status field in the database. + FieldStatus = "status" + // FieldTargeting holds the string denoting the targeting field in the database. + FieldTargeting = "targeting" + // FieldStartsAt holds the string denoting the starts_at field in the database. + FieldStartsAt = "starts_at" + // FieldEndsAt holds the string denoting the ends_at field in the database. + FieldEndsAt = "ends_at" + // FieldCreatedBy holds the string denoting the created_by field in the database. + FieldCreatedBy = "created_by" + // FieldUpdatedBy holds the string denoting the updated_by field in the database. + FieldUpdatedBy = "updated_by" + // FieldCreatedAt holds the string denoting the created_at field in the database. + FieldCreatedAt = "created_at" + // FieldUpdatedAt holds the string denoting the updated_at field in the database. + FieldUpdatedAt = "updated_at" + // EdgeReads holds the string denoting the reads edge name in mutations. + EdgeReads = "reads" + // Table holds the table name of the announcement in the database. + Table = "announcements" + // ReadsTable is the table that holds the reads relation/edge. + ReadsTable = "announcement_reads" + // ReadsInverseTable is the table name for the AnnouncementRead entity. + // It exists in this package in order to avoid circular dependency with the "announcementread" package. + ReadsInverseTable = "announcement_reads" + // ReadsColumn is the table column denoting the reads relation/edge. + ReadsColumn = "announcement_id" +) + +// Columns holds all SQL columns for announcement fields. +var Columns = []string{ + FieldID, + FieldTitle, + FieldContent, + FieldStatus, + FieldTargeting, + FieldStartsAt, + FieldEndsAt, + FieldCreatedBy, + FieldUpdatedBy, + FieldCreatedAt, + FieldUpdatedAt, +} + +// ValidColumn reports if the column name is valid (part of the table columns). +func ValidColumn(column string) bool { + for i := range Columns { + if column == Columns[i] { + return true + } + } + return false +} + +var ( + // TitleValidator is a validator for the "title" field. It is called by the builders before save. + TitleValidator func(string) error + // ContentValidator is a validator for the "content" field. It is called by the builders before save. + ContentValidator func(string) error + // DefaultStatus holds the default value on creation for the "status" field. + DefaultStatus string + // StatusValidator is a validator for the "status" field. It is called by the builders before save. + StatusValidator func(string) error + // DefaultCreatedAt holds the default value on creation for the "created_at" field. + DefaultCreatedAt func() time.Time + // DefaultUpdatedAt holds the default value on creation for the "updated_at" field. + DefaultUpdatedAt func() time.Time + // UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field. + UpdateDefaultUpdatedAt func() time.Time +) + +// OrderOption defines the ordering options for the Announcement queries. +type OrderOption func(*sql.Selector) + +// ByID orders the results by the id field. +func ByID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldID, opts...).ToFunc() +} + +// ByTitle orders the results by the title field. +func ByTitle(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldTitle, opts...).ToFunc() +} + +// ByContent orders the results by the content field. +func ByContent(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldContent, opts...).ToFunc() +} + +// ByStatus orders the results by the status field. +func ByStatus(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldStatus, opts...).ToFunc() +} + +// ByStartsAt orders the results by the starts_at field. +func ByStartsAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldStartsAt, opts...).ToFunc() +} + +// ByEndsAt orders the results by the ends_at field. +func ByEndsAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldEndsAt, opts...).ToFunc() +} + +// ByCreatedBy orders the results by the created_by field. +func ByCreatedBy(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCreatedBy, opts...).ToFunc() +} + +// ByUpdatedBy orders the results by the updated_by field. +func ByUpdatedBy(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUpdatedBy, opts...).ToFunc() +} + +// ByCreatedAt orders the results by the created_at field. +func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCreatedAt, opts...).ToFunc() +} + +// ByUpdatedAt orders the results by the updated_at field. +func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc() +} + +// ByReadsCount orders the results by reads count. +func ByReadsCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newReadsStep(), opts...) + } +} + +// ByReads orders the results by reads terms. +func ByReads(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newReadsStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} +func newReadsStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(ReadsInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ReadsTable, ReadsColumn), + ) +} diff --git a/backend/ent/announcement/where.go b/backend/ent/announcement/where.go new file mode 100644 index 00000000..d3cad2a5 --- /dev/null +++ b/backend/ent/announcement/where.go @@ -0,0 +1,624 @@ +// Code generated by ent, DO NOT EDIT. + +package announcement + +import ( + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "github.com/Wei-Shaw/sub2api/ent/predicate" +) + +// ID filters vertices based on their ID field. +func ID(id int64) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldID, id)) +} + +// IDEQ applies the EQ predicate on the ID field. +func IDEQ(id int64) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldID, id)) +} + +// IDNEQ applies the NEQ predicate on the ID field. +func IDNEQ(id int64) predicate.Announcement { + return predicate.Announcement(sql.FieldNEQ(FieldID, id)) +} + +// IDIn applies the In predicate on the ID field. +func IDIn(ids ...int64) predicate.Announcement { + return predicate.Announcement(sql.FieldIn(FieldID, ids...)) +} + +// IDNotIn applies the NotIn predicate on the ID field. +func IDNotIn(ids ...int64) predicate.Announcement { + return predicate.Announcement(sql.FieldNotIn(FieldID, ids...)) +} + +// IDGT applies the GT predicate on the ID field. +func IDGT(id int64) predicate.Announcement { + return predicate.Announcement(sql.FieldGT(FieldID, id)) +} + +// IDGTE applies the GTE predicate on the ID field. +func IDGTE(id int64) predicate.Announcement { + return predicate.Announcement(sql.FieldGTE(FieldID, id)) +} + +// IDLT applies the LT predicate on the ID field. +func IDLT(id int64) predicate.Announcement { + return predicate.Announcement(sql.FieldLT(FieldID, id)) +} + +// IDLTE applies the LTE predicate on the ID field. +func IDLTE(id int64) predicate.Announcement { + return predicate.Announcement(sql.FieldLTE(FieldID, id)) +} + +// Title applies equality check predicate on the "title" field. It's identical to TitleEQ. +func Title(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldTitle, v)) +} + +// Content applies equality check predicate on the "content" field. It's identical to ContentEQ. +func Content(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldContent, v)) +} + +// Status applies equality check predicate on the "status" field. It's identical to StatusEQ. +func Status(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldStatus, v)) +} + +// StartsAt applies equality check predicate on the "starts_at" field. It's identical to StartsAtEQ. +func StartsAt(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldStartsAt, v)) +} + +// EndsAt applies equality check predicate on the "ends_at" field. It's identical to EndsAtEQ. +func EndsAt(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldEndsAt, v)) +} + +// CreatedBy applies equality check predicate on the "created_by" field. It's identical to CreatedByEQ. +func CreatedBy(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldCreatedBy, v)) +} + +// UpdatedBy applies equality check predicate on the "updated_by" field. It's identical to UpdatedByEQ. +func UpdatedBy(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldUpdatedBy, v)) +} + +// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ. +func CreatedAt(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldCreatedAt, v)) +} + +// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ. +func UpdatedAt(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// TitleEQ applies the EQ predicate on the "title" field. +func TitleEQ(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldTitle, v)) +} + +// TitleNEQ applies the NEQ predicate on the "title" field. +func TitleNEQ(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldNEQ(FieldTitle, v)) +} + +// TitleIn applies the In predicate on the "title" field. +func TitleIn(vs ...string) predicate.Announcement { + return predicate.Announcement(sql.FieldIn(FieldTitle, vs...)) +} + +// TitleNotIn applies the NotIn predicate on the "title" field. +func TitleNotIn(vs ...string) predicate.Announcement { + return predicate.Announcement(sql.FieldNotIn(FieldTitle, vs...)) +} + +// TitleGT applies the GT predicate on the "title" field. +func TitleGT(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldGT(FieldTitle, v)) +} + +// TitleGTE applies the GTE predicate on the "title" field. +func TitleGTE(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldGTE(FieldTitle, v)) +} + +// TitleLT applies the LT predicate on the "title" field. +func TitleLT(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldLT(FieldTitle, v)) +} + +// TitleLTE applies the LTE predicate on the "title" field. +func TitleLTE(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldLTE(FieldTitle, v)) +} + +// TitleContains applies the Contains predicate on the "title" field. +func TitleContains(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldContains(FieldTitle, v)) +} + +// TitleHasPrefix applies the HasPrefix predicate on the "title" field. +func TitleHasPrefix(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldHasPrefix(FieldTitle, v)) +} + +// TitleHasSuffix applies the HasSuffix predicate on the "title" field. +func TitleHasSuffix(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldHasSuffix(FieldTitle, v)) +} + +// TitleEqualFold applies the EqualFold predicate on the "title" field. +func TitleEqualFold(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldEqualFold(FieldTitle, v)) +} + +// TitleContainsFold applies the ContainsFold predicate on the "title" field. +func TitleContainsFold(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldContainsFold(FieldTitle, v)) +} + +// ContentEQ applies the EQ predicate on the "content" field. +func ContentEQ(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldContent, v)) +} + +// ContentNEQ applies the NEQ predicate on the "content" field. +func ContentNEQ(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldNEQ(FieldContent, v)) +} + +// ContentIn applies the In predicate on the "content" field. +func ContentIn(vs ...string) predicate.Announcement { + return predicate.Announcement(sql.FieldIn(FieldContent, vs...)) +} + +// ContentNotIn applies the NotIn predicate on the "content" field. +func ContentNotIn(vs ...string) predicate.Announcement { + return predicate.Announcement(sql.FieldNotIn(FieldContent, vs...)) +} + +// ContentGT applies the GT predicate on the "content" field. +func ContentGT(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldGT(FieldContent, v)) +} + +// ContentGTE applies the GTE predicate on the "content" field. +func ContentGTE(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldGTE(FieldContent, v)) +} + +// ContentLT applies the LT predicate on the "content" field. +func ContentLT(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldLT(FieldContent, v)) +} + +// ContentLTE applies the LTE predicate on the "content" field. +func ContentLTE(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldLTE(FieldContent, v)) +} + +// ContentContains applies the Contains predicate on the "content" field. +func ContentContains(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldContains(FieldContent, v)) +} + +// ContentHasPrefix applies the HasPrefix predicate on the "content" field. +func ContentHasPrefix(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldHasPrefix(FieldContent, v)) +} + +// ContentHasSuffix applies the HasSuffix predicate on the "content" field. +func ContentHasSuffix(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldHasSuffix(FieldContent, v)) +} + +// ContentEqualFold applies the EqualFold predicate on the "content" field. +func ContentEqualFold(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldEqualFold(FieldContent, v)) +} + +// ContentContainsFold applies the ContainsFold predicate on the "content" field. +func ContentContainsFold(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldContainsFold(FieldContent, v)) +} + +// StatusEQ applies the EQ predicate on the "status" field. +func StatusEQ(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldStatus, v)) +} + +// StatusNEQ applies the NEQ predicate on the "status" field. +func StatusNEQ(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldNEQ(FieldStatus, v)) +} + +// StatusIn applies the In predicate on the "status" field. +func StatusIn(vs ...string) predicate.Announcement { + return predicate.Announcement(sql.FieldIn(FieldStatus, vs...)) +} + +// StatusNotIn applies the NotIn predicate on the "status" field. +func StatusNotIn(vs ...string) predicate.Announcement { + return predicate.Announcement(sql.FieldNotIn(FieldStatus, vs...)) +} + +// StatusGT applies the GT predicate on the "status" field. +func StatusGT(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldGT(FieldStatus, v)) +} + +// StatusGTE applies the GTE predicate on the "status" field. +func StatusGTE(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldGTE(FieldStatus, v)) +} + +// StatusLT applies the LT predicate on the "status" field. +func StatusLT(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldLT(FieldStatus, v)) +} + +// StatusLTE applies the LTE predicate on the "status" field. +func StatusLTE(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldLTE(FieldStatus, v)) +} + +// StatusContains applies the Contains predicate on the "status" field. +func StatusContains(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldContains(FieldStatus, v)) +} + +// StatusHasPrefix applies the HasPrefix predicate on the "status" field. +func StatusHasPrefix(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldHasPrefix(FieldStatus, v)) +} + +// StatusHasSuffix applies the HasSuffix predicate on the "status" field. +func StatusHasSuffix(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldHasSuffix(FieldStatus, v)) +} + +// StatusEqualFold applies the EqualFold predicate on the "status" field. +func StatusEqualFold(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldEqualFold(FieldStatus, v)) +} + +// StatusContainsFold applies the ContainsFold predicate on the "status" field. +func StatusContainsFold(v string) predicate.Announcement { + return predicate.Announcement(sql.FieldContainsFold(FieldStatus, v)) +} + +// TargetingIsNil applies the IsNil predicate on the "targeting" field. +func TargetingIsNil() predicate.Announcement { + return predicate.Announcement(sql.FieldIsNull(FieldTargeting)) +} + +// TargetingNotNil applies the NotNil predicate on the "targeting" field. +func TargetingNotNil() predicate.Announcement { + return predicate.Announcement(sql.FieldNotNull(FieldTargeting)) +} + +// StartsAtEQ applies the EQ predicate on the "starts_at" field. +func StartsAtEQ(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldStartsAt, v)) +} + +// StartsAtNEQ applies the NEQ predicate on the "starts_at" field. +func StartsAtNEQ(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldNEQ(FieldStartsAt, v)) +} + +// StartsAtIn applies the In predicate on the "starts_at" field. +func StartsAtIn(vs ...time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldIn(FieldStartsAt, vs...)) +} + +// StartsAtNotIn applies the NotIn predicate on the "starts_at" field. +func StartsAtNotIn(vs ...time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldNotIn(FieldStartsAt, vs...)) +} + +// StartsAtGT applies the GT predicate on the "starts_at" field. +func StartsAtGT(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldGT(FieldStartsAt, v)) +} + +// StartsAtGTE applies the GTE predicate on the "starts_at" field. +func StartsAtGTE(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldGTE(FieldStartsAt, v)) +} + +// StartsAtLT applies the LT predicate on the "starts_at" field. +func StartsAtLT(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldLT(FieldStartsAt, v)) +} + +// StartsAtLTE applies the LTE predicate on the "starts_at" field. +func StartsAtLTE(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldLTE(FieldStartsAt, v)) +} + +// StartsAtIsNil applies the IsNil predicate on the "starts_at" field. +func StartsAtIsNil() predicate.Announcement { + return predicate.Announcement(sql.FieldIsNull(FieldStartsAt)) +} + +// StartsAtNotNil applies the NotNil predicate on the "starts_at" field. +func StartsAtNotNil() predicate.Announcement { + return predicate.Announcement(sql.FieldNotNull(FieldStartsAt)) +} + +// EndsAtEQ applies the EQ predicate on the "ends_at" field. +func EndsAtEQ(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldEndsAt, v)) +} + +// EndsAtNEQ applies the NEQ predicate on the "ends_at" field. +func EndsAtNEQ(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldNEQ(FieldEndsAt, v)) +} + +// EndsAtIn applies the In predicate on the "ends_at" field. +func EndsAtIn(vs ...time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldIn(FieldEndsAt, vs...)) +} + +// EndsAtNotIn applies the NotIn predicate on the "ends_at" field. +func EndsAtNotIn(vs ...time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldNotIn(FieldEndsAt, vs...)) +} + +// EndsAtGT applies the GT predicate on the "ends_at" field. +func EndsAtGT(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldGT(FieldEndsAt, v)) +} + +// EndsAtGTE applies the GTE predicate on the "ends_at" field. +func EndsAtGTE(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldGTE(FieldEndsAt, v)) +} + +// EndsAtLT applies the LT predicate on the "ends_at" field. +func EndsAtLT(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldLT(FieldEndsAt, v)) +} + +// EndsAtLTE applies the LTE predicate on the "ends_at" field. +func EndsAtLTE(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldLTE(FieldEndsAt, v)) +} + +// EndsAtIsNil applies the IsNil predicate on the "ends_at" field. +func EndsAtIsNil() predicate.Announcement { + return predicate.Announcement(sql.FieldIsNull(FieldEndsAt)) +} + +// EndsAtNotNil applies the NotNil predicate on the "ends_at" field. +func EndsAtNotNil() predicate.Announcement { + return predicate.Announcement(sql.FieldNotNull(FieldEndsAt)) +} + +// CreatedByEQ applies the EQ predicate on the "created_by" field. +func CreatedByEQ(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldCreatedBy, v)) +} + +// CreatedByNEQ applies the NEQ predicate on the "created_by" field. +func CreatedByNEQ(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldNEQ(FieldCreatedBy, v)) +} + +// CreatedByIn applies the In predicate on the "created_by" field. +func CreatedByIn(vs ...int64) predicate.Announcement { + return predicate.Announcement(sql.FieldIn(FieldCreatedBy, vs...)) +} + +// CreatedByNotIn applies the NotIn predicate on the "created_by" field. +func CreatedByNotIn(vs ...int64) predicate.Announcement { + return predicate.Announcement(sql.FieldNotIn(FieldCreatedBy, vs...)) +} + +// CreatedByGT applies the GT predicate on the "created_by" field. +func CreatedByGT(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldGT(FieldCreatedBy, v)) +} + +// CreatedByGTE applies the GTE predicate on the "created_by" field. +func CreatedByGTE(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldGTE(FieldCreatedBy, v)) +} + +// CreatedByLT applies the LT predicate on the "created_by" field. +func CreatedByLT(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldLT(FieldCreatedBy, v)) +} + +// CreatedByLTE applies the LTE predicate on the "created_by" field. +func CreatedByLTE(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldLTE(FieldCreatedBy, v)) +} + +// CreatedByIsNil applies the IsNil predicate on the "created_by" field. +func CreatedByIsNil() predicate.Announcement { + return predicate.Announcement(sql.FieldIsNull(FieldCreatedBy)) +} + +// CreatedByNotNil applies the NotNil predicate on the "created_by" field. +func CreatedByNotNil() predicate.Announcement { + return predicate.Announcement(sql.FieldNotNull(FieldCreatedBy)) +} + +// UpdatedByEQ applies the EQ predicate on the "updated_by" field. +func UpdatedByEQ(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldUpdatedBy, v)) +} + +// UpdatedByNEQ applies the NEQ predicate on the "updated_by" field. +func UpdatedByNEQ(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldNEQ(FieldUpdatedBy, v)) +} + +// UpdatedByIn applies the In predicate on the "updated_by" field. +func UpdatedByIn(vs ...int64) predicate.Announcement { + return predicate.Announcement(sql.FieldIn(FieldUpdatedBy, vs...)) +} + +// UpdatedByNotIn applies the NotIn predicate on the "updated_by" field. +func UpdatedByNotIn(vs ...int64) predicate.Announcement { + return predicate.Announcement(sql.FieldNotIn(FieldUpdatedBy, vs...)) +} + +// UpdatedByGT applies the GT predicate on the "updated_by" field. +func UpdatedByGT(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldGT(FieldUpdatedBy, v)) +} + +// UpdatedByGTE applies the GTE predicate on the "updated_by" field. +func UpdatedByGTE(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldGTE(FieldUpdatedBy, v)) +} + +// UpdatedByLT applies the LT predicate on the "updated_by" field. +func UpdatedByLT(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldLT(FieldUpdatedBy, v)) +} + +// UpdatedByLTE applies the LTE predicate on the "updated_by" field. +func UpdatedByLTE(v int64) predicate.Announcement { + return predicate.Announcement(sql.FieldLTE(FieldUpdatedBy, v)) +} + +// UpdatedByIsNil applies the IsNil predicate on the "updated_by" field. +func UpdatedByIsNil() predicate.Announcement { + return predicate.Announcement(sql.FieldIsNull(FieldUpdatedBy)) +} + +// UpdatedByNotNil applies the NotNil predicate on the "updated_by" field. +func UpdatedByNotNil() predicate.Announcement { + return predicate.Announcement(sql.FieldNotNull(FieldUpdatedBy)) +} + +// CreatedAtEQ applies the EQ predicate on the "created_at" field. +func CreatedAtEQ(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldCreatedAt, v)) +} + +// CreatedAtNEQ applies the NEQ predicate on the "created_at" field. +func CreatedAtNEQ(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldNEQ(FieldCreatedAt, v)) +} + +// CreatedAtIn applies the In predicate on the "created_at" field. +func CreatedAtIn(vs ...time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldIn(FieldCreatedAt, vs...)) +} + +// CreatedAtNotIn applies the NotIn predicate on the "created_at" field. +func CreatedAtNotIn(vs ...time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldNotIn(FieldCreatedAt, vs...)) +} + +// CreatedAtGT applies the GT predicate on the "created_at" field. +func CreatedAtGT(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldGT(FieldCreatedAt, v)) +} + +// CreatedAtGTE applies the GTE predicate on the "created_at" field. +func CreatedAtGTE(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldGTE(FieldCreatedAt, v)) +} + +// CreatedAtLT applies the LT predicate on the "created_at" field. +func CreatedAtLT(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldLT(FieldCreatedAt, v)) +} + +// CreatedAtLTE applies the LTE predicate on the "created_at" field. +func CreatedAtLTE(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldLTE(FieldCreatedAt, v)) +} + +// UpdatedAtEQ applies the EQ predicate on the "updated_at" field. +func UpdatedAtEQ(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field. +func UpdatedAtNEQ(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldNEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtIn applies the In predicate on the "updated_at" field. +func UpdatedAtIn(vs ...time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field. +func UpdatedAtNotIn(vs ...time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldNotIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtGT applies the GT predicate on the "updated_at" field. +func UpdatedAtGT(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldGT(FieldUpdatedAt, v)) +} + +// UpdatedAtGTE applies the GTE predicate on the "updated_at" field. +func UpdatedAtGTE(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldGTE(FieldUpdatedAt, v)) +} + +// UpdatedAtLT applies the LT predicate on the "updated_at" field. +func UpdatedAtLT(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldLT(FieldUpdatedAt, v)) +} + +// UpdatedAtLTE applies the LTE predicate on the "updated_at" field. +func UpdatedAtLTE(v time.Time) predicate.Announcement { + return predicate.Announcement(sql.FieldLTE(FieldUpdatedAt, v)) +} + +// HasReads applies the HasEdge predicate on the "reads" edge. +func HasReads() predicate.Announcement { + return predicate.Announcement(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ReadsTable, ReadsColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasReadsWith applies the HasEdge predicate on the "reads" edge with a given conditions (other predicates). +func HasReadsWith(preds ...predicate.AnnouncementRead) predicate.Announcement { + return predicate.Announcement(func(s *sql.Selector) { + step := newReadsStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// And groups predicates with the AND operator between them. +func And(predicates ...predicate.Announcement) predicate.Announcement { + return predicate.Announcement(sql.AndPredicates(predicates...)) +} + +// Or groups predicates with the OR operator between them. +func Or(predicates ...predicate.Announcement) predicate.Announcement { + return predicate.Announcement(sql.OrPredicates(predicates...)) +} + +// Not applies the not operator on the given predicate. +func Not(p predicate.Announcement) predicate.Announcement { + return predicate.Announcement(sql.NotPredicates(p)) +} diff --git a/backend/ent/announcement_create.go b/backend/ent/announcement_create.go new file mode 100644 index 00000000..151d4c11 --- /dev/null +++ b/backend/ent/announcement_create.go @@ -0,0 +1,1159 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" + "github.com/Wei-Shaw/sub2api/internal/domain" +) + +// AnnouncementCreate is the builder for creating a Announcement entity. +type AnnouncementCreate struct { + config + mutation *AnnouncementMutation + hooks []Hook + conflict []sql.ConflictOption +} + +// SetTitle sets the "title" field. +func (_c *AnnouncementCreate) SetTitle(v string) *AnnouncementCreate { + _c.mutation.SetTitle(v) + return _c +} + +// SetContent sets the "content" field. +func (_c *AnnouncementCreate) SetContent(v string) *AnnouncementCreate { + _c.mutation.SetContent(v) + return _c +} + +// SetStatus sets the "status" field. +func (_c *AnnouncementCreate) SetStatus(v string) *AnnouncementCreate { + _c.mutation.SetStatus(v) + return _c +} + +// SetNillableStatus sets the "status" field if the given value is not nil. +func (_c *AnnouncementCreate) SetNillableStatus(v *string) *AnnouncementCreate { + if v != nil { + _c.SetStatus(*v) + } + return _c +} + +// SetTargeting sets the "targeting" field. +func (_c *AnnouncementCreate) SetTargeting(v domain.AnnouncementTargeting) *AnnouncementCreate { + _c.mutation.SetTargeting(v) + return _c +} + +// SetNillableTargeting sets the "targeting" field if the given value is not nil. +func (_c *AnnouncementCreate) SetNillableTargeting(v *domain.AnnouncementTargeting) *AnnouncementCreate { + if v != nil { + _c.SetTargeting(*v) + } + return _c +} + +// SetStartsAt sets the "starts_at" field. +func (_c *AnnouncementCreate) SetStartsAt(v time.Time) *AnnouncementCreate { + _c.mutation.SetStartsAt(v) + return _c +} + +// SetNillableStartsAt sets the "starts_at" field if the given value is not nil. +func (_c *AnnouncementCreate) SetNillableStartsAt(v *time.Time) *AnnouncementCreate { + if v != nil { + _c.SetStartsAt(*v) + } + return _c +} + +// SetEndsAt sets the "ends_at" field. +func (_c *AnnouncementCreate) SetEndsAt(v time.Time) *AnnouncementCreate { + _c.mutation.SetEndsAt(v) + return _c +} + +// SetNillableEndsAt sets the "ends_at" field if the given value is not nil. +func (_c *AnnouncementCreate) SetNillableEndsAt(v *time.Time) *AnnouncementCreate { + if v != nil { + _c.SetEndsAt(*v) + } + return _c +} + +// SetCreatedBy sets the "created_by" field. +func (_c *AnnouncementCreate) SetCreatedBy(v int64) *AnnouncementCreate { + _c.mutation.SetCreatedBy(v) + return _c +} + +// SetNillableCreatedBy sets the "created_by" field if the given value is not nil. +func (_c *AnnouncementCreate) SetNillableCreatedBy(v *int64) *AnnouncementCreate { + if v != nil { + _c.SetCreatedBy(*v) + } + return _c +} + +// SetUpdatedBy sets the "updated_by" field. +func (_c *AnnouncementCreate) SetUpdatedBy(v int64) *AnnouncementCreate { + _c.mutation.SetUpdatedBy(v) + return _c +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (_c *AnnouncementCreate) SetNillableUpdatedBy(v *int64) *AnnouncementCreate { + if v != nil { + _c.SetUpdatedBy(*v) + } + return _c +} + +// SetCreatedAt sets the "created_at" field. +func (_c *AnnouncementCreate) SetCreatedAt(v time.Time) *AnnouncementCreate { + _c.mutation.SetCreatedAt(v) + return _c +} + +// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. +func (_c *AnnouncementCreate) SetNillableCreatedAt(v *time.Time) *AnnouncementCreate { + if v != nil { + _c.SetCreatedAt(*v) + } + return _c +} + +// SetUpdatedAt sets the "updated_at" field. +func (_c *AnnouncementCreate) SetUpdatedAt(v time.Time) *AnnouncementCreate { + _c.mutation.SetUpdatedAt(v) + return _c +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (_c *AnnouncementCreate) SetNillableUpdatedAt(v *time.Time) *AnnouncementCreate { + if v != nil { + _c.SetUpdatedAt(*v) + } + return _c +} + +// AddReadIDs adds the "reads" edge to the AnnouncementRead entity by IDs. +func (_c *AnnouncementCreate) AddReadIDs(ids ...int64) *AnnouncementCreate { + _c.mutation.AddReadIDs(ids...) + return _c +} + +// AddReads adds the "reads" edges to the AnnouncementRead entity. +func (_c *AnnouncementCreate) AddReads(v ...*AnnouncementRead) *AnnouncementCreate { + ids := make([]int64, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddReadIDs(ids...) +} + +// Mutation returns the AnnouncementMutation object of the builder. +func (_c *AnnouncementCreate) Mutation() *AnnouncementMutation { + return _c.mutation +} + +// Save creates the Announcement in the database. +func (_c *AnnouncementCreate) Save(ctx context.Context) (*Announcement, error) { + _c.defaults() + return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks) +} + +// SaveX calls Save and panics if Save returns an error. +func (_c *AnnouncementCreate) SaveX(ctx context.Context) *Announcement { + v, err := _c.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (_c *AnnouncementCreate) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_c *AnnouncementCreate) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (_c *AnnouncementCreate) defaults() { + if _, ok := _c.mutation.Status(); !ok { + v := announcement.DefaultStatus + _c.mutation.SetStatus(v) + } + if _, ok := _c.mutation.CreatedAt(); !ok { + v := announcement.DefaultCreatedAt() + _c.mutation.SetCreatedAt(v) + } + if _, ok := _c.mutation.UpdatedAt(); !ok { + v := announcement.DefaultUpdatedAt() + _c.mutation.SetUpdatedAt(v) + } +} + +// check runs all checks and user-defined validators on the builder. +func (_c *AnnouncementCreate) check() error { + if _, ok := _c.mutation.Title(); !ok { + return &ValidationError{Name: "title", err: errors.New(`ent: missing required field "Announcement.title"`)} + } + if v, ok := _c.mutation.Title(); ok { + if err := announcement.TitleValidator(v); err != nil { + return &ValidationError{Name: "title", err: fmt.Errorf(`ent: validator failed for field "Announcement.title": %w`, err)} + } + } + if _, ok := _c.mutation.Content(); !ok { + return &ValidationError{Name: "content", err: errors.New(`ent: missing required field "Announcement.content"`)} + } + if v, ok := _c.mutation.Content(); ok { + if err := announcement.ContentValidator(v); err != nil { + return &ValidationError{Name: "content", err: fmt.Errorf(`ent: validator failed for field "Announcement.content": %w`, err)} + } + } + if _, ok := _c.mutation.Status(); !ok { + return &ValidationError{Name: "status", err: errors.New(`ent: missing required field "Announcement.status"`)} + } + if v, ok := _c.mutation.Status(); ok { + if err := announcement.StatusValidator(v); err != nil { + return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "Announcement.status": %w`, err)} + } + } + if _, ok := _c.mutation.CreatedAt(); !ok { + return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "Announcement.created_at"`)} + } + if _, ok := _c.mutation.UpdatedAt(); !ok { + return &ValidationError{Name: "updated_at", err: errors.New(`ent: missing required field "Announcement.updated_at"`)} + } + return nil +} + +func (_c *AnnouncementCreate) sqlSave(ctx context.Context) (*Announcement, error) { + if err := _c.check(); err != nil { + return nil, err + } + _node, _spec := _c.createSpec() + if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + id := _spec.ID.Value.(int64) + _node.ID = int64(id) + _c.mutation.id = &_node.ID + _c.mutation.done = true + return _node, nil +} + +func (_c *AnnouncementCreate) createSpec() (*Announcement, *sqlgraph.CreateSpec) { + var ( + _node = &Announcement{config: _c.config} + _spec = sqlgraph.NewCreateSpec(announcement.Table, sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64)) + ) + _spec.OnConflict = _c.conflict + if value, ok := _c.mutation.Title(); ok { + _spec.SetField(announcement.FieldTitle, field.TypeString, value) + _node.Title = value + } + if value, ok := _c.mutation.Content(); ok { + _spec.SetField(announcement.FieldContent, field.TypeString, value) + _node.Content = value + } + if value, ok := _c.mutation.Status(); ok { + _spec.SetField(announcement.FieldStatus, field.TypeString, value) + _node.Status = value + } + if value, ok := _c.mutation.Targeting(); ok { + _spec.SetField(announcement.FieldTargeting, field.TypeJSON, value) + _node.Targeting = value + } + if value, ok := _c.mutation.StartsAt(); ok { + _spec.SetField(announcement.FieldStartsAt, field.TypeTime, value) + _node.StartsAt = &value + } + if value, ok := _c.mutation.EndsAt(); ok { + _spec.SetField(announcement.FieldEndsAt, field.TypeTime, value) + _node.EndsAt = &value + } + if value, ok := _c.mutation.CreatedBy(); ok { + _spec.SetField(announcement.FieldCreatedBy, field.TypeInt64, value) + _node.CreatedBy = &value + } + if value, ok := _c.mutation.UpdatedBy(); ok { + _spec.SetField(announcement.FieldUpdatedBy, field.TypeInt64, value) + _node.UpdatedBy = &value + } + if value, ok := _c.mutation.CreatedAt(); ok { + _spec.SetField(announcement.FieldCreatedAt, field.TypeTime, value) + _node.CreatedAt = value + } + if value, ok := _c.mutation.UpdatedAt(); ok { + _spec.SetField(announcement.FieldUpdatedAt, field.TypeTime, value) + _node.UpdatedAt = value + } + if nodes := _c.mutation.ReadsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: announcement.ReadsTable, + Columns: []string{announcement.ReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } + return _node, _spec +} + +// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause +// of the `INSERT` statement. For example: +// +// client.Announcement.Create(). +// SetTitle(v). +// OnConflict( +// // Update the row with the new values +// // the was proposed for insertion. +// sql.ResolveWithNewValues(), +// ). +// // Override some of the fields with custom +// // update values. +// Update(func(u *ent.AnnouncementUpsert) { +// SetTitle(v+v). +// }). +// Exec(ctx) +func (_c *AnnouncementCreate) OnConflict(opts ...sql.ConflictOption) *AnnouncementUpsertOne { + _c.conflict = opts + return &AnnouncementUpsertOne{ + create: _c, + } +} + +// OnConflictColumns calls `OnConflict` and configures the columns +// as conflict target. Using this option is equivalent to using: +// +// client.Announcement.Create(). +// OnConflict(sql.ConflictColumns(columns...)). +// Exec(ctx) +func (_c *AnnouncementCreate) OnConflictColumns(columns ...string) *AnnouncementUpsertOne { + _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...)) + return &AnnouncementUpsertOne{ + create: _c, + } +} + +type ( + // AnnouncementUpsertOne is the builder for "upsert"-ing + // one Announcement node. + AnnouncementUpsertOne struct { + create *AnnouncementCreate + } + + // AnnouncementUpsert is the "OnConflict" setter. + AnnouncementUpsert struct { + *sql.UpdateSet + } +) + +// SetTitle sets the "title" field. +func (u *AnnouncementUpsert) SetTitle(v string) *AnnouncementUpsert { + u.Set(announcement.FieldTitle, v) + return u +} + +// UpdateTitle sets the "title" field to the value that was provided on create. +func (u *AnnouncementUpsert) UpdateTitle() *AnnouncementUpsert { + u.SetExcluded(announcement.FieldTitle) + return u +} + +// SetContent sets the "content" field. +func (u *AnnouncementUpsert) SetContent(v string) *AnnouncementUpsert { + u.Set(announcement.FieldContent, v) + return u +} + +// UpdateContent sets the "content" field to the value that was provided on create. +func (u *AnnouncementUpsert) UpdateContent() *AnnouncementUpsert { + u.SetExcluded(announcement.FieldContent) + return u +} + +// SetStatus sets the "status" field. +func (u *AnnouncementUpsert) SetStatus(v string) *AnnouncementUpsert { + u.Set(announcement.FieldStatus, v) + return u +} + +// UpdateStatus sets the "status" field to the value that was provided on create. +func (u *AnnouncementUpsert) UpdateStatus() *AnnouncementUpsert { + u.SetExcluded(announcement.FieldStatus) + return u +} + +// SetTargeting sets the "targeting" field. +func (u *AnnouncementUpsert) SetTargeting(v domain.AnnouncementTargeting) *AnnouncementUpsert { + u.Set(announcement.FieldTargeting, v) + return u +} + +// UpdateTargeting sets the "targeting" field to the value that was provided on create. +func (u *AnnouncementUpsert) UpdateTargeting() *AnnouncementUpsert { + u.SetExcluded(announcement.FieldTargeting) + return u +} + +// ClearTargeting clears the value of the "targeting" field. +func (u *AnnouncementUpsert) ClearTargeting() *AnnouncementUpsert { + u.SetNull(announcement.FieldTargeting) + return u +} + +// SetStartsAt sets the "starts_at" field. +func (u *AnnouncementUpsert) SetStartsAt(v time.Time) *AnnouncementUpsert { + u.Set(announcement.FieldStartsAt, v) + return u +} + +// UpdateStartsAt sets the "starts_at" field to the value that was provided on create. +func (u *AnnouncementUpsert) UpdateStartsAt() *AnnouncementUpsert { + u.SetExcluded(announcement.FieldStartsAt) + return u +} + +// ClearStartsAt clears the value of the "starts_at" field. +func (u *AnnouncementUpsert) ClearStartsAt() *AnnouncementUpsert { + u.SetNull(announcement.FieldStartsAt) + return u +} + +// SetEndsAt sets the "ends_at" field. +func (u *AnnouncementUpsert) SetEndsAt(v time.Time) *AnnouncementUpsert { + u.Set(announcement.FieldEndsAt, v) + return u +} + +// UpdateEndsAt sets the "ends_at" field to the value that was provided on create. +func (u *AnnouncementUpsert) UpdateEndsAt() *AnnouncementUpsert { + u.SetExcluded(announcement.FieldEndsAt) + return u +} + +// ClearEndsAt clears the value of the "ends_at" field. +func (u *AnnouncementUpsert) ClearEndsAt() *AnnouncementUpsert { + u.SetNull(announcement.FieldEndsAt) + return u +} + +// SetCreatedBy sets the "created_by" field. +func (u *AnnouncementUpsert) SetCreatedBy(v int64) *AnnouncementUpsert { + u.Set(announcement.FieldCreatedBy, v) + return u +} + +// UpdateCreatedBy sets the "created_by" field to the value that was provided on create. +func (u *AnnouncementUpsert) UpdateCreatedBy() *AnnouncementUpsert { + u.SetExcluded(announcement.FieldCreatedBy) + return u +} + +// AddCreatedBy adds v to the "created_by" field. +func (u *AnnouncementUpsert) AddCreatedBy(v int64) *AnnouncementUpsert { + u.Add(announcement.FieldCreatedBy, v) + return u +} + +// ClearCreatedBy clears the value of the "created_by" field. +func (u *AnnouncementUpsert) ClearCreatedBy() *AnnouncementUpsert { + u.SetNull(announcement.FieldCreatedBy) + return u +} + +// SetUpdatedBy sets the "updated_by" field. +func (u *AnnouncementUpsert) SetUpdatedBy(v int64) *AnnouncementUpsert { + u.Set(announcement.FieldUpdatedBy, v) + return u +} + +// UpdateUpdatedBy sets the "updated_by" field to the value that was provided on create. +func (u *AnnouncementUpsert) UpdateUpdatedBy() *AnnouncementUpsert { + u.SetExcluded(announcement.FieldUpdatedBy) + return u +} + +// AddUpdatedBy adds v to the "updated_by" field. +func (u *AnnouncementUpsert) AddUpdatedBy(v int64) *AnnouncementUpsert { + u.Add(announcement.FieldUpdatedBy, v) + return u +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (u *AnnouncementUpsert) ClearUpdatedBy() *AnnouncementUpsert { + u.SetNull(announcement.FieldUpdatedBy) + return u +} + +// SetUpdatedAt sets the "updated_at" field. +func (u *AnnouncementUpsert) SetUpdatedAt(v time.Time) *AnnouncementUpsert { + u.Set(announcement.FieldUpdatedAt, v) + return u +} + +// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create. +func (u *AnnouncementUpsert) UpdateUpdatedAt() *AnnouncementUpsert { + u.SetExcluded(announcement.FieldUpdatedAt) + return u +} + +// UpdateNewValues updates the mutable fields using the new values that were set on create. +// Using this option is equivalent to using: +// +// client.Announcement.Create(). +// OnConflict( +// sql.ResolveWithNewValues(), +// ). +// Exec(ctx) +func (u *AnnouncementUpsertOne) UpdateNewValues() *AnnouncementUpsertOne { + u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues()) + u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) { + if _, exists := u.create.mutation.CreatedAt(); exists { + s.SetIgnore(announcement.FieldCreatedAt) + } + })) + return u +} + +// Ignore sets each column to itself in case of conflict. +// Using this option is equivalent to using: +// +// client.Announcement.Create(). +// OnConflict(sql.ResolveWithIgnore()). +// Exec(ctx) +func (u *AnnouncementUpsertOne) Ignore() *AnnouncementUpsertOne { + u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore()) + return u +} + +// DoNothing configures the conflict_action to `DO NOTHING`. +// Supported only by SQLite and PostgreSQL. +func (u *AnnouncementUpsertOne) DoNothing() *AnnouncementUpsertOne { + u.create.conflict = append(u.create.conflict, sql.DoNothing()) + return u +} + +// Update allows overriding fields `UPDATE` values. See the AnnouncementCreate.OnConflict +// documentation for more info. +func (u *AnnouncementUpsertOne) Update(set func(*AnnouncementUpsert)) *AnnouncementUpsertOne { + u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) { + set(&AnnouncementUpsert{UpdateSet: update}) + })) + return u +} + +// SetTitle sets the "title" field. +func (u *AnnouncementUpsertOne) SetTitle(v string) *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.SetTitle(v) + }) +} + +// UpdateTitle sets the "title" field to the value that was provided on create. +func (u *AnnouncementUpsertOne) UpdateTitle() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateTitle() + }) +} + +// SetContent sets the "content" field. +func (u *AnnouncementUpsertOne) SetContent(v string) *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.SetContent(v) + }) +} + +// UpdateContent sets the "content" field to the value that was provided on create. +func (u *AnnouncementUpsertOne) UpdateContent() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateContent() + }) +} + +// SetStatus sets the "status" field. +func (u *AnnouncementUpsertOne) SetStatus(v string) *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.SetStatus(v) + }) +} + +// UpdateStatus sets the "status" field to the value that was provided on create. +func (u *AnnouncementUpsertOne) UpdateStatus() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateStatus() + }) +} + +// SetTargeting sets the "targeting" field. +func (u *AnnouncementUpsertOne) SetTargeting(v domain.AnnouncementTargeting) *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.SetTargeting(v) + }) +} + +// UpdateTargeting sets the "targeting" field to the value that was provided on create. +func (u *AnnouncementUpsertOne) UpdateTargeting() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateTargeting() + }) +} + +// ClearTargeting clears the value of the "targeting" field. +func (u *AnnouncementUpsertOne) ClearTargeting() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.ClearTargeting() + }) +} + +// SetStartsAt sets the "starts_at" field. +func (u *AnnouncementUpsertOne) SetStartsAt(v time.Time) *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.SetStartsAt(v) + }) +} + +// UpdateStartsAt sets the "starts_at" field to the value that was provided on create. +func (u *AnnouncementUpsertOne) UpdateStartsAt() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateStartsAt() + }) +} + +// ClearStartsAt clears the value of the "starts_at" field. +func (u *AnnouncementUpsertOne) ClearStartsAt() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.ClearStartsAt() + }) +} + +// SetEndsAt sets the "ends_at" field. +func (u *AnnouncementUpsertOne) SetEndsAt(v time.Time) *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.SetEndsAt(v) + }) +} + +// UpdateEndsAt sets the "ends_at" field to the value that was provided on create. +func (u *AnnouncementUpsertOne) UpdateEndsAt() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateEndsAt() + }) +} + +// ClearEndsAt clears the value of the "ends_at" field. +func (u *AnnouncementUpsertOne) ClearEndsAt() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.ClearEndsAt() + }) +} + +// SetCreatedBy sets the "created_by" field. +func (u *AnnouncementUpsertOne) SetCreatedBy(v int64) *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.SetCreatedBy(v) + }) +} + +// AddCreatedBy adds v to the "created_by" field. +func (u *AnnouncementUpsertOne) AddCreatedBy(v int64) *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.AddCreatedBy(v) + }) +} + +// UpdateCreatedBy sets the "created_by" field to the value that was provided on create. +func (u *AnnouncementUpsertOne) UpdateCreatedBy() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateCreatedBy() + }) +} + +// ClearCreatedBy clears the value of the "created_by" field. +func (u *AnnouncementUpsertOne) ClearCreatedBy() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.ClearCreatedBy() + }) +} + +// SetUpdatedBy sets the "updated_by" field. +func (u *AnnouncementUpsertOne) SetUpdatedBy(v int64) *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.SetUpdatedBy(v) + }) +} + +// AddUpdatedBy adds v to the "updated_by" field. +func (u *AnnouncementUpsertOne) AddUpdatedBy(v int64) *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.AddUpdatedBy(v) + }) +} + +// UpdateUpdatedBy sets the "updated_by" field to the value that was provided on create. +func (u *AnnouncementUpsertOne) UpdateUpdatedBy() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateUpdatedBy() + }) +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (u *AnnouncementUpsertOne) ClearUpdatedBy() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.ClearUpdatedBy() + }) +} + +// SetUpdatedAt sets the "updated_at" field. +func (u *AnnouncementUpsertOne) SetUpdatedAt(v time.Time) *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.SetUpdatedAt(v) + }) +} + +// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create. +func (u *AnnouncementUpsertOne) UpdateUpdatedAt() *AnnouncementUpsertOne { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateUpdatedAt() + }) +} + +// Exec executes the query. +func (u *AnnouncementUpsertOne) Exec(ctx context.Context) error { + if len(u.create.conflict) == 0 { + return errors.New("ent: missing options for AnnouncementCreate.OnConflict") + } + return u.create.Exec(ctx) +} + +// ExecX is like Exec, but panics if an error occurs. +func (u *AnnouncementUpsertOne) ExecX(ctx context.Context) { + if err := u.create.Exec(ctx); err != nil { + panic(err) + } +} + +// Exec executes the UPSERT query and returns the inserted/updated ID. +func (u *AnnouncementUpsertOne) ID(ctx context.Context) (id int64, err error) { + node, err := u.create.Save(ctx) + if err != nil { + return id, err + } + return node.ID, nil +} + +// IDX is like ID, but panics if an error occurs. +func (u *AnnouncementUpsertOne) IDX(ctx context.Context) int64 { + id, err := u.ID(ctx) + if err != nil { + panic(err) + } + return id +} + +// AnnouncementCreateBulk is the builder for creating many Announcement entities in bulk. +type AnnouncementCreateBulk struct { + config + err error + builders []*AnnouncementCreate + conflict []sql.ConflictOption +} + +// Save creates the Announcement entities in the database. +func (_c *AnnouncementCreateBulk) Save(ctx context.Context) ([]*Announcement, error) { + if _c.err != nil { + return nil, _c.err + } + specs := make([]*sqlgraph.CreateSpec, len(_c.builders)) + nodes := make([]*Announcement, len(_c.builders)) + mutators := make([]Mutator, len(_c.builders)) + for i := range _c.builders { + func(i int, root context.Context) { + builder := _c.builders[i] + builder.defaults() + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*AnnouncementMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err := builder.check(); err != nil { + return nil, err + } + builder.mutation = mutation + var err error + nodes[i], specs[i] = builder.createSpec() + if i < len(mutators)-1 { + _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation) + } else { + spec := &sqlgraph.BatchCreateSpec{Nodes: specs} + spec.OnConflict = _c.conflict + // Invoke the actual operation on the latest mutation in the chain. + if err = sqlgraph.BatchCreate(ctx, _c.driver, spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + } + } + if err != nil { + return nil, err + } + mutation.id = &nodes[i].ID + if specs[i].ID.Value != nil { + id := specs[i].ID.Value.(int64) + nodes[i].ID = int64(id) + } + mutation.done = true + return nodes[i], nil + }) + for i := len(builder.hooks) - 1; i >= 0; i-- { + mut = builder.hooks[i](mut) + } + mutators[i] = mut + }(i, ctx) + } + if len(mutators) > 0 { + if _, err := mutators[0].Mutate(ctx, _c.builders[0].mutation); err != nil { + return nil, err + } + } + return nodes, nil +} + +// SaveX is like Save, but panics if an error occurs. +func (_c *AnnouncementCreateBulk) SaveX(ctx context.Context) []*Announcement { + v, err := _c.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (_c *AnnouncementCreateBulk) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_c *AnnouncementCreateBulk) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { + panic(err) + } +} + +// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause +// of the `INSERT` statement. For example: +// +// client.Announcement.CreateBulk(builders...). +// OnConflict( +// // Update the row with the new values +// // the was proposed for insertion. +// sql.ResolveWithNewValues(), +// ). +// // Override some of the fields with custom +// // update values. +// Update(func(u *ent.AnnouncementUpsert) { +// SetTitle(v+v). +// }). +// Exec(ctx) +func (_c *AnnouncementCreateBulk) OnConflict(opts ...sql.ConflictOption) *AnnouncementUpsertBulk { + _c.conflict = opts + return &AnnouncementUpsertBulk{ + create: _c, + } +} + +// OnConflictColumns calls `OnConflict` and configures the columns +// as conflict target. Using this option is equivalent to using: +// +// client.Announcement.Create(). +// OnConflict(sql.ConflictColumns(columns...)). +// Exec(ctx) +func (_c *AnnouncementCreateBulk) OnConflictColumns(columns ...string) *AnnouncementUpsertBulk { + _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...)) + return &AnnouncementUpsertBulk{ + create: _c, + } +} + +// AnnouncementUpsertBulk is the builder for "upsert"-ing +// a bulk of Announcement nodes. +type AnnouncementUpsertBulk struct { + create *AnnouncementCreateBulk +} + +// UpdateNewValues updates the mutable fields using the new values that +// were set on create. Using this option is equivalent to using: +// +// client.Announcement.Create(). +// OnConflict( +// sql.ResolveWithNewValues(), +// ). +// Exec(ctx) +func (u *AnnouncementUpsertBulk) UpdateNewValues() *AnnouncementUpsertBulk { + u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues()) + u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) { + for _, b := range u.create.builders { + if _, exists := b.mutation.CreatedAt(); exists { + s.SetIgnore(announcement.FieldCreatedAt) + } + } + })) + return u +} + +// Ignore sets each column to itself in case of conflict. +// Using this option is equivalent to using: +// +// client.Announcement.Create(). +// OnConflict(sql.ResolveWithIgnore()). +// Exec(ctx) +func (u *AnnouncementUpsertBulk) Ignore() *AnnouncementUpsertBulk { + u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore()) + return u +} + +// DoNothing configures the conflict_action to `DO NOTHING`. +// Supported only by SQLite and PostgreSQL. +func (u *AnnouncementUpsertBulk) DoNothing() *AnnouncementUpsertBulk { + u.create.conflict = append(u.create.conflict, sql.DoNothing()) + return u +} + +// Update allows overriding fields `UPDATE` values. See the AnnouncementCreateBulk.OnConflict +// documentation for more info. +func (u *AnnouncementUpsertBulk) Update(set func(*AnnouncementUpsert)) *AnnouncementUpsertBulk { + u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) { + set(&AnnouncementUpsert{UpdateSet: update}) + })) + return u +} + +// SetTitle sets the "title" field. +func (u *AnnouncementUpsertBulk) SetTitle(v string) *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.SetTitle(v) + }) +} + +// UpdateTitle sets the "title" field to the value that was provided on create. +func (u *AnnouncementUpsertBulk) UpdateTitle() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateTitle() + }) +} + +// SetContent sets the "content" field. +func (u *AnnouncementUpsertBulk) SetContent(v string) *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.SetContent(v) + }) +} + +// UpdateContent sets the "content" field to the value that was provided on create. +func (u *AnnouncementUpsertBulk) UpdateContent() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateContent() + }) +} + +// SetStatus sets the "status" field. +func (u *AnnouncementUpsertBulk) SetStatus(v string) *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.SetStatus(v) + }) +} + +// UpdateStatus sets the "status" field to the value that was provided on create. +func (u *AnnouncementUpsertBulk) UpdateStatus() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateStatus() + }) +} + +// SetTargeting sets the "targeting" field. +func (u *AnnouncementUpsertBulk) SetTargeting(v domain.AnnouncementTargeting) *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.SetTargeting(v) + }) +} + +// UpdateTargeting sets the "targeting" field to the value that was provided on create. +func (u *AnnouncementUpsertBulk) UpdateTargeting() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateTargeting() + }) +} + +// ClearTargeting clears the value of the "targeting" field. +func (u *AnnouncementUpsertBulk) ClearTargeting() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.ClearTargeting() + }) +} + +// SetStartsAt sets the "starts_at" field. +func (u *AnnouncementUpsertBulk) SetStartsAt(v time.Time) *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.SetStartsAt(v) + }) +} + +// UpdateStartsAt sets the "starts_at" field to the value that was provided on create. +func (u *AnnouncementUpsertBulk) UpdateStartsAt() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateStartsAt() + }) +} + +// ClearStartsAt clears the value of the "starts_at" field. +func (u *AnnouncementUpsertBulk) ClearStartsAt() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.ClearStartsAt() + }) +} + +// SetEndsAt sets the "ends_at" field. +func (u *AnnouncementUpsertBulk) SetEndsAt(v time.Time) *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.SetEndsAt(v) + }) +} + +// UpdateEndsAt sets the "ends_at" field to the value that was provided on create. +func (u *AnnouncementUpsertBulk) UpdateEndsAt() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateEndsAt() + }) +} + +// ClearEndsAt clears the value of the "ends_at" field. +func (u *AnnouncementUpsertBulk) ClearEndsAt() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.ClearEndsAt() + }) +} + +// SetCreatedBy sets the "created_by" field. +func (u *AnnouncementUpsertBulk) SetCreatedBy(v int64) *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.SetCreatedBy(v) + }) +} + +// AddCreatedBy adds v to the "created_by" field. +func (u *AnnouncementUpsertBulk) AddCreatedBy(v int64) *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.AddCreatedBy(v) + }) +} + +// UpdateCreatedBy sets the "created_by" field to the value that was provided on create. +func (u *AnnouncementUpsertBulk) UpdateCreatedBy() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateCreatedBy() + }) +} + +// ClearCreatedBy clears the value of the "created_by" field. +func (u *AnnouncementUpsertBulk) ClearCreatedBy() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.ClearCreatedBy() + }) +} + +// SetUpdatedBy sets the "updated_by" field. +func (u *AnnouncementUpsertBulk) SetUpdatedBy(v int64) *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.SetUpdatedBy(v) + }) +} + +// AddUpdatedBy adds v to the "updated_by" field. +func (u *AnnouncementUpsertBulk) AddUpdatedBy(v int64) *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.AddUpdatedBy(v) + }) +} + +// UpdateUpdatedBy sets the "updated_by" field to the value that was provided on create. +func (u *AnnouncementUpsertBulk) UpdateUpdatedBy() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateUpdatedBy() + }) +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (u *AnnouncementUpsertBulk) ClearUpdatedBy() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.ClearUpdatedBy() + }) +} + +// SetUpdatedAt sets the "updated_at" field. +func (u *AnnouncementUpsertBulk) SetUpdatedAt(v time.Time) *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.SetUpdatedAt(v) + }) +} + +// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create. +func (u *AnnouncementUpsertBulk) UpdateUpdatedAt() *AnnouncementUpsertBulk { + return u.Update(func(s *AnnouncementUpsert) { + s.UpdateUpdatedAt() + }) +} + +// Exec executes the query. +func (u *AnnouncementUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } + for i, b := range u.create.builders { + if len(b.conflict) != 0 { + return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the AnnouncementCreateBulk instead", i) + } + } + if len(u.create.conflict) == 0 { + return errors.New("ent: missing options for AnnouncementCreateBulk.OnConflict") + } + return u.create.Exec(ctx) +} + +// ExecX is like Exec, but panics if an error occurs. +func (u *AnnouncementUpsertBulk) ExecX(ctx context.Context) { + if err := u.create.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/backend/ent/announcement_delete.go b/backend/ent/announcement_delete.go new file mode 100644 index 00000000..d185e9f7 --- /dev/null +++ b/backend/ent/announcement_delete.go @@ -0,0 +1,88 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/predicate" +) + +// AnnouncementDelete is the builder for deleting a Announcement entity. +type AnnouncementDelete struct { + config + hooks []Hook + mutation *AnnouncementMutation +} + +// Where appends a list predicates to the AnnouncementDelete builder. +func (_d *AnnouncementDelete) Where(ps ...predicate.Announcement) *AnnouncementDelete { + _d.mutation.Where(ps...) + return _d +} + +// Exec executes the deletion query and returns how many vertices were deleted. +func (_d *AnnouncementDelete) Exec(ctx context.Context) (int, error) { + return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks) +} + +// ExecX is like Exec, but panics if an error occurs. +func (_d *AnnouncementDelete) ExecX(ctx context.Context) int { + n, err := _d.Exec(ctx) + if err != nil { + panic(err) + } + return n +} + +func (_d *AnnouncementDelete) sqlExec(ctx context.Context) (int, error) { + _spec := sqlgraph.NewDeleteSpec(announcement.Table, sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64)) + if ps := _d.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec) + if err != nil && sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + _d.mutation.done = true + return affected, err +} + +// AnnouncementDeleteOne is the builder for deleting a single Announcement entity. +type AnnouncementDeleteOne struct { + _d *AnnouncementDelete +} + +// Where appends a list predicates to the AnnouncementDelete builder. +func (_d *AnnouncementDeleteOne) Where(ps ...predicate.Announcement) *AnnouncementDeleteOne { + _d._d.mutation.Where(ps...) + return _d +} + +// Exec executes the deletion query. +func (_d *AnnouncementDeleteOne) Exec(ctx context.Context) error { + n, err := _d._d.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &NotFoundError{announcement.Label} + default: + return nil + } +} + +// ExecX is like Exec, but panics if an error occurs. +func (_d *AnnouncementDeleteOne) ExecX(ctx context.Context) { + if err := _d.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/backend/ent/announcement_query.go b/backend/ent/announcement_query.go new file mode 100644 index 00000000..a27d50fa --- /dev/null +++ b/backend/ent/announcement_query.go @@ -0,0 +1,643 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "database/sql/driver" + "fmt" + "math" + + "entgo.io/ent" + "entgo.io/ent/dialect" + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" + "github.com/Wei-Shaw/sub2api/ent/predicate" +) + +// AnnouncementQuery is the builder for querying Announcement entities. +type AnnouncementQuery struct { + config + ctx *QueryContext + order []announcement.OrderOption + inters []Interceptor + predicates []predicate.Announcement + withReads *AnnouncementReadQuery + modifiers []func(*sql.Selector) + // intermediate query (i.e. traversal path). + sql *sql.Selector + path func(context.Context) (*sql.Selector, error) +} + +// Where adds a new predicate for the AnnouncementQuery builder. +func (_q *AnnouncementQuery) Where(ps ...predicate.Announcement) *AnnouncementQuery { + _q.predicates = append(_q.predicates, ps...) + return _q +} + +// Limit the number of records to be returned by this query. +func (_q *AnnouncementQuery) Limit(limit int) *AnnouncementQuery { + _q.ctx.Limit = &limit + return _q +} + +// Offset to start from. +func (_q *AnnouncementQuery) Offset(offset int) *AnnouncementQuery { + _q.ctx.Offset = &offset + return _q +} + +// Unique configures the query builder to filter duplicate records on query. +// By default, unique is set to true, and can be disabled using this method. +func (_q *AnnouncementQuery) Unique(unique bool) *AnnouncementQuery { + _q.ctx.Unique = &unique + return _q +} + +// Order specifies how the records should be ordered. +func (_q *AnnouncementQuery) Order(o ...announcement.OrderOption) *AnnouncementQuery { + _q.order = append(_q.order, o...) + return _q +} + +// QueryReads chains the current query on the "reads" edge. +func (_q *AnnouncementQuery) QueryReads() *AnnouncementReadQuery { + query := (&AnnouncementReadClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(announcement.Table, announcement.FieldID, selector), + sqlgraph.To(announcementread.Table, announcementread.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, announcement.ReadsTable, announcement.ReadsColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// First returns the first Announcement entity from the query. +// Returns a *NotFoundError when no Announcement was found. +func (_q *AnnouncementQuery) First(ctx context.Context) (*Announcement, error) { + nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst)) + if err != nil { + return nil, err + } + if len(nodes) == 0 { + return nil, &NotFoundError{announcement.Label} + } + return nodes[0], nil +} + +// FirstX is like First, but panics if an error occurs. +func (_q *AnnouncementQuery) FirstX(ctx context.Context) *Announcement { + node, err := _q.First(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return node +} + +// FirstID returns the first Announcement ID from the query. +// Returns a *NotFoundError when no Announcement ID was found. +func (_q *AnnouncementQuery) FirstID(ctx context.Context) (id int64, err error) { + var ids []int64 + if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil { + return + } + if len(ids) == 0 { + err = &NotFoundError{announcement.Label} + return + } + return ids[0], nil +} + +// FirstIDX is like FirstID, but panics if an error occurs. +func (_q *AnnouncementQuery) FirstIDX(ctx context.Context) int64 { + id, err := _q.FirstID(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return id +} + +// Only returns a single Announcement entity found by the query, ensuring it only returns one. +// Returns a *NotSingularError when more than one Announcement entity is found. +// Returns a *NotFoundError when no Announcement entities are found. +func (_q *AnnouncementQuery) Only(ctx context.Context) (*Announcement, error) { + nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly)) + if err != nil { + return nil, err + } + switch len(nodes) { + case 1: + return nodes[0], nil + case 0: + return nil, &NotFoundError{announcement.Label} + default: + return nil, &NotSingularError{announcement.Label} + } +} + +// OnlyX is like Only, but panics if an error occurs. +func (_q *AnnouncementQuery) OnlyX(ctx context.Context) *Announcement { + node, err := _q.Only(ctx) + if err != nil { + panic(err) + } + return node +} + +// OnlyID is like Only, but returns the only Announcement ID in the query. +// Returns a *NotSingularError when more than one Announcement ID is found. +// Returns a *NotFoundError when no entities are found. +func (_q *AnnouncementQuery) OnlyID(ctx context.Context) (id int64, err error) { + var ids []int64 + if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil { + return + } + switch len(ids) { + case 1: + id = ids[0] + case 0: + err = &NotFoundError{announcement.Label} + default: + err = &NotSingularError{announcement.Label} + } + return +} + +// OnlyIDX is like OnlyID, but panics if an error occurs. +func (_q *AnnouncementQuery) OnlyIDX(ctx context.Context) int64 { + id, err := _q.OnlyID(ctx) + if err != nil { + panic(err) + } + return id +} + +// All executes the query and returns a list of Announcements. +func (_q *AnnouncementQuery) All(ctx context.Context) ([]*Announcement, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll) + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + qr := querierAll[[]*Announcement, *AnnouncementQuery]() + return withInterceptors[[]*Announcement](ctx, _q, qr, _q.inters) +} + +// AllX is like All, but panics if an error occurs. +func (_q *AnnouncementQuery) AllX(ctx context.Context) []*Announcement { + nodes, err := _q.All(ctx) + if err != nil { + panic(err) + } + return nodes +} + +// IDs executes the query and returns a list of Announcement IDs. +func (_q *AnnouncementQuery) IDs(ctx context.Context) (ids []int64, err error) { + if _q.ctx.Unique == nil && _q.path != nil { + _q.Unique(true) + } + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs) + if err = _q.Select(announcement.FieldID).Scan(ctx, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// IDsX is like IDs, but panics if an error occurs. +func (_q *AnnouncementQuery) IDsX(ctx context.Context) []int64 { + ids, err := _q.IDs(ctx) + if err != nil { + panic(err) + } + return ids +} + +// Count returns the count of the given query. +func (_q *AnnouncementQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount) + if err := _q.prepareQuery(ctx); err != nil { + return 0, err + } + return withInterceptors[int](ctx, _q, querierCount[*AnnouncementQuery](), _q.inters) +} + +// CountX is like Count, but panics if an error occurs. +func (_q *AnnouncementQuery) CountX(ctx context.Context) int { + count, err := _q.Count(ctx) + if err != nil { + panic(err) + } + return count +} + +// Exist returns true if the query has elements in the graph. +func (_q *AnnouncementQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist) + switch _, err := _q.FirstID(ctx); { + case IsNotFound(err): + return false, nil + case err != nil: + return false, fmt.Errorf("ent: check existence: %w", err) + default: + return true, nil + } +} + +// ExistX is like Exist, but panics if an error occurs. +func (_q *AnnouncementQuery) ExistX(ctx context.Context) bool { + exist, err := _q.Exist(ctx) + if err != nil { + panic(err) + } + return exist +} + +// Clone returns a duplicate of the AnnouncementQuery builder, including all associated steps. It can be +// used to prepare common query builders and use them differently after the clone is made. +func (_q *AnnouncementQuery) Clone() *AnnouncementQuery { + if _q == nil { + return nil + } + return &AnnouncementQuery{ + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]announcement.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.Announcement{}, _q.predicates...), + withReads: _q.withReads.Clone(), + // clone intermediate query. + sql: _q.sql.Clone(), + path: _q.path, + } +} + +// WithReads tells the query-builder to eager-load the nodes that are connected to +// the "reads" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *AnnouncementQuery) WithReads(opts ...func(*AnnouncementReadQuery)) *AnnouncementQuery { + query := (&AnnouncementReadClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withReads = query + return _q +} + +// GroupBy is used to group vertices by one or more fields/columns. +// It is often used with aggregate functions, like: count, max, mean, min, sum. +// +// Example: +// +// var v []struct { +// Title string `json:"title,omitempty"` +// Count int `json:"count,omitempty"` +// } +// +// client.Announcement.Query(). +// GroupBy(announcement.FieldTitle). +// Aggregate(ent.Count()). +// Scan(ctx, &v) +func (_q *AnnouncementQuery) GroupBy(field string, fields ...string) *AnnouncementGroupBy { + _q.ctx.Fields = append([]string{field}, fields...) + grbuild := &AnnouncementGroupBy{build: _q} + grbuild.flds = &_q.ctx.Fields + grbuild.label = announcement.Label + grbuild.scan = grbuild.Scan + return grbuild +} + +// Select allows the selection one or more fields/columns for the given query, +// instead of selecting all fields in the entity. +// +// Example: +// +// var v []struct { +// Title string `json:"title,omitempty"` +// } +// +// client.Announcement.Query(). +// Select(announcement.FieldTitle). +// Scan(ctx, &v) +func (_q *AnnouncementQuery) Select(fields ...string) *AnnouncementSelect { + _q.ctx.Fields = append(_q.ctx.Fields, fields...) + sbuild := &AnnouncementSelect{AnnouncementQuery: _q} + sbuild.label = announcement.Label + sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan + return sbuild +} + +// Aggregate returns a AnnouncementSelect configured with the given aggregations. +func (_q *AnnouncementQuery) Aggregate(fns ...AggregateFunc) *AnnouncementSelect { + return _q.Select().Aggregate(fns...) +} + +func (_q *AnnouncementQuery) prepareQuery(ctx context.Context) error { + for _, inter := range _q.inters { + if inter == nil { + return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)") + } + if trv, ok := inter.(Traverser); ok { + if err := trv.Traverse(ctx, _q); err != nil { + return err + } + } + } + for _, f := range _q.ctx.Fields { + if !announcement.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + } + if _q.path != nil { + prev, err := _q.path(ctx) + if err != nil { + return err + } + _q.sql = prev + } + return nil +} + +func (_q *AnnouncementQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Announcement, error) { + var ( + nodes = []*Announcement{} + _spec = _q.querySpec() + loadedTypes = [1]bool{ + _q.withReads != nil, + } + ) + _spec.ScanValues = func(columns []string) ([]any, error) { + return (*Announcement).scanValues(nil, columns) + } + _spec.Assign = func(columns []string, values []any) error { + node := &Announcement{config: _q.config} + nodes = append(nodes, node) + node.Edges.loadedTypes = loadedTypes + return node.assignValues(columns, values) + } + if len(_q.modifiers) > 0 { + _spec.Modifiers = _q.modifiers + } + for i := range hooks { + hooks[i](ctx, _spec) + } + if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil { + return nil, err + } + if len(nodes) == 0 { + return nodes, nil + } + if query := _q.withReads; query != nil { + if err := _q.loadReads(ctx, query, nodes, + func(n *Announcement) { n.Edges.Reads = []*AnnouncementRead{} }, + func(n *Announcement, e *AnnouncementRead) { n.Edges.Reads = append(n.Edges.Reads, e) }); err != nil { + return nil, err + } + } + return nodes, nil +} + +func (_q *AnnouncementQuery) loadReads(ctx context.Context, query *AnnouncementReadQuery, nodes []*Announcement, init func(*Announcement), assign func(*Announcement, *AnnouncementRead)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[int64]*Announcement) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(announcementread.FieldAnnouncementID) + } + query.Where(predicate.AnnouncementRead(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(announcement.ReadsColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.AnnouncementID + node, ok := nodeids[fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "announcement_id" returned %v for node %v`, fk, n.ID) + } + assign(node, n) + } + return nil +} + +func (_q *AnnouncementQuery) sqlCount(ctx context.Context) (int, error) { + _spec := _q.querySpec() + if len(_q.modifiers) > 0 { + _spec.Modifiers = _q.modifiers + } + _spec.Node.Columns = _q.ctx.Fields + if len(_q.ctx.Fields) > 0 { + _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique + } + return sqlgraph.CountNodes(ctx, _q.driver, _spec) +} + +func (_q *AnnouncementQuery) querySpec() *sqlgraph.QuerySpec { + _spec := sqlgraph.NewQuerySpec(announcement.Table, announcement.Columns, sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64)) + _spec.From = _q.sql + if unique := _q.ctx.Unique; unique != nil { + _spec.Unique = *unique + } else if _q.path != nil { + _spec.Unique = true + } + if fields := _q.ctx.Fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, announcement.FieldID) + for i := range fields { + if fields[i] != announcement.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) + } + } + } + if ps := _q.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if limit := _q.ctx.Limit; limit != nil { + _spec.Limit = *limit + } + if offset := _q.ctx.Offset; offset != nil { + _spec.Offset = *offset + } + if ps := _q.order; len(ps) > 0 { + _spec.Order = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + return _spec +} + +func (_q *AnnouncementQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(_q.driver.Dialect()) + t1 := builder.Table(announcement.Table) + columns := _q.ctx.Fields + if len(columns) == 0 { + columns = announcement.Columns + } + selector := builder.Select(t1.Columns(columns...)...).From(t1) + if _q.sql != nil { + selector = _q.sql + selector.Select(selector.Columns(columns...)...) + } + if _q.ctx.Unique != nil && *_q.ctx.Unique { + selector.Distinct() + } + for _, m := range _q.modifiers { + m(selector) + } + for _, p := range _q.predicates { + p(selector) + } + for _, p := range _q.order { + p(selector) + } + if offset := _q.ctx.Offset; offset != nil { + // limit is mandatory for offset clause. We start + // with default value, and override it below if needed. + selector.Offset(*offset).Limit(math.MaxInt32) + } + if limit := _q.ctx.Limit; limit != nil { + selector.Limit(*limit) + } + return selector +} + +// ForUpdate locks the selected rows against concurrent updates, and prevent them from being +// updated, deleted or "selected ... for update" by other sessions, until the transaction is +// either committed or rolled-back. +func (_q *AnnouncementQuery) ForUpdate(opts ...sql.LockOption) *AnnouncementQuery { + if _q.driver.Dialect() == dialect.Postgres { + _q.Unique(false) + } + _q.modifiers = append(_q.modifiers, func(s *sql.Selector) { + s.ForUpdate(opts...) + }) + return _q +} + +// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock +// on any rows that are read. Other sessions can read the rows, but cannot modify them +// until your transaction commits. +func (_q *AnnouncementQuery) ForShare(opts ...sql.LockOption) *AnnouncementQuery { + if _q.driver.Dialect() == dialect.Postgres { + _q.Unique(false) + } + _q.modifiers = append(_q.modifiers, func(s *sql.Selector) { + s.ForShare(opts...) + }) + return _q +} + +// AnnouncementGroupBy is the group-by builder for Announcement entities. +type AnnouncementGroupBy struct { + selector + build *AnnouncementQuery +} + +// Aggregate adds the given aggregation functions to the group-by query. +func (_g *AnnouncementGroupBy) Aggregate(fns ...AggregateFunc) *AnnouncementGroupBy { + _g.fns = append(_g.fns, fns...) + return _g +} + +// Scan applies the selector query and scans the result into the given value. +func (_g *AnnouncementGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy) + if err := _g.build.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*AnnouncementQuery, *AnnouncementGroupBy](ctx, _g.build, _g, _g.build.inters, v) +} + +func (_g *AnnouncementGroupBy) sqlScan(ctx context.Context, root *AnnouncementQuery, v any) error { + selector := root.sqlQuery(ctx).Select() + aggregation := make([]string, 0, len(_g.fns)) + for _, fn := range _g.fns { + aggregation = append(aggregation, fn(selector)) + } + if len(selector.SelectedColumns()) == 0 { + columns := make([]string, 0, len(*_g.flds)+len(_g.fns)) + for _, f := range *_g.flds { + columns = append(columns, selector.C(f)) + } + columns = append(columns, aggregation...) + selector.Select(columns...) + } + selector.GroupBy(selector.Columns(*_g.flds...)...) + if err := selector.Err(); err != nil { + return err + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := _g.build.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// AnnouncementSelect is the builder for selecting fields of Announcement entities. +type AnnouncementSelect struct { + *AnnouncementQuery + selector +} + +// Aggregate adds the given aggregation functions to the selector query. +func (_s *AnnouncementSelect) Aggregate(fns ...AggregateFunc) *AnnouncementSelect { + _s.fns = append(_s.fns, fns...) + return _s +} + +// Scan applies the selector query and scans the result into the given value. +func (_s *AnnouncementSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect) + if err := _s.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*AnnouncementQuery, *AnnouncementSelect](ctx, _s.AnnouncementQuery, _s, _s.inters, v) +} + +func (_s *AnnouncementSelect) sqlScan(ctx context.Context, root *AnnouncementQuery, v any) error { + selector := root.sqlQuery(ctx) + aggregation := make([]string, 0, len(_s.fns)) + for _, fn := range _s.fns { + aggregation = append(aggregation, fn(selector)) + } + switch n := len(*_s.selector.flds); { + case n == 0 && len(aggregation) > 0: + selector.Select(aggregation...) + case n != 0 && len(aggregation) > 0: + selector.AppendSelect(aggregation...) + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := _s.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} diff --git a/backend/ent/announcement_update.go b/backend/ent/announcement_update.go new file mode 100644 index 00000000..702d0817 --- /dev/null +++ b/backend/ent/announcement_update.go @@ -0,0 +1,824 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" + "github.com/Wei-Shaw/sub2api/ent/predicate" + "github.com/Wei-Shaw/sub2api/internal/domain" +) + +// AnnouncementUpdate is the builder for updating Announcement entities. +type AnnouncementUpdate struct { + config + hooks []Hook + mutation *AnnouncementMutation +} + +// Where appends a list predicates to the AnnouncementUpdate builder. +func (_u *AnnouncementUpdate) Where(ps ...predicate.Announcement) *AnnouncementUpdate { + _u.mutation.Where(ps...) + return _u +} + +// SetTitle sets the "title" field. +func (_u *AnnouncementUpdate) SetTitle(v string) *AnnouncementUpdate { + _u.mutation.SetTitle(v) + return _u +} + +// SetNillableTitle sets the "title" field if the given value is not nil. +func (_u *AnnouncementUpdate) SetNillableTitle(v *string) *AnnouncementUpdate { + if v != nil { + _u.SetTitle(*v) + } + return _u +} + +// SetContent sets the "content" field. +func (_u *AnnouncementUpdate) SetContent(v string) *AnnouncementUpdate { + _u.mutation.SetContent(v) + return _u +} + +// SetNillableContent sets the "content" field if the given value is not nil. +func (_u *AnnouncementUpdate) SetNillableContent(v *string) *AnnouncementUpdate { + if v != nil { + _u.SetContent(*v) + } + return _u +} + +// SetStatus sets the "status" field. +func (_u *AnnouncementUpdate) SetStatus(v string) *AnnouncementUpdate { + _u.mutation.SetStatus(v) + return _u +} + +// SetNillableStatus sets the "status" field if the given value is not nil. +func (_u *AnnouncementUpdate) SetNillableStatus(v *string) *AnnouncementUpdate { + if v != nil { + _u.SetStatus(*v) + } + return _u +} + +// SetTargeting sets the "targeting" field. +func (_u *AnnouncementUpdate) SetTargeting(v domain.AnnouncementTargeting) *AnnouncementUpdate { + _u.mutation.SetTargeting(v) + return _u +} + +// SetNillableTargeting sets the "targeting" field if the given value is not nil. +func (_u *AnnouncementUpdate) SetNillableTargeting(v *domain.AnnouncementTargeting) *AnnouncementUpdate { + if v != nil { + _u.SetTargeting(*v) + } + return _u +} + +// ClearTargeting clears the value of the "targeting" field. +func (_u *AnnouncementUpdate) ClearTargeting() *AnnouncementUpdate { + _u.mutation.ClearTargeting() + return _u +} + +// SetStartsAt sets the "starts_at" field. +func (_u *AnnouncementUpdate) SetStartsAt(v time.Time) *AnnouncementUpdate { + _u.mutation.SetStartsAt(v) + return _u +} + +// SetNillableStartsAt sets the "starts_at" field if the given value is not nil. +func (_u *AnnouncementUpdate) SetNillableStartsAt(v *time.Time) *AnnouncementUpdate { + if v != nil { + _u.SetStartsAt(*v) + } + return _u +} + +// ClearStartsAt clears the value of the "starts_at" field. +func (_u *AnnouncementUpdate) ClearStartsAt() *AnnouncementUpdate { + _u.mutation.ClearStartsAt() + return _u +} + +// SetEndsAt sets the "ends_at" field. +func (_u *AnnouncementUpdate) SetEndsAt(v time.Time) *AnnouncementUpdate { + _u.mutation.SetEndsAt(v) + return _u +} + +// SetNillableEndsAt sets the "ends_at" field if the given value is not nil. +func (_u *AnnouncementUpdate) SetNillableEndsAt(v *time.Time) *AnnouncementUpdate { + if v != nil { + _u.SetEndsAt(*v) + } + return _u +} + +// ClearEndsAt clears the value of the "ends_at" field. +func (_u *AnnouncementUpdate) ClearEndsAt() *AnnouncementUpdate { + _u.mutation.ClearEndsAt() + return _u +} + +// SetCreatedBy sets the "created_by" field. +func (_u *AnnouncementUpdate) SetCreatedBy(v int64) *AnnouncementUpdate { + _u.mutation.ResetCreatedBy() + _u.mutation.SetCreatedBy(v) + return _u +} + +// SetNillableCreatedBy sets the "created_by" field if the given value is not nil. +func (_u *AnnouncementUpdate) SetNillableCreatedBy(v *int64) *AnnouncementUpdate { + if v != nil { + _u.SetCreatedBy(*v) + } + return _u +} + +// AddCreatedBy adds value to the "created_by" field. +func (_u *AnnouncementUpdate) AddCreatedBy(v int64) *AnnouncementUpdate { + _u.mutation.AddCreatedBy(v) + return _u +} + +// ClearCreatedBy clears the value of the "created_by" field. +func (_u *AnnouncementUpdate) ClearCreatedBy() *AnnouncementUpdate { + _u.mutation.ClearCreatedBy() + return _u +} + +// SetUpdatedBy sets the "updated_by" field. +func (_u *AnnouncementUpdate) SetUpdatedBy(v int64) *AnnouncementUpdate { + _u.mutation.ResetUpdatedBy() + _u.mutation.SetUpdatedBy(v) + return _u +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (_u *AnnouncementUpdate) SetNillableUpdatedBy(v *int64) *AnnouncementUpdate { + if v != nil { + _u.SetUpdatedBy(*v) + } + return _u +} + +// AddUpdatedBy adds value to the "updated_by" field. +func (_u *AnnouncementUpdate) AddUpdatedBy(v int64) *AnnouncementUpdate { + _u.mutation.AddUpdatedBy(v) + return _u +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (_u *AnnouncementUpdate) ClearUpdatedBy() *AnnouncementUpdate { + _u.mutation.ClearUpdatedBy() + return _u +} + +// SetUpdatedAt sets the "updated_at" field. +func (_u *AnnouncementUpdate) SetUpdatedAt(v time.Time) *AnnouncementUpdate { + _u.mutation.SetUpdatedAt(v) + return _u +} + +// AddReadIDs adds the "reads" edge to the AnnouncementRead entity by IDs. +func (_u *AnnouncementUpdate) AddReadIDs(ids ...int64) *AnnouncementUpdate { + _u.mutation.AddReadIDs(ids...) + return _u +} + +// AddReads adds the "reads" edges to the AnnouncementRead entity. +func (_u *AnnouncementUpdate) AddReads(v ...*AnnouncementRead) *AnnouncementUpdate { + ids := make([]int64, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddReadIDs(ids...) +} + +// Mutation returns the AnnouncementMutation object of the builder. +func (_u *AnnouncementUpdate) Mutation() *AnnouncementMutation { + return _u.mutation +} + +// ClearReads clears all "reads" edges to the AnnouncementRead entity. +func (_u *AnnouncementUpdate) ClearReads() *AnnouncementUpdate { + _u.mutation.ClearReads() + return _u +} + +// RemoveReadIDs removes the "reads" edge to AnnouncementRead entities by IDs. +func (_u *AnnouncementUpdate) RemoveReadIDs(ids ...int64) *AnnouncementUpdate { + _u.mutation.RemoveReadIDs(ids...) + return _u +} + +// RemoveReads removes "reads" edges to AnnouncementRead entities. +func (_u *AnnouncementUpdate) RemoveReads(v ...*AnnouncementRead) *AnnouncementUpdate { + ids := make([]int64, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveReadIDs(ids...) +} + +// Save executes the query and returns the number of nodes affected by the update operation. +func (_u *AnnouncementUpdate) Save(ctx context.Context) (int, error) { + _u.defaults() + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (_u *AnnouncementUpdate) SaveX(ctx context.Context) int { + affected, err := _u.Save(ctx) + if err != nil { + panic(err) + } + return affected +} + +// Exec executes the query. +func (_u *AnnouncementUpdate) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_u *AnnouncementUpdate) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (_u *AnnouncementUpdate) defaults() { + if _, ok := _u.mutation.UpdatedAt(); !ok { + v := announcement.UpdateDefaultUpdatedAt() + _u.mutation.SetUpdatedAt(v) + } +} + +// check runs all checks and user-defined validators on the builder. +func (_u *AnnouncementUpdate) check() error { + if v, ok := _u.mutation.Title(); ok { + if err := announcement.TitleValidator(v); err != nil { + return &ValidationError{Name: "title", err: fmt.Errorf(`ent: validator failed for field "Announcement.title": %w`, err)} + } + } + if v, ok := _u.mutation.Content(); ok { + if err := announcement.ContentValidator(v); err != nil { + return &ValidationError{Name: "content", err: fmt.Errorf(`ent: validator failed for field "Announcement.content": %w`, err)} + } + } + if v, ok := _u.mutation.Status(); ok { + if err := announcement.StatusValidator(v); err != nil { + return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "Announcement.status": %w`, err)} + } + } + return nil +} + +func (_u *AnnouncementUpdate) sqlSave(ctx context.Context) (_node int, err error) { + if err := _u.check(); err != nil { + return _node, err + } + _spec := sqlgraph.NewUpdateSpec(announcement.Table, announcement.Columns, sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64)) + if ps := _u.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := _u.mutation.Title(); ok { + _spec.SetField(announcement.FieldTitle, field.TypeString, value) + } + if value, ok := _u.mutation.Content(); ok { + _spec.SetField(announcement.FieldContent, field.TypeString, value) + } + if value, ok := _u.mutation.Status(); ok { + _spec.SetField(announcement.FieldStatus, field.TypeString, value) + } + if value, ok := _u.mutation.Targeting(); ok { + _spec.SetField(announcement.FieldTargeting, field.TypeJSON, value) + } + if _u.mutation.TargetingCleared() { + _spec.ClearField(announcement.FieldTargeting, field.TypeJSON) + } + if value, ok := _u.mutation.StartsAt(); ok { + _spec.SetField(announcement.FieldStartsAt, field.TypeTime, value) + } + if _u.mutation.StartsAtCleared() { + _spec.ClearField(announcement.FieldStartsAt, field.TypeTime) + } + if value, ok := _u.mutation.EndsAt(); ok { + _spec.SetField(announcement.FieldEndsAt, field.TypeTime, value) + } + if _u.mutation.EndsAtCleared() { + _spec.ClearField(announcement.FieldEndsAt, field.TypeTime) + } + if value, ok := _u.mutation.CreatedBy(); ok { + _spec.SetField(announcement.FieldCreatedBy, field.TypeInt64, value) + } + if value, ok := _u.mutation.AddedCreatedBy(); ok { + _spec.AddField(announcement.FieldCreatedBy, field.TypeInt64, value) + } + if _u.mutation.CreatedByCleared() { + _spec.ClearField(announcement.FieldCreatedBy, field.TypeInt64) + } + if value, ok := _u.mutation.UpdatedBy(); ok { + _spec.SetField(announcement.FieldUpdatedBy, field.TypeInt64, value) + } + if value, ok := _u.mutation.AddedUpdatedBy(); ok { + _spec.AddField(announcement.FieldUpdatedBy, field.TypeInt64, value) + } + if _u.mutation.UpdatedByCleared() { + _spec.ClearField(announcement.FieldUpdatedBy, field.TypeInt64) + } + if value, ok := _u.mutation.UpdatedAt(); ok { + _spec.SetField(announcement.FieldUpdatedAt, field.TypeTime, value) + } + if _u.mutation.ReadsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: announcement.ReadsTable, + Columns: []string{announcement.ReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedReadsIDs(); len(nodes) > 0 && !_u.mutation.ReadsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: announcement.ReadsTable, + Columns: []string{announcement.ReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.ReadsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: announcement.ReadsTable, + Columns: []string{announcement.ReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{announcement.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return 0, err + } + _u.mutation.done = true + return _node, nil +} + +// AnnouncementUpdateOne is the builder for updating a single Announcement entity. +type AnnouncementUpdateOne struct { + config + fields []string + hooks []Hook + mutation *AnnouncementMutation +} + +// SetTitle sets the "title" field. +func (_u *AnnouncementUpdateOne) SetTitle(v string) *AnnouncementUpdateOne { + _u.mutation.SetTitle(v) + return _u +} + +// SetNillableTitle sets the "title" field if the given value is not nil. +func (_u *AnnouncementUpdateOne) SetNillableTitle(v *string) *AnnouncementUpdateOne { + if v != nil { + _u.SetTitle(*v) + } + return _u +} + +// SetContent sets the "content" field. +func (_u *AnnouncementUpdateOne) SetContent(v string) *AnnouncementUpdateOne { + _u.mutation.SetContent(v) + return _u +} + +// SetNillableContent sets the "content" field if the given value is not nil. +func (_u *AnnouncementUpdateOne) SetNillableContent(v *string) *AnnouncementUpdateOne { + if v != nil { + _u.SetContent(*v) + } + return _u +} + +// SetStatus sets the "status" field. +func (_u *AnnouncementUpdateOne) SetStatus(v string) *AnnouncementUpdateOne { + _u.mutation.SetStatus(v) + return _u +} + +// SetNillableStatus sets the "status" field if the given value is not nil. +func (_u *AnnouncementUpdateOne) SetNillableStatus(v *string) *AnnouncementUpdateOne { + if v != nil { + _u.SetStatus(*v) + } + return _u +} + +// SetTargeting sets the "targeting" field. +func (_u *AnnouncementUpdateOne) SetTargeting(v domain.AnnouncementTargeting) *AnnouncementUpdateOne { + _u.mutation.SetTargeting(v) + return _u +} + +// SetNillableTargeting sets the "targeting" field if the given value is not nil. +func (_u *AnnouncementUpdateOne) SetNillableTargeting(v *domain.AnnouncementTargeting) *AnnouncementUpdateOne { + if v != nil { + _u.SetTargeting(*v) + } + return _u +} + +// ClearTargeting clears the value of the "targeting" field. +func (_u *AnnouncementUpdateOne) ClearTargeting() *AnnouncementUpdateOne { + _u.mutation.ClearTargeting() + return _u +} + +// SetStartsAt sets the "starts_at" field. +func (_u *AnnouncementUpdateOne) SetStartsAt(v time.Time) *AnnouncementUpdateOne { + _u.mutation.SetStartsAt(v) + return _u +} + +// SetNillableStartsAt sets the "starts_at" field if the given value is not nil. +func (_u *AnnouncementUpdateOne) SetNillableStartsAt(v *time.Time) *AnnouncementUpdateOne { + if v != nil { + _u.SetStartsAt(*v) + } + return _u +} + +// ClearStartsAt clears the value of the "starts_at" field. +func (_u *AnnouncementUpdateOne) ClearStartsAt() *AnnouncementUpdateOne { + _u.mutation.ClearStartsAt() + return _u +} + +// SetEndsAt sets the "ends_at" field. +func (_u *AnnouncementUpdateOne) SetEndsAt(v time.Time) *AnnouncementUpdateOne { + _u.mutation.SetEndsAt(v) + return _u +} + +// SetNillableEndsAt sets the "ends_at" field if the given value is not nil. +func (_u *AnnouncementUpdateOne) SetNillableEndsAt(v *time.Time) *AnnouncementUpdateOne { + if v != nil { + _u.SetEndsAt(*v) + } + return _u +} + +// ClearEndsAt clears the value of the "ends_at" field. +func (_u *AnnouncementUpdateOne) ClearEndsAt() *AnnouncementUpdateOne { + _u.mutation.ClearEndsAt() + return _u +} + +// SetCreatedBy sets the "created_by" field. +func (_u *AnnouncementUpdateOne) SetCreatedBy(v int64) *AnnouncementUpdateOne { + _u.mutation.ResetCreatedBy() + _u.mutation.SetCreatedBy(v) + return _u +} + +// SetNillableCreatedBy sets the "created_by" field if the given value is not nil. +func (_u *AnnouncementUpdateOne) SetNillableCreatedBy(v *int64) *AnnouncementUpdateOne { + if v != nil { + _u.SetCreatedBy(*v) + } + return _u +} + +// AddCreatedBy adds value to the "created_by" field. +func (_u *AnnouncementUpdateOne) AddCreatedBy(v int64) *AnnouncementUpdateOne { + _u.mutation.AddCreatedBy(v) + return _u +} + +// ClearCreatedBy clears the value of the "created_by" field. +func (_u *AnnouncementUpdateOne) ClearCreatedBy() *AnnouncementUpdateOne { + _u.mutation.ClearCreatedBy() + return _u +} + +// SetUpdatedBy sets the "updated_by" field. +func (_u *AnnouncementUpdateOne) SetUpdatedBy(v int64) *AnnouncementUpdateOne { + _u.mutation.ResetUpdatedBy() + _u.mutation.SetUpdatedBy(v) + return _u +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (_u *AnnouncementUpdateOne) SetNillableUpdatedBy(v *int64) *AnnouncementUpdateOne { + if v != nil { + _u.SetUpdatedBy(*v) + } + return _u +} + +// AddUpdatedBy adds value to the "updated_by" field. +func (_u *AnnouncementUpdateOne) AddUpdatedBy(v int64) *AnnouncementUpdateOne { + _u.mutation.AddUpdatedBy(v) + return _u +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (_u *AnnouncementUpdateOne) ClearUpdatedBy() *AnnouncementUpdateOne { + _u.mutation.ClearUpdatedBy() + return _u +} + +// SetUpdatedAt sets the "updated_at" field. +func (_u *AnnouncementUpdateOne) SetUpdatedAt(v time.Time) *AnnouncementUpdateOne { + _u.mutation.SetUpdatedAt(v) + return _u +} + +// AddReadIDs adds the "reads" edge to the AnnouncementRead entity by IDs. +func (_u *AnnouncementUpdateOne) AddReadIDs(ids ...int64) *AnnouncementUpdateOne { + _u.mutation.AddReadIDs(ids...) + return _u +} + +// AddReads adds the "reads" edges to the AnnouncementRead entity. +func (_u *AnnouncementUpdateOne) AddReads(v ...*AnnouncementRead) *AnnouncementUpdateOne { + ids := make([]int64, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddReadIDs(ids...) +} + +// Mutation returns the AnnouncementMutation object of the builder. +func (_u *AnnouncementUpdateOne) Mutation() *AnnouncementMutation { + return _u.mutation +} + +// ClearReads clears all "reads" edges to the AnnouncementRead entity. +func (_u *AnnouncementUpdateOne) ClearReads() *AnnouncementUpdateOne { + _u.mutation.ClearReads() + return _u +} + +// RemoveReadIDs removes the "reads" edge to AnnouncementRead entities by IDs. +func (_u *AnnouncementUpdateOne) RemoveReadIDs(ids ...int64) *AnnouncementUpdateOne { + _u.mutation.RemoveReadIDs(ids...) + return _u +} + +// RemoveReads removes "reads" edges to AnnouncementRead entities. +func (_u *AnnouncementUpdateOne) RemoveReads(v ...*AnnouncementRead) *AnnouncementUpdateOne { + ids := make([]int64, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveReadIDs(ids...) +} + +// Where appends a list predicates to the AnnouncementUpdate builder. +func (_u *AnnouncementUpdateOne) Where(ps ...predicate.Announcement) *AnnouncementUpdateOne { + _u.mutation.Where(ps...) + return _u +} + +// Select allows selecting one or more fields (columns) of the returned entity. +// The default is selecting all fields defined in the entity schema. +func (_u *AnnouncementUpdateOne) Select(field string, fields ...string) *AnnouncementUpdateOne { + _u.fields = append([]string{field}, fields...) + return _u +} + +// Save executes the query and returns the updated Announcement entity. +func (_u *AnnouncementUpdateOne) Save(ctx context.Context) (*Announcement, error) { + _u.defaults() + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (_u *AnnouncementUpdateOne) SaveX(ctx context.Context) *Announcement { + node, err := _u.Save(ctx) + if err != nil { + panic(err) + } + return node +} + +// Exec executes the query on the entity. +func (_u *AnnouncementUpdateOne) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_u *AnnouncementUpdateOne) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (_u *AnnouncementUpdateOne) defaults() { + if _, ok := _u.mutation.UpdatedAt(); !ok { + v := announcement.UpdateDefaultUpdatedAt() + _u.mutation.SetUpdatedAt(v) + } +} + +// check runs all checks and user-defined validators on the builder. +func (_u *AnnouncementUpdateOne) check() error { + if v, ok := _u.mutation.Title(); ok { + if err := announcement.TitleValidator(v); err != nil { + return &ValidationError{Name: "title", err: fmt.Errorf(`ent: validator failed for field "Announcement.title": %w`, err)} + } + } + if v, ok := _u.mutation.Content(); ok { + if err := announcement.ContentValidator(v); err != nil { + return &ValidationError{Name: "content", err: fmt.Errorf(`ent: validator failed for field "Announcement.content": %w`, err)} + } + } + if v, ok := _u.mutation.Status(); ok { + if err := announcement.StatusValidator(v); err != nil { + return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "Announcement.status": %w`, err)} + } + } + return nil +} + +func (_u *AnnouncementUpdateOne) sqlSave(ctx context.Context) (_node *Announcement, err error) { + if err := _u.check(); err != nil { + return _node, err + } + _spec := sqlgraph.NewUpdateSpec(announcement.Table, announcement.Columns, sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64)) + id, ok := _u.mutation.ID() + if !ok { + return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Announcement.id" for update`)} + } + _spec.Node.ID.Value = id + if fields := _u.fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, announcement.FieldID) + for _, f := range fields { + if !announcement.ValidColumn(f) { + return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + if f != announcement.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, f) + } + } + } + if ps := _u.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := _u.mutation.Title(); ok { + _spec.SetField(announcement.FieldTitle, field.TypeString, value) + } + if value, ok := _u.mutation.Content(); ok { + _spec.SetField(announcement.FieldContent, field.TypeString, value) + } + if value, ok := _u.mutation.Status(); ok { + _spec.SetField(announcement.FieldStatus, field.TypeString, value) + } + if value, ok := _u.mutation.Targeting(); ok { + _spec.SetField(announcement.FieldTargeting, field.TypeJSON, value) + } + if _u.mutation.TargetingCleared() { + _spec.ClearField(announcement.FieldTargeting, field.TypeJSON) + } + if value, ok := _u.mutation.StartsAt(); ok { + _spec.SetField(announcement.FieldStartsAt, field.TypeTime, value) + } + if _u.mutation.StartsAtCleared() { + _spec.ClearField(announcement.FieldStartsAt, field.TypeTime) + } + if value, ok := _u.mutation.EndsAt(); ok { + _spec.SetField(announcement.FieldEndsAt, field.TypeTime, value) + } + if _u.mutation.EndsAtCleared() { + _spec.ClearField(announcement.FieldEndsAt, field.TypeTime) + } + if value, ok := _u.mutation.CreatedBy(); ok { + _spec.SetField(announcement.FieldCreatedBy, field.TypeInt64, value) + } + if value, ok := _u.mutation.AddedCreatedBy(); ok { + _spec.AddField(announcement.FieldCreatedBy, field.TypeInt64, value) + } + if _u.mutation.CreatedByCleared() { + _spec.ClearField(announcement.FieldCreatedBy, field.TypeInt64) + } + if value, ok := _u.mutation.UpdatedBy(); ok { + _spec.SetField(announcement.FieldUpdatedBy, field.TypeInt64, value) + } + if value, ok := _u.mutation.AddedUpdatedBy(); ok { + _spec.AddField(announcement.FieldUpdatedBy, field.TypeInt64, value) + } + if _u.mutation.UpdatedByCleared() { + _spec.ClearField(announcement.FieldUpdatedBy, field.TypeInt64) + } + if value, ok := _u.mutation.UpdatedAt(); ok { + _spec.SetField(announcement.FieldUpdatedAt, field.TypeTime, value) + } + if _u.mutation.ReadsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: announcement.ReadsTable, + Columns: []string{announcement.ReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedReadsIDs(); len(nodes) > 0 && !_u.mutation.ReadsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: announcement.ReadsTable, + Columns: []string{announcement.ReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.ReadsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: announcement.ReadsTable, + Columns: []string{announcement.ReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + _node = &Announcement{config: _u.config} + _spec.Assign = _node.assignValues + _spec.ScanValues = _node.scanValues + if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{announcement.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + _u.mutation.done = true + return _node, nil +} diff --git a/backend/ent/announcementread.go b/backend/ent/announcementread.go new file mode 100644 index 00000000..7bba04f2 --- /dev/null +++ b/backend/ent/announcementread.go @@ -0,0 +1,185 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "fmt" + "strings" + "time" + + "entgo.io/ent" + "entgo.io/ent/dialect/sql" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" + "github.com/Wei-Shaw/sub2api/ent/user" +) + +// AnnouncementRead is the model entity for the AnnouncementRead schema. +type AnnouncementRead struct { + config `json:"-"` + // ID of the ent. + ID int64 `json:"id,omitempty"` + // AnnouncementID holds the value of the "announcement_id" field. + AnnouncementID int64 `json:"announcement_id,omitempty"` + // UserID holds the value of the "user_id" field. + UserID int64 `json:"user_id,omitempty"` + // 用户首次已读时间 + ReadAt time.Time `json:"read_at,omitempty"` + // CreatedAt holds the value of the "created_at" field. + CreatedAt time.Time `json:"created_at,omitempty"` + // Edges holds the relations/edges for other nodes in the graph. + // The values are being populated by the AnnouncementReadQuery when eager-loading is set. + Edges AnnouncementReadEdges `json:"edges"` + selectValues sql.SelectValues +} + +// AnnouncementReadEdges holds the relations/edges for other nodes in the graph. +type AnnouncementReadEdges struct { + // Announcement holds the value of the announcement edge. + Announcement *Announcement `json:"announcement,omitempty"` + // User holds the value of the user edge. + User *User `json:"user,omitempty"` + // loadedTypes holds the information for reporting if a + // type was loaded (or requested) in eager-loading or not. + loadedTypes [2]bool +} + +// AnnouncementOrErr returns the Announcement value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e AnnouncementReadEdges) AnnouncementOrErr() (*Announcement, error) { + if e.Announcement != nil { + return e.Announcement, nil + } else if e.loadedTypes[0] { + return nil, &NotFoundError{label: announcement.Label} + } + return nil, &NotLoadedError{edge: "announcement"} +} + +// UserOrErr returns the User value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e AnnouncementReadEdges) UserOrErr() (*User, error) { + if e.User != nil { + return e.User, nil + } else if e.loadedTypes[1] { + return nil, &NotFoundError{label: user.Label} + } + return nil, &NotLoadedError{edge: "user"} +} + +// scanValues returns the types for scanning values from sql.Rows. +func (*AnnouncementRead) scanValues(columns []string) ([]any, error) { + values := make([]any, len(columns)) + for i := range columns { + switch columns[i] { + case announcementread.FieldID, announcementread.FieldAnnouncementID, announcementread.FieldUserID: + values[i] = new(sql.NullInt64) + case announcementread.FieldReadAt, announcementread.FieldCreatedAt: + values[i] = new(sql.NullTime) + default: + values[i] = new(sql.UnknownType) + } + } + return values, nil +} + +// assignValues assigns the values that were returned from sql.Rows (after scanning) +// to the AnnouncementRead fields. +func (_m *AnnouncementRead) assignValues(columns []string, values []any) error { + if m, n := len(values), len(columns); m < n { + return fmt.Errorf("mismatch number of scan values: %d != %d", m, n) + } + for i := range columns { + switch columns[i] { + case announcementread.FieldID: + value, ok := values[i].(*sql.NullInt64) + if !ok { + return fmt.Errorf("unexpected type %T for field id", value) + } + _m.ID = int64(value.Int64) + case announcementread.FieldAnnouncementID: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field announcement_id", values[i]) + } else if value.Valid { + _m.AnnouncementID = value.Int64 + } + case announcementread.FieldUserID: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field user_id", values[i]) + } else if value.Valid { + _m.UserID = value.Int64 + } + case announcementread.FieldReadAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field read_at", values[i]) + } else if value.Valid { + _m.ReadAt = value.Time + } + case announcementread.FieldCreatedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field created_at", values[i]) + } else if value.Valid { + _m.CreatedAt = value.Time + } + default: + _m.selectValues.Set(columns[i], values[i]) + } + } + return nil +} + +// Value returns the ent.Value that was dynamically selected and assigned to the AnnouncementRead. +// This includes values selected through modifiers, order, etc. +func (_m *AnnouncementRead) Value(name string) (ent.Value, error) { + return _m.selectValues.Get(name) +} + +// QueryAnnouncement queries the "announcement" edge of the AnnouncementRead entity. +func (_m *AnnouncementRead) QueryAnnouncement() *AnnouncementQuery { + return NewAnnouncementReadClient(_m.config).QueryAnnouncement(_m) +} + +// QueryUser queries the "user" edge of the AnnouncementRead entity. +func (_m *AnnouncementRead) QueryUser() *UserQuery { + return NewAnnouncementReadClient(_m.config).QueryUser(_m) +} + +// Update returns a builder for updating this AnnouncementRead. +// Note that you need to call AnnouncementRead.Unwrap() before calling this method if this AnnouncementRead +// was returned from a transaction, and the transaction was committed or rolled back. +func (_m *AnnouncementRead) Update() *AnnouncementReadUpdateOne { + return NewAnnouncementReadClient(_m.config).UpdateOne(_m) +} + +// Unwrap unwraps the AnnouncementRead entity that was returned from a transaction after it was closed, +// so that all future queries will be executed through the driver which created the transaction. +func (_m *AnnouncementRead) Unwrap() *AnnouncementRead { + _tx, ok := _m.config.driver.(*txDriver) + if !ok { + panic("ent: AnnouncementRead is not a transactional entity") + } + _m.config.driver = _tx.drv + return _m +} + +// String implements the fmt.Stringer. +func (_m *AnnouncementRead) String() string { + var builder strings.Builder + builder.WriteString("AnnouncementRead(") + builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID)) + builder.WriteString("announcement_id=") + builder.WriteString(fmt.Sprintf("%v", _m.AnnouncementID)) + builder.WriteString(", ") + builder.WriteString("user_id=") + builder.WriteString(fmt.Sprintf("%v", _m.UserID)) + builder.WriteString(", ") + builder.WriteString("read_at=") + builder.WriteString(_m.ReadAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("created_at=") + builder.WriteString(_m.CreatedAt.Format(time.ANSIC)) + builder.WriteByte(')') + return builder.String() +} + +// AnnouncementReads is a parsable slice of AnnouncementRead. +type AnnouncementReads []*AnnouncementRead diff --git a/backend/ent/announcementread/announcementread.go b/backend/ent/announcementread/announcementread.go new file mode 100644 index 00000000..cf5fe458 --- /dev/null +++ b/backend/ent/announcementread/announcementread.go @@ -0,0 +1,127 @@ +// Code generated by ent, DO NOT EDIT. + +package announcementread + +import ( + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" +) + +const ( + // Label holds the string label denoting the announcementread type in the database. + Label = "announcement_read" + // FieldID holds the string denoting the id field in the database. + FieldID = "id" + // FieldAnnouncementID holds the string denoting the announcement_id field in the database. + FieldAnnouncementID = "announcement_id" + // FieldUserID holds the string denoting the user_id field in the database. + FieldUserID = "user_id" + // FieldReadAt holds the string denoting the read_at field in the database. + FieldReadAt = "read_at" + // FieldCreatedAt holds the string denoting the created_at field in the database. + FieldCreatedAt = "created_at" + // EdgeAnnouncement holds the string denoting the announcement edge name in mutations. + EdgeAnnouncement = "announcement" + // EdgeUser holds the string denoting the user edge name in mutations. + EdgeUser = "user" + // Table holds the table name of the announcementread in the database. + Table = "announcement_reads" + // AnnouncementTable is the table that holds the announcement relation/edge. + AnnouncementTable = "announcement_reads" + // AnnouncementInverseTable is the table name for the Announcement entity. + // It exists in this package in order to avoid circular dependency with the "announcement" package. + AnnouncementInverseTable = "announcements" + // AnnouncementColumn is the table column denoting the announcement relation/edge. + AnnouncementColumn = "announcement_id" + // UserTable is the table that holds the user relation/edge. + UserTable = "announcement_reads" + // UserInverseTable is the table name for the User entity. + // It exists in this package in order to avoid circular dependency with the "user" package. + UserInverseTable = "users" + // UserColumn is the table column denoting the user relation/edge. + UserColumn = "user_id" +) + +// Columns holds all SQL columns for announcementread fields. +var Columns = []string{ + FieldID, + FieldAnnouncementID, + FieldUserID, + FieldReadAt, + FieldCreatedAt, +} + +// ValidColumn reports if the column name is valid (part of the table columns). +func ValidColumn(column string) bool { + for i := range Columns { + if column == Columns[i] { + return true + } + } + return false +} + +var ( + // DefaultReadAt holds the default value on creation for the "read_at" field. + DefaultReadAt func() time.Time + // DefaultCreatedAt holds the default value on creation for the "created_at" field. + DefaultCreatedAt func() time.Time +) + +// OrderOption defines the ordering options for the AnnouncementRead queries. +type OrderOption func(*sql.Selector) + +// ByID orders the results by the id field. +func ByID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldID, opts...).ToFunc() +} + +// ByAnnouncementID orders the results by the announcement_id field. +func ByAnnouncementID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldAnnouncementID, opts...).ToFunc() +} + +// ByUserID orders the results by the user_id field. +func ByUserID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUserID, opts...).ToFunc() +} + +// ByReadAt orders the results by the read_at field. +func ByReadAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldReadAt, opts...).ToFunc() +} + +// ByCreatedAt orders the results by the created_at field. +func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCreatedAt, opts...).ToFunc() +} + +// ByAnnouncementField orders the results by announcement field. +func ByAnnouncementField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newAnnouncementStep(), sql.OrderByField(field, opts...)) + } +} + +// ByUserField orders the results by user field. +func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...)) + } +} +func newAnnouncementStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(AnnouncementInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, AnnouncementTable, AnnouncementColumn), + ) +} +func newUserStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(UserInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn), + ) +} diff --git a/backend/ent/announcementread/where.go b/backend/ent/announcementread/where.go new file mode 100644 index 00000000..1a4305e8 --- /dev/null +++ b/backend/ent/announcementread/where.go @@ -0,0 +1,257 @@ +// Code generated by ent, DO NOT EDIT. + +package announcementread + +import ( + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "github.com/Wei-Shaw/sub2api/ent/predicate" +) + +// ID filters vertices based on their ID field. +func ID(id int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldEQ(FieldID, id)) +} + +// IDEQ applies the EQ predicate on the ID field. +func IDEQ(id int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldEQ(FieldID, id)) +} + +// IDNEQ applies the NEQ predicate on the ID field. +func IDNEQ(id int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldNEQ(FieldID, id)) +} + +// IDIn applies the In predicate on the ID field. +func IDIn(ids ...int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldIn(FieldID, ids...)) +} + +// IDNotIn applies the NotIn predicate on the ID field. +func IDNotIn(ids ...int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldNotIn(FieldID, ids...)) +} + +// IDGT applies the GT predicate on the ID field. +func IDGT(id int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldGT(FieldID, id)) +} + +// IDGTE applies the GTE predicate on the ID field. +func IDGTE(id int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldGTE(FieldID, id)) +} + +// IDLT applies the LT predicate on the ID field. +func IDLT(id int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldLT(FieldID, id)) +} + +// IDLTE applies the LTE predicate on the ID field. +func IDLTE(id int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldLTE(FieldID, id)) +} + +// AnnouncementID applies equality check predicate on the "announcement_id" field. It's identical to AnnouncementIDEQ. +func AnnouncementID(v int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldEQ(FieldAnnouncementID, v)) +} + +// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ. +func UserID(v int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldEQ(FieldUserID, v)) +} + +// ReadAt applies equality check predicate on the "read_at" field. It's identical to ReadAtEQ. +func ReadAt(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldEQ(FieldReadAt, v)) +} + +// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ. +func CreatedAt(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldEQ(FieldCreatedAt, v)) +} + +// AnnouncementIDEQ applies the EQ predicate on the "announcement_id" field. +func AnnouncementIDEQ(v int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldEQ(FieldAnnouncementID, v)) +} + +// AnnouncementIDNEQ applies the NEQ predicate on the "announcement_id" field. +func AnnouncementIDNEQ(v int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldNEQ(FieldAnnouncementID, v)) +} + +// AnnouncementIDIn applies the In predicate on the "announcement_id" field. +func AnnouncementIDIn(vs ...int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldIn(FieldAnnouncementID, vs...)) +} + +// AnnouncementIDNotIn applies the NotIn predicate on the "announcement_id" field. +func AnnouncementIDNotIn(vs ...int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldNotIn(FieldAnnouncementID, vs...)) +} + +// UserIDEQ applies the EQ predicate on the "user_id" field. +func UserIDEQ(v int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldEQ(FieldUserID, v)) +} + +// UserIDNEQ applies the NEQ predicate on the "user_id" field. +func UserIDNEQ(v int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldNEQ(FieldUserID, v)) +} + +// UserIDIn applies the In predicate on the "user_id" field. +func UserIDIn(vs ...int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldIn(FieldUserID, vs...)) +} + +// UserIDNotIn applies the NotIn predicate on the "user_id" field. +func UserIDNotIn(vs ...int64) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldNotIn(FieldUserID, vs...)) +} + +// ReadAtEQ applies the EQ predicate on the "read_at" field. +func ReadAtEQ(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldEQ(FieldReadAt, v)) +} + +// ReadAtNEQ applies the NEQ predicate on the "read_at" field. +func ReadAtNEQ(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldNEQ(FieldReadAt, v)) +} + +// ReadAtIn applies the In predicate on the "read_at" field. +func ReadAtIn(vs ...time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldIn(FieldReadAt, vs...)) +} + +// ReadAtNotIn applies the NotIn predicate on the "read_at" field. +func ReadAtNotIn(vs ...time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldNotIn(FieldReadAt, vs...)) +} + +// ReadAtGT applies the GT predicate on the "read_at" field. +func ReadAtGT(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldGT(FieldReadAt, v)) +} + +// ReadAtGTE applies the GTE predicate on the "read_at" field. +func ReadAtGTE(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldGTE(FieldReadAt, v)) +} + +// ReadAtLT applies the LT predicate on the "read_at" field. +func ReadAtLT(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldLT(FieldReadAt, v)) +} + +// ReadAtLTE applies the LTE predicate on the "read_at" field. +func ReadAtLTE(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldLTE(FieldReadAt, v)) +} + +// CreatedAtEQ applies the EQ predicate on the "created_at" field. +func CreatedAtEQ(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldEQ(FieldCreatedAt, v)) +} + +// CreatedAtNEQ applies the NEQ predicate on the "created_at" field. +func CreatedAtNEQ(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldNEQ(FieldCreatedAt, v)) +} + +// CreatedAtIn applies the In predicate on the "created_at" field. +func CreatedAtIn(vs ...time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldIn(FieldCreatedAt, vs...)) +} + +// CreatedAtNotIn applies the NotIn predicate on the "created_at" field. +func CreatedAtNotIn(vs ...time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldNotIn(FieldCreatedAt, vs...)) +} + +// CreatedAtGT applies the GT predicate on the "created_at" field. +func CreatedAtGT(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldGT(FieldCreatedAt, v)) +} + +// CreatedAtGTE applies the GTE predicate on the "created_at" field. +func CreatedAtGTE(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldGTE(FieldCreatedAt, v)) +} + +// CreatedAtLT applies the LT predicate on the "created_at" field. +func CreatedAtLT(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldLT(FieldCreatedAt, v)) +} + +// CreatedAtLTE applies the LTE predicate on the "created_at" field. +func CreatedAtLTE(v time.Time) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.FieldLTE(FieldCreatedAt, v)) +} + +// HasAnnouncement applies the HasEdge predicate on the "announcement" edge. +func HasAnnouncement() predicate.AnnouncementRead { + return predicate.AnnouncementRead(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, AnnouncementTable, AnnouncementColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasAnnouncementWith applies the HasEdge predicate on the "announcement" edge with a given conditions (other predicates). +func HasAnnouncementWith(preds ...predicate.Announcement) predicate.AnnouncementRead { + return predicate.AnnouncementRead(func(s *sql.Selector) { + step := newAnnouncementStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasUser applies the HasEdge predicate on the "user" edge. +func HasUser() predicate.AnnouncementRead { + return predicate.AnnouncementRead(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates). +func HasUserWith(preds ...predicate.User) predicate.AnnouncementRead { + return predicate.AnnouncementRead(func(s *sql.Selector) { + step := newUserStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// And groups predicates with the AND operator between them. +func And(predicates ...predicate.AnnouncementRead) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.AndPredicates(predicates...)) +} + +// Or groups predicates with the OR operator between them. +func Or(predicates ...predicate.AnnouncementRead) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.OrPredicates(predicates...)) +} + +// Not applies the not operator on the given predicate. +func Not(p predicate.AnnouncementRead) predicate.AnnouncementRead { + return predicate.AnnouncementRead(sql.NotPredicates(p)) +} diff --git a/backend/ent/announcementread_create.go b/backend/ent/announcementread_create.go new file mode 100644 index 00000000..c8c211ff --- /dev/null +++ b/backend/ent/announcementread_create.go @@ -0,0 +1,660 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" + "github.com/Wei-Shaw/sub2api/ent/user" +) + +// AnnouncementReadCreate is the builder for creating a AnnouncementRead entity. +type AnnouncementReadCreate struct { + config + mutation *AnnouncementReadMutation + hooks []Hook + conflict []sql.ConflictOption +} + +// SetAnnouncementID sets the "announcement_id" field. +func (_c *AnnouncementReadCreate) SetAnnouncementID(v int64) *AnnouncementReadCreate { + _c.mutation.SetAnnouncementID(v) + return _c +} + +// SetUserID sets the "user_id" field. +func (_c *AnnouncementReadCreate) SetUserID(v int64) *AnnouncementReadCreate { + _c.mutation.SetUserID(v) + return _c +} + +// SetReadAt sets the "read_at" field. +func (_c *AnnouncementReadCreate) SetReadAt(v time.Time) *AnnouncementReadCreate { + _c.mutation.SetReadAt(v) + return _c +} + +// SetNillableReadAt sets the "read_at" field if the given value is not nil. +func (_c *AnnouncementReadCreate) SetNillableReadAt(v *time.Time) *AnnouncementReadCreate { + if v != nil { + _c.SetReadAt(*v) + } + return _c +} + +// SetCreatedAt sets the "created_at" field. +func (_c *AnnouncementReadCreate) SetCreatedAt(v time.Time) *AnnouncementReadCreate { + _c.mutation.SetCreatedAt(v) + return _c +} + +// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. +func (_c *AnnouncementReadCreate) SetNillableCreatedAt(v *time.Time) *AnnouncementReadCreate { + if v != nil { + _c.SetCreatedAt(*v) + } + return _c +} + +// SetAnnouncement sets the "announcement" edge to the Announcement entity. +func (_c *AnnouncementReadCreate) SetAnnouncement(v *Announcement) *AnnouncementReadCreate { + return _c.SetAnnouncementID(v.ID) +} + +// SetUser sets the "user" edge to the User entity. +func (_c *AnnouncementReadCreate) SetUser(v *User) *AnnouncementReadCreate { + return _c.SetUserID(v.ID) +} + +// Mutation returns the AnnouncementReadMutation object of the builder. +func (_c *AnnouncementReadCreate) Mutation() *AnnouncementReadMutation { + return _c.mutation +} + +// Save creates the AnnouncementRead in the database. +func (_c *AnnouncementReadCreate) Save(ctx context.Context) (*AnnouncementRead, error) { + _c.defaults() + return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks) +} + +// SaveX calls Save and panics if Save returns an error. +func (_c *AnnouncementReadCreate) SaveX(ctx context.Context) *AnnouncementRead { + v, err := _c.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (_c *AnnouncementReadCreate) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_c *AnnouncementReadCreate) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (_c *AnnouncementReadCreate) defaults() { + if _, ok := _c.mutation.ReadAt(); !ok { + v := announcementread.DefaultReadAt() + _c.mutation.SetReadAt(v) + } + if _, ok := _c.mutation.CreatedAt(); !ok { + v := announcementread.DefaultCreatedAt() + _c.mutation.SetCreatedAt(v) + } +} + +// check runs all checks and user-defined validators on the builder. +func (_c *AnnouncementReadCreate) check() error { + if _, ok := _c.mutation.AnnouncementID(); !ok { + return &ValidationError{Name: "announcement_id", err: errors.New(`ent: missing required field "AnnouncementRead.announcement_id"`)} + } + if _, ok := _c.mutation.UserID(); !ok { + return &ValidationError{Name: "user_id", err: errors.New(`ent: missing required field "AnnouncementRead.user_id"`)} + } + if _, ok := _c.mutation.ReadAt(); !ok { + return &ValidationError{Name: "read_at", err: errors.New(`ent: missing required field "AnnouncementRead.read_at"`)} + } + if _, ok := _c.mutation.CreatedAt(); !ok { + return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "AnnouncementRead.created_at"`)} + } + if len(_c.mutation.AnnouncementIDs()) == 0 { + return &ValidationError{Name: "announcement", err: errors.New(`ent: missing required edge "AnnouncementRead.announcement"`)} + } + if len(_c.mutation.UserIDs()) == 0 { + return &ValidationError{Name: "user", err: errors.New(`ent: missing required edge "AnnouncementRead.user"`)} + } + return nil +} + +func (_c *AnnouncementReadCreate) sqlSave(ctx context.Context) (*AnnouncementRead, error) { + if err := _c.check(); err != nil { + return nil, err + } + _node, _spec := _c.createSpec() + if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + id := _spec.ID.Value.(int64) + _node.ID = int64(id) + _c.mutation.id = &_node.ID + _c.mutation.done = true + return _node, nil +} + +func (_c *AnnouncementReadCreate) createSpec() (*AnnouncementRead, *sqlgraph.CreateSpec) { + var ( + _node = &AnnouncementRead{config: _c.config} + _spec = sqlgraph.NewCreateSpec(announcementread.Table, sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64)) + ) + _spec.OnConflict = _c.conflict + if value, ok := _c.mutation.ReadAt(); ok { + _spec.SetField(announcementread.FieldReadAt, field.TypeTime, value) + _node.ReadAt = value + } + if value, ok := _c.mutation.CreatedAt(); ok { + _spec.SetField(announcementread.FieldCreatedAt, field.TypeTime, value) + _node.CreatedAt = value + } + if nodes := _c.mutation.AnnouncementIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: announcementread.AnnouncementTable, + Columns: []string{announcementread.AnnouncementColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.AnnouncementID = nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.UserIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: announcementread.UserTable, + Columns: []string{announcementread.UserColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.UserID = nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + return _node, _spec +} + +// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause +// of the `INSERT` statement. For example: +// +// client.AnnouncementRead.Create(). +// SetAnnouncementID(v). +// OnConflict( +// // Update the row with the new values +// // the was proposed for insertion. +// sql.ResolveWithNewValues(), +// ). +// // Override some of the fields with custom +// // update values. +// Update(func(u *ent.AnnouncementReadUpsert) { +// SetAnnouncementID(v+v). +// }). +// Exec(ctx) +func (_c *AnnouncementReadCreate) OnConflict(opts ...sql.ConflictOption) *AnnouncementReadUpsertOne { + _c.conflict = opts + return &AnnouncementReadUpsertOne{ + create: _c, + } +} + +// OnConflictColumns calls `OnConflict` and configures the columns +// as conflict target. Using this option is equivalent to using: +// +// client.AnnouncementRead.Create(). +// OnConflict(sql.ConflictColumns(columns...)). +// Exec(ctx) +func (_c *AnnouncementReadCreate) OnConflictColumns(columns ...string) *AnnouncementReadUpsertOne { + _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...)) + return &AnnouncementReadUpsertOne{ + create: _c, + } +} + +type ( + // AnnouncementReadUpsertOne is the builder for "upsert"-ing + // one AnnouncementRead node. + AnnouncementReadUpsertOne struct { + create *AnnouncementReadCreate + } + + // AnnouncementReadUpsert is the "OnConflict" setter. + AnnouncementReadUpsert struct { + *sql.UpdateSet + } +) + +// SetAnnouncementID sets the "announcement_id" field. +func (u *AnnouncementReadUpsert) SetAnnouncementID(v int64) *AnnouncementReadUpsert { + u.Set(announcementread.FieldAnnouncementID, v) + return u +} + +// UpdateAnnouncementID sets the "announcement_id" field to the value that was provided on create. +func (u *AnnouncementReadUpsert) UpdateAnnouncementID() *AnnouncementReadUpsert { + u.SetExcluded(announcementread.FieldAnnouncementID) + return u +} + +// SetUserID sets the "user_id" field. +func (u *AnnouncementReadUpsert) SetUserID(v int64) *AnnouncementReadUpsert { + u.Set(announcementread.FieldUserID, v) + return u +} + +// UpdateUserID sets the "user_id" field to the value that was provided on create. +func (u *AnnouncementReadUpsert) UpdateUserID() *AnnouncementReadUpsert { + u.SetExcluded(announcementread.FieldUserID) + return u +} + +// SetReadAt sets the "read_at" field. +func (u *AnnouncementReadUpsert) SetReadAt(v time.Time) *AnnouncementReadUpsert { + u.Set(announcementread.FieldReadAt, v) + return u +} + +// UpdateReadAt sets the "read_at" field to the value that was provided on create. +func (u *AnnouncementReadUpsert) UpdateReadAt() *AnnouncementReadUpsert { + u.SetExcluded(announcementread.FieldReadAt) + return u +} + +// UpdateNewValues updates the mutable fields using the new values that were set on create. +// Using this option is equivalent to using: +// +// client.AnnouncementRead.Create(). +// OnConflict( +// sql.ResolveWithNewValues(), +// ). +// Exec(ctx) +func (u *AnnouncementReadUpsertOne) UpdateNewValues() *AnnouncementReadUpsertOne { + u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues()) + u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) { + if _, exists := u.create.mutation.CreatedAt(); exists { + s.SetIgnore(announcementread.FieldCreatedAt) + } + })) + return u +} + +// Ignore sets each column to itself in case of conflict. +// Using this option is equivalent to using: +// +// client.AnnouncementRead.Create(). +// OnConflict(sql.ResolveWithIgnore()). +// Exec(ctx) +func (u *AnnouncementReadUpsertOne) Ignore() *AnnouncementReadUpsertOne { + u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore()) + return u +} + +// DoNothing configures the conflict_action to `DO NOTHING`. +// Supported only by SQLite and PostgreSQL. +func (u *AnnouncementReadUpsertOne) DoNothing() *AnnouncementReadUpsertOne { + u.create.conflict = append(u.create.conflict, sql.DoNothing()) + return u +} + +// Update allows overriding fields `UPDATE` values. See the AnnouncementReadCreate.OnConflict +// documentation for more info. +func (u *AnnouncementReadUpsertOne) Update(set func(*AnnouncementReadUpsert)) *AnnouncementReadUpsertOne { + u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) { + set(&AnnouncementReadUpsert{UpdateSet: update}) + })) + return u +} + +// SetAnnouncementID sets the "announcement_id" field. +func (u *AnnouncementReadUpsertOne) SetAnnouncementID(v int64) *AnnouncementReadUpsertOne { + return u.Update(func(s *AnnouncementReadUpsert) { + s.SetAnnouncementID(v) + }) +} + +// UpdateAnnouncementID sets the "announcement_id" field to the value that was provided on create. +func (u *AnnouncementReadUpsertOne) UpdateAnnouncementID() *AnnouncementReadUpsertOne { + return u.Update(func(s *AnnouncementReadUpsert) { + s.UpdateAnnouncementID() + }) +} + +// SetUserID sets the "user_id" field. +func (u *AnnouncementReadUpsertOne) SetUserID(v int64) *AnnouncementReadUpsertOne { + return u.Update(func(s *AnnouncementReadUpsert) { + s.SetUserID(v) + }) +} + +// UpdateUserID sets the "user_id" field to the value that was provided on create. +func (u *AnnouncementReadUpsertOne) UpdateUserID() *AnnouncementReadUpsertOne { + return u.Update(func(s *AnnouncementReadUpsert) { + s.UpdateUserID() + }) +} + +// SetReadAt sets the "read_at" field. +func (u *AnnouncementReadUpsertOne) SetReadAt(v time.Time) *AnnouncementReadUpsertOne { + return u.Update(func(s *AnnouncementReadUpsert) { + s.SetReadAt(v) + }) +} + +// UpdateReadAt sets the "read_at" field to the value that was provided on create. +func (u *AnnouncementReadUpsertOne) UpdateReadAt() *AnnouncementReadUpsertOne { + return u.Update(func(s *AnnouncementReadUpsert) { + s.UpdateReadAt() + }) +} + +// Exec executes the query. +func (u *AnnouncementReadUpsertOne) Exec(ctx context.Context) error { + if len(u.create.conflict) == 0 { + return errors.New("ent: missing options for AnnouncementReadCreate.OnConflict") + } + return u.create.Exec(ctx) +} + +// ExecX is like Exec, but panics if an error occurs. +func (u *AnnouncementReadUpsertOne) ExecX(ctx context.Context) { + if err := u.create.Exec(ctx); err != nil { + panic(err) + } +} + +// Exec executes the UPSERT query and returns the inserted/updated ID. +func (u *AnnouncementReadUpsertOne) ID(ctx context.Context) (id int64, err error) { + node, err := u.create.Save(ctx) + if err != nil { + return id, err + } + return node.ID, nil +} + +// IDX is like ID, but panics if an error occurs. +func (u *AnnouncementReadUpsertOne) IDX(ctx context.Context) int64 { + id, err := u.ID(ctx) + if err != nil { + panic(err) + } + return id +} + +// AnnouncementReadCreateBulk is the builder for creating many AnnouncementRead entities in bulk. +type AnnouncementReadCreateBulk struct { + config + err error + builders []*AnnouncementReadCreate + conflict []sql.ConflictOption +} + +// Save creates the AnnouncementRead entities in the database. +func (_c *AnnouncementReadCreateBulk) Save(ctx context.Context) ([]*AnnouncementRead, error) { + if _c.err != nil { + return nil, _c.err + } + specs := make([]*sqlgraph.CreateSpec, len(_c.builders)) + nodes := make([]*AnnouncementRead, len(_c.builders)) + mutators := make([]Mutator, len(_c.builders)) + for i := range _c.builders { + func(i int, root context.Context) { + builder := _c.builders[i] + builder.defaults() + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*AnnouncementReadMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err := builder.check(); err != nil { + return nil, err + } + builder.mutation = mutation + var err error + nodes[i], specs[i] = builder.createSpec() + if i < len(mutators)-1 { + _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation) + } else { + spec := &sqlgraph.BatchCreateSpec{Nodes: specs} + spec.OnConflict = _c.conflict + // Invoke the actual operation on the latest mutation in the chain. + if err = sqlgraph.BatchCreate(ctx, _c.driver, spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + } + } + if err != nil { + return nil, err + } + mutation.id = &nodes[i].ID + if specs[i].ID.Value != nil { + id := specs[i].ID.Value.(int64) + nodes[i].ID = int64(id) + } + mutation.done = true + return nodes[i], nil + }) + for i := len(builder.hooks) - 1; i >= 0; i-- { + mut = builder.hooks[i](mut) + } + mutators[i] = mut + }(i, ctx) + } + if len(mutators) > 0 { + if _, err := mutators[0].Mutate(ctx, _c.builders[0].mutation); err != nil { + return nil, err + } + } + return nodes, nil +} + +// SaveX is like Save, but panics if an error occurs. +func (_c *AnnouncementReadCreateBulk) SaveX(ctx context.Context) []*AnnouncementRead { + v, err := _c.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (_c *AnnouncementReadCreateBulk) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_c *AnnouncementReadCreateBulk) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { + panic(err) + } +} + +// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause +// of the `INSERT` statement. For example: +// +// client.AnnouncementRead.CreateBulk(builders...). +// OnConflict( +// // Update the row with the new values +// // the was proposed for insertion. +// sql.ResolveWithNewValues(), +// ). +// // Override some of the fields with custom +// // update values. +// Update(func(u *ent.AnnouncementReadUpsert) { +// SetAnnouncementID(v+v). +// }). +// Exec(ctx) +func (_c *AnnouncementReadCreateBulk) OnConflict(opts ...sql.ConflictOption) *AnnouncementReadUpsertBulk { + _c.conflict = opts + return &AnnouncementReadUpsertBulk{ + create: _c, + } +} + +// OnConflictColumns calls `OnConflict` and configures the columns +// as conflict target. Using this option is equivalent to using: +// +// client.AnnouncementRead.Create(). +// OnConflict(sql.ConflictColumns(columns...)). +// Exec(ctx) +func (_c *AnnouncementReadCreateBulk) OnConflictColumns(columns ...string) *AnnouncementReadUpsertBulk { + _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...)) + return &AnnouncementReadUpsertBulk{ + create: _c, + } +} + +// AnnouncementReadUpsertBulk is the builder for "upsert"-ing +// a bulk of AnnouncementRead nodes. +type AnnouncementReadUpsertBulk struct { + create *AnnouncementReadCreateBulk +} + +// UpdateNewValues updates the mutable fields using the new values that +// were set on create. Using this option is equivalent to using: +// +// client.AnnouncementRead.Create(). +// OnConflict( +// sql.ResolveWithNewValues(), +// ). +// Exec(ctx) +func (u *AnnouncementReadUpsertBulk) UpdateNewValues() *AnnouncementReadUpsertBulk { + u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues()) + u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) { + for _, b := range u.create.builders { + if _, exists := b.mutation.CreatedAt(); exists { + s.SetIgnore(announcementread.FieldCreatedAt) + } + } + })) + return u +} + +// Ignore sets each column to itself in case of conflict. +// Using this option is equivalent to using: +// +// client.AnnouncementRead.Create(). +// OnConflict(sql.ResolveWithIgnore()). +// Exec(ctx) +func (u *AnnouncementReadUpsertBulk) Ignore() *AnnouncementReadUpsertBulk { + u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore()) + return u +} + +// DoNothing configures the conflict_action to `DO NOTHING`. +// Supported only by SQLite and PostgreSQL. +func (u *AnnouncementReadUpsertBulk) DoNothing() *AnnouncementReadUpsertBulk { + u.create.conflict = append(u.create.conflict, sql.DoNothing()) + return u +} + +// Update allows overriding fields `UPDATE` values. See the AnnouncementReadCreateBulk.OnConflict +// documentation for more info. +func (u *AnnouncementReadUpsertBulk) Update(set func(*AnnouncementReadUpsert)) *AnnouncementReadUpsertBulk { + u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) { + set(&AnnouncementReadUpsert{UpdateSet: update}) + })) + return u +} + +// SetAnnouncementID sets the "announcement_id" field. +func (u *AnnouncementReadUpsertBulk) SetAnnouncementID(v int64) *AnnouncementReadUpsertBulk { + return u.Update(func(s *AnnouncementReadUpsert) { + s.SetAnnouncementID(v) + }) +} + +// UpdateAnnouncementID sets the "announcement_id" field to the value that was provided on create. +func (u *AnnouncementReadUpsertBulk) UpdateAnnouncementID() *AnnouncementReadUpsertBulk { + return u.Update(func(s *AnnouncementReadUpsert) { + s.UpdateAnnouncementID() + }) +} + +// SetUserID sets the "user_id" field. +func (u *AnnouncementReadUpsertBulk) SetUserID(v int64) *AnnouncementReadUpsertBulk { + return u.Update(func(s *AnnouncementReadUpsert) { + s.SetUserID(v) + }) +} + +// UpdateUserID sets the "user_id" field to the value that was provided on create. +func (u *AnnouncementReadUpsertBulk) UpdateUserID() *AnnouncementReadUpsertBulk { + return u.Update(func(s *AnnouncementReadUpsert) { + s.UpdateUserID() + }) +} + +// SetReadAt sets the "read_at" field. +func (u *AnnouncementReadUpsertBulk) SetReadAt(v time.Time) *AnnouncementReadUpsertBulk { + return u.Update(func(s *AnnouncementReadUpsert) { + s.SetReadAt(v) + }) +} + +// UpdateReadAt sets the "read_at" field to the value that was provided on create. +func (u *AnnouncementReadUpsertBulk) UpdateReadAt() *AnnouncementReadUpsertBulk { + return u.Update(func(s *AnnouncementReadUpsert) { + s.UpdateReadAt() + }) +} + +// Exec executes the query. +func (u *AnnouncementReadUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } + for i, b := range u.create.builders { + if len(b.conflict) != 0 { + return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the AnnouncementReadCreateBulk instead", i) + } + } + if len(u.create.conflict) == 0 { + return errors.New("ent: missing options for AnnouncementReadCreateBulk.OnConflict") + } + return u.create.Exec(ctx) +} + +// ExecX is like Exec, but panics if an error occurs. +func (u *AnnouncementReadUpsertBulk) ExecX(ctx context.Context) { + if err := u.create.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/backend/ent/announcementread_delete.go b/backend/ent/announcementread_delete.go new file mode 100644 index 00000000..a4da0821 --- /dev/null +++ b/backend/ent/announcementread_delete.go @@ -0,0 +1,88 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/Wei-Shaw/sub2api/ent/announcementread" + "github.com/Wei-Shaw/sub2api/ent/predicate" +) + +// AnnouncementReadDelete is the builder for deleting a AnnouncementRead entity. +type AnnouncementReadDelete struct { + config + hooks []Hook + mutation *AnnouncementReadMutation +} + +// Where appends a list predicates to the AnnouncementReadDelete builder. +func (_d *AnnouncementReadDelete) Where(ps ...predicate.AnnouncementRead) *AnnouncementReadDelete { + _d.mutation.Where(ps...) + return _d +} + +// Exec executes the deletion query and returns how many vertices were deleted. +func (_d *AnnouncementReadDelete) Exec(ctx context.Context) (int, error) { + return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks) +} + +// ExecX is like Exec, but panics if an error occurs. +func (_d *AnnouncementReadDelete) ExecX(ctx context.Context) int { + n, err := _d.Exec(ctx) + if err != nil { + panic(err) + } + return n +} + +func (_d *AnnouncementReadDelete) sqlExec(ctx context.Context) (int, error) { + _spec := sqlgraph.NewDeleteSpec(announcementread.Table, sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64)) + if ps := _d.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec) + if err != nil && sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + _d.mutation.done = true + return affected, err +} + +// AnnouncementReadDeleteOne is the builder for deleting a single AnnouncementRead entity. +type AnnouncementReadDeleteOne struct { + _d *AnnouncementReadDelete +} + +// Where appends a list predicates to the AnnouncementReadDelete builder. +func (_d *AnnouncementReadDeleteOne) Where(ps ...predicate.AnnouncementRead) *AnnouncementReadDeleteOne { + _d._d.mutation.Where(ps...) + return _d +} + +// Exec executes the deletion query. +func (_d *AnnouncementReadDeleteOne) Exec(ctx context.Context) error { + n, err := _d._d.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &NotFoundError{announcementread.Label} + default: + return nil + } +} + +// ExecX is like Exec, but panics if an error occurs. +func (_d *AnnouncementReadDeleteOne) ExecX(ctx context.Context) { + if err := _d.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/backend/ent/announcementread_query.go b/backend/ent/announcementread_query.go new file mode 100644 index 00000000..108299fd --- /dev/null +++ b/backend/ent/announcementread_query.go @@ -0,0 +1,718 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "fmt" + "math" + + "entgo.io/ent" + "entgo.io/ent/dialect" + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" + "github.com/Wei-Shaw/sub2api/ent/predicate" + "github.com/Wei-Shaw/sub2api/ent/user" +) + +// AnnouncementReadQuery is the builder for querying AnnouncementRead entities. +type AnnouncementReadQuery struct { + config + ctx *QueryContext + order []announcementread.OrderOption + inters []Interceptor + predicates []predicate.AnnouncementRead + withAnnouncement *AnnouncementQuery + withUser *UserQuery + modifiers []func(*sql.Selector) + // intermediate query (i.e. traversal path). + sql *sql.Selector + path func(context.Context) (*sql.Selector, error) +} + +// Where adds a new predicate for the AnnouncementReadQuery builder. +func (_q *AnnouncementReadQuery) Where(ps ...predicate.AnnouncementRead) *AnnouncementReadQuery { + _q.predicates = append(_q.predicates, ps...) + return _q +} + +// Limit the number of records to be returned by this query. +func (_q *AnnouncementReadQuery) Limit(limit int) *AnnouncementReadQuery { + _q.ctx.Limit = &limit + return _q +} + +// Offset to start from. +func (_q *AnnouncementReadQuery) Offset(offset int) *AnnouncementReadQuery { + _q.ctx.Offset = &offset + return _q +} + +// Unique configures the query builder to filter duplicate records on query. +// By default, unique is set to true, and can be disabled using this method. +func (_q *AnnouncementReadQuery) Unique(unique bool) *AnnouncementReadQuery { + _q.ctx.Unique = &unique + return _q +} + +// Order specifies how the records should be ordered. +func (_q *AnnouncementReadQuery) Order(o ...announcementread.OrderOption) *AnnouncementReadQuery { + _q.order = append(_q.order, o...) + return _q +} + +// QueryAnnouncement chains the current query on the "announcement" edge. +func (_q *AnnouncementReadQuery) QueryAnnouncement() *AnnouncementQuery { + query := (&AnnouncementClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(announcementread.Table, announcementread.FieldID, selector), + sqlgraph.To(announcement.Table, announcement.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, announcementread.AnnouncementTable, announcementread.AnnouncementColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryUser chains the current query on the "user" edge. +func (_q *AnnouncementReadQuery) QueryUser() *UserQuery { + query := (&UserClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(announcementread.Table, announcementread.FieldID, selector), + sqlgraph.To(user.Table, user.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, announcementread.UserTable, announcementread.UserColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// First returns the first AnnouncementRead entity from the query. +// Returns a *NotFoundError when no AnnouncementRead was found. +func (_q *AnnouncementReadQuery) First(ctx context.Context) (*AnnouncementRead, error) { + nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst)) + if err != nil { + return nil, err + } + if len(nodes) == 0 { + return nil, &NotFoundError{announcementread.Label} + } + return nodes[0], nil +} + +// FirstX is like First, but panics if an error occurs. +func (_q *AnnouncementReadQuery) FirstX(ctx context.Context) *AnnouncementRead { + node, err := _q.First(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return node +} + +// FirstID returns the first AnnouncementRead ID from the query. +// Returns a *NotFoundError when no AnnouncementRead ID was found. +func (_q *AnnouncementReadQuery) FirstID(ctx context.Context) (id int64, err error) { + var ids []int64 + if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil { + return + } + if len(ids) == 0 { + err = &NotFoundError{announcementread.Label} + return + } + return ids[0], nil +} + +// FirstIDX is like FirstID, but panics if an error occurs. +func (_q *AnnouncementReadQuery) FirstIDX(ctx context.Context) int64 { + id, err := _q.FirstID(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return id +} + +// Only returns a single AnnouncementRead entity found by the query, ensuring it only returns one. +// Returns a *NotSingularError when more than one AnnouncementRead entity is found. +// Returns a *NotFoundError when no AnnouncementRead entities are found. +func (_q *AnnouncementReadQuery) Only(ctx context.Context) (*AnnouncementRead, error) { + nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly)) + if err != nil { + return nil, err + } + switch len(nodes) { + case 1: + return nodes[0], nil + case 0: + return nil, &NotFoundError{announcementread.Label} + default: + return nil, &NotSingularError{announcementread.Label} + } +} + +// OnlyX is like Only, but panics if an error occurs. +func (_q *AnnouncementReadQuery) OnlyX(ctx context.Context) *AnnouncementRead { + node, err := _q.Only(ctx) + if err != nil { + panic(err) + } + return node +} + +// OnlyID is like Only, but returns the only AnnouncementRead ID in the query. +// Returns a *NotSingularError when more than one AnnouncementRead ID is found. +// Returns a *NotFoundError when no entities are found. +func (_q *AnnouncementReadQuery) OnlyID(ctx context.Context) (id int64, err error) { + var ids []int64 + if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil { + return + } + switch len(ids) { + case 1: + id = ids[0] + case 0: + err = &NotFoundError{announcementread.Label} + default: + err = &NotSingularError{announcementread.Label} + } + return +} + +// OnlyIDX is like OnlyID, but panics if an error occurs. +func (_q *AnnouncementReadQuery) OnlyIDX(ctx context.Context) int64 { + id, err := _q.OnlyID(ctx) + if err != nil { + panic(err) + } + return id +} + +// All executes the query and returns a list of AnnouncementReads. +func (_q *AnnouncementReadQuery) All(ctx context.Context) ([]*AnnouncementRead, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll) + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + qr := querierAll[[]*AnnouncementRead, *AnnouncementReadQuery]() + return withInterceptors[[]*AnnouncementRead](ctx, _q, qr, _q.inters) +} + +// AllX is like All, but panics if an error occurs. +func (_q *AnnouncementReadQuery) AllX(ctx context.Context) []*AnnouncementRead { + nodes, err := _q.All(ctx) + if err != nil { + panic(err) + } + return nodes +} + +// IDs executes the query and returns a list of AnnouncementRead IDs. +func (_q *AnnouncementReadQuery) IDs(ctx context.Context) (ids []int64, err error) { + if _q.ctx.Unique == nil && _q.path != nil { + _q.Unique(true) + } + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs) + if err = _q.Select(announcementread.FieldID).Scan(ctx, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// IDsX is like IDs, but panics if an error occurs. +func (_q *AnnouncementReadQuery) IDsX(ctx context.Context) []int64 { + ids, err := _q.IDs(ctx) + if err != nil { + panic(err) + } + return ids +} + +// Count returns the count of the given query. +func (_q *AnnouncementReadQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount) + if err := _q.prepareQuery(ctx); err != nil { + return 0, err + } + return withInterceptors[int](ctx, _q, querierCount[*AnnouncementReadQuery](), _q.inters) +} + +// CountX is like Count, but panics if an error occurs. +func (_q *AnnouncementReadQuery) CountX(ctx context.Context) int { + count, err := _q.Count(ctx) + if err != nil { + panic(err) + } + return count +} + +// Exist returns true if the query has elements in the graph. +func (_q *AnnouncementReadQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist) + switch _, err := _q.FirstID(ctx); { + case IsNotFound(err): + return false, nil + case err != nil: + return false, fmt.Errorf("ent: check existence: %w", err) + default: + return true, nil + } +} + +// ExistX is like Exist, but panics if an error occurs. +func (_q *AnnouncementReadQuery) ExistX(ctx context.Context) bool { + exist, err := _q.Exist(ctx) + if err != nil { + panic(err) + } + return exist +} + +// Clone returns a duplicate of the AnnouncementReadQuery builder, including all associated steps. It can be +// used to prepare common query builders and use them differently after the clone is made. +func (_q *AnnouncementReadQuery) Clone() *AnnouncementReadQuery { + if _q == nil { + return nil + } + return &AnnouncementReadQuery{ + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]announcementread.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.AnnouncementRead{}, _q.predicates...), + withAnnouncement: _q.withAnnouncement.Clone(), + withUser: _q.withUser.Clone(), + // clone intermediate query. + sql: _q.sql.Clone(), + path: _q.path, + } +} + +// WithAnnouncement tells the query-builder to eager-load the nodes that are connected to +// the "announcement" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *AnnouncementReadQuery) WithAnnouncement(opts ...func(*AnnouncementQuery)) *AnnouncementReadQuery { + query := (&AnnouncementClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withAnnouncement = query + return _q +} + +// WithUser tells the query-builder to eager-load the nodes that are connected to +// the "user" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *AnnouncementReadQuery) WithUser(opts ...func(*UserQuery)) *AnnouncementReadQuery { + query := (&UserClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withUser = query + return _q +} + +// GroupBy is used to group vertices by one or more fields/columns. +// It is often used with aggregate functions, like: count, max, mean, min, sum. +// +// Example: +// +// var v []struct { +// AnnouncementID int64 `json:"announcement_id,omitempty"` +// Count int `json:"count,omitempty"` +// } +// +// client.AnnouncementRead.Query(). +// GroupBy(announcementread.FieldAnnouncementID). +// Aggregate(ent.Count()). +// Scan(ctx, &v) +func (_q *AnnouncementReadQuery) GroupBy(field string, fields ...string) *AnnouncementReadGroupBy { + _q.ctx.Fields = append([]string{field}, fields...) + grbuild := &AnnouncementReadGroupBy{build: _q} + grbuild.flds = &_q.ctx.Fields + grbuild.label = announcementread.Label + grbuild.scan = grbuild.Scan + return grbuild +} + +// Select allows the selection one or more fields/columns for the given query, +// instead of selecting all fields in the entity. +// +// Example: +// +// var v []struct { +// AnnouncementID int64 `json:"announcement_id,omitempty"` +// } +// +// client.AnnouncementRead.Query(). +// Select(announcementread.FieldAnnouncementID). +// Scan(ctx, &v) +func (_q *AnnouncementReadQuery) Select(fields ...string) *AnnouncementReadSelect { + _q.ctx.Fields = append(_q.ctx.Fields, fields...) + sbuild := &AnnouncementReadSelect{AnnouncementReadQuery: _q} + sbuild.label = announcementread.Label + sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan + return sbuild +} + +// Aggregate returns a AnnouncementReadSelect configured with the given aggregations. +func (_q *AnnouncementReadQuery) Aggregate(fns ...AggregateFunc) *AnnouncementReadSelect { + return _q.Select().Aggregate(fns...) +} + +func (_q *AnnouncementReadQuery) prepareQuery(ctx context.Context) error { + for _, inter := range _q.inters { + if inter == nil { + return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)") + } + if trv, ok := inter.(Traverser); ok { + if err := trv.Traverse(ctx, _q); err != nil { + return err + } + } + } + for _, f := range _q.ctx.Fields { + if !announcementread.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + } + if _q.path != nil { + prev, err := _q.path(ctx) + if err != nil { + return err + } + _q.sql = prev + } + return nil +} + +func (_q *AnnouncementReadQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*AnnouncementRead, error) { + var ( + nodes = []*AnnouncementRead{} + _spec = _q.querySpec() + loadedTypes = [2]bool{ + _q.withAnnouncement != nil, + _q.withUser != nil, + } + ) + _spec.ScanValues = func(columns []string) ([]any, error) { + return (*AnnouncementRead).scanValues(nil, columns) + } + _spec.Assign = func(columns []string, values []any) error { + node := &AnnouncementRead{config: _q.config} + nodes = append(nodes, node) + node.Edges.loadedTypes = loadedTypes + return node.assignValues(columns, values) + } + if len(_q.modifiers) > 0 { + _spec.Modifiers = _q.modifiers + } + for i := range hooks { + hooks[i](ctx, _spec) + } + if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil { + return nil, err + } + if len(nodes) == 0 { + return nodes, nil + } + if query := _q.withAnnouncement; query != nil { + if err := _q.loadAnnouncement(ctx, query, nodes, nil, + func(n *AnnouncementRead, e *Announcement) { n.Edges.Announcement = e }); err != nil { + return nil, err + } + } + if query := _q.withUser; query != nil { + if err := _q.loadUser(ctx, query, nodes, nil, + func(n *AnnouncementRead, e *User) { n.Edges.User = e }); err != nil { + return nil, err + } + } + return nodes, nil +} + +func (_q *AnnouncementReadQuery) loadAnnouncement(ctx context.Context, query *AnnouncementQuery, nodes []*AnnouncementRead, init func(*AnnouncementRead), assign func(*AnnouncementRead, *Announcement)) error { + ids := make([]int64, 0, len(nodes)) + nodeids := make(map[int64][]*AnnouncementRead) + for i := range nodes { + fk := nodes[i].AnnouncementID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(announcement.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "announcement_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} +func (_q *AnnouncementReadQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*AnnouncementRead, init func(*AnnouncementRead), assign func(*AnnouncementRead, *User)) error { + ids := make([]int64, 0, len(nodes)) + nodeids := make(map[int64][]*AnnouncementRead) + for i := range nodes { + fk := nodes[i].UserID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(user.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} + +func (_q *AnnouncementReadQuery) sqlCount(ctx context.Context) (int, error) { + _spec := _q.querySpec() + if len(_q.modifiers) > 0 { + _spec.Modifiers = _q.modifiers + } + _spec.Node.Columns = _q.ctx.Fields + if len(_q.ctx.Fields) > 0 { + _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique + } + return sqlgraph.CountNodes(ctx, _q.driver, _spec) +} + +func (_q *AnnouncementReadQuery) querySpec() *sqlgraph.QuerySpec { + _spec := sqlgraph.NewQuerySpec(announcementread.Table, announcementread.Columns, sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64)) + _spec.From = _q.sql + if unique := _q.ctx.Unique; unique != nil { + _spec.Unique = *unique + } else if _q.path != nil { + _spec.Unique = true + } + if fields := _q.ctx.Fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, announcementread.FieldID) + for i := range fields { + if fields[i] != announcementread.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) + } + } + if _q.withAnnouncement != nil { + _spec.Node.AddColumnOnce(announcementread.FieldAnnouncementID) + } + if _q.withUser != nil { + _spec.Node.AddColumnOnce(announcementread.FieldUserID) + } + } + if ps := _q.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if limit := _q.ctx.Limit; limit != nil { + _spec.Limit = *limit + } + if offset := _q.ctx.Offset; offset != nil { + _spec.Offset = *offset + } + if ps := _q.order; len(ps) > 0 { + _spec.Order = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + return _spec +} + +func (_q *AnnouncementReadQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(_q.driver.Dialect()) + t1 := builder.Table(announcementread.Table) + columns := _q.ctx.Fields + if len(columns) == 0 { + columns = announcementread.Columns + } + selector := builder.Select(t1.Columns(columns...)...).From(t1) + if _q.sql != nil { + selector = _q.sql + selector.Select(selector.Columns(columns...)...) + } + if _q.ctx.Unique != nil && *_q.ctx.Unique { + selector.Distinct() + } + for _, m := range _q.modifiers { + m(selector) + } + for _, p := range _q.predicates { + p(selector) + } + for _, p := range _q.order { + p(selector) + } + if offset := _q.ctx.Offset; offset != nil { + // limit is mandatory for offset clause. We start + // with default value, and override it below if needed. + selector.Offset(*offset).Limit(math.MaxInt32) + } + if limit := _q.ctx.Limit; limit != nil { + selector.Limit(*limit) + } + return selector +} + +// ForUpdate locks the selected rows against concurrent updates, and prevent them from being +// updated, deleted or "selected ... for update" by other sessions, until the transaction is +// either committed or rolled-back. +func (_q *AnnouncementReadQuery) ForUpdate(opts ...sql.LockOption) *AnnouncementReadQuery { + if _q.driver.Dialect() == dialect.Postgres { + _q.Unique(false) + } + _q.modifiers = append(_q.modifiers, func(s *sql.Selector) { + s.ForUpdate(opts...) + }) + return _q +} + +// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock +// on any rows that are read. Other sessions can read the rows, but cannot modify them +// until your transaction commits. +func (_q *AnnouncementReadQuery) ForShare(opts ...sql.LockOption) *AnnouncementReadQuery { + if _q.driver.Dialect() == dialect.Postgres { + _q.Unique(false) + } + _q.modifiers = append(_q.modifiers, func(s *sql.Selector) { + s.ForShare(opts...) + }) + return _q +} + +// AnnouncementReadGroupBy is the group-by builder for AnnouncementRead entities. +type AnnouncementReadGroupBy struct { + selector + build *AnnouncementReadQuery +} + +// Aggregate adds the given aggregation functions to the group-by query. +func (_g *AnnouncementReadGroupBy) Aggregate(fns ...AggregateFunc) *AnnouncementReadGroupBy { + _g.fns = append(_g.fns, fns...) + return _g +} + +// Scan applies the selector query and scans the result into the given value. +func (_g *AnnouncementReadGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy) + if err := _g.build.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*AnnouncementReadQuery, *AnnouncementReadGroupBy](ctx, _g.build, _g, _g.build.inters, v) +} + +func (_g *AnnouncementReadGroupBy) sqlScan(ctx context.Context, root *AnnouncementReadQuery, v any) error { + selector := root.sqlQuery(ctx).Select() + aggregation := make([]string, 0, len(_g.fns)) + for _, fn := range _g.fns { + aggregation = append(aggregation, fn(selector)) + } + if len(selector.SelectedColumns()) == 0 { + columns := make([]string, 0, len(*_g.flds)+len(_g.fns)) + for _, f := range *_g.flds { + columns = append(columns, selector.C(f)) + } + columns = append(columns, aggregation...) + selector.Select(columns...) + } + selector.GroupBy(selector.Columns(*_g.flds...)...) + if err := selector.Err(); err != nil { + return err + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := _g.build.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// AnnouncementReadSelect is the builder for selecting fields of AnnouncementRead entities. +type AnnouncementReadSelect struct { + *AnnouncementReadQuery + selector +} + +// Aggregate adds the given aggregation functions to the selector query. +func (_s *AnnouncementReadSelect) Aggregate(fns ...AggregateFunc) *AnnouncementReadSelect { + _s.fns = append(_s.fns, fns...) + return _s +} + +// Scan applies the selector query and scans the result into the given value. +func (_s *AnnouncementReadSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect) + if err := _s.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*AnnouncementReadQuery, *AnnouncementReadSelect](ctx, _s.AnnouncementReadQuery, _s, _s.inters, v) +} + +func (_s *AnnouncementReadSelect) sqlScan(ctx context.Context, root *AnnouncementReadQuery, v any) error { + selector := root.sqlQuery(ctx) + aggregation := make([]string, 0, len(_s.fns)) + for _, fn := range _s.fns { + aggregation = append(aggregation, fn(selector)) + } + switch n := len(*_s.selector.flds); { + case n == 0 && len(aggregation) > 0: + selector.Select(aggregation...) + case n != 0 && len(aggregation) > 0: + selector.AppendSelect(aggregation...) + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := _s.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} diff --git a/backend/ent/announcementread_update.go b/backend/ent/announcementread_update.go new file mode 100644 index 00000000..55a4eef8 --- /dev/null +++ b/backend/ent/announcementread_update.go @@ -0,0 +1,456 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" + "github.com/Wei-Shaw/sub2api/ent/predicate" + "github.com/Wei-Shaw/sub2api/ent/user" +) + +// AnnouncementReadUpdate is the builder for updating AnnouncementRead entities. +type AnnouncementReadUpdate struct { + config + hooks []Hook + mutation *AnnouncementReadMutation +} + +// Where appends a list predicates to the AnnouncementReadUpdate builder. +func (_u *AnnouncementReadUpdate) Where(ps ...predicate.AnnouncementRead) *AnnouncementReadUpdate { + _u.mutation.Where(ps...) + return _u +} + +// SetAnnouncementID sets the "announcement_id" field. +func (_u *AnnouncementReadUpdate) SetAnnouncementID(v int64) *AnnouncementReadUpdate { + _u.mutation.SetAnnouncementID(v) + return _u +} + +// SetNillableAnnouncementID sets the "announcement_id" field if the given value is not nil. +func (_u *AnnouncementReadUpdate) SetNillableAnnouncementID(v *int64) *AnnouncementReadUpdate { + if v != nil { + _u.SetAnnouncementID(*v) + } + return _u +} + +// SetUserID sets the "user_id" field. +func (_u *AnnouncementReadUpdate) SetUserID(v int64) *AnnouncementReadUpdate { + _u.mutation.SetUserID(v) + return _u +} + +// SetNillableUserID sets the "user_id" field if the given value is not nil. +func (_u *AnnouncementReadUpdate) SetNillableUserID(v *int64) *AnnouncementReadUpdate { + if v != nil { + _u.SetUserID(*v) + } + return _u +} + +// SetReadAt sets the "read_at" field. +func (_u *AnnouncementReadUpdate) SetReadAt(v time.Time) *AnnouncementReadUpdate { + _u.mutation.SetReadAt(v) + return _u +} + +// SetNillableReadAt sets the "read_at" field if the given value is not nil. +func (_u *AnnouncementReadUpdate) SetNillableReadAt(v *time.Time) *AnnouncementReadUpdate { + if v != nil { + _u.SetReadAt(*v) + } + return _u +} + +// SetAnnouncement sets the "announcement" edge to the Announcement entity. +func (_u *AnnouncementReadUpdate) SetAnnouncement(v *Announcement) *AnnouncementReadUpdate { + return _u.SetAnnouncementID(v.ID) +} + +// SetUser sets the "user" edge to the User entity. +func (_u *AnnouncementReadUpdate) SetUser(v *User) *AnnouncementReadUpdate { + return _u.SetUserID(v.ID) +} + +// Mutation returns the AnnouncementReadMutation object of the builder. +func (_u *AnnouncementReadUpdate) Mutation() *AnnouncementReadMutation { + return _u.mutation +} + +// ClearAnnouncement clears the "announcement" edge to the Announcement entity. +func (_u *AnnouncementReadUpdate) ClearAnnouncement() *AnnouncementReadUpdate { + _u.mutation.ClearAnnouncement() + return _u +} + +// ClearUser clears the "user" edge to the User entity. +func (_u *AnnouncementReadUpdate) ClearUser() *AnnouncementReadUpdate { + _u.mutation.ClearUser() + return _u +} + +// Save executes the query and returns the number of nodes affected by the update operation. +func (_u *AnnouncementReadUpdate) Save(ctx context.Context) (int, error) { + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (_u *AnnouncementReadUpdate) SaveX(ctx context.Context) int { + affected, err := _u.Save(ctx) + if err != nil { + panic(err) + } + return affected +} + +// Exec executes the query. +func (_u *AnnouncementReadUpdate) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_u *AnnouncementReadUpdate) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { + panic(err) + } +} + +// check runs all checks and user-defined validators on the builder. +func (_u *AnnouncementReadUpdate) check() error { + if _u.mutation.AnnouncementCleared() && len(_u.mutation.AnnouncementIDs()) > 0 { + return errors.New(`ent: clearing a required unique edge "AnnouncementRead.announcement"`) + } + if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 { + return errors.New(`ent: clearing a required unique edge "AnnouncementRead.user"`) + } + return nil +} + +func (_u *AnnouncementReadUpdate) sqlSave(ctx context.Context) (_node int, err error) { + if err := _u.check(); err != nil { + return _node, err + } + _spec := sqlgraph.NewUpdateSpec(announcementread.Table, announcementread.Columns, sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64)) + if ps := _u.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := _u.mutation.ReadAt(); ok { + _spec.SetField(announcementread.FieldReadAt, field.TypeTime, value) + } + if _u.mutation.AnnouncementCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: announcementread.AnnouncementTable, + Columns: []string{announcementread.AnnouncementColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.AnnouncementIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: announcementread.AnnouncementTable, + Columns: []string{announcementread.AnnouncementColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _u.mutation.UserCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: announcementread.UserTable, + Columns: []string{announcementread.UserColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.UserIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: announcementread.UserTable, + Columns: []string{announcementread.UserColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{announcementread.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return 0, err + } + _u.mutation.done = true + return _node, nil +} + +// AnnouncementReadUpdateOne is the builder for updating a single AnnouncementRead entity. +type AnnouncementReadUpdateOne struct { + config + fields []string + hooks []Hook + mutation *AnnouncementReadMutation +} + +// SetAnnouncementID sets the "announcement_id" field. +func (_u *AnnouncementReadUpdateOne) SetAnnouncementID(v int64) *AnnouncementReadUpdateOne { + _u.mutation.SetAnnouncementID(v) + return _u +} + +// SetNillableAnnouncementID sets the "announcement_id" field if the given value is not nil. +func (_u *AnnouncementReadUpdateOne) SetNillableAnnouncementID(v *int64) *AnnouncementReadUpdateOne { + if v != nil { + _u.SetAnnouncementID(*v) + } + return _u +} + +// SetUserID sets the "user_id" field. +func (_u *AnnouncementReadUpdateOne) SetUserID(v int64) *AnnouncementReadUpdateOne { + _u.mutation.SetUserID(v) + return _u +} + +// SetNillableUserID sets the "user_id" field if the given value is not nil. +func (_u *AnnouncementReadUpdateOne) SetNillableUserID(v *int64) *AnnouncementReadUpdateOne { + if v != nil { + _u.SetUserID(*v) + } + return _u +} + +// SetReadAt sets the "read_at" field. +func (_u *AnnouncementReadUpdateOne) SetReadAt(v time.Time) *AnnouncementReadUpdateOne { + _u.mutation.SetReadAt(v) + return _u +} + +// SetNillableReadAt sets the "read_at" field if the given value is not nil. +func (_u *AnnouncementReadUpdateOne) SetNillableReadAt(v *time.Time) *AnnouncementReadUpdateOne { + if v != nil { + _u.SetReadAt(*v) + } + return _u +} + +// SetAnnouncement sets the "announcement" edge to the Announcement entity. +func (_u *AnnouncementReadUpdateOne) SetAnnouncement(v *Announcement) *AnnouncementReadUpdateOne { + return _u.SetAnnouncementID(v.ID) +} + +// SetUser sets the "user" edge to the User entity. +func (_u *AnnouncementReadUpdateOne) SetUser(v *User) *AnnouncementReadUpdateOne { + return _u.SetUserID(v.ID) +} + +// Mutation returns the AnnouncementReadMutation object of the builder. +func (_u *AnnouncementReadUpdateOne) Mutation() *AnnouncementReadMutation { + return _u.mutation +} + +// ClearAnnouncement clears the "announcement" edge to the Announcement entity. +func (_u *AnnouncementReadUpdateOne) ClearAnnouncement() *AnnouncementReadUpdateOne { + _u.mutation.ClearAnnouncement() + return _u +} + +// ClearUser clears the "user" edge to the User entity. +func (_u *AnnouncementReadUpdateOne) ClearUser() *AnnouncementReadUpdateOne { + _u.mutation.ClearUser() + return _u +} + +// Where appends a list predicates to the AnnouncementReadUpdate builder. +func (_u *AnnouncementReadUpdateOne) Where(ps ...predicate.AnnouncementRead) *AnnouncementReadUpdateOne { + _u.mutation.Where(ps...) + return _u +} + +// Select allows selecting one or more fields (columns) of the returned entity. +// The default is selecting all fields defined in the entity schema. +func (_u *AnnouncementReadUpdateOne) Select(field string, fields ...string) *AnnouncementReadUpdateOne { + _u.fields = append([]string{field}, fields...) + return _u +} + +// Save executes the query and returns the updated AnnouncementRead entity. +func (_u *AnnouncementReadUpdateOne) Save(ctx context.Context) (*AnnouncementRead, error) { + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (_u *AnnouncementReadUpdateOne) SaveX(ctx context.Context) *AnnouncementRead { + node, err := _u.Save(ctx) + if err != nil { + panic(err) + } + return node +} + +// Exec executes the query on the entity. +func (_u *AnnouncementReadUpdateOne) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_u *AnnouncementReadUpdateOne) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { + panic(err) + } +} + +// check runs all checks and user-defined validators on the builder. +func (_u *AnnouncementReadUpdateOne) check() error { + if _u.mutation.AnnouncementCleared() && len(_u.mutation.AnnouncementIDs()) > 0 { + return errors.New(`ent: clearing a required unique edge "AnnouncementRead.announcement"`) + } + if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 { + return errors.New(`ent: clearing a required unique edge "AnnouncementRead.user"`) + } + return nil +} + +func (_u *AnnouncementReadUpdateOne) sqlSave(ctx context.Context) (_node *AnnouncementRead, err error) { + if err := _u.check(); err != nil { + return _node, err + } + _spec := sqlgraph.NewUpdateSpec(announcementread.Table, announcementread.Columns, sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64)) + id, ok := _u.mutation.ID() + if !ok { + return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "AnnouncementRead.id" for update`)} + } + _spec.Node.ID.Value = id + if fields := _u.fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, announcementread.FieldID) + for _, f := range fields { + if !announcementread.ValidColumn(f) { + return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + if f != announcementread.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, f) + } + } + } + if ps := _u.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := _u.mutation.ReadAt(); ok { + _spec.SetField(announcementread.FieldReadAt, field.TypeTime, value) + } + if _u.mutation.AnnouncementCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: announcementread.AnnouncementTable, + Columns: []string{announcementread.AnnouncementColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.AnnouncementIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: announcementread.AnnouncementTable, + Columns: []string{announcementread.AnnouncementColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _u.mutation.UserCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: announcementread.UserTable, + Columns: []string{announcementread.UserColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.UserIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: announcementread.UserTable, + Columns: []string{announcementread.UserColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + _node = &AnnouncementRead{config: _u.config} + _spec.Assign = _node.assignValues + _spec.ScanValues = _node.scanValues + if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{announcementread.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + _u.mutation.done = true + return _node, nil +} diff --git a/backend/ent/client.go b/backend/ent/client.go index f6c13e84..a17721da 100644 --- a/backend/ent/client.go +++ b/backend/ent/client.go @@ -17,6 +17,8 @@ import ( "entgo.io/ent/dialect/sql/sqlgraph" "github.com/Wei-Shaw/sub2api/ent/account" "github.com/Wei-Shaw/sub2api/ent/accountgroup" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" "github.com/Wei-Shaw/sub2api/ent/apikey" "github.com/Wei-Shaw/sub2api/ent/group" "github.com/Wei-Shaw/sub2api/ent/promocode" @@ -46,6 +48,10 @@ type Client struct { Account *AccountClient // AccountGroup is the client for interacting with the AccountGroup builders. AccountGroup *AccountGroupClient + // Announcement is the client for interacting with the Announcement builders. + Announcement *AnnouncementClient + // AnnouncementRead is the client for interacting with the AnnouncementRead builders. + AnnouncementRead *AnnouncementReadClient // Group is the client for interacting with the Group builders. Group *GroupClient // PromoCode is the client for interacting with the PromoCode builders. @@ -86,6 +92,8 @@ func (c *Client) init() { c.APIKey = NewAPIKeyClient(c.config) c.Account = NewAccountClient(c.config) c.AccountGroup = NewAccountGroupClient(c.config) + c.Announcement = NewAnnouncementClient(c.config) + c.AnnouncementRead = NewAnnouncementReadClient(c.config) c.Group = NewGroupClient(c.config) c.PromoCode = NewPromoCodeClient(c.config) c.PromoCodeUsage = NewPromoCodeUsageClient(c.config) @@ -194,6 +202,8 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) { APIKey: NewAPIKeyClient(cfg), Account: NewAccountClient(cfg), AccountGroup: NewAccountGroupClient(cfg), + Announcement: NewAnnouncementClient(cfg), + AnnouncementRead: NewAnnouncementReadClient(cfg), Group: NewGroupClient(cfg), PromoCode: NewPromoCodeClient(cfg), PromoCodeUsage: NewPromoCodeUsageClient(cfg), @@ -229,6 +239,8 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) APIKey: NewAPIKeyClient(cfg), Account: NewAccountClient(cfg), AccountGroup: NewAccountGroupClient(cfg), + Announcement: NewAnnouncementClient(cfg), + AnnouncementRead: NewAnnouncementReadClient(cfg), Group: NewGroupClient(cfg), PromoCode: NewPromoCodeClient(cfg), PromoCodeUsage: NewPromoCodeUsageClient(cfg), @@ -271,10 +283,10 @@ func (c *Client) Close() error { // In order to add hooks to a specific client, call: `client.Node.Use(...)`. func (c *Client) Use(hooks ...Hook) { for _, n := range []interface{ Use(...Hook) }{ - c.APIKey, c.Account, c.AccountGroup, c.Group, c.PromoCode, c.PromoCodeUsage, - c.Proxy, c.RedeemCode, c.Setting, c.UsageCleanupTask, c.UsageLog, c.User, - c.UserAllowedGroup, c.UserAttributeDefinition, c.UserAttributeValue, - c.UserSubscription, + c.APIKey, c.Account, c.AccountGroup, c.Announcement, c.AnnouncementRead, + c.Group, c.PromoCode, c.PromoCodeUsage, c.Proxy, c.RedeemCode, c.Setting, + c.UsageCleanupTask, c.UsageLog, c.User, c.UserAllowedGroup, + c.UserAttributeDefinition, c.UserAttributeValue, c.UserSubscription, } { n.Use(hooks...) } @@ -284,10 +296,10 @@ func (c *Client) Use(hooks ...Hook) { // In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`. func (c *Client) Intercept(interceptors ...Interceptor) { for _, n := range []interface{ Intercept(...Interceptor) }{ - c.APIKey, c.Account, c.AccountGroup, c.Group, c.PromoCode, c.PromoCodeUsage, - c.Proxy, c.RedeemCode, c.Setting, c.UsageCleanupTask, c.UsageLog, c.User, - c.UserAllowedGroup, c.UserAttributeDefinition, c.UserAttributeValue, - c.UserSubscription, + c.APIKey, c.Account, c.AccountGroup, c.Announcement, c.AnnouncementRead, + c.Group, c.PromoCode, c.PromoCodeUsage, c.Proxy, c.RedeemCode, c.Setting, + c.UsageCleanupTask, c.UsageLog, c.User, c.UserAllowedGroup, + c.UserAttributeDefinition, c.UserAttributeValue, c.UserSubscription, } { n.Intercept(interceptors...) } @@ -302,6 +314,10 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) { return c.Account.mutate(ctx, m) case *AccountGroupMutation: return c.AccountGroup.mutate(ctx, m) + case *AnnouncementMutation: + return c.Announcement.mutate(ctx, m) + case *AnnouncementReadMutation: + return c.AnnouncementRead.mutate(ctx, m) case *GroupMutation: return c.Group.mutate(ctx, m) case *PromoCodeMutation: @@ -831,6 +847,320 @@ func (c *AccountGroupClient) mutate(ctx context.Context, m *AccountGroupMutation } } +// AnnouncementClient is a client for the Announcement schema. +type AnnouncementClient struct { + config +} + +// NewAnnouncementClient returns a client for the Announcement from the given config. +func NewAnnouncementClient(c config) *AnnouncementClient { + return &AnnouncementClient{config: c} +} + +// Use adds a list of mutation hooks to the hooks stack. +// A call to `Use(f, g, h)` equals to `announcement.Hooks(f(g(h())))`. +func (c *AnnouncementClient) Use(hooks ...Hook) { + c.hooks.Announcement = append(c.hooks.Announcement, hooks...) +} + +// Intercept adds a list of query interceptors to the interceptors stack. +// A call to `Intercept(f, g, h)` equals to `announcement.Intercept(f(g(h())))`. +func (c *AnnouncementClient) Intercept(interceptors ...Interceptor) { + c.inters.Announcement = append(c.inters.Announcement, interceptors...) +} + +// Create returns a builder for creating a Announcement entity. +func (c *AnnouncementClient) Create() *AnnouncementCreate { + mutation := newAnnouncementMutation(c.config, OpCreate) + return &AnnouncementCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// CreateBulk returns a builder for creating a bulk of Announcement entities. +func (c *AnnouncementClient) CreateBulk(builders ...*AnnouncementCreate) *AnnouncementCreateBulk { + return &AnnouncementCreateBulk{config: c.config, builders: builders} +} + +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *AnnouncementClient) MapCreateBulk(slice any, setFunc func(*AnnouncementCreate, int)) *AnnouncementCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &AnnouncementCreateBulk{err: fmt.Errorf("calling to AnnouncementClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*AnnouncementCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &AnnouncementCreateBulk{config: c.config, builders: builders} +} + +// Update returns an update builder for Announcement. +func (c *AnnouncementClient) Update() *AnnouncementUpdate { + mutation := newAnnouncementMutation(c.config, OpUpdate) + return &AnnouncementUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOne returns an update builder for the given entity. +func (c *AnnouncementClient) UpdateOne(_m *Announcement) *AnnouncementUpdateOne { + mutation := newAnnouncementMutation(c.config, OpUpdateOne, withAnnouncement(_m)) + return &AnnouncementUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOneID returns an update builder for the given id. +func (c *AnnouncementClient) UpdateOneID(id int64) *AnnouncementUpdateOne { + mutation := newAnnouncementMutation(c.config, OpUpdateOne, withAnnouncementID(id)) + return &AnnouncementUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// Delete returns a delete builder for Announcement. +func (c *AnnouncementClient) Delete() *AnnouncementDelete { + mutation := newAnnouncementMutation(c.config, OpDelete) + return &AnnouncementDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// DeleteOne returns a builder for deleting the given entity. +func (c *AnnouncementClient) DeleteOne(_m *Announcement) *AnnouncementDeleteOne { + return c.DeleteOneID(_m.ID) +} + +// DeleteOneID returns a builder for deleting the given entity by its id. +func (c *AnnouncementClient) DeleteOneID(id int64) *AnnouncementDeleteOne { + builder := c.Delete().Where(announcement.ID(id)) + builder.mutation.id = &id + builder.mutation.op = OpDeleteOne + return &AnnouncementDeleteOne{builder} +} + +// Query returns a query builder for Announcement. +func (c *AnnouncementClient) Query() *AnnouncementQuery { + return &AnnouncementQuery{ + config: c.config, + ctx: &QueryContext{Type: TypeAnnouncement}, + inters: c.Interceptors(), + } +} + +// Get returns a Announcement entity by its id. +func (c *AnnouncementClient) Get(ctx context.Context, id int64) (*Announcement, error) { + return c.Query().Where(announcement.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *AnnouncementClient) GetX(ctx context.Context, id int64) *Announcement { + obj, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return obj +} + +// QueryReads queries the reads edge of a Announcement. +func (c *AnnouncementClient) QueryReads(_m *Announcement) *AnnouncementReadQuery { + query := (&AnnouncementReadClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(announcement.Table, announcement.FieldID, id), + sqlgraph.To(announcementread.Table, announcementread.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, announcement.ReadsTable, announcement.ReadsColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// Hooks returns the client hooks. +func (c *AnnouncementClient) Hooks() []Hook { + return c.hooks.Announcement +} + +// Interceptors returns the client interceptors. +func (c *AnnouncementClient) Interceptors() []Interceptor { + return c.inters.Announcement +} + +func (c *AnnouncementClient) mutate(ctx context.Context, m *AnnouncementMutation) (Value, error) { + switch m.Op() { + case OpCreate: + return (&AnnouncementCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdate: + return (&AnnouncementUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdateOne: + return (&AnnouncementUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpDelete, OpDeleteOne: + return (&AnnouncementDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx) + default: + return nil, fmt.Errorf("ent: unknown Announcement mutation op: %q", m.Op()) + } +} + +// AnnouncementReadClient is a client for the AnnouncementRead schema. +type AnnouncementReadClient struct { + config +} + +// NewAnnouncementReadClient returns a client for the AnnouncementRead from the given config. +func NewAnnouncementReadClient(c config) *AnnouncementReadClient { + return &AnnouncementReadClient{config: c} +} + +// Use adds a list of mutation hooks to the hooks stack. +// A call to `Use(f, g, h)` equals to `announcementread.Hooks(f(g(h())))`. +func (c *AnnouncementReadClient) Use(hooks ...Hook) { + c.hooks.AnnouncementRead = append(c.hooks.AnnouncementRead, hooks...) +} + +// Intercept adds a list of query interceptors to the interceptors stack. +// A call to `Intercept(f, g, h)` equals to `announcementread.Intercept(f(g(h())))`. +func (c *AnnouncementReadClient) Intercept(interceptors ...Interceptor) { + c.inters.AnnouncementRead = append(c.inters.AnnouncementRead, interceptors...) +} + +// Create returns a builder for creating a AnnouncementRead entity. +func (c *AnnouncementReadClient) Create() *AnnouncementReadCreate { + mutation := newAnnouncementReadMutation(c.config, OpCreate) + return &AnnouncementReadCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// CreateBulk returns a builder for creating a bulk of AnnouncementRead entities. +func (c *AnnouncementReadClient) CreateBulk(builders ...*AnnouncementReadCreate) *AnnouncementReadCreateBulk { + return &AnnouncementReadCreateBulk{config: c.config, builders: builders} +} + +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *AnnouncementReadClient) MapCreateBulk(slice any, setFunc func(*AnnouncementReadCreate, int)) *AnnouncementReadCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &AnnouncementReadCreateBulk{err: fmt.Errorf("calling to AnnouncementReadClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*AnnouncementReadCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &AnnouncementReadCreateBulk{config: c.config, builders: builders} +} + +// Update returns an update builder for AnnouncementRead. +func (c *AnnouncementReadClient) Update() *AnnouncementReadUpdate { + mutation := newAnnouncementReadMutation(c.config, OpUpdate) + return &AnnouncementReadUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOne returns an update builder for the given entity. +func (c *AnnouncementReadClient) UpdateOne(_m *AnnouncementRead) *AnnouncementReadUpdateOne { + mutation := newAnnouncementReadMutation(c.config, OpUpdateOne, withAnnouncementRead(_m)) + return &AnnouncementReadUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOneID returns an update builder for the given id. +func (c *AnnouncementReadClient) UpdateOneID(id int64) *AnnouncementReadUpdateOne { + mutation := newAnnouncementReadMutation(c.config, OpUpdateOne, withAnnouncementReadID(id)) + return &AnnouncementReadUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// Delete returns a delete builder for AnnouncementRead. +func (c *AnnouncementReadClient) Delete() *AnnouncementReadDelete { + mutation := newAnnouncementReadMutation(c.config, OpDelete) + return &AnnouncementReadDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// DeleteOne returns a builder for deleting the given entity. +func (c *AnnouncementReadClient) DeleteOne(_m *AnnouncementRead) *AnnouncementReadDeleteOne { + return c.DeleteOneID(_m.ID) +} + +// DeleteOneID returns a builder for deleting the given entity by its id. +func (c *AnnouncementReadClient) DeleteOneID(id int64) *AnnouncementReadDeleteOne { + builder := c.Delete().Where(announcementread.ID(id)) + builder.mutation.id = &id + builder.mutation.op = OpDeleteOne + return &AnnouncementReadDeleteOne{builder} +} + +// Query returns a query builder for AnnouncementRead. +func (c *AnnouncementReadClient) Query() *AnnouncementReadQuery { + return &AnnouncementReadQuery{ + config: c.config, + ctx: &QueryContext{Type: TypeAnnouncementRead}, + inters: c.Interceptors(), + } +} + +// Get returns a AnnouncementRead entity by its id. +func (c *AnnouncementReadClient) Get(ctx context.Context, id int64) (*AnnouncementRead, error) { + return c.Query().Where(announcementread.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *AnnouncementReadClient) GetX(ctx context.Context, id int64) *AnnouncementRead { + obj, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return obj +} + +// QueryAnnouncement queries the announcement edge of a AnnouncementRead. +func (c *AnnouncementReadClient) QueryAnnouncement(_m *AnnouncementRead) *AnnouncementQuery { + query := (&AnnouncementClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(announcementread.Table, announcementread.FieldID, id), + sqlgraph.To(announcement.Table, announcement.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, announcementread.AnnouncementTable, announcementread.AnnouncementColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryUser queries the user edge of a AnnouncementRead. +func (c *AnnouncementReadClient) QueryUser(_m *AnnouncementRead) *UserQuery { + query := (&UserClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(announcementread.Table, announcementread.FieldID, id), + sqlgraph.To(user.Table, user.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, announcementread.UserTable, announcementread.UserColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// Hooks returns the client hooks. +func (c *AnnouncementReadClient) Hooks() []Hook { + return c.hooks.AnnouncementRead +} + +// Interceptors returns the client interceptors. +func (c *AnnouncementReadClient) Interceptors() []Interceptor { + return c.inters.AnnouncementRead +} + +func (c *AnnouncementReadClient) mutate(ctx context.Context, m *AnnouncementReadMutation) (Value, error) { + switch m.Op() { + case OpCreate: + return (&AnnouncementReadCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdate: + return (&AnnouncementReadUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdateOne: + return (&AnnouncementReadUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpDelete, OpDeleteOne: + return (&AnnouncementReadDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx) + default: + return nil, fmt.Errorf("ent: unknown AnnouncementRead mutation op: %q", m.Op()) + } +} + // GroupClient is a client for the Group schema. type GroupClient struct { config @@ -2375,6 +2705,22 @@ func (c *UserClient) QueryAssignedSubscriptions(_m *User) *UserSubscriptionQuery return query } +// QueryAnnouncementReads queries the announcement_reads edge of a User. +func (c *UserClient) QueryAnnouncementReads(_m *User) *AnnouncementReadQuery { + query := (&AnnouncementReadClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(user.Table, user.FieldID, id), + sqlgraph.To(announcementread.Table, announcementread.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, user.AnnouncementReadsTable, user.AnnouncementReadsColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + // QueryAllowedGroups queries the allowed_groups edge of a User. func (c *UserClient) QueryAllowedGroups(_m *User) *GroupQuery { query := (&GroupClient{config: c.config}).Query() @@ -3116,14 +3462,16 @@ func (c *UserSubscriptionClient) mutate(ctx context.Context, m *UserSubscription // hooks and interceptors per client, for fast access. type ( hooks struct { - APIKey, Account, AccountGroup, Group, PromoCode, PromoCodeUsage, Proxy, - RedeemCode, Setting, UsageCleanupTask, UsageLog, User, UserAllowedGroup, - UserAttributeDefinition, UserAttributeValue, UserSubscription []ent.Hook + APIKey, Account, AccountGroup, Announcement, AnnouncementRead, Group, PromoCode, + PromoCodeUsage, Proxy, RedeemCode, Setting, UsageCleanupTask, UsageLog, User, + UserAllowedGroup, UserAttributeDefinition, UserAttributeValue, + UserSubscription []ent.Hook } inters struct { - APIKey, Account, AccountGroup, Group, PromoCode, PromoCodeUsage, Proxy, - RedeemCode, Setting, UsageCleanupTask, UsageLog, User, UserAllowedGroup, - UserAttributeDefinition, UserAttributeValue, UserSubscription []ent.Interceptor + APIKey, Account, AccountGroup, Announcement, AnnouncementRead, Group, PromoCode, + PromoCodeUsage, Proxy, RedeemCode, Setting, UsageCleanupTask, UsageLog, User, + UserAllowedGroup, UserAttributeDefinition, UserAttributeValue, + UserSubscription []ent.Interceptor } ) diff --git a/backend/ent/ent.go b/backend/ent/ent.go index 4bcc2642..05e30ba7 100644 --- a/backend/ent/ent.go +++ b/backend/ent/ent.go @@ -14,6 +14,8 @@ import ( "entgo.io/ent/dialect/sql/sqlgraph" "github.com/Wei-Shaw/sub2api/ent/account" "github.com/Wei-Shaw/sub2api/ent/accountgroup" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" "github.com/Wei-Shaw/sub2api/ent/apikey" "github.com/Wei-Shaw/sub2api/ent/group" "github.com/Wei-Shaw/sub2api/ent/promocode" @@ -91,6 +93,8 @@ func checkColumn(t, c string) error { apikey.Table: apikey.ValidColumn, account.Table: account.ValidColumn, accountgroup.Table: accountgroup.ValidColumn, + announcement.Table: announcement.ValidColumn, + announcementread.Table: announcementread.ValidColumn, group.Table: group.ValidColumn, promocode.Table: promocode.ValidColumn, promocodeusage.Table: promocodeusage.ValidColumn, diff --git a/backend/ent/hook/hook.go b/backend/ent/hook/hook.go index edd84f5e..1e653c77 100644 --- a/backend/ent/hook/hook.go +++ b/backend/ent/hook/hook.go @@ -45,6 +45,30 @@ func (f AccountGroupFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.AccountGroupMutation", m) } +// The AnnouncementFunc type is an adapter to allow the use of ordinary +// function as Announcement mutator. +type AnnouncementFunc func(context.Context, *ent.AnnouncementMutation) (ent.Value, error) + +// Mutate calls f(ctx, m). +func (f AnnouncementFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) { + if mv, ok := m.(*ent.AnnouncementMutation); ok { + return f(ctx, mv) + } + return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.AnnouncementMutation", m) +} + +// The AnnouncementReadFunc type is an adapter to allow the use of ordinary +// function as AnnouncementRead mutator. +type AnnouncementReadFunc func(context.Context, *ent.AnnouncementReadMutation) (ent.Value, error) + +// Mutate calls f(ctx, m). +func (f AnnouncementReadFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) { + if mv, ok := m.(*ent.AnnouncementReadMutation); ok { + return f(ctx, mv) + } + return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.AnnouncementReadMutation", m) +} + // The GroupFunc type is an adapter to allow the use of ordinary // function as Group mutator. type GroupFunc func(context.Context, *ent.GroupMutation) (ent.Value, error) diff --git a/backend/ent/intercept/intercept.go b/backend/ent/intercept/intercept.go index f18c0624..a37be48f 100644 --- a/backend/ent/intercept/intercept.go +++ b/backend/ent/intercept/intercept.go @@ -10,6 +10,8 @@ import ( "github.com/Wei-Shaw/sub2api/ent" "github.com/Wei-Shaw/sub2api/ent/account" "github.com/Wei-Shaw/sub2api/ent/accountgroup" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" "github.com/Wei-Shaw/sub2api/ent/apikey" "github.com/Wei-Shaw/sub2api/ent/group" "github.com/Wei-Shaw/sub2api/ent/predicate" @@ -164,6 +166,60 @@ func (f TraverseAccountGroup) Traverse(ctx context.Context, q ent.Query) error { return fmt.Errorf("unexpected query type %T. expect *ent.AccountGroupQuery", q) } +// The AnnouncementFunc type is an adapter to allow the use of ordinary function as a Querier. +type AnnouncementFunc func(context.Context, *ent.AnnouncementQuery) (ent.Value, error) + +// Query calls f(ctx, q). +func (f AnnouncementFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) { + if q, ok := q.(*ent.AnnouncementQuery); ok { + return f(ctx, q) + } + return nil, fmt.Errorf("unexpected query type %T. expect *ent.AnnouncementQuery", q) +} + +// The TraverseAnnouncement type is an adapter to allow the use of ordinary function as Traverser. +type TraverseAnnouncement func(context.Context, *ent.AnnouncementQuery) error + +// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline. +func (f TraverseAnnouncement) Intercept(next ent.Querier) ent.Querier { + return next +} + +// Traverse calls f(ctx, q). +func (f TraverseAnnouncement) Traverse(ctx context.Context, q ent.Query) error { + if q, ok := q.(*ent.AnnouncementQuery); ok { + return f(ctx, q) + } + return fmt.Errorf("unexpected query type %T. expect *ent.AnnouncementQuery", q) +} + +// The AnnouncementReadFunc type is an adapter to allow the use of ordinary function as a Querier. +type AnnouncementReadFunc func(context.Context, *ent.AnnouncementReadQuery) (ent.Value, error) + +// Query calls f(ctx, q). +func (f AnnouncementReadFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) { + if q, ok := q.(*ent.AnnouncementReadQuery); ok { + return f(ctx, q) + } + return nil, fmt.Errorf("unexpected query type %T. expect *ent.AnnouncementReadQuery", q) +} + +// The TraverseAnnouncementRead type is an adapter to allow the use of ordinary function as Traverser. +type TraverseAnnouncementRead func(context.Context, *ent.AnnouncementReadQuery) error + +// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline. +func (f TraverseAnnouncementRead) Intercept(next ent.Querier) ent.Querier { + return next +} + +// Traverse calls f(ctx, q). +func (f TraverseAnnouncementRead) Traverse(ctx context.Context, q ent.Query) error { + if q, ok := q.(*ent.AnnouncementReadQuery); ok { + return f(ctx, q) + } + return fmt.Errorf("unexpected query type %T. expect *ent.AnnouncementReadQuery", q) +} + // The GroupFunc type is an adapter to allow the use of ordinary function as a Querier. type GroupFunc func(context.Context, *ent.GroupQuery) (ent.Value, error) @@ -524,6 +580,10 @@ func NewQuery(q ent.Query) (Query, error) { return &query[*ent.AccountQuery, predicate.Account, account.OrderOption]{typ: ent.TypeAccount, tq: q}, nil case *ent.AccountGroupQuery: return &query[*ent.AccountGroupQuery, predicate.AccountGroup, accountgroup.OrderOption]{typ: ent.TypeAccountGroup, tq: q}, nil + case *ent.AnnouncementQuery: + return &query[*ent.AnnouncementQuery, predicate.Announcement, announcement.OrderOption]{typ: ent.TypeAnnouncement, tq: q}, nil + case *ent.AnnouncementReadQuery: + return &query[*ent.AnnouncementReadQuery, predicate.AnnouncementRead, announcementread.OrderOption]{typ: ent.TypeAnnouncementRead, tq: q}, nil case *ent.GroupQuery: return &query[*ent.GroupQuery, predicate.Group, group.OrderOption]{typ: ent.TypeGroup, tq: q}, nil case *ent.PromoCodeQuery: diff --git a/backend/ent/migrate/schema.go b/backend/ent/migrate/schema.go index d2a39331..e2ed7340 100644 --- a/backend/ent/migrate/schema.go +++ b/backend/ent/migrate/schema.go @@ -204,6 +204,98 @@ var ( }, }, } + // AnnouncementsColumns holds the columns for the "announcements" table. + AnnouncementsColumns = []*schema.Column{ + {Name: "id", Type: field.TypeInt64, Increment: true}, + {Name: "title", Type: field.TypeString, Size: 200}, + {Name: "content", Type: field.TypeString, SchemaType: map[string]string{"postgres": "text"}}, + {Name: "status", Type: field.TypeString, Size: 20, Default: "draft"}, + {Name: "targeting", Type: field.TypeJSON, Nullable: true, SchemaType: map[string]string{"postgres": "jsonb"}}, + {Name: "starts_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}}, + {Name: "ends_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}}, + {Name: "created_by", Type: field.TypeInt64, Nullable: true}, + {Name: "updated_by", Type: field.TypeInt64, Nullable: true}, + {Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}}, + {Name: "updated_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}}, + } + // AnnouncementsTable holds the schema information for the "announcements" table. + AnnouncementsTable = &schema.Table{ + Name: "announcements", + Columns: AnnouncementsColumns, + PrimaryKey: []*schema.Column{AnnouncementsColumns[0]}, + Indexes: []*schema.Index{ + { + Name: "announcement_status", + Unique: false, + Columns: []*schema.Column{AnnouncementsColumns[3]}, + }, + { + Name: "announcement_created_at", + Unique: false, + Columns: []*schema.Column{AnnouncementsColumns[9]}, + }, + { + Name: "announcement_starts_at", + Unique: false, + Columns: []*schema.Column{AnnouncementsColumns[5]}, + }, + { + Name: "announcement_ends_at", + Unique: false, + Columns: []*schema.Column{AnnouncementsColumns[6]}, + }, + }, + } + // AnnouncementReadsColumns holds the columns for the "announcement_reads" table. + AnnouncementReadsColumns = []*schema.Column{ + {Name: "id", Type: field.TypeInt64, Increment: true}, + {Name: "read_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}}, + {Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}}, + {Name: "announcement_id", Type: field.TypeInt64}, + {Name: "user_id", Type: field.TypeInt64}, + } + // AnnouncementReadsTable holds the schema information for the "announcement_reads" table. + AnnouncementReadsTable = &schema.Table{ + Name: "announcement_reads", + Columns: AnnouncementReadsColumns, + PrimaryKey: []*schema.Column{AnnouncementReadsColumns[0]}, + ForeignKeys: []*schema.ForeignKey{ + { + Symbol: "announcement_reads_announcements_reads", + Columns: []*schema.Column{AnnouncementReadsColumns[3]}, + RefColumns: []*schema.Column{AnnouncementsColumns[0]}, + OnDelete: schema.NoAction, + }, + { + Symbol: "announcement_reads_users_announcement_reads", + Columns: []*schema.Column{AnnouncementReadsColumns[4]}, + RefColumns: []*schema.Column{UsersColumns[0]}, + OnDelete: schema.NoAction, + }, + }, + Indexes: []*schema.Index{ + { + Name: "announcementread_announcement_id", + Unique: false, + Columns: []*schema.Column{AnnouncementReadsColumns[3]}, + }, + { + Name: "announcementread_user_id", + Unique: false, + Columns: []*schema.Column{AnnouncementReadsColumns[4]}, + }, + { + Name: "announcementread_read_at", + Unique: false, + Columns: []*schema.Column{AnnouncementReadsColumns[1]}, + }, + { + Name: "announcementread_announcement_id_user_id", + Unique: true, + Columns: []*schema.Column{AnnouncementReadsColumns[3], AnnouncementReadsColumns[4]}, + }, + }, + } // GroupsColumns holds the columns for the "groups" table. GroupsColumns = []*schema.Column{ {Name: "id", Type: field.TypeInt64, Increment: true}, @@ -840,6 +932,8 @@ var ( APIKeysTable, AccountsTable, AccountGroupsTable, + AnnouncementsTable, + AnnouncementReadsTable, GroupsTable, PromoCodesTable, PromoCodeUsagesTable, @@ -871,6 +965,14 @@ func init() { AccountGroupsTable.Annotation = &entsql.Annotation{ Table: "account_groups", } + AnnouncementsTable.Annotation = &entsql.Annotation{ + Table: "announcements", + } + AnnouncementReadsTable.ForeignKeys[0].RefTable = AnnouncementsTable + AnnouncementReadsTable.ForeignKeys[1].RefTable = UsersTable + AnnouncementReadsTable.Annotation = &entsql.Annotation{ + Table: "announcement_reads", + } GroupsTable.Annotation = &entsql.Annotation{ Table: "groups", } diff --git a/backend/ent/mutation.go b/backend/ent/mutation.go index 7f3071c2..38e0c7e5 100644 --- a/backend/ent/mutation.go +++ b/backend/ent/mutation.go @@ -14,6 +14,8 @@ import ( "entgo.io/ent/dialect/sql" "github.com/Wei-Shaw/sub2api/ent/account" "github.com/Wei-Shaw/sub2api/ent/accountgroup" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" "github.com/Wei-Shaw/sub2api/ent/apikey" "github.com/Wei-Shaw/sub2api/ent/group" "github.com/Wei-Shaw/sub2api/ent/predicate" @@ -29,6 +31,7 @@ import ( "github.com/Wei-Shaw/sub2api/ent/userattributedefinition" "github.com/Wei-Shaw/sub2api/ent/userattributevalue" "github.com/Wei-Shaw/sub2api/ent/usersubscription" + "github.com/Wei-Shaw/sub2api/internal/domain" ) const ( @@ -43,6 +46,8 @@ const ( TypeAPIKey = "APIKey" TypeAccount = "Account" TypeAccountGroup = "AccountGroup" + TypeAnnouncement = "Announcement" + TypeAnnouncementRead = "AnnouncementRead" TypeGroup = "Group" TypePromoCode = "PromoCode" TypePromoCodeUsage = "PromoCodeUsage" @@ -3833,6 +3838,1671 @@ func (m *AccountGroupMutation) ResetEdge(name string) error { return fmt.Errorf("unknown AccountGroup edge %s", name) } +// AnnouncementMutation represents an operation that mutates the Announcement nodes in the graph. +type AnnouncementMutation struct { + config + op Op + typ string + id *int64 + title *string + content *string + status *string + targeting *domain.AnnouncementTargeting + starts_at *time.Time + ends_at *time.Time + created_by *int64 + addcreated_by *int64 + updated_by *int64 + addupdated_by *int64 + created_at *time.Time + updated_at *time.Time + clearedFields map[string]struct{} + reads map[int64]struct{} + removedreads map[int64]struct{} + clearedreads bool + done bool + oldValue func(context.Context) (*Announcement, error) + predicates []predicate.Announcement +} + +var _ ent.Mutation = (*AnnouncementMutation)(nil) + +// announcementOption allows management of the mutation configuration using functional options. +type announcementOption func(*AnnouncementMutation) + +// newAnnouncementMutation creates new mutation for the Announcement entity. +func newAnnouncementMutation(c config, op Op, opts ...announcementOption) *AnnouncementMutation { + m := &AnnouncementMutation{ + config: c, + op: op, + typ: TypeAnnouncement, + clearedFields: make(map[string]struct{}), + } + for _, opt := range opts { + opt(m) + } + return m +} + +// withAnnouncementID sets the ID field of the mutation. +func withAnnouncementID(id int64) announcementOption { + return func(m *AnnouncementMutation) { + var ( + err error + once sync.Once + value *Announcement + ) + m.oldValue = func(ctx context.Context) (*Announcement, error) { + once.Do(func() { + if m.done { + err = errors.New("querying old values post mutation is not allowed") + } else { + value, err = m.Client().Announcement.Get(ctx, id) + } + }) + return value, err + } + m.id = &id + } +} + +// withAnnouncement sets the old Announcement of the mutation. +func withAnnouncement(node *Announcement) announcementOption { + return func(m *AnnouncementMutation) { + m.oldValue = func(context.Context) (*Announcement, error) { + return node, nil + } + m.id = &node.ID + } +} + +// Client returns a new `ent.Client` from the mutation. If the mutation was +// executed in a transaction (ent.Tx), a transactional client is returned. +func (m AnnouncementMutation) Client() *Client { + client := &Client{config: m.config} + client.init() + return client +} + +// Tx returns an `ent.Tx` for mutations that were executed in transactions; +// it returns an error otherwise. +func (m AnnouncementMutation) Tx() (*Tx, error) { + if _, ok := m.driver.(*txDriver); !ok { + return nil, errors.New("ent: mutation is not running in a transaction") + } + tx := &Tx{config: m.config} + tx.init() + return tx, nil +} + +// ID returns the ID value in the mutation. Note that the ID is only available +// if it was provided to the builder or after it was returned from the database. +func (m *AnnouncementMutation) ID() (id int64, exists bool) { + if m.id == nil { + return + } + return *m.id, true +} + +// IDs queries the database and returns the entity ids that match the mutation's predicate. +// That means, if the mutation is applied within a transaction with an isolation level such +// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated +// or updated by the mutation. +func (m *AnnouncementMutation) IDs(ctx context.Context) ([]int64, error) { + switch { + case m.op.Is(OpUpdateOne | OpDeleteOne): + id, exists := m.ID() + if exists { + return []int64{id}, nil + } + fallthrough + case m.op.Is(OpUpdate | OpDelete): + return m.Client().Announcement.Query().Where(m.predicates...).IDs(ctx) + default: + return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op) + } +} + +// SetTitle sets the "title" field. +func (m *AnnouncementMutation) SetTitle(s string) { + m.title = &s +} + +// Title returns the value of the "title" field in the mutation. +func (m *AnnouncementMutation) Title() (r string, exists bool) { + v := m.title + if v == nil { + return + } + return *v, true +} + +// OldTitle returns the old "title" field's value of the Announcement entity. +// If the Announcement object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementMutation) OldTitle(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTitle is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTitle requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTitle: %w", err) + } + return oldValue.Title, nil +} + +// ResetTitle resets all changes to the "title" field. +func (m *AnnouncementMutation) ResetTitle() { + m.title = nil +} + +// SetContent sets the "content" field. +func (m *AnnouncementMutation) SetContent(s string) { + m.content = &s +} + +// Content returns the value of the "content" field in the mutation. +func (m *AnnouncementMutation) Content() (r string, exists bool) { + v := m.content + if v == nil { + return + } + return *v, true +} + +// OldContent returns the old "content" field's value of the Announcement entity. +// If the Announcement object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementMutation) OldContent(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldContent is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldContent requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldContent: %w", err) + } + return oldValue.Content, nil +} + +// ResetContent resets all changes to the "content" field. +func (m *AnnouncementMutation) ResetContent() { + m.content = nil +} + +// SetStatus sets the "status" field. +func (m *AnnouncementMutation) SetStatus(s string) { + m.status = &s +} + +// Status returns the value of the "status" field in the mutation. +func (m *AnnouncementMutation) Status() (r string, exists bool) { + v := m.status + if v == nil { + return + } + return *v, true +} + +// OldStatus returns the old "status" field's value of the Announcement entity. +// If the Announcement object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementMutation) OldStatus(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldStatus is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldStatus requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldStatus: %w", err) + } + return oldValue.Status, nil +} + +// ResetStatus resets all changes to the "status" field. +func (m *AnnouncementMutation) ResetStatus() { + m.status = nil +} + +// SetTargeting sets the "targeting" field. +func (m *AnnouncementMutation) SetTargeting(dt domain.AnnouncementTargeting) { + m.targeting = &dt +} + +// Targeting returns the value of the "targeting" field in the mutation. +func (m *AnnouncementMutation) Targeting() (r domain.AnnouncementTargeting, exists bool) { + v := m.targeting + if v == nil { + return + } + return *v, true +} + +// OldTargeting returns the old "targeting" field's value of the Announcement entity. +// If the Announcement object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementMutation) OldTargeting(ctx context.Context) (v domain.AnnouncementTargeting, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTargeting is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTargeting requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTargeting: %w", err) + } + return oldValue.Targeting, nil +} + +// ClearTargeting clears the value of the "targeting" field. +func (m *AnnouncementMutation) ClearTargeting() { + m.targeting = nil + m.clearedFields[announcement.FieldTargeting] = struct{}{} +} + +// TargetingCleared returns if the "targeting" field was cleared in this mutation. +func (m *AnnouncementMutation) TargetingCleared() bool { + _, ok := m.clearedFields[announcement.FieldTargeting] + return ok +} + +// ResetTargeting resets all changes to the "targeting" field. +func (m *AnnouncementMutation) ResetTargeting() { + m.targeting = nil + delete(m.clearedFields, announcement.FieldTargeting) +} + +// SetStartsAt sets the "starts_at" field. +func (m *AnnouncementMutation) SetStartsAt(t time.Time) { + m.starts_at = &t +} + +// StartsAt returns the value of the "starts_at" field in the mutation. +func (m *AnnouncementMutation) StartsAt() (r time.Time, exists bool) { + v := m.starts_at + if v == nil { + return + } + return *v, true +} + +// OldStartsAt returns the old "starts_at" field's value of the Announcement entity. +// If the Announcement object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementMutation) OldStartsAt(ctx context.Context) (v *time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldStartsAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldStartsAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldStartsAt: %w", err) + } + return oldValue.StartsAt, nil +} + +// ClearStartsAt clears the value of the "starts_at" field. +func (m *AnnouncementMutation) ClearStartsAt() { + m.starts_at = nil + m.clearedFields[announcement.FieldStartsAt] = struct{}{} +} + +// StartsAtCleared returns if the "starts_at" field was cleared in this mutation. +func (m *AnnouncementMutation) StartsAtCleared() bool { + _, ok := m.clearedFields[announcement.FieldStartsAt] + return ok +} + +// ResetStartsAt resets all changes to the "starts_at" field. +func (m *AnnouncementMutation) ResetStartsAt() { + m.starts_at = nil + delete(m.clearedFields, announcement.FieldStartsAt) +} + +// SetEndsAt sets the "ends_at" field. +func (m *AnnouncementMutation) SetEndsAt(t time.Time) { + m.ends_at = &t +} + +// EndsAt returns the value of the "ends_at" field in the mutation. +func (m *AnnouncementMutation) EndsAt() (r time.Time, exists bool) { + v := m.ends_at + if v == nil { + return + } + return *v, true +} + +// OldEndsAt returns the old "ends_at" field's value of the Announcement entity. +// If the Announcement object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementMutation) OldEndsAt(ctx context.Context) (v *time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldEndsAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldEndsAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldEndsAt: %w", err) + } + return oldValue.EndsAt, nil +} + +// ClearEndsAt clears the value of the "ends_at" field. +func (m *AnnouncementMutation) ClearEndsAt() { + m.ends_at = nil + m.clearedFields[announcement.FieldEndsAt] = struct{}{} +} + +// EndsAtCleared returns if the "ends_at" field was cleared in this mutation. +func (m *AnnouncementMutation) EndsAtCleared() bool { + _, ok := m.clearedFields[announcement.FieldEndsAt] + return ok +} + +// ResetEndsAt resets all changes to the "ends_at" field. +func (m *AnnouncementMutation) ResetEndsAt() { + m.ends_at = nil + delete(m.clearedFields, announcement.FieldEndsAt) +} + +// SetCreatedBy sets the "created_by" field. +func (m *AnnouncementMutation) SetCreatedBy(i int64) { + m.created_by = &i + m.addcreated_by = nil +} + +// CreatedBy returns the value of the "created_by" field in the mutation. +func (m *AnnouncementMutation) CreatedBy() (r int64, exists bool) { + v := m.created_by + if v == nil { + return + } + return *v, true +} + +// OldCreatedBy returns the old "created_by" field's value of the Announcement entity. +// If the Announcement object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementMutation) OldCreatedBy(ctx context.Context) (v *int64, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCreatedBy is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCreatedBy requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCreatedBy: %w", err) + } + return oldValue.CreatedBy, nil +} + +// AddCreatedBy adds i to the "created_by" field. +func (m *AnnouncementMutation) AddCreatedBy(i int64) { + if m.addcreated_by != nil { + *m.addcreated_by += i + } else { + m.addcreated_by = &i + } +} + +// AddedCreatedBy returns the value that was added to the "created_by" field in this mutation. +func (m *AnnouncementMutation) AddedCreatedBy() (r int64, exists bool) { + v := m.addcreated_by + if v == nil { + return + } + return *v, true +} + +// ClearCreatedBy clears the value of the "created_by" field. +func (m *AnnouncementMutation) ClearCreatedBy() { + m.created_by = nil + m.addcreated_by = nil + m.clearedFields[announcement.FieldCreatedBy] = struct{}{} +} + +// CreatedByCleared returns if the "created_by" field was cleared in this mutation. +func (m *AnnouncementMutation) CreatedByCleared() bool { + _, ok := m.clearedFields[announcement.FieldCreatedBy] + return ok +} + +// ResetCreatedBy resets all changes to the "created_by" field. +func (m *AnnouncementMutation) ResetCreatedBy() { + m.created_by = nil + m.addcreated_by = nil + delete(m.clearedFields, announcement.FieldCreatedBy) +} + +// SetUpdatedBy sets the "updated_by" field. +func (m *AnnouncementMutation) SetUpdatedBy(i int64) { + m.updated_by = &i + m.addupdated_by = nil +} + +// UpdatedBy returns the value of the "updated_by" field in the mutation. +func (m *AnnouncementMutation) UpdatedBy() (r int64, exists bool) { + v := m.updated_by + if v == nil { + return + } + return *v, true +} + +// OldUpdatedBy returns the old "updated_by" field's value of the Announcement entity. +// If the Announcement object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementMutation) OldUpdatedBy(ctx context.Context) (v *int64, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUpdatedBy is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUpdatedBy requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUpdatedBy: %w", err) + } + return oldValue.UpdatedBy, nil +} + +// AddUpdatedBy adds i to the "updated_by" field. +func (m *AnnouncementMutation) AddUpdatedBy(i int64) { + if m.addupdated_by != nil { + *m.addupdated_by += i + } else { + m.addupdated_by = &i + } +} + +// AddedUpdatedBy returns the value that was added to the "updated_by" field in this mutation. +func (m *AnnouncementMutation) AddedUpdatedBy() (r int64, exists bool) { + v := m.addupdated_by + if v == nil { + return + } + return *v, true +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (m *AnnouncementMutation) ClearUpdatedBy() { + m.updated_by = nil + m.addupdated_by = nil + m.clearedFields[announcement.FieldUpdatedBy] = struct{}{} +} + +// UpdatedByCleared returns if the "updated_by" field was cleared in this mutation. +func (m *AnnouncementMutation) UpdatedByCleared() bool { + _, ok := m.clearedFields[announcement.FieldUpdatedBy] + return ok +} + +// ResetUpdatedBy resets all changes to the "updated_by" field. +func (m *AnnouncementMutation) ResetUpdatedBy() { + m.updated_by = nil + m.addupdated_by = nil + delete(m.clearedFields, announcement.FieldUpdatedBy) +} + +// SetCreatedAt sets the "created_at" field. +func (m *AnnouncementMutation) SetCreatedAt(t time.Time) { + m.created_at = &t +} + +// CreatedAt returns the value of the "created_at" field in the mutation. +func (m *AnnouncementMutation) CreatedAt() (r time.Time, exists bool) { + v := m.created_at + if v == nil { + return + } + return *v, true +} + +// OldCreatedAt returns the old "created_at" field's value of the Announcement entity. +// If the Announcement object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCreatedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err) + } + return oldValue.CreatedAt, nil +} + +// ResetCreatedAt resets all changes to the "created_at" field. +func (m *AnnouncementMutation) ResetCreatedAt() { + m.created_at = nil +} + +// SetUpdatedAt sets the "updated_at" field. +func (m *AnnouncementMutation) SetUpdatedAt(t time.Time) { + m.updated_at = &t +} + +// UpdatedAt returns the value of the "updated_at" field in the mutation. +func (m *AnnouncementMutation) UpdatedAt() (r time.Time, exists bool) { + v := m.updated_at + if v == nil { + return + } + return *v, true +} + +// OldUpdatedAt returns the old "updated_at" field's value of the Announcement entity. +// If the Announcement object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUpdatedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err) + } + return oldValue.UpdatedAt, nil +} + +// ResetUpdatedAt resets all changes to the "updated_at" field. +func (m *AnnouncementMutation) ResetUpdatedAt() { + m.updated_at = nil +} + +// AddReadIDs adds the "reads" edge to the AnnouncementRead entity by ids. +func (m *AnnouncementMutation) AddReadIDs(ids ...int64) { + if m.reads == nil { + m.reads = make(map[int64]struct{}) + } + for i := range ids { + m.reads[ids[i]] = struct{}{} + } +} + +// ClearReads clears the "reads" edge to the AnnouncementRead entity. +func (m *AnnouncementMutation) ClearReads() { + m.clearedreads = true +} + +// ReadsCleared reports if the "reads" edge to the AnnouncementRead entity was cleared. +func (m *AnnouncementMutation) ReadsCleared() bool { + return m.clearedreads +} + +// RemoveReadIDs removes the "reads" edge to the AnnouncementRead entity by IDs. +func (m *AnnouncementMutation) RemoveReadIDs(ids ...int64) { + if m.removedreads == nil { + m.removedreads = make(map[int64]struct{}) + } + for i := range ids { + delete(m.reads, ids[i]) + m.removedreads[ids[i]] = struct{}{} + } +} + +// RemovedReads returns the removed IDs of the "reads" edge to the AnnouncementRead entity. +func (m *AnnouncementMutation) RemovedReadsIDs() (ids []int64) { + for id := range m.removedreads { + ids = append(ids, id) + } + return +} + +// ReadsIDs returns the "reads" edge IDs in the mutation. +func (m *AnnouncementMutation) ReadsIDs() (ids []int64) { + for id := range m.reads { + ids = append(ids, id) + } + return +} + +// ResetReads resets all changes to the "reads" edge. +func (m *AnnouncementMutation) ResetReads() { + m.reads = nil + m.clearedreads = false + m.removedreads = nil +} + +// Where appends a list predicates to the AnnouncementMutation builder. +func (m *AnnouncementMutation) Where(ps ...predicate.Announcement) { + m.predicates = append(m.predicates, ps...) +} + +// WhereP appends storage-level predicates to the AnnouncementMutation builder. Using this method, +// users can use type-assertion to append predicates that do not depend on any generated package. +func (m *AnnouncementMutation) WhereP(ps ...func(*sql.Selector)) { + p := make([]predicate.Announcement, len(ps)) + for i := range ps { + p[i] = ps[i] + } + m.Where(p...) +} + +// Op returns the operation name. +func (m *AnnouncementMutation) Op() Op { + return m.op +} + +// SetOp allows setting the mutation operation. +func (m *AnnouncementMutation) SetOp(op Op) { + m.op = op +} + +// Type returns the node type of this mutation (Announcement). +func (m *AnnouncementMutation) Type() string { + return m.typ +} + +// Fields returns all fields that were changed during this mutation. Note that in +// order to get all numeric fields that were incremented/decremented, call +// AddedFields(). +func (m *AnnouncementMutation) Fields() []string { + fields := make([]string, 0, 10) + if m.title != nil { + fields = append(fields, announcement.FieldTitle) + } + if m.content != nil { + fields = append(fields, announcement.FieldContent) + } + if m.status != nil { + fields = append(fields, announcement.FieldStatus) + } + if m.targeting != nil { + fields = append(fields, announcement.FieldTargeting) + } + if m.starts_at != nil { + fields = append(fields, announcement.FieldStartsAt) + } + if m.ends_at != nil { + fields = append(fields, announcement.FieldEndsAt) + } + if m.created_by != nil { + fields = append(fields, announcement.FieldCreatedBy) + } + if m.updated_by != nil { + fields = append(fields, announcement.FieldUpdatedBy) + } + if m.created_at != nil { + fields = append(fields, announcement.FieldCreatedAt) + } + if m.updated_at != nil { + fields = append(fields, announcement.FieldUpdatedAt) + } + return fields +} + +// Field returns the value of a field with the given name. The second boolean +// return value indicates that this field was not set, or was not defined in the +// schema. +func (m *AnnouncementMutation) Field(name string) (ent.Value, bool) { + switch name { + case announcement.FieldTitle: + return m.Title() + case announcement.FieldContent: + return m.Content() + case announcement.FieldStatus: + return m.Status() + case announcement.FieldTargeting: + return m.Targeting() + case announcement.FieldStartsAt: + return m.StartsAt() + case announcement.FieldEndsAt: + return m.EndsAt() + case announcement.FieldCreatedBy: + return m.CreatedBy() + case announcement.FieldUpdatedBy: + return m.UpdatedBy() + case announcement.FieldCreatedAt: + return m.CreatedAt() + case announcement.FieldUpdatedAt: + return m.UpdatedAt() + } + return nil, false +} + +// OldField returns the old value of the field from the database. An error is +// returned if the mutation operation is not UpdateOne, or the query to the +// database failed. +func (m *AnnouncementMutation) OldField(ctx context.Context, name string) (ent.Value, error) { + switch name { + case announcement.FieldTitle: + return m.OldTitle(ctx) + case announcement.FieldContent: + return m.OldContent(ctx) + case announcement.FieldStatus: + return m.OldStatus(ctx) + case announcement.FieldTargeting: + return m.OldTargeting(ctx) + case announcement.FieldStartsAt: + return m.OldStartsAt(ctx) + case announcement.FieldEndsAt: + return m.OldEndsAt(ctx) + case announcement.FieldCreatedBy: + return m.OldCreatedBy(ctx) + case announcement.FieldUpdatedBy: + return m.OldUpdatedBy(ctx) + case announcement.FieldCreatedAt: + return m.OldCreatedAt(ctx) + case announcement.FieldUpdatedAt: + return m.OldUpdatedAt(ctx) + } + return nil, fmt.Errorf("unknown Announcement field %s", name) +} + +// SetField sets the value of a field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *AnnouncementMutation) SetField(name string, value ent.Value) error { + switch name { + case announcement.FieldTitle: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTitle(v) + return nil + case announcement.FieldContent: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetContent(v) + return nil + case announcement.FieldStatus: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetStatus(v) + return nil + case announcement.FieldTargeting: + v, ok := value.(domain.AnnouncementTargeting) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTargeting(v) + return nil + case announcement.FieldStartsAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetStartsAt(v) + return nil + case announcement.FieldEndsAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetEndsAt(v) + return nil + case announcement.FieldCreatedBy: + v, ok := value.(int64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCreatedBy(v) + return nil + case announcement.FieldUpdatedBy: + v, ok := value.(int64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUpdatedBy(v) + return nil + case announcement.FieldCreatedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCreatedAt(v) + return nil + case announcement.FieldUpdatedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUpdatedAt(v) + return nil + } + return fmt.Errorf("unknown Announcement field %s", name) +} + +// AddedFields returns all numeric fields that were incremented/decremented during +// this mutation. +func (m *AnnouncementMutation) AddedFields() []string { + var fields []string + if m.addcreated_by != nil { + fields = append(fields, announcement.FieldCreatedBy) + } + if m.addupdated_by != nil { + fields = append(fields, announcement.FieldUpdatedBy) + } + return fields +} + +// AddedField returns the numeric value that was incremented/decremented on a field +// with the given name. The second boolean return value indicates that this field +// was not set, or was not defined in the schema. +func (m *AnnouncementMutation) AddedField(name string) (ent.Value, bool) { + switch name { + case announcement.FieldCreatedBy: + return m.AddedCreatedBy() + case announcement.FieldUpdatedBy: + return m.AddedUpdatedBy() + } + return nil, false +} + +// AddField adds the value to the field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *AnnouncementMutation) AddField(name string, value ent.Value) error { + switch name { + case announcement.FieldCreatedBy: + v, ok := value.(int64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddCreatedBy(v) + return nil + case announcement.FieldUpdatedBy: + v, ok := value.(int64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddUpdatedBy(v) + return nil + } + return fmt.Errorf("unknown Announcement numeric field %s", name) +} + +// ClearedFields returns all nullable fields that were cleared during this +// mutation. +func (m *AnnouncementMutation) ClearedFields() []string { + var fields []string + if m.FieldCleared(announcement.FieldTargeting) { + fields = append(fields, announcement.FieldTargeting) + } + if m.FieldCleared(announcement.FieldStartsAt) { + fields = append(fields, announcement.FieldStartsAt) + } + if m.FieldCleared(announcement.FieldEndsAt) { + fields = append(fields, announcement.FieldEndsAt) + } + if m.FieldCleared(announcement.FieldCreatedBy) { + fields = append(fields, announcement.FieldCreatedBy) + } + if m.FieldCleared(announcement.FieldUpdatedBy) { + fields = append(fields, announcement.FieldUpdatedBy) + } + return fields +} + +// FieldCleared returns a boolean indicating if a field with the given name was +// cleared in this mutation. +func (m *AnnouncementMutation) FieldCleared(name string) bool { + _, ok := m.clearedFields[name] + return ok +} + +// ClearField clears the value of the field with the given name. It returns an +// error if the field is not defined in the schema. +func (m *AnnouncementMutation) ClearField(name string) error { + switch name { + case announcement.FieldTargeting: + m.ClearTargeting() + return nil + case announcement.FieldStartsAt: + m.ClearStartsAt() + return nil + case announcement.FieldEndsAt: + m.ClearEndsAt() + return nil + case announcement.FieldCreatedBy: + m.ClearCreatedBy() + return nil + case announcement.FieldUpdatedBy: + m.ClearUpdatedBy() + return nil + } + return fmt.Errorf("unknown Announcement nullable field %s", name) +} + +// ResetField resets all changes in the mutation for the field with the given name. +// It returns an error if the field is not defined in the schema. +func (m *AnnouncementMutation) ResetField(name string) error { + switch name { + case announcement.FieldTitle: + m.ResetTitle() + return nil + case announcement.FieldContent: + m.ResetContent() + return nil + case announcement.FieldStatus: + m.ResetStatus() + return nil + case announcement.FieldTargeting: + m.ResetTargeting() + return nil + case announcement.FieldStartsAt: + m.ResetStartsAt() + return nil + case announcement.FieldEndsAt: + m.ResetEndsAt() + return nil + case announcement.FieldCreatedBy: + m.ResetCreatedBy() + return nil + case announcement.FieldUpdatedBy: + m.ResetUpdatedBy() + return nil + case announcement.FieldCreatedAt: + m.ResetCreatedAt() + return nil + case announcement.FieldUpdatedAt: + m.ResetUpdatedAt() + return nil + } + return fmt.Errorf("unknown Announcement field %s", name) +} + +// AddedEdges returns all edge names that were set/added in this mutation. +func (m *AnnouncementMutation) AddedEdges() []string { + edges := make([]string, 0, 1) + if m.reads != nil { + edges = append(edges, announcement.EdgeReads) + } + return edges +} + +// AddedIDs returns all IDs (to other nodes) that were added for the given edge +// name in this mutation. +func (m *AnnouncementMutation) AddedIDs(name string) []ent.Value { + switch name { + case announcement.EdgeReads: + ids := make([]ent.Value, 0, len(m.reads)) + for id := range m.reads { + ids = append(ids, id) + } + return ids + } + return nil +} + +// RemovedEdges returns all edge names that were removed in this mutation. +func (m *AnnouncementMutation) RemovedEdges() []string { + edges := make([]string, 0, 1) + if m.removedreads != nil { + edges = append(edges, announcement.EdgeReads) + } + return edges +} + +// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with +// the given name in this mutation. +func (m *AnnouncementMutation) RemovedIDs(name string) []ent.Value { + switch name { + case announcement.EdgeReads: + ids := make([]ent.Value, 0, len(m.removedreads)) + for id := range m.removedreads { + ids = append(ids, id) + } + return ids + } + return nil +} + +// ClearedEdges returns all edge names that were cleared in this mutation. +func (m *AnnouncementMutation) ClearedEdges() []string { + edges := make([]string, 0, 1) + if m.clearedreads { + edges = append(edges, announcement.EdgeReads) + } + return edges +} + +// EdgeCleared returns a boolean which indicates if the edge with the given name +// was cleared in this mutation. +func (m *AnnouncementMutation) EdgeCleared(name string) bool { + switch name { + case announcement.EdgeReads: + return m.clearedreads + } + return false +} + +// ClearEdge clears the value of the edge with the given name. It returns an error +// if that edge is not defined in the schema. +func (m *AnnouncementMutation) ClearEdge(name string) error { + switch name { + } + return fmt.Errorf("unknown Announcement unique edge %s", name) +} + +// ResetEdge resets all changes to the edge with the given name in this mutation. +// It returns an error if the edge is not defined in the schema. +func (m *AnnouncementMutation) ResetEdge(name string) error { + switch name { + case announcement.EdgeReads: + m.ResetReads() + return nil + } + return fmt.Errorf("unknown Announcement edge %s", name) +} + +// AnnouncementReadMutation represents an operation that mutates the AnnouncementRead nodes in the graph. +type AnnouncementReadMutation struct { + config + op Op + typ string + id *int64 + read_at *time.Time + created_at *time.Time + clearedFields map[string]struct{} + announcement *int64 + clearedannouncement bool + user *int64 + cleareduser bool + done bool + oldValue func(context.Context) (*AnnouncementRead, error) + predicates []predicate.AnnouncementRead +} + +var _ ent.Mutation = (*AnnouncementReadMutation)(nil) + +// announcementreadOption allows management of the mutation configuration using functional options. +type announcementreadOption func(*AnnouncementReadMutation) + +// newAnnouncementReadMutation creates new mutation for the AnnouncementRead entity. +func newAnnouncementReadMutation(c config, op Op, opts ...announcementreadOption) *AnnouncementReadMutation { + m := &AnnouncementReadMutation{ + config: c, + op: op, + typ: TypeAnnouncementRead, + clearedFields: make(map[string]struct{}), + } + for _, opt := range opts { + opt(m) + } + return m +} + +// withAnnouncementReadID sets the ID field of the mutation. +func withAnnouncementReadID(id int64) announcementreadOption { + return func(m *AnnouncementReadMutation) { + var ( + err error + once sync.Once + value *AnnouncementRead + ) + m.oldValue = func(ctx context.Context) (*AnnouncementRead, error) { + once.Do(func() { + if m.done { + err = errors.New("querying old values post mutation is not allowed") + } else { + value, err = m.Client().AnnouncementRead.Get(ctx, id) + } + }) + return value, err + } + m.id = &id + } +} + +// withAnnouncementRead sets the old AnnouncementRead of the mutation. +func withAnnouncementRead(node *AnnouncementRead) announcementreadOption { + return func(m *AnnouncementReadMutation) { + m.oldValue = func(context.Context) (*AnnouncementRead, error) { + return node, nil + } + m.id = &node.ID + } +} + +// Client returns a new `ent.Client` from the mutation. If the mutation was +// executed in a transaction (ent.Tx), a transactional client is returned. +func (m AnnouncementReadMutation) Client() *Client { + client := &Client{config: m.config} + client.init() + return client +} + +// Tx returns an `ent.Tx` for mutations that were executed in transactions; +// it returns an error otherwise. +func (m AnnouncementReadMutation) Tx() (*Tx, error) { + if _, ok := m.driver.(*txDriver); !ok { + return nil, errors.New("ent: mutation is not running in a transaction") + } + tx := &Tx{config: m.config} + tx.init() + return tx, nil +} + +// ID returns the ID value in the mutation. Note that the ID is only available +// if it was provided to the builder or after it was returned from the database. +func (m *AnnouncementReadMutation) ID() (id int64, exists bool) { + if m.id == nil { + return + } + return *m.id, true +} + +// IDs queries the database and returns the entity ids that match the mutation's predicate. +// That means, if the mutation is applied within a transaction with an isolation level such +// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated +// or updated by the mutation. +func (m *AnnouncementReadMutation) IDs(ctx context.Context) ([]int64, error) { + switch { + case m.op.Is(OpUpdateOne | OpDeleteOne): + id, exists := m.ID() + if exists { + return []int64{id}, nil + } + fallthrough + case m.op.Is(OpUpdate | OpDelete): + return m.Client().AnnouncementRead.Query().Where(m.predicates...).IDs(ctx) + default: + return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op) + } +} + +// SetAnnouncementID sets the "announcement_id" field. +func (m *AnnouncementReadMutation) SetAnnouncementID(i int64) { + m.announcement = &i +} + +// AnnouncementID returns the value of the "announcement_id" field in the mutation. +func (m *AnnouncementReadMutation) AnnouncementID() (r int64, exists bool) { + v := m.announcement + if v == nil { + return + } + return *v, true +} + +// OldAnnouncementID returns the old "announcement_id" field's value of the AnnouncementRead entity. +// If the AnnouncementRead object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementReadMutation) OldAnnouncementID(ctx context.Context) (v int64, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldAnnouncementID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldAnnouncementID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldAnnouncementID: %w", err) + } + return oldValue.AnnouncementID, nil +} + +// ResetAnnouncementID resets all changes to the "announcement_id" field. +func (m *AnnouncementReadMutation) ResetAnnouncementID() { + m.announcement = nil +} + +// SetUserID sets the "user_id" field. +func (m *AnnouncementReadMutation) SetUserID(i int64) { + m.user = &i +} + +// UserID returns the value of the "user_id" field in the mutation. +func (m *AnnouncementReadMutation) UserID() (r int64, exists bool) { + v := m.user + if v == nil { + return + } + return *v, true +} + +// OldUserID returns the old "user_id" field's value of the AnnouncementRead entity. +// If the AnnouncementRead object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementReadMutation) OldUserID(ctx context.Context) (v int64, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUserID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUserID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUserID: %w", err) + } + return oldValue.UserID, nil +} + +// ResetUserID resets all changes to the "user_id" field. +func (m *AnnouncementReadMutation) ResetUserID() { + m.user = nil +} + +// SetReadAt sets the "read_at" field. +func (m *AnnouncementReadMutation) SetReadAt(t time.Time) { + m.read_at = &t +} + +// ReadAt returns the value of the "read_at" field in the mutation. +func (m *AnnouncementReadMutation) ReadAt() (r time.Time, exists bool) { + v := m.read_at + if v == nil { + return + } + return *v, true +} + +// OldReadAt returns the old "read_at" field's value of the AnnouncementRead entity. +// If the AnnouncementRead object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementReadMutation) OldReadAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldReadAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldReadAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldReadAt: %w", err) + } + return oldValue.ReadAt, nil +} + +// ResetReadAt resets all changes to the "read_at" field. +func (m *AnnouncementReadMutation) ResetReadAt() { + m.read_at = nil +} + +// SetCreatedAt sets the "created_at" field. +func (m *AnnouncementReadMutation) SetCreatedAt(t time.Time) { + m.created_at = &t +} + +// CreatedAt returns the value of the "created_at" field in the mutation. +func (m *AnnouncementReadMutation) CreatedAt() (r time.Time, exists bool) { + v := m.created_at + if v == nil { + return + } + return *v, true +} + +// OldCreatedAt returns the old "created_at" field's value of the AnnouncementRead entity. +// If the AnnouncementRead object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AnnouncementReadMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCreatedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err) + } + return oldValue.CreatedAt, nil +} + +// ResetCreatedAt resets all changes to the "created_at" field. +func (m *AnnouncementReadMutation) ResetCreatedAt() { + m.created_at = nil +} + +// ClearAnnouncement clears the "announcement" edge to the Announcement entity. +func (m *AnnouncementReadMutation) ClearAnnouncement() { + m.clearedannouncement = true + m.clearedFields[announcementread.FieldAnnouncementID] = struct{}{} +} + +// AnnouncementCleared reports if the "announcement" edge to the Announcement entity was cleared. +func (m *AnnouncementReadMutation) AnnouncementCleared() bool { + return m.clearedannouncement +} + +// AnnouncementIDs returns the "announcement" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// AnnouncementID instead. It exists only for internal usage by the builders. +func (m *AnnouncementReadMutation) AnnouncementIDs() (ids []int64) { + if id := m.announcement; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetAnnouncement resets all changes to the "announcement" edge. +func (m *AnnouncementReadMutation) ResetAnnouncement() { + m.announcement = nil + m.clearedannouncement = false +} + +// ClearUser clears the "user" edge to the User entity. +func (m *AnnouncementReadMutation) ClearUser() { + m.cleareduser = true + m.clearedFields[announcementread.FieldUserID] = struct{}{} +} + +// UserCleared reports if the "user" edge to the User entity was cleared. +func (m *AnnouncementReadMutation) UserCleared() bool { + return m.cleareduser +} + +// UserIDs returns the "user" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// UserID instead. It exists only for internal usage by the builders. +func (m *AnnouncementReadMutation) UserIDs() (ids []int64) { + if id := m.user; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetUser resets all changes to the "user" edge. +func (m *AnnouncementReadMutation) ResetUser() { + m.user = nil + m.cleareduser = false +} + +// Where appends a list predicates to the AnnouncementReadMutation builder. +func (m *AnnouncementReadMutation) Where(ps ...predicate.AnnouncementRead) { + m.predicates = append(m.predicates, ps...) +} + +// WhereP appends storage-level predicates to the AnnouncementReadMutation builder. Using this method, +// users can use type-assertion to append predicates that do not depend on any generated package. +func (m *AnnouncementReadMutation) WhereP(ps ...func(*sql.Selector)) { + p := make([]predicate.AnnouncementRead, len(ps)) + for i := range ps { + p[i] = ps[i] + } + m.Where(p...) +} + +// Op returns the operation name. +func (m *AnnouncementReadMutation) Op() Op { + return m.op +} + +// SetOp allows setting the mutation operation. +func (m *AnnouncementReadMutation) SetOp(op Op) { + m.op = op +} + +// Type returns the node type of this mutation (AnnouncementRead). +func (m *AnnouncementReadMutation) Type() string { + return m.typ +} + +// Fields returns all fields that were changed during this mutation. Note that in +// order to get all numeric fields that were incremented/decremented, call +// AddedFields(). +func (m *AnnouncementReadMutation) Fields() []string { + fields := make([]string, 0, 4) + if m.announcement != nil { + fields = append(fields, announcementread.FieldAnnouncementID) + } + if m.user != nil { + fields = append(fields, announcementread.FieldUserID) + } + if m.read_at != nil { + fields = append(fields, announcementread.FieldReadAt) + } + if m.created_at != nil { + fields = append(fields, announcementread.FieldCreatedAt) + } + return fields +} + +// Field returns the value of a field with the given name. The second boolean +// return value indicates that this field was not set, or was not defined in the +// schema. +func (m *AnnouncementReadMutation) Field(name string) (ent.Value, bool) { + switch name { + case announcementread.FieldAnnouncementID: + return m.AnnouncementID() + case announcementread.FieldUserID: + return m.UserID() + case announcementread.FieldReadAt: + return m.ReadAt() + case announcementread.FieldCreatedAt: + return m.CreatedAt() + } + return nil, false +} + +// OldField returns the old value of the field from the database. An error is +// returned if the mutation operation is not UpdateOne, or the query to the +// database failed. +func (m *AnnouncementReadMutation) OldField(ctx context.Context, name string) (ent.Value, error) { + switch name { + case announcementread.FieldAnnouncementID: + return m.OldAnnouncementID(ctx) + case announcementread.FieldUserID: + return m.OldUserID(ctx) + case announcementread.FieldReadAt: + return m.OldReadAt(ctx) + case announcementread.FieldCreatedAt: + return m.OldCreatedAt(ctx) + } + return nil, fmt.Errorf("unknown AnnouncementRead field %s", name) +} + +// SetField sets the value of a field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *AnnouncementReadMutation) SetField(name string, value ent.Value) error { + switch name { + case announcementread.FieldAnnouncementID: + v, ok := value.(int64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetAnnouncementID(v) + return nil + case announcementread.FieldUserID: + v, ok := value.(int64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUserID(v) + return nil + case announcementread.FieldReadAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetReadAt(v) + return nil + case announcementread.FieldCreatedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCreatedAt(v) + return nil + } + return fmt.Errorf("unknown AnnouncementRead field %s", name) +} + +// AddedFields returns all numeric fields that were incremented/decremented during +// this mutation. +func (m *AnnouncementReadMutation) AddedFields() []string { + var fields []string + return fields +} + +// AddedField returns the numeric value that was incremented/decremented on a field +// with the given name. The second boolean return value indicates that this field +// was not set, or was not defined in the schema. +func (m *AnnouncementReadMutation) AddedField(name string) (ent.Value, bool) { + switch name { + } + return nil, false +} + +// AddField adds the value to the field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *AnnouncementReadMutation) AddField(name string, value ent.Value) error { + switch name { + } + return fmt.Errorf("unknown AnnouncementRead numeric field %s", name) +} + +// ClearedFields returns all nullable fields that were cleared during this +// mutation. +func (m *AnnouncementReadMutation) ClearedFields() []string { + return nil +} + +// FieldCleared returns a boolean indicating if a field with the given name was +// cleared in this mutation. +func (m *AnnouncementReadMutation) FieldCleared(name string) bool { + _, ok := m.clearedFields[name] + return ok +} + +// ClearField clears the value of the field with the given name. It returns an +// error if the field is not defined in the schema. +func (m *AnnouncementReadMutation) ClearField(name string) error { + return fmt.Errorf("unknown AnnouncementRead nullable field %s", name) +} + +// ResetField resets all changes in the mutation for the field with the given name. +// It returns an error if the field is not defined in the schema. +func (m *AnnouncementReadMutation) ResetField(name string) error { + switch name { + case announcementread.FieldAnnouncementID: + m.ResetAnnouncementID() + return nil + case announcementread.FieldUserID: + m.ResetUserID() + return nil + case announcementread.FieldReadAt: + m.ResetReadAt() + return nil + case announcementread.FieldCreatedAt: + m.ResetCreatedAt() + return nil + } + return fmt.Errorf("unknown AnnouncementRead field %s", name) +} + +// AddedEdges returns all edge names that were set/added in this mutation. +func (m *AnnouncementReadMutation) AddedEdges() []string { + edges := make([]string, 0, 2) + if m.announcement != nil { + edges = append(edges, announcementread.EdgeAnnouncement) + } + if m.user != nil { + edges = append(edges, announcementread.EdgeUser) + } + return edges +} + +// AddedIDs returns all IDs (to other nodes) that were added for the given edge +// name in this mutation. +func (m *AnnouncementReadMutation) AddedIDs(name string) []ent.Value { + switch name { + case announcementread.EdgeAnnouncement: + if id := m.announcement; id != nil { + return []ent.Value{*id} + } + case announcementread.EdgeUser: + if id := m.user; id != nil { + return []ent.Value{*id} + } + } + return nil +} + +// RemovedEdges returns all edge names that were removed in this mutation. +func (m *AnnouncementReadMutation) RemovedEdges() []string { + edges := make([]string, 0, 2) + return edges +} + +// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with +// the given name in this mutation. +func (m *AnnouncementReadMutation) RemovedIDs(name string) []ent.Value { + return nil +} + +// ClearedEdges returns all edge names that were cleared in this mutation. +func (m *AnnouncementReadMutation) ClearedEdges() []string { + edges := make([]string, 0, 2) + if m.clearedannouncement { + edges = append(edges, announcementread.EdgeAnnouncement) + } + if m.cleareduser { + edges = append(edges, announcementread.EdgeUser) + } + return edges +} + +// EdgeCleared returns a boolean which indicates if the edge with the given name +// was cleared in this mutation. +func (m *AnnouncementReadMutation) EdgeCleared(name string) bool { + switch name { + case announcementread.EdgeAnnouncement: + return m.clearedannouncement + case announcementread.EdgeUser: + return m.cleareduser + } + return false +} + +// ClearEdge clears the value of the edge with the given name. It returns an error +// if that edge is not defined in the schema. +func (m *AnnouncementReadMutation) ClearEdge(name string) error { + switch name { + case announcementread.EdgeAnnouncement: + m.ClearAnnouncement() + return nil + case announcementread.EdgeUser: + m.ClearUser() + return nil + } + return fmt.Errorf("unknown AnnouncementRead unique edge %s", name) +} + +// ResetEdge resets all changes to the edge with the given name in this mutation. +// It returns an error if the edge is not defined in the schema. +func (m *AnnouncementReadMutation) ResetEdge(name string) error { + switch name { + case announcementread.EdgeAnnouncement: + m.ResetAnnouncement() + return nil + case announcementread.EdgeUser: + m.ResetUser() + return nil + } + return fmt.Errorf("unknown AnnouncementRead edge %s", name) +} + // GroupMutation represents an operation that mutates the Group nodes in the graph. type GroupMutation struct { config @@ -14376,6 +16046,9 @@ type UserMutation struct { assigned_subscriptions map[int64]struct{} removedassigned_subscriptions map[int64]struct{} clearedassigned_subscriptions bool + announcement_reads map[int64]struct{} + removedannouncement_reads map[int64]struct{} + clearedannouncement_reads bool allowed_groups map[int64]struct{} removedallowed_groups map[int64]struct{} clearedallowed_groups bool @@ -15290,6 +16963,60 @@ func (m *UserMutation) ResetAssignedSubscriptions() { m.removedassigned_subscriptions = nil } +// AddAnnouncementReadIDs adds the "announcement_reads" edge to the AnnouncementRead entity by ids. +func (m *UserMutation) AddAnnouncementReadIDs(ids ...int64) { + if m.announcement_reads == nil { + m.announcement_reads = make(map[int64]struct{}) + } + for i := range ids { + m.announcement_reads[ids[i]] = struct{}{} + } +} + +// ClearAnnouncementReads clears the "announcement_reads" edge to the AnnouncementRead entity. +func (m *UserMutation) ClearAnnouncementReads() { + m.clearedannouncement_reads = true +} + +// AnnouncementReadsCleared reports if the "announcement_reads" edge to the AnnouncementRead entity was cleared. +func (m *UserMutation) AnnouncementReadsCleared() bool { + return m.clearedannouncement_reads +} + +// RemoveAnnouncementReadIDs removes the "announcement_reads" edge to the AnnouncementRead entity by IDs. +func (m *UserMutation) RemoveAnnouncementReadIDs(ids ...int64) { + if m.removedannouncement_reads == nil { + m.removedannouncement_reads = make(map[int64]struct{}) + } + for i := range ids { + delete(m.announcement_reads, ids[i]) + m.removedannouncement_reads[ids[i]] = struct{}{} + } +} + +// RemovedAnnouncementReads returns the removed IDs of the "announcement_reads" edge to the AnnouncementRead entity. +func (m *UserMutation) RemovedAnnouncementReadsIDs() (ids []int64) { + for id := range m.removedannouncement_reads { + ids = append(ids, id) + } + return +} + +// AnnouncementReadsIDs returns the "announcement_reads" edge IDs in the mutation. +func (m *UserMutation) AnnouncementReadsIDs() (ids []int64) { + for id := range m.announcement_reads { + ids = append(ids, id) + } + return +} + +// ResetAnnouncementReads resets all changes to the "announcement_reads" edge. +func (m *UserMutation) ResetAnnouncementReads() { + m.announcement_reads = nil + m.clearedannouncement_reads = false + m.removedannouncement_reads = nil +} + // AddAllowedGroupIDs adds the "allowed_groups" edge to the Group entity by ids. func (m *UserMutation) AddAllowedGroupIDs(ids ...int64) { if m.allowed_groups == nil { @@ -15908,7 +17635,7 @@ func (m *UserMutation) ResetField(name string) error { // AddedEdges returns all edge names that were set/added in this mutation. func (m *UserMutation) AddedEdges() []string { - edges := make([]string, 0, 8) + edges := make([]string, 0, 9) if m.api_keys != nil { edges = append(edges, user.EdgeAPIKeys) } @@ -15921,6 +17648,9 @@ func (m *UserMutation) AddedEdges() []string { if m.assigned_subscriptions != nil { edges = append(edges, user.EdgeAssignedSubscriptions) } + if m.announcement_reads != nil { + edges = append(edges, user.EdgeAnnouncementReads) + } if m.allowed_groups != nil { edges = append(edges, user.EdgeAllowedGroups) } @@ -15964,6 +17694,12 @@ func (m *UserMutation) AddedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case user.EdgeAnnouncementReads: + ids := make([]ent.Value, 0, len(m.announcement_reads)) + for id := range m.announcement_reads { + ids = append(ids, id) + } + return ids case user.EdgeAllowedGroups: ids := make([]ent.Value, 0, len(m.allowed_groups)) for id := range m.allowed_groups { @@ -15994,7 +17730,7 @@ func (m *UserMutation) AddedIDs(name string) []ent.Value { // RemovedEdges returns all edge names that were removed in this mutation. func (m *UserMutation) RemovedEdges() []string { - edges := make([]string, 0, 8) + edges := make([]string, 0, 9) if m.removedapi_keys != nil { edges = append(edges, user.EdgeAPIKeys) } @@ -16007,6 +17743,9 @@ func (m *UserMutation) RemovedEdges() []string { if m.removedassigned_subscriptions != nil { edges = append(edges, user.EdgeAssignedSubscriptions) } + if m.removedannouncement_reads != nil { + edges = append(edges, user.EdgeAnnouncementReads) + } if m.removedallowed_groups != nil { edges = append(edges, user.EdgeAllowedGroups) } @@ -16050,6 +17789,12 @@ func (m *UserMutation) RemovedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case user.EdgeAnnouncementReads: + ids := make([]ent.Value, 0, len(m.removedannouncement_reads)) + for id := range m.removedannouncement_reads { + ids = append(ids, id) + } + return ids case user.EdgeAllowedGroups: ids := make([]ent.Value, 0, len(m.removedallowed_groups)) for id := range m.removedallowed_groups { @@ -16080,7 +17825,7 @@ func (m *UserMutation) RemovedIDs(name string) []ent.Value { // ClearedEdges returns all edge names that were cleared in this mutation. func (m *UserMutation) ClearedEdges() []string { - edges := make([]string, 0, 8) + edges := make([]string, 0, 9) if m.clearedapi_keys { edges = append(edges, user.EdgeAPIKeys) } @@ -16093,6 +17838,9 @@ func (m *UserMutation) ClearedEdges() []string { if m.clearedassigned_subscriptions { edges = append(edges, user.EdgeAssignedSubscriptions) } + if m.clearedannouncement_reads { + edges = append(edges, user.EdgeAnnouncementReads) + } if m.clearedallowed_groups { edges = append(edges, user.EdgeAllowedGroups) } @@ -16120,6 +17868,8 @@ func (m *UserMutation) EdgeCleared(name string) bool { return m.clearedsubscriptions case user.EdgeAssignedSubscriptions: return m.clearedassigned_subscriptions + case user.EdgeAnnouncementReads: + return m.clearedannouncement_reads case user.EdgeAllowedGroups: return m.clearedallowed_groups case user.EdgeUsageLogs: @@ -16156,6 +17906,9 @@ func (m *UserMutation) ResetEdge(name string) error { case user.EdgeAssignedSubscriptions: m.ResetAssignedSubscriptions() return nil + case user.EdgeAnnouncementReads: + m.ResetAnnouncementReads() + return nil case user.EdgeAllowedGroups: m.ResetAllowedGroups() return nil diff --git a/backend/ent/predicate/predicate.go b/backend/ent/predicate/predicate.go index 785cb4e6..613c5913 100644 --- a/backend/ent/predicate/predicate.go +++ b/backend/ent/predicate/predicate.go @@ -15,6 +15,12 @@ type Account func(*sql.Selector) // AccountGroup is the predicate function for accountgroup builders. type AccountGroup func(*sql.Selector) +// Announcement is the predicate function for announcement builders. +type Announcement func(*sql.Selector) + +// AnnouncementRead is the predicate function for announcementread builders. +type AnnouncementRead func(*sql.Selector) + // Group is the predicate function for group builders. type Group func(*sql.Selector) diff --git a/backend/ent/runtime/runtime.go b/backend/ent/runtime/runtime.go index 14323f8c..ae4eece8 100644 --- a/backend/ent/runtime/runtime.go +++ b/backend/ent/runtime/runtime.go @@ -7,6 +7,8 @@ import ( "github.com/Wei-Shaw/sub2api/ent/account" "github.com/Wei-Shaw/sub2api/ent/accountgroup" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/ent/announcementread" "github.com/Wei-Shaw/sub2api/ent/apikey" "github.com/Wei-Shaw/sub2api/ent/group" "github.com/Wei-Shaw/sub2api/ent/promocode" @@ -210,6 +212,56 @@ func init() { accountgroupDescCreatedAt := accountgroupFields[3].Descriptor() // accountgroup.DefaultCreatedAt holds the default value on creation for the created_at field. accountgroup.DefaultCreatedAt = accountgroupDescCreatedAt.Default.(func() time.Time) + announcementFields := schema.Announcement{}.Fields() + _ = announcementFields + // announcementDescTitle is the schema descriptor for title field. + announcementDescTitle := announcementFields[0].Descriptor() + // announcement.TitleValidator is a validator for the "title" field. It is called by the builders before save. + announcement.TitleValidator = func() func(string) error { + validators := announcementDescTitle.Validators + fns := [...]func(string) error{ + validators[0].(func(string) error), + validators[1].(func(string) error), + } + return func(title string) error { + for _, fn := range fns { + if err := fn(title); err != nil { + return err + } + } + return nil + } + }() + // announcementDescContent is the schema descriptor for content field. + announcementDescContent := announcementFields[1].Descriptor() + // announcement.ContentValidator is a validator for the "content" field. It is called by the builders before save. + announcement.ContentValidator = announcementDescContent.Validators[0].(func(string) error) + // announcementDescStatus is the schema descriptor for status field. + announcementDescStatus := announcementFields[2].Descriptor() + // announcement.DefaultStatus holds the default value on creation for the status field. + announcement.DefaultStatus = announcementDescStatus.Default.(string) + // announcement.StatusValidator is a validator for the "status" field. It is called by the builders before save. + announcement.StatusValidator = announcementDescStatus.Validators[0].(func(string) error) + // announcementDescCreatedAt is the schema descriptor for created_at field. + announcementDescCreatedAt := announcementFields[8].Descriptor() + // announcement.DefaultCreatedAt holds the default value on creation for the created_at field. + announcement.DefaultCreatedAt = announcementDescCreatedAt.Default.(func() time.Time) + // announcementDescUpdatedAt is the schema descriptor for updated_at field. + announcementDescUpdatedAt := announcementFields[9].Descriptor() + // announcement.DefaultUpdatedAt holds the default value on creation for the updated_at field. + announcement.DefaultUpdatedAt = announcementDescUpdatedAt.Default.(func() time.Time) + // announcement.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field. + announcement.UpdateDefaultUpdatedAt = announcementDescUpdatedAt.UpdateDefault.(func() time.Time) + announcementreadFields := schema.AnnouncementRead{}.Fields() + _ = announcementreadFields + // announcementreadDescReadAt is the schema descriptor for read_at field. + announcementreadDescReadAt := announcementreadFields[2].Descriptor() + // announcementread.DefaultReadAt holds the default value on creation for the read_at field. + announcementread.DefaultReadAt = announcementreadDescReadAt.Default.(func() time.Time) + // announcementreadDescCreatedAt is the schema descriptor for created_at field. + announcementreadDescCreatedAt := announcementreadFields[3].Descriptor() + // announcementread.DefaultCreatedAt holds the default value on creation for the created_at field. + announcementread.DefaultCreatedAt = announcementreadDescCreatedAt.Default.(func() time.Time) groupMixin := schema.Group{}.Mixin() groupMixinHooks1 := groupMixin[1].Hooks() group.Hooks[0] = groupMixinHooks1[0] diff --git a/backend/ent/schema/account.go b/backend/ent/schema/account.go index dd79ba96..1cfecc2d 100644 --- a/backend/ent/schema/account.go +++ b/backend/ent/schema/account.go @@ -4,7 +4,7 @@ package schema import ( "github.com/Wei-Shaw/sub2api/ent/schema/mixins" - "github.com/Wei-Shaw/sub2api/internal/service" + "github.com/Wei-Shaw/sub2api/internal/domain" "entgo.io/ent" "entgo.io/ent/dialect" @@ -111,7 +111,7 @@ func (Account) Fields() []ent.Field { // status: 账户状态，如 "active", "error", "disabled" field.String("status"). MaxLen(20). - Default(service.StatusActive), + Default(domain.StatusActive), // error_message: 错误信息，记录账户异常时的详细信息 field.String("error_message"). diff --git a/backend/ent/schema/announcement.go b/backend/ent/schema/announcement.go new file mode 100644 index 00000000..3b534831 --- /dev/null +++ b/backend/ent/schema/announcement.go @@ -0,0 +1,91 @@ +package schema + +import ( + "time" + + "github.com/Wei-Shaw/sub2api/internal/domain" + + "entgo.io/ent" + "entgo.io/ent/dialect" + "entgo.io/ent/dialect/entsql" + "entgo.io/ent/schema" + "entgo.io/ent/schema/edge" + "entgo.io/ent/schema/field" + "entgo.io/ent/schema/index" +) + +// Announcement holds the schema definition for the Announcement entity. +// +// 删除策略：硬删除（已读记录通过外键级联删除） +type Announcement struct { + ent.Schema +} + +func (Announcement) Annotations() []schema.Annotation { + return []schema.Annotation{ + entsql.Annotation{Table: "announcements"}, + } +} + +func (Announcement) Fields() []ent.Field { + return []ent.Field{ + field.String("title"). + MaxLen(200). + NotEmpty(). + Comment("公告标题"), + field.String("content"). + SchemaType(map[string]string{dialect.Postgres: "text"}). + NotEmpty(). + Comment("公告内容（支持 Markdown）"), + field.String("status"). + MaxLen(20). + Default(domain.AnnouncementStatusDraft). + Comment("状态: draft, active, archived"), + field.JSON("targeting", domain.AnnouncementTargeting{}). + Optional(). + SchemaType(map[string]string{dialect.Postgres: "jsonb"}). + Comment("展示条件（JSON 规则）"), + field.Time("starts_at"). + Optional(). + Nillable(). + SchemaType(map[string]string{dialect.Postgres: "timestamptz"}). + Comment("开始展示时间（为空表示立即生效）"), + field.Time("ends_at"). + Optional(). + Nillable(). + SchemaType(map[string]string{dialect.Postgres: "timestamptz"}). + Comment("结束展示时间（为空表示永久生效）"), + field.Int64("created_by"). + Optional(). + Nillable(). + Comment("创建人用户ID（管理员）"), + field.Int64("updated_by"). + Optional(). + Nillable(). + Comment("更新人用户ID（管理员）"), + field.Time("created_at"). + Immutable(). + Default(time.Now). + SchemaType(map[string]string{dialect.Postgres: "timestamptz"}), + field.Time("updated_at"). + Default(time.Now). + UpdateDefault(time.Now). + SchemaType(map[string]string{dialect.Postgres: "timestamptz"}), + } +} + +func (Announcement) Edges() []ent.Edge { + return []ent.Edge{ + edge.To("reads", AnnouncementRead.Type), + } +} + +func (Announcement) Indexes() []ent.Index { + return []ent.Index{ + index.Fields("status"), + index.Fields("created_at"), + index.Fields("starts_at"), + index.Fields("ends_at"), + } +} + diff --git a/backend/ent/schema/announcement_read.go b/backend/ent/schema/announcement_read.go new file mode 100644 index 00000000..2f80d8b2 --- /dev/null +++ b/backend/ent/schema/announcement_read.go @@ -0,0 +1,66 @@ +package schema + +import ( + "time" + + "entgo.io/ent" + "entgo.io/ent/dialect" + "entgo.io/ent/dialect/entsql" + "entgo.io/ent/schema" + "entgo.io/ent/schema/edge" + "entgo.io/ent/schema/field" + "entgo.io/ent/schema/index" +) + +// AnnouncementRead holds the schema definition for the AnnouncementRead entity. +// +// 记录用户对公告的已读状态（首次已读时间）。 +type AnnouncementRead struct { + ent.Schema +} + +func (AnnouncementRead) Annotations() []schema.Annotation { + return []schema.Annotation{ + entsql.Annotation{Table: "announcement_reads"}, + } +} + +func (AnnouncementRead) Fields() []ent.Field { + return []ent.Field{ + field.Int64("announcement_id"), + field.Int64("user_id"), + field.Time("read_at"). + Default(time.Now). + SchemaType(map[string]string{dialect.Postgres: "timestamptz"}). + Comment("用户首次已读时间"), + field.Time("created_at"). + Immutable(). + Default(time.Now). + SchemaType(map[string]string{dialect.Postgres: "timestamptz"}), + } +} + +func (AnnouncementRead) Edges() []ent.Edge { + return []ent.Edge{ + edge.From("announcement", Announcement.Type). + Ref("reads"). + Field("announcement_id"). + Unique(). + Required(), + edge.From("user", User.Type). + Ref("announcement_reads"). + Field("user_id"). + Unique(). + Required(), + } +} + +func (AnnouncementRead) Indexes() []ent.Index { + return []ent.Index{ + index.Fields("announcement_id"), + index.Fields("user_id"), + index.Fields("read_at"), + index.Fields("announcement_id", "user_id").Unique(), + } +} + diff --git a/backend/ent/schema/api_key.go b/backend/ent/schema/api_key.go index 1b206089..1c2d4bd4 100644 --- a/backend/ent/schema/api_key.go +++ b/backend/ent/schema/api_key.go @@ -2,7 +2,7 @@ package schema import ( "github.com/Wei-Shaw/sub2api/ent/schema/mixins" - "github.com/Wei-Shaw/sub2api/internal/service" + "github.com/Wei-Shaw/sub2api/internal/domain" "entgo.io/ent" "entgo.io/ent/dialect/entsql" @@ -45,7 +45,7 @@ func (APIKey) Fields() []ent.Field { Nillable(), field.String("status"). MaxLen(20). - Default(service.StatusActive), + Default(domain.StatusActive), field.JSON("ip_whitelist", []string{}). Optional(). Comment("Allowed IPs/CIDRs, e.g. [\"192.168.1.100\", \"10.0.0.0/8\"]"), diff --git a/backend/ent/schema/group.go b/backend/ent/schema/group.go index 5d0a1e9a..ccd72eac 100644 --- a/backend/ent/schema/group.go +++ b/backend/ent/schema/group.go @@ -2,7 +2,7 @@ package schema import ( "github.com/Wei-Shaw/sub2api/ent/schema/mixins" - "github.com/Wei-Shaw/sub2api/internal/service" + "github.com/Wei-Shaw/sub2api/internal/domain" "entgo.io/ent" "entgo.io/ent/dialect" @@ -49,15 +49,15 @@ func (Group) Fields() []ent.Field { Default(false), field.String("status"). MaxLen(20). - Default(service.StatusActive), + Default(domain.StatusActive), // Subscription-related fields (added by migration 003) field.String("platform"). MaxLen(50). - Default(service.PlatformAnthropic), + Default(domain.PlatformAnthropic), field.String("subscription_type"). MaxLen(20). - Default(service.SubscriptionTypeStandard), + Default(domain.SubscriptionTypeStandard), field.Float("daily_limit_usd"). Optional(). Nillable(). diff --git a/backend/ent/schema/promo_code.go b/backend/ent/schema/promo_code.go index c3bb824b..3dd08c0e 100644 --- a/backend/ent/schema/promo_code.go +++ b/backend/ent/schema/promo_code.go @@ -3,7 +3,7 @@ package schema import ( "time" - "github.com/Wei-Shaw/sub2api/internal/service" + "github.com/Wei-Shaw/sub2api/internal/domain" "entgo.io/ent" "entgo.io/ent/dialect" @@ -49,7 +49,7 @@ func (PromoCode) Fields() []ent.Field { Comment("已使用次数"), field.String("status"). MaxLen(20). - Default(service.PromoCodeStatusActive). + Default(domain.PromoCodeStatusActive). Comment("状态: active, disabled"), field.Time("expires_at"). Optional(). diff --git a/backend/ent/schema/redeem_code.go b/backend/ent/schema/redeem_code.go index b4664e06..6fb86148 100644 --- a/backend/ent/schema/redeem_code.go +++ b/backend/ent/schema/redeem_code.go @@ -3,7 +3,7 @@ package schema import ( "time" - "github.com/Wei-Shaw/sub2api/internal/service" + "github.com/Wei-Shaw/sub2api/internal/domain" "entgo.io/ent" "entgo.io/ent/dialect" @@ -41,13 +41,13 @@ func (RedeemCode) Fields() []ent.Field { Unique(), field.String("type"). MaxLen(20). - Default(service.RedeemTypeBalance), + Default(domain.RedeemTypeBalance), field.Float("value"). SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}). Default(0), field.String("status"). MaxLen(20). - Default(service.StatusUnused), + Default(domain.StatusUnused), field.Int64("used_by"). Optional(). Nillable(), diff --git a/backend/ent/schema/user.go b/backend/ent/schema/user.go index 335c1cc8..d443ef45 100644 --- a/backend/ent/schema/user.go +++ b/backend/ent/schema/user.go @@ -2,7 +2,7 @@ package schema import ( "github.com/Wei-Shaw/sub2api/ent/schema/mixins" - "github.com/Wei-Shaw/sub2api/internal/service" + "github.com/Wei-Shaw/sub2api/internal/domain" "entgo.io/ent" "entgo.io/ent/dialect" @@ -43,7 +43,7 @@ func (User) Fields() []ent.Field { NotEmpty(), field.String("role"). MaxLen(20). - Default(service.RoleUser), + Default(domain.RoleUser), field.Float("balance"). SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}). Default(0), @@ -51,7 +51,7 @@ func (User) Fields() []ent.Field { Default(5), field.String("status"). MaxLen(20). - Default(service.StatusActive), + Default(domain.StatusActive), // Optional profile fields (added later; default '' in DB migration) field.String("username"). @@ -81,6 +81,7 @@ func (User) Edges() []ent.Edge { edge.To("redeem_codes", RedeemCode.Type), edge.To("subscriptions", UserSubscription.Type), edge.To("assigned_subscriptions", UserSubscription.Type), + edge.To("announcement_reads", AnnouncementRead.Type), edge.To("allowed_groups", Group.Type). Through("user_allowed_groups", UserAllowedGroup.Type), edge.To("usage_logs", UsageLog.Type), diff --git a/backend/ent/schema/user_subscription.go b/backend/ent/schema/user_subscription.go index b21f4083..fa13612b 100644 --- a/backend/ent/schema/user_subscription.go +++ b/backend/ent/schema/user_subscription.go @@ -4,7 +4,7 @@ import ( "time" "github.com/Wei-Shaw/sub2api/ent/schema/mixins" - "github.com/Wei-Shaw/sub2api/internal/service" + "github.com/Wei-Shaw/sub2api/internal/domain" "entgo.io/ent" "entgo.io/ent/dialect" @@ -44,7 +44,7 @@ func (UserSubscription) Fields() []ent.Field { SchemaType(map[string]string{dialect.Postgres: "timestamptz"}), field.String("status"). MaxLen(20). - Default(service.SubscriptionStatusActive), + Default(domain.SubscriptionStatusActive), field.Time("daily_window_start"). Optional(). diff --git a/backend/ent/tx.go b/backend/ent/tx.go index 7ff16ec8..702bdf90 100644 --- a/backend/ent/tx.go +++ b/backend/ent/tx.go @@ -20,6 +20,10 @@ type Tx struct { Account *AccountClient // AccountGroup is the client for interacting with the AccountGroup builders. AccountGroup *AccountGroupClient + // Announcement is the client for interacting with the Announcement builders. + Announcement *AnnouncementClient + // AnnouncementRead is the client for interacting with the AnnouncementRead builders. + AnnouncementRead *AnnouncementReadClient // Group is the client for interacting with the Group builders. Group *GroupClient // PromoCode is the client for interacting with the PromoCode builders. @@ -180,6 +184,8 @@ func (tx *Tx) init() { tx.APIKey = NewAPIKeyClient(tx.config) tx.Account = NewAccountClient(tx.config) tx.AccountGroup = NewAccountGroupClient(tx.config) + tx.Announcement = NewAnnouncementClient(tx.config) + tx.AnnouncementRead = NewAnnouncementReadClient(tx.config) tx.Group = NewGroupClient(tx.config) tx.PromoCode = NewPromoCodeClient(tx.config) tx.PromoCodeUsage = NewPromoCodeUsageClient(tx.config) diff --git a/backend/ent/user.go b/backend/ent/user.go index 82830a95..2435aa1b 100644 --- a/backend/ent/user.go +++ b/backend/ent/user.go @@ -61,6 +61,8 @@ type UserEdges struct { Subscriptions []*UserSubscription `json:"subscriptions,omitempty"` // AssignedSubscriptions holds the value of the assigned_subscriptions edge. AssignedSubscriptions []*UserSubscription `json:"assigned_subscriptions,omitempty"` + // AnnouncementReads holds the value of the announcement_reads edge. + AnnouncementReads []*AnnouncementRead `json:"announcement_reads,omitempty"` // AllowedGroups holds the value of the allowed_groups edge. AllowedGroups []*Group `json:"allowed_groups,omitempty"` // UsageLogs holds the value of the usage_logs edge. @@ -73,7 +75,7 @@ type UserEdges struct { UserAllowedGroups []*UserAllowedGroup `json:"user_allowed_groups,omitempty"` // loadedTypes holds the information for reporting if a // type was loaded (or requested) in eager-loading or not. - loadedTypes [9]bool + loadedTypes [10]bool } // APIKeysOrErr returns the APIKeys value or an error if the edge @@ -112,10 +114,19 @@ func (e UserEdges) AssignedSubscriptionsOrErr() ([]*UserSubscription, error) { return nil, &NotLoadedError{edge: "assigned_subscriptions"} } +// AnnouncementReadsOrErr returns the AnnouncementReads value or an error if the edge +// was not loaded in eager-loading. +func (e UserEdges) AnnouncementReadsOrErr() ([]*AnnouncementRead, error) { + if e.loadedTypes[4] { + return e.AnnouncementReads, nil + } + return nil, &NotLoadedError{edge: "announcement_reads"} +} + // AllowedGroupsOrErr returns the AllowedGroups value or an error if the edge // was not loaded in eager-loading. func (e UserEdges) AllowedGroupsOrErr() ([]*Group, error) { - if e.loadedTypes[4] { + if e.loadedTypes[5] { return e.AllowedGroups, nil } return nil, &NotLoadedError{edge: "allowed_groups"} @@ -124,7 +135,7 @@ func (e UserEdges) AllowedGroupsOrErr() ([]*Group, error) { // UsageLogsOrErr returns the UsageLogs value or an error if the edge // was not loaded in eager-loading. func (e UserEdges) UsageLogsOrErr() ([]*UsageLog, error) { - if e.loadedTypes[5] { + if e.loadedTypes[6] { return e.UsageLogs, nil } return nil, &NotLoadedError{edge: "usage_logs"} @@ -133,7 +144,7 @@ func (e UserEdges) UsageLogsOrErr() ([]*UsageLog, error) { // AttributeValuesOrErr returns the AttributeValues value or an error if the edge // was not loaded in eager-loading. func (e UserEdges) AttributeValuesOrErr() ([]*UserAttributeValue, error) { - if e.loadedTypes[6] { + if e.loadedTypes[7] { return e.AttributeValues, nil } return nil, &NotLoadedError{edge: "attribute_values"} @@ -142,7 +153,7 @@ func (e UserEdges) AttributeValuesOrErr() ([]*UserAttributeValue, error) { // PromoCodeUsagesOrErr returns the PromoCodeUsages value or an error if the edge // was not loaded in eager-loading. func (e UserEdges) PromoCodeUsagesOrErr() ([]*PromoCodeUsage, error) { - if e.loadedTypes[7] { + if e.loadedTypes[8] { return e.PromoCodeUsages, nil } return nil, &NotLoadedError{edge: "promo_code_usages"} @@ -151,7 +162,7 @@ func (e UserEdges) PromoCodeUsagesOrErr() ([]*PromoCodeUsage, error) { // UserAllowedGroupsOrErr returns the UserAllowedGroups value or an error if the edge // was not loaded in eager-loading. func (e UserEdges) UserAllowedGroupsOrErr() ([]*UserAllowedGroup, error) { - if e.loadedTypes[8] { + if e.loadedTypes[9] { return e.UserAllowedGroups, nil } return nil, &NotLoadedError{edge: "user_allowed_groups"} @@ -313,6 +324,11 @@ func (_m *User) QueryAssignedSubscriptions() *UserSubscriptionQuery { return NewUserClient(_m.config).QueryAssignedSubscriptions(_m) } +// QueryAnnouncementReads queries the "announcement_reads" edge of the User entity. +func (_m *User) QueryAnnouncementReads() *AnnouncementReadQuery { + return NewUserClient(_m.config).QueryAnnouncementReads(_m) +} + // QueryAllowedGroups queries the "allowed_groups" edge of the User entity. func (_m *User) QueryAllowedGroups() *GroupQuery { return NewUserClient(_m.config).QueryAllowedGroups(_m) diff --git a/backend/ent/user/user.go b/backend/ent/user/user.go index 0685ed72..ae9418ff 100644 --- a/backend/ent/user/user.go +++ b/backend/ent/user/user.go @@ -51,6 +51,8 @@ const ( EdgeSubscriptions = "subscriptions" // EdgeAssignedSubscriptions holds the string denoting the assigned_subscriptions edge name in mutations. EdgeAssignedSubscriptions = "assigned_subscriptions" + // EdgeAnnouncementReads holds the string denoting the announcement_reads edge name in mutations. + EdgeAnnouncementReads = "announcement_reads" // EdgeAllowedGroups holds the string denoting the allowed_groups edge name in mutations. EdgeAllowedGroups = "allowed_groups" // EdgeUsageLogs holds the string denoting the usage_logs edge name in mutations. @@ -91,6 +93,13 @@ const ( AssignedSubscriptionsInverseTable = "user_subscriptions" // AssignedSubscriptionsColumn is the table column denoting the assigned_subscriptions relation/edge. AssignedSubscriptionsColumn = "assigned_by" + // AnnouncementReadsTable is the table that holds the announcement_reads relation/edge. + AnnouncementReadsTable = "announcement_reads" + // AnnouncementReadsInverseTable is the table name for the AnnouncementRead entity. + // It exists in this package in order to avoid circular dependency with the "announcementread" package. + AnnouncementReadsInverseTable = "announcement_reads" + // AnnouncementReadsColumn is the table column denoting the announcement_reads relation/edge. + AnnouncementReadsColumn = "user_id" // AllowedGroupsTable is the table that holds the allowed_groups relation/edge. The primary key declared below. AllowedGroupsTable = "user_allowed_groups" // AllowedGroupsInverseTable is the table name for the Group entity. @@ -335,6 +344,20 @@ func ByAssignedSubscriptions(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOp } } +// ByAnnouncementReadsCount orders the results by announcement_reads count. +func ByAnnouncementReadsCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newAnnouncementReadsStep(), opts...) + } +} + +// ByAnnouncementReads orders the results by announcement_reads terms. +func ByAnnouncementReads(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newAnnouncementReadsStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} + // ByAllowedGroupsCount orders the results by allowed_groups count. func ByAllowedGroupsCount(opts ...sql.OrderTermOption) OrderOption { return func(s *sql.Selector) { @@ -432,6 +455,13 @@ func newAssignedSubscriptionsStep() *sqlgraph.Step { sqlgraph.Edge(sqlgraph.O2M, false, AssignedSubscriptionsTable, AssignedSubscriptionsColumn), ) } +func newAnnouncementReadsStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(AnnouncementReadsInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, AnnouncementReadsTable, AnnouncementReadsColumn), + ) +} func newAllowedGroupsStep() *sqlgraph.Step { return sqlgraph.NewStep( sqlgraph.From(Table, FieldID), diff --git a/backend/ent/user/where.go b/backend/ent/user/where.go index 3dc4fec7..1de61037 100644 --- a/backend/ent/user/where.go +++ b/backend/ent/user/where.go @@ -952,6 +952,29 @@ func HasAssignedSubscriptionsWith(preds ...predicate.UserSubscription) predicate }) } +// HasAnnouncementReads applies the HasEdge predicate on the "announcement_reads" edge. +func HasAnnouncementReads() predicate.User { + return predicate.User(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, AnnouncementReadsTable, AnnouncementReadsColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasAnnouncementReadsWith applies the HasEdge predicate on the "announcement_reads" edge with a given conditions (other predicates). +func HasAnnouncementReadsWith(preds ...predicate.AnnouncementRead) predicate.User { + return predicate.User(func(s *sql.Selector) { + step := newAnnouncementReadsStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + // HasAllowedGroups applies the HasEdge predicate on the "allowed_groups" edge. func HasAllowedGroups() predicate.User { return predicate.User(func(s *sql.Selector) { diff --git a/backend/ent/user_create.go b/backend/ent/user_create.go index 6b4ebc59..f862a580 100644 --- a/backend/ent/user_create.go +++ b/backend/ent/user_create.go @@ -11,6 +11,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/Wei-Shaw/sub2api/ent/announcementread" "github.com/Wei-Shaw/sub2api/ent/apikey" "github.com/Wei-Shaw/sub2api/ent/group" "github.com/Wei-Shaw/sub2api/ent/promocodeusage" @@ -269,6 +270,21 @@ func (_c *UserCreate) AddAssignedSubscriptions(v ...*UserSubscription) *UserCrea return _c.AddAssignedSubscriptionIDs(ids...) } +// AddAnnouncementReadIDs adds the "announcement_reads" edge to the AnnouncementRead entity by IDs. +func (_c *UserCreate) AddAnnouncementReadIDs(ids ...int64) *UserCreate { + _c.mutation.AddAnnouncementReadIDs(ids...) + return _c +} + +// AddAnnouncementReads adds the "announcement_reads" edges to the AnnouncementRead entity. +func (_c *UserCreate) AddAnnouncementReads(v ...*AnnouncementRead) *UserCreate { + ids := make([]int64, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddAnnouncementReadIDs(ids...) +} + // AddAllowedGroupIDs adds the "allowed_groups" edge to the Group entity by IDs. func (_c *UserCreate) AddAllowedGroupIDs(ids ...int64) *UserCreate { _c.mutation.AddAllowedGroupIDs(ids...) @@ -618,6 +634,22 @@ func (_c *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { } _spec.Edges = append(_spec.Edges, edge) } + if nodes := _c.mutation.AnnouncementReadsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.AnnouncementReadsTable, + Columns: []string{user.AnnouncementReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } if nodes := _c.mutation.AllowedGroupsIDs(); len(nodes) > 0 { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.M2M, diff --git a/backend/ent/user_query.go b/backend/ent/user_query.go index e66e2dc8..4b56e16f 100644 --- a/backend/ent/user_query.go +++ b/backend/ent/user_query.go @@ -13,6 +13,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/Wei-Shaw/sub2api/ent/announcementread" "github.com/Wei-Shaw/sub2api/ent/apikey" "github.com/Wei-Shaw/sub2api/ent/group" "github.com/Wei-Shaw/sub2api/ent/predicate" @@ -36,6 +37,7 @@ type UserQuery struct { withRedeemCodes *RedeemCodeQuery withSubscriptions *UserSubscriptionQuery withAssignedSubscriptions *UserSubscriptionQuery + withAnnouncementReads *AnnouncementReadQuery withAllowedGroups *GroupQuery withUsageLogs *UsageLogQuery withAttributeValues *UserAttributeValueQuery @@ -166,6 +168,28 @@ func (_q *UserQuery) QueryAssignedSubscriptions() *UserSubscriptionQuery { return query } +// QueryAnnouncementReads chains the current query on the "announcement_reads" edge. +func (_q *UserQuery) QueryAnnouncementReads() *AnnouncementReadQuery { + query := (&AnnouncementReadClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(user.Table, user.FieldID, selector), + sqlgraph.To(announcementread.Table, announcementread.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, user.AnnouncementReadsTable, user.AnnouncementReadsColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + // QueryAllowedGroups chains the current query on the "allowed_groups" edge. func (_q *UserQuery) QueryAllowedGroups() *GroupQuery { query := (&GroupClient{config: _q.config}).Query() @@ -472,6 +496,7 @@ func (_q *UserQuery) Clone() *UserQuery { withRedeemCodes: _q.withRedeemCodes.Clone(), withSubscriptions: _q.withSubscriptions.Clone(), withAssignedSubscriptions: _q.withAssignedSubscriptions.Clone(), + withAnnouncementReads: _q.withAnnouncementReads.Clone(), withAllowedGroups: _q.withAllowedGroups.Clone(), withUsageLogs: _q.withUsageLogs.Clone(), withAttributeValues: _q.withAttributeValues.Clone(), @@ -527,6 +552,17 @@ func (_q *UserQuery) WithAssignedSubscriptions(opts ...func(*UserSubscriptionQue return _q } +// WithAnnouncementReads tells the query-builder to eager-load the nodes that are connected to +// the "announcement_reads" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *UserQuery) WithAnnouncementReads(opts ...func(*AnnouncementReadQuery)) *UserQuery { + query := (&AnnouncementReadClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withAnnouncementReads = query + return _q +} + // WithAllowedGroups tells the query-builder to eager-load the nodes that are connected to // the "allowed_groups" edge. The optional arguments are used to configure the query builder of the edge. func (_q *UserQuery) WithAllowedGroups(opts ...func(*GroupQuery)) *UserQuery { @@ -660,11 +696,12 @@ func (_q *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e var ( nodes = []*User{} _spec = _q.querySpec() - loadedTypes = [9]bool{ + loadedTypes = [10]bool{ _q.withAPIKeys != nil, _q.withRedeemCodes != nil, _q.withSubscriptions != nil, _q.withAssignedSubscriptions != nil, + _q.withAnnouncementReads != nil, _q.withAllowedGroups != nil, _q.withUsageLogs != nil, _q.withAttributeValues != nil, @@ -723,6 +760,13 @@ func (_q *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e return nil, err } } + if query := _q.withAnnouncementReads; query != nil { + if err := _q.loadAnnouncementReads(ctx, query, nodes, + func(n *User) { n.Edges.AnnouncementReads = []*AnnouncementRead{} }, + func(n *User, e *AnnouncementRead) { n.Edges.AnnouncementReads = append(n.Edges.AnnouncementReads, e) }); err != nil { + return nil, err + } + } if query := _q.withAllowedGroups; query != nil { if err := _q.loadAllowedGroups(ctx, query, nodes, func(n *User) { n.Edges.AllowedGroups = []*Group{} }, @@ -887,6 +931,36 @@ func (_q *UserQuery) loadAssignedSubscriptions(ctx context.Context, query *UserS } return nil } +func (_q *UserQuery) loadAnnouncementReads(ctx context.Context, query *AnnouncementReadQuery, nodes []*User, init func(*User), assign func(*User, *AnnouncementRead)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[int64]*User) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(announcementread.FieldUserID) + } + query.Where(predicate.AnnouncementRead(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(user.AnnouncementReadsColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.UserID + node, ok := nodeids[fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID) + } + assign(node, n) + } + return nil +} func (_q *UserQuery) loadAllowedGroups(ctx context.Context, query *GroupQuery, nodes []*User, init func(*User), assign func(*User, *Group)) error { edgeIDs := make([]driver.Value, len(nodes)) byID := make(map[int64]*User) diff --git a/backend/ent/user_update.go b/backend/ent/user_update.go index b98a41c6..80222c92 100644 --- a/backend/ent/user_update.go +++ b/backend/ent/user_update.go @@ -11,6 +11,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/Wei-Shaw/sub2api/ent/announcementread" "github.com/Wei-Shaw/sub2api/ent/apikey" "github.com/Wei-Shaw/sub2api/ent/group" "github.com/Wei-Shaw/sub2api/ent/predicate" @@ -301,6 +302,21 @@ func (_u *UserUpdate) AddAssignedSubscriptions(v ...*UserSubscription) *UserUpda return _u.AddAssignedSubscriptionIDs(ids...) } +// AddAnnouncementReadIDs adds the "announcement_reads" edge to the AnnouncementRead entity by IDs. +func (_u *UserUpdate) AddAnnouncementReadIDs(ids ...int64) *UserUpdate { + _u.mutation.AddAnnouncementReadIDs(ids...) + return _u +} + +// AddAnnouncementReads adds the "announcement_reads" edges to the AnnouncementRead entity. +func (_u *UserUpdate) AddAnnouncementReads(v ...*AnnouncementRead) *UserUpdate { + ids := make([]int64, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddAnnouncementReadIDs(ids...) +} + // AddAllowedGroupIDs adds the "allowed_groups" edge to the Group entity by IDs. func (_u *UserUpdate) AddAllowedGroupIDs(ids ...int64) *UserUpdate { _u.mutation.AddAllowedGroupIDs(ids...) @@ -450,6 +466,27 @@ func (_u *UserUpdate) RemoveAssignedSubscriptions(v ...*UserSubscription) *UserU return _u.RemoveAssignedSubscriptionIDs(ids...) } +// ClearAnnouncementReads clears all "announcement_reads" edges to the AnnouncementRead entity. +func (_u *UserUpdate) ClearAnnouncementReads() *UserUpdate { + _u.mutation.ClearAnnouncementReads() + return _u +} + +// RemoveAnnouncementReadIDs removes the "announcement_reads" edge to AnnouncementRead entities by IDs. +func (_u *UserUpdate) RemoveAnnouncementReadIDs(ids ...int64) *UserUpdate { + _u.mutation.RemoveAnnouncementReadIDs(ids...) + return _u +} + +// RemoveAnnouncementReads removes "announcement_reads" edges to AnnouncementRead entities. +func (_u *UserUpdate) RemoveAnnouncementReads(v ...*AnnouncementRead) *UserUpdate { + ids := make([]int64, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveAnnouncementReadIDs(ids...) +} + // ClearAllowedGroups clears all "allowed_groups" edges to the Group entity. func (_u *UserUpdate) ClearAllowedGroups() *UserUpdate { _u.mutation.ClearAllowedGroups() @@ -852,6 +889,51 @@ func (_u *UserUpdate) sqlSave(ctx context.Context) (_node int, err error) { } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if _u.mutation.AnnouncementReadsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.AnnouncementReadsTable, + Columns: []string{user.AnnouncementReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedAnnouncementReadsIDs(); len(nodes) > 0 && !_u.mutation.AnnouncementReadsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.AnnouncementReadsTable, + Columns: []string{user.AnnouncementReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.AnnouncementReadsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.AnnouncementReadsTable, + Columns: []string{user.AnnouncementReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } if _u.mutation.AllowedGroupsCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.M2M, @@ -1330,6 +1412,21 @@ func (_u *UserUpdateOne) AddAssignedSubscriptions(v ...*UserSubscription) *UserU return _u.AddAssignedSubscriptionIDs(ids...) } +// AddAnnouncementReadIDs adds the "announcement_reads" edge to the AnnouncementRead entity by IDs. +func (_u *UserUpdateOne) AddAnnouncementReadIDs(ids ...int64) *UserUpdateOne { + _u.mutation.AddAnnouncementReadIDs(ids...) + return _u +} + +// AddAnnouncementReads adds the "announcement_reads" edges to the AnnouncementRead entity. +func (_u *UserUpdateOne) AddAnnouncementReads(v ...*AnnouncementRead) *UserUpdateOne { + ids := make([]int64, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddAnnouncementReadIDs(ids...) +} + // AddAllowedGroupIDs adds the "allowed_groups" edge to the Group entity by IDs. func (_u *UserUpdateOne) AddAllowedGroupIDs(ids ...int64) *UserUpdateOne { _u.mutation.AddAllowedGroupIDs(ids...) @@ -1479,6 +1576,27 @@ func (_u *UserUpdateOne) RemoveAssignedSubscriptions(v ...*UserSubscription) *Us return _u.RemoveAssignedSubscriptionIDs(ids...) } +// ClearAnnouncementReads clears all "announcement_reads" edges to the AnnouncementRead entity. +func (_u *UserUpdateOne) ClearAnnouncementReads() *UserUpdateOne { + _u.mutation.ClearAnnouncementReads() + return _u +} + +// RemoveAnnouncementReadIDs removes the "announcement_reads" edge to AnnouncementRead entities by IDs. +func (_u *UserUpdateOne) RemoveAnnouncementReadIDs(ids ...int64) *UserUpdateOne { + _u.mutation.RemoveAnnouncementReadIDs(ids...) + return _u +} + +// RemoveAnnouncementReads removes "announcement_reads" edges to AnnouncementRead entities. +func (_u *UserUpdateOne) RemoveAnnouncementReads(v ...*AnnouncementRead) *UserUpdateOne { + ids := make([]int64, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveAnnouncementReadIDs(ids...) +} + // ClearAllowedGroups clears all "allowed_groups" edges to the Group entity. func (_u *UserUpdateOne) ClearAllowedGroups() *UserUpdateOne { _u.mutation.ClearAllowedGroups() @@ -1911,6 +2029,51 @@ func (_u *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) { } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if _u.mutation.AnnouncementReadsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.AnnouncementReadsTable, + Columns: []string{user.AnnouncementReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedAnnouncementReadsIDs(); len(nodes) > 0 && !_u.mutation.AnnouncementReadsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.AnnouncementReadsTable, + Columns: []string{user.AnnouncementReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.AnnouncementReadsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.AnnouncementReadsTable, + Columns: []string{user.AnnouncementReadsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } if _u.mutation.AllowedGroupsCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.M2M, diff --git a/backend/internal/domain/announcement.go b/backend/internal/domain/announcement.go new file mode 100644 index 00000000..7dc9a9cc --- /dev/null +++ b/backend/internal/domain/announcement.go @@ -0,0 +1,226 @@ +package domain + +import ( + "strings" + "time" + + infraerrors "github.com/Wei-Shaw/sub2api/internal/pkg/errors" +) + +const ( + AnnouncementStatusDraft = "draft" + AnnouncementStatusActive = "active" + AnnouncementStatusArchived = "archived" +) + +const ( + AnnouncementConditionTypeSubscription = "subscription" + AnnouncementConditionTypeBalance = "balance" +) + +const ( + AnnouncementOperatorIn = "in" + AnnouncementOperatorGT = "gt" + AnnouncementOperatorGTE = "gte" + AnnouncementOperatorLT = "lt" + AnnouncementOperatorLTE = "lte" + AnnouncementOperatorEQ = "eq" +) + +var ( + ErrAnnouncementNotFound = infraerrors.NotFound("ANNOUNCEMENT_NOT_FOUND", "announcement not found") + ErrAnnouncementInvalidTarget = infraerrors.BadRequest("ANNOUNCEMENT_INVALID_TARGET", "invalid announcement targeting rules") +) + +type AnnouncementTargeting struct { + // AnyOf 表示 OR：任意一个条件组满足即可展示。 + AnyOf []AnnouncementConditionGroup `json:"any_of,omitempty"` +} + +type AnnouncementConditionGroup struct { + // AllOf 表示 AND：组内所有条件都满足才算命中该组。 + AllOf []AnnouncementCondition `json:"all_of,omitempty"` +} + +type AnnouncementCondition struct { + // Type: subscription | balance + Type string `json:"type"` + + // Operator: + // - subscription: in + // - balance: gt/gte/lt/lte/eq + Operator string `json:"operator"` + + // subscription 条件：匹配的订阅套餐（group_id） + GroupIDs []int64 `json:"group_ids,omitempty"` + + // balance 条件：比较阈值 + Value float64 `json:"value,omitempty"` +} + +func (t AnnouncementTargeting) Matches(balance float64, activeSubscriptionGroupIDs map[int64]struct{}) bool { + // 空规则：展示给所有用户 + if len(t.AnyOf) == 0 { + return true + } + + for _, group := range t.AnyOf { + if len(group.AllOf) == 0 { + // 空条件组不命中（避免 OR 中出现无条件 “全命中”） + continue + } + allMatched := true + for _, cond := range group.AllOf { + if !cond.Matches(balance, activeSubscriptionGroupIDs) { + allMatched = false + break + } + } + if allMatched { + return true + } + } + + return false +} + +func (c AnnouncementCondition) Matches(balance float64, activeSubscriptionGroupIDs map[int64]struct{}) bool { + switch c.Type { + case AnnouncementConditionTypeSubscription: + if c.Operator != AnnouncementOperatorIn { + return false + } + if len(c.GroupIDs) == 0 { + return false + } + if len(activeSubscriptionGroupIDs) == 0 { + return false + } + for _, gid := range c.GroupIDs { + if _, ok := activeSubscriptionGroupIDs[gid]; ok { + return true + } + } + return false + + case AnnouncementConditionTypeBalance: + switch c.Operator { + case AnnouncementOperatorGT: + return balance > c.Value + case AnnouncementOperatorGTE: + return balance >= c.Value + case AnnouncementOperatorLT: + return balance < c.Value + case AnnouncementOperatorLTE: + return balance <= c.Value + case AnnouncementOperatorEQ: + return balance == c.Value + default: + return false + } + + default: + return false + } +} + +func (t AnnouncementTargeting) NormalizeAndValidate() (AnnouncementTargeting, error) { + normalized := AnnouncementTargeting{AnyOf: make([]AnnouncementConditionGroup, 0, len(t.AnyOf))} + + // 允许空 targeting（展示给所有用户） + if len(t.AnyOf) == 0 { + return normalized, nil + } + + if len(t.AnyOf) > 50 { + return AnnouncementTargeting{}, ErrAnnouncementInvalidTarget + } + + for _, g := range t.AnyOf { + if len(g.AllOf) == 0 { + return AnnouncementTargeting{}, ErrAnnouncementInvalidTarget + } + if len(g.AllOf) > 50 { + return AnnouncementTargeting{}, ErrAnnouncementInvalidTarget + } + + group := AnnouncementConditionGroup{AllOf: make([]AnnouncementCondition, 0, len(g.AllOf))} + for _, c := range g.AllOf { + cond := AnnouncementCondition{ + Type: strings.TrimSpace(c.Type), + Operator: strings.TrimSpace(c.Operator), + Value: c.Value, + } + for _, gid := range c.GroupIDs { + if gid <= 0 { + return AnnouncementTargeting{}, ErrAnnouncementInvalidTarget + } + cond.GroupIDs = append(cond.GroupIDs, gid) + } + + if err := cond.validate(); err != nil { + return AnnouncementTargeting{}, err + } + group.AllOf = append(group.AllOf, cond) + } + + normalized.AnyOf = append(normalized.AnyOf, group) + } + + return normalized, nil +} + +func (c AnnouncementCondition) validate() error { + switch c.Type { + case AnnouncementConditionTypeSubscription: + if c.Operator != AnnouncementOperatorIn { + return ErrAnnouncementInvalidTarget + } + if len(c.GroupIDs) == 0 { + return ErrAnnouncementInvalidTarget + } + return nil + + case AnnouncementConditionTypeBalance: + switch c.Operator { + case AnnouncementOperatorGT, AnnouncementOperatorGTE, AnnouncementOperatorLT, AnnouncementOperatorLTE, AnnouncementOperatorEQ: + return nil + default: + return ErrAnnouncementInvalidTarget + } + + default: + return ErrAnnouncementInvalidTarget + } +} + +type Announcement struct { + ID int64 + Title string + Content string + Status string + Targeting AnnouncementTargeting + StartsAt *time.Time + EndsAt *time.Time + CreatedBy *int64 + UpdatedBy *int64 + CreatedAt time.Time + UpdatedAt time.Time +} + +func (a *Announcement) IsActiveAt(now time.Time) bool { + if a == nil { + return false + } + if a.Status != AnnouncementStatusActive { + return false + } + if a.StartsAt != nil && now.Before(*a.StartsAt) { + return false + } + if a.EndsAt != nil && !now.Before(*a.EndsAt) { + // ends_at 语义：到点即下线 + return false + } + return true +} diff --git a/backend/internal/domain/constants.go b/backend/internal/domain/constants.go new file mode 100644 index 00000000..4ecea9d8 --- /dev/null +++ b/backend/internal/domain/constants.go @@ -0,0 +1,64 @@ +package domain + +// Status constants +const ( + StatusActive = "active" + StatusDisabled = "disabled" + StatusError = "error" + StatusUnused = "unused" + StatusUsed = "used" + StatusExpired = "expired" +) + +// Role constants +const ( + RoleAdmin = "admin" + RoleUser = "user" +) + +// Platform constants +const ( + PlatformAnthropic = "anthropic" + PlatformOpenAI = "openai" + PlatformGemini = "gemini" + PlatformAntigravity = "antigravity" +) + +// Account type constants +const ( + AccountTypeOAuth = "oauth" // OAuth类型账号（full scope: profile + inference） + AccountTypeSetupToken = "setup-token" // Setup Token类型账号（inference only scope） + AccountTypeAPIKey = "apikey" // API Key类型账号 +) + +// Redeem type constants +const ( + RedeemTypeBalance = "balance" + RedeemTypeConcurrency = "concurrency" + RedeemTypeSubscription = "subscription" +) + +// PromoCode status constants +const ( + PromoCodeStatusActive = "active" + PromoCodeStatusDisabled = "disabled" +) + +// Admin adjustment type constants +const ( + AdjustmentTypeAdminBalance = "admin_balance" // 管理员调整余额 + AdjustmentTypeAdminConcurrency = "admin_concurrency" // 管理员调整并发数 +) + +// Group subscription type constants +const ( + SubscriptionTypeStandard = "standard" // 标准计费模式（按余额扣费） + SubscriptionTypeSubscription = "subscription" // 订阅模式（按限额控制） +) + +// Subscription status constants +const ( + SubscriptionStatusActive = "active" + SubscriptionStatusExpired = "expired" + SubscriptionStatusSuspended = "suspended" +) diff --git a/backend/internal/handler/admin/announcement_handler.go b/backend/internal/handler/admin/announcement_handler.go new file mode 100644 index 00000000..a4e9f2f0 --- /dev/null +++ b/backend/internal/handler/admin/announcement_handler.go @@ -0,0 +1,247 @@ +package admin + +import ( + "strconv" + "strings" + "time" + + "github.com/Wei-Shaw/sub2api/internal/handler/dto" + "github.com/Wei-Shaw/sub2api/internal/pkg/pagination" + "github.com/Wei-Shaw/sub2api/internal/pkg/response" + middleware2 "github.com/Wei-Shaw/sub2api/internal/server/middleware" + "github.com/Wei-Shaw/sub2api/internal/service" + + "github.com/gin-gonic/gin" +) + +// AnnouncementHandler handles admin announcement management +type AnnouncementHandler struct { + announcementService *service.AnnouncementService +} + +// NewAnnouncementHandler creates a new admin announcement handler +func NewAnnouncementHandler(announcementService *service.AnnouncementService) *AnnouncementHandler { + return &AnnouncementHandler{ + announcementService: announcementService, + } +} + +type CreateAnnouncementRequest struct { + Title string `json:"title" binding:"required"` + Content string `json:"content" binding:"required"` + Status string `json:"status" binding:"omitempty,oneof=draft active archived"` + Targeting service.AnnouncementTargeting `json:"targeting"` + StartsAt *int64 `json:"starts_at"` // Unix seconds, 0/empty = immediate + EndsAt *int64 `json:"ends_at"` // Unix seconds, 0/empty = never +} + +type UpdateAnnouncementRequest struct { + Title *string `json:"title"` + Content *string `json:"content"` + Status *string `json:"status" binding:"omitempty,oneof=draft active archived"` + Targeting *service.AnnouncementTargeting `json:"targeting"` + StartsAt *int64 `json:"starts_at"` // Unix seconds, 0 = clear + EndsAt *int64 `json:"ends_at"` // Unix seconds, 0 = clear +} + +// List handles listing announcements with filters +// GET /api/v1/admin/announcements +func (h *AnnouncementHandler) List(c *gin.Context) { + page, pageSize := response.ParsePagination(c) + status := strings.TrimSpace(c.Query("status")) + search := strings.TrimSpace(c.Query("search")) + if len(search) > 200 { + search = search[:200] + } + + params := pagination.PaginationParams{ + Page: page, + PageSize: pageSize, + } + + items, paginationResult, err := h.announcementService.List( + c.Request.Context(), + params, + service.AnnouncementListFilters{Status: status, Search: search}, + ) + if err != nil { + response.ErrorFrom(c, err) + return + } + + out := make([]dto.Announcement, 0, len(items)) + for i := range items { + out = append(out, *dto.AnnouncementFromService(&items[i])) + } + response.Paginated(c, out, paginationResult.Total, page, pageSize) +} + +// GetByID handles getting an announcement by ID +// GET /api/v1/admin/announcements/:id +func (h *AnnouncementHandler) GetByID(c *gin.Context) { + announcementID, err := strconv.ParseInt(c.Param("id"), 10, 64) + if err != nil || announcementID <= 0 { + response.BadRequest(c, "Invalid announcement ID") + return + } + + item, err := h.announcementService.GetByID(c.Request.Context(), announcementID) + if err != nil { + response.ErrorFrom(c, err) + return + } + + response.Success(c, dto.AnnouncementFromService(item)) +} + +// Create handles creating a new announcement +// POST /api/v1/admin/announcements +func (h *AnnouncementHandler) Create(c *gin.Context) { + var req CreateAnnouncementRequest + if err := c.ShouldBindJSON(&req); err != nil { + response.BadRequest(c, "Invalid request: "+err.Error()) + return + } + + subject, ok := middleware2.GetAuthSubjectFromContext(c) + if !ok { + response.Unauthorized(c, "User not found in context") + return + } + + input := &service.CreateAnnouncementInput{ + Title: req.Title, + Content: req.Content, + Status: req.Status, + Targeting: req.Targeting, + ActorID: &subject.UserID, + } + + if req.StartsAt != nil && *req.StartsAt > 0 { + t := time.Unix(*req.StartsAt, 0) + input.StartsAt = &t + } + if req.EndsAt != nil && *req.EndsAt > 0 { + t := time.Unix(*req.EndsAt, 0) + input.EndsAt = &t + } + + created, err := h.announcementService.Create(c.Request.Context(), input) + if err != nil { + response.ErrorFrom(c, err) + return + } + + response.Success(c, dto.AnnouncementFromService(created)) +} + +// Update handles updating an announcement +// PUT /api/v1/admin/announcements/:id +func (h *AnnouncementHandler) Update(c *gin.Context) { + announcementID, err := strconv.ParseInt(c.Param("id"), 10, 64) + if err != nil || announcementID <= 0 { + response.BadRequest(c, "Invalid announcement ID") + return + } + + var req UpdateAnnouncementRequest + if err := c.ShouldBindJSON(&req); err != nil { + response.BadRequest(c, "Invalid request: "+err.Error()) + return + } + + subject, ok := middleware2.GetAuthSubjectFromContext(c) + if !ok { + response.Unauthorized(c, "User not found in context") + return + } + + input := &service.UpdateAnnouncementInput{ + Title: req.Title, + Content: req.Content, + Status: req.Status, + Targeting: req.Targeting, + ActorID: &subject.UserID, + } + + if req.StartsAt != nil { + if *req.StartsAt == 0 { + var cleared *time.Time = nil + input.StartsAt = &cleared + } else { + t := time.Unix(*req.StartsAt, 0) + ptr := &t + input.StartsAt = &ptr + } + } + + if req.EndsAt != nil { + if *req.EndsAt == 0 { + var cleared *time.Time = nil + input.EndsAt = &cleared + } else { + t := time.Unix(*req.EndsAt, 0) + ptr := &t + input.EndsAt = &ptr + } + } + + updated, err := h.announcementService.Update(c.Request.Context(), announcementID, input) + if err != nil { + response.ErrorFrom(c, err) + return + } + + response.Success(c, dto.AnnouncementFromService(updated)) +} + +// Delete handles deleting an announcement +// DELETE /api/v1/admin/announcements/:id +func (h *AnnouncementHandler) Delete(c *gin.Context) { + announcementID, err := strconv.ParseInt(c.Param("id"), 10, 64) + if err != nil || announcementID <= 0 { + response.BadRequest(c, "Invalid announcement ID") + return + } + + if err := h.announcementService.Delete(c.Request.Context(), announcementID); err != nil { + response.ErrorFrom(c, err) + return + } + + response.Success(c, gin.H{"message": "Announcement deleted successfully"}) +} + +// ListReadStatus handles listing users read status for an announcement +// GET /api/v1/admin/announcements/:id/read-status +func (h *AnnouncementHandler) ListReadStatus(c *gin.Context) { + announcementID, err := strconv.ParseInt(c.Param("id"), 10, 64) + if err != nil || announcementID <= 0 { + response.BadRequest(c, "Invalid announcement ID") + return + } + + page, pageSize := response.ParsePagination(c) + params := pagination.PaginationParams{ + Page: page, + PageSize: pageSize, + } + search := strings.TrimSpace(c.Query("search")) + if len(search) > 200 { + search = search[:200] + } + + items, paginationResult, err := h.announcementService.ListUserReadStatus( + c.Request.Context(), + announcementID, + params, + search, + ) + if err != nil { + response.ErrorFrom(c, err) + return + } + + response.Paginated(c, items, paginationResult.Total, page, pageSize) +} + diff --git a/backend/internal/handler/announcement_handler.go b/backend/internal/handler/announcement_handler.go new file mode 100644 index 00000000..1e1424eb --- /dev/null +++ b/backend/internal/handler/announcement_handler.go @@ -0,0 +1,82 @@ +package handler + +import ( + "strconv" + "strings" + + "github.com/Wei-Shaw/sub2api/internal/handler/dto" + "github.com/Wei-Shaw/sub2api/internal/pkg/response" + middleware2 "github.com/Wei-Shaw/sub2api/internal/server/middleware" + "github.com/Wei-Shaw/sub2api/internal/service" + + "github.com/gin-gonic/gin" +) + +// AnnouncementHandler handles user announcement operations +type AnnouncementHandler struct { + announcementService *service.AnnouncementService +} + +// NewAnnouncementHandler creates a new user announcement handler +func NewAnnouncementHandler(announcementService *service.AnnouncementService) *AnnouncementHandler { + return &AnnouncementHandler{ + announcementService: announcementService, + } +} + +// List handles listing announcements visible to current user +// GET /api/v1/announcements +func (h *AnnouncementHandler) List(c *gin.Context) { + subject, ok := middleware2.GetAuthSubjectFromContext(c) + if !ok { + response.Unauthorized(c, "User not found in context") + return + } + + unreadOnly := parseBoolQuery(c.Query("unread_only")) + + items, err := h.announcementService.ListForUser(c.Request.Context(), subject.UserID, unreadOnly) + if err != nil { + response.ErrorFrom(c, err) + return + } + + out := make([]dto.UserAnnouncement, 0, len(items)) + for i := range items { + out = append(out, *dto.UserAnnouncementFromService(&items[i])) + } + response.Success(c, out) +} + +// MarkRead marks an announcement as read for current user +// POST /api/v1/announcements/:id/read +func (h *AnnouncementHandler) MarkRead(c *gin.Context) { + subject, ok := middleware2.GetAuthSubjectFromContext(c) + if !ok { + response.Unauthorized(c, "User not found in context") + return + } + + announcementID, err := strconv.ParseInt(c.Param("id"), 10, 64) + if err != nil || announcementID <= 0 { + response.BadRequest(c, "Invalid announcement ID") + return + } + + if err := h.announcementService.MarkRead(c.Request.Context(), subject.UserID, announcementID); err != nil { + response.ErrorFrom(c, err) + return + } + + response.Success(c, gin.H{"message": "ok"}) +} + +func parseBoolQuery(v string) bool { + switch strings.TrimSpace(strings.ToLower(v)) { + case "1", "true", "yes", "y", "on": + return true + default: + return false + } +} + diff --git a/backend/internal/handler/dto/announcement.go b/backend/internal/handler/dto/announcement.go new file mode 100644 index 00000000..ec2a8ca7 --- /dev/null +++ b/backend/internal/handler/dto/announcement.go @@ -0,0 +1,75 @@ +package dto + +import ( + "time" + + "github.com/Wei-Shaw/sub2api/internal/service" +) + +type Announcement struct { + ID int64 `json:"id"` + Title string `json:"title"` + Content string `json:"content"` + Status string `json:"status"` + + Targeting service.AnnouncementTargeting `json:"targeting"` + + StartsAt *time.Time `json:"starts_at,omitempty"` + EndsAt *time.Time `json:"ends_at,omitempty"` + + CreatedBy *int64 `json:"created_by,omitempty"` + UpdatedBy *int64 `json:"updated_by,omitempty"` + + CreatedAt time.Time `json:"created_at"` + UpdatedAt time.Time `json:"updated_at"` +} + +type UserAnnouncement struct { + ID int64 `json:"id"` + Title string `json:"title"` + Content string `json:"content"` + + StartsAt *time.Time `json:"starts_at,omitempty"` + EndsAt *time.Time `json:"ends_at,omitempty"` + + ReadAt *time.Time `json:"read_at,omitempty"` + + CreatedAt time.Time `json:"created_at"` + UpdatedAt time.Time `json:"updated_at"` +} + +func AnnouncementFromService(a *service.Announcement) *Announcement { + if a == nil { + return nil + } + return &Announcement{ + ID: a.ID, + Title: a.Title, + Content: a.Content, + Status: a.Status, + Targeting: a.Targeting, + StartsAt: a.StartsAt, + EndsAt: a.EndsAt, + CreatedBy: a.CreatedBy, + UpdatedBy: a.UpdatedBy, + CreatedAt: a.CreatedAt, + UpdatedAt: a.UpdatedAt, + } +} + +func UserAnnouncementFromService(a *service.UserAnnouncement) *UserAnnouncement { + if a == nil { + return nil + } + return &UserAnnouncement{ + ID: a.Announcement.ID, + Title: a.Announcement.Title, + Content: a.Announcement.Content, + StartsAt: a.Announcement.StartsAt, + EndsAt: a.Announcement.EndsAt, + ReadAt: a.ReadAt, + CreatedAt: a.Announcement.CreatedAt, + UpdatedAt: a.Announcement.UpdatedAt, + } +} + diff --git a/backend/internal/handler/handler.go b/backend/internal/handler/handler.go index 907c314d..b8f7d417 100644 --- a/backend/internal/handler/handler.go +++ b/backend/internal/handler/handler.go @@ -10,6 +10,7 @@ type AdminHandlers struct { User *admin.UserHandler Group *admin.GroupHandler Account *admin.AccountHandler + Announcement *admin.AnnouncementHandler OAuth *admin.OAuthHandler OpenAIOAuth *admin.OpenAIOAuthHandler GeminiOAuth *admin.GeminiOAuthHandler @@ -33,6 +34,7 @@ type Handlers struct { Usage *UsageHandler Redeem *RedeemHandler Subscription *SubscriptionHandler + Announcement *AnnouncementHandler Admin *AdminHandlers Gateway *GatewayHandler OpenAIGateway *OpenAIGatewayHandler diff --git a/backend/internal/handler/wire.go b/backend/internal/handler/wire.go index 92e8edeb..48a3794b 100644 --- a/backend/internal/handler/wire.go +++ b/backend/internal/handler/wire.go @@ -13,6 +13,7 @@ func ProvideAdminHandlers( userHandler *admin.UserHandler, groupHandler *admin.GroupHandler, accountHandler *admin.AccountHandler, + announcementHandler *admin.AnnouncementHandler, oauthHandler *admin.OAuthHandler, openaiOAuthHandler *admin.OpenAIOAuthHandler, geminiOAuthHandler *admin.GeminiOAuthHandler, @@ -32,6 +33,7 @@ func ProvideAdminHandlers( User: userHandler, Group: groupHandler, Account: accountHandler, + Announcement: announcementHandler, OAuth: oauthHandler, OpenAIOAuth: openaiOAuthHandler, GeminiOAuth: geminiOAuthHandler, @@ -66,6 +68,7 @@ func ProvideHandlers( usageHandler *UsageHandler, redeemHandler *RedeemHandler, subscriptionHandler *SubscriptionHandler, + announcementHandler *AnnouncementHandler, adminHandlers *AdminHandlers, gatewayHandler *GatewayHandler, openaiGatewayHandler *OpenAIGatewayHandler, @@ -79,6 +82,7 @@ func ProvideHandlers( Usage: usageHandler, Redeem: redeemHandler, Subscription: subscriptionHandler, + Announcement: announcementHandler, Admin: adminHandlers, Gateway: gatewayHandler, OpenAIGateway: openaiGatewayHandler, @@ -96,6 +100,7 @@ var ProviderSet = wire.NewSet( NewUsageHandler, NewRedeemHandler, NewSubscriptionHandler, + NewAnnouncementHandler, NewGatewayHandler, NewOpenAIGatewayHandler, NewTotpHandler, @@ -106,6 +111,7 @@ var ProviderSet = wire.NewSet( admin.NewUserHandler, admin.NewGroupHandler, admin.NewAccountHandler, + admin.NewAnnouncementHandler, admin.NewOAuthHandler, admin.NewOpenAIOAuthHandler, admin.NewGeminiOAuthHandler, diff --git a/backend/internal/repository/announcement_read_repo.go b/backend/internal/repository/announcement_read_repo.go new file mode 100644 index 00000000..1c6b480a --- /dev/null +++ b/backend/internal/repository/announcement_read_repo.go @@ -0,0 +1,84 @@ +package repository + +import ( + "context" + "time" + + dbent "github.com/Wei-Shaw/sub2api/ent" + "github.com/Wei-Shaw/sub2api/ent/announcementread" + "github.com/Wei-Shaw/sub2api/internal/service" +) + +type announcementReadRepository struct { + client *dbent.Client +} + +func NewAnnouncementReadRepository(client *dbent.Client) service.AnnouncementReadRepository { + return &announcementReadRepository{client: client} +} + +func (r *announcementReadRepository) MarkRead(ctx context.Context, announcementID, userID int64, readAt time.Time) error { + client := clientFromContext(ctx, r.client) + return client.AnnouncementRead.Create(). + SetAnnouncementID(announcementID). + SetUserID(userID). + SetReadAt(readAt). + OnConflictColumns(announcementread.FieldAnnouncementID, announcementread.FieldUserID). + DoNothing(). + Exec(ctx) +} + +func (r *announcementReadRepository) GetReadMapByUser(ctx context.Context, userID int64, announcementIDs []int64) (map[int64]time.Time, error) { + if len(announcementIDs) == 0 { + return map[int64]time.Time{}, nil + } + + rows, err := r.client.AnnouncementRead.Query(). + Where( + announcementread.UserIDEQ(userID), + announcementread.AnnouncementIDIn(announcementIDs...), + ). + All(ctx) + if err != nil { + return nil, err + } + + out := make(map[int64]time.Time, len(rows)) + for i := range rows { + out[rows[i].AnnouncementID] = rows[i].ReadAt + } + return out, nil +} + +func (r *announcementReadRepository) GetReadMapByUsers(ctx context.Context, announcementID int64, userIDs []int64) (map[int64]time.Time, error) { + if len(userIDs) == 0 { + return map[int64]time.Time{}, nil + } + + rows, err := r.client.AnnouncementRead.Query(). + Where( + announcementread.AnnouncementIDEQ(announcementID), + announcementread.UserIDIn(userIDs...), + ). + All(ctx) + if err != nil { + return nil, err + } + + out := make(map[int64]time.Time, len(rows)) + for i := range rows { + out[rows[i].UserID] = rows[i].ReadAt + } + return out, nil +} + +func (r *announcementReadRepository) CountByAnnouncementID(ctx context.Context, announcementID int64) (int64, error) { + count, err := r.client.AnnouncementRead.Query(). + Where(announcementread.AnnouncementIDEQ(announcementID)). + Count(ctx) + if err != nil { + return 0, err + } + return int64(count), nil +} + diff --git a/backend/internal/repository/announcement_repo.go b/backend/internal/repository/announcement_repo.go new file mode 100644 index 00000000..edeb82e6 --- /dev/null +++ b/backend/internal/repository/announcement_repo.go @@ -0,0 +1,195 @@ +package repository + +import ( + "context" + "time" + + dbent "github.com/Wei-Shaw/sub2api/ent" + "github.com/Wei-Shaw/sub2api/ent/announcement" + "github.com/Wei-Shaw/sub2api/internal/pkg/pagination" + "github.com/Wei-Shaw/sub2api/internal/service" +) + +type announcementRepository struct { + client *dbent.Client +} + +func NewAnnouncementRepository(client *dbent.Client) service.AnnouncementRepository { + return &announcementRepository{client: client} +} + +func (r *announcementRepository) Create(ctx context.Context, a *service.Announcement) error { + client := clientFromContext(ctx, r.client) + builder := client.Announcement.Create(). + SetTitle(a.Title). + SetContent(a.Content). + SetStatus(a.Status). + SetTargeting(a.Targeting) + + if a.StartsAt != nil { + builder.SetStartsAt(*a.StartsAt) + } + if a.EndsAt != nil { + builder.SetEndsAt(*a.EndsAt) + } + if a.CreatedBy != nil { + builder.SetCreatedBy(*a.CreatedBy) + } + if a.UpdatedBy != nil { + builder.SetUpdatedBy(*a.UpdatedBy) + } + + created, err := builder.Save(ctx) + if err != nil { + return err + } + + applyAnnouncementEntityToService(a, created) + return nil +} + +func (r *announcementRepository) GetByID(ctx context.Context, id int64) (*service.Announcement, error) { + m, err := r.client.Announcement.Query(). + Where(announcement.IDEQ(id)). + Only(ctx) + if err != nil { + return nil, translatePersistenceError(err, service.ErrAnnouncementNotFound, nil) + } + return announcementEntityToService(m), nil +} + +func (r *announcementRepository) Update(ctx context.Context, a *service.Announcement) error { + client := clientFromContext(ctx, r.client) + builder := client.Announcement.UpdateOneID(a.ID). + SetTitle(a.Title). + SetContent(a.Content). + SetStatus(a.Status). + SetTargeting(a.Targeting) + + if a.StartsAt != nil { + builder.SetStartsAt(*a.StartsAt) + } else { + builder.ClearStartsAt() + } + if a.EndsAt != nil { + builder.SetEndsAt(*a.EndsAt) + } else { + builder.ClearEndsAt() + } + if a.CreatedBy != nil { + builder.SetCreatedBy(*a.CreatedBy) + } else { + builder.ClearCreatedBy() + } + if a.UpdatedBy != nil { + builder.SetUpdatedBy(*a.UpdatedBy) + } else { + builder.ClearUpdatedBy() + } + + updated, err := builder.Save(ctx) + if err != nil { + return translatePersistenceError(err, service.ErrAnnouncementNotFound, nil) + } + + a.UpdatedAt = updated.UpdatedAt + return nil +} + +func (r *announcementRepository) Delete(ctx context.Context, id int64) error { + client := clientFromContext(ctx, r.client) + _, err := client.Announcement.Delete().Where(announcement.IDEQ(id)).Exec(ctx) + return err +} + +func (r *announcementRepository) List( + ctx context.Context, + params pagination.PaginationParams, + filters service.AnnouncementListFilters, +) ([]service.Announcement, *pagination.PaginationResult, error) { + q := r.client.Announcement.Query() + + if filters.Status != "" { + q = q.Where(announcement.StatusEQ(filters.Status)) + } + if filters.Search != "" { + q = q.Where( + announcement.Or( + announcement.TitleContainsFold(filters.Search), + announcement.ContentContainsFold(filters.Search), + ), + ) + } + + total, err := q.Count(ctx) + if err != nil { + return nil, nil, err + } + + items, err := q. + Offset(params.Offset()). + Limit(params.Limit()). + Order(dbent.Desc(announcement.FieldID)). + All(ctx) + if err != nil { + return nil, nil, err + } + + out := announcementEntitiesToService(items) + return out, paginationResultFromTotal(int64(total), params), nil +} + +func (r *announcementRepository) ListActive(ctx context.Context, now time.Time) ([]service.Announcement, error) { + q := r.client.Announcement.Query(). + Where( + announcement.StatusEQ(service.AnnouncementStatusActive), + announcement.Or(announcement.StartsAtIsNil(), announcement.StartsAtLTE(now)), + announcement.Or(announcement.EndsAtIsNil(), announcement.EndsAtGT(now)), + ). + Order(dbent.Desc(announcement.FieldID)) + + items, err := q.All(ctx) + if err != nil { + return nil, err + } + return announcementEntitiesToService(items), nil +} + +func applyAnnouncementEntityToService(dst *service.Announcement, src *dbent.Announcement) { + if dst == nil || src == nil { + return + } + dst.ID = src.ID + dst.CreatedAt = src.CreatedAt + dst.UpdatedAt = src.UpdatedAt +} + +func announcementEntityToService(m *dbent.Announcement) *service.Announcement { + if m == nil { + return nil + } + return &service.Announcement{ + ID: m.ID, + Title: m.Title, + Content: m.Content, + Status: m.Status, + Targeting: m.Targeting, + StartsAt: m.StartsAt, + EndsAt: m.EndsAt, + CreatedBy: m.CreatedBy, + UpdatedBy: m.UpdatedBy, + CreatedAt: m.CreatedAt, + UpdatedAt: m.UpdatedAt, + } +} + +func announcementEntitiesToService(models []*dbent.Announcement) []service.Announcement { + out := make([]service.Announcement, 0, len(models)) + for i := range models { + if s := announcementEntityToService(models[i]); s != nil { + out = append(out, *s) + } + } + return out +} + diff --git a/backend/internal/repository/wire.go b/backend/internal/repository/wire.go index 3e1c05fc..e3394361 100644 --- a/backend/internal/repository/wire.go +++ b/backend/internal/repository/wire.go @@ -56,6 +56,8 @@ var ProviderSet = wire.NewSet( NewProxyRepository, NewRedeemCodeRepository, NewPromoCodeRepository, + NewAnnouncementRepository, + NewAnnouncementReadRepository, NewUsageLogRepository, NewUsageCleanupRepository, NewDashboardAggregationRepository, diff --git a/backend/internal/server/routes/admin.go b/backend/internal/server/routes/admin.go index 050e724d..3e0033e7 100644 --- a/backend/internal/server/routes/admin.go +++ b/backend/internal/server/routes/admin.go @@ -29,6 +29,9 @@ func RegisterAdminRoutes( // 账号管理 registerAccountRoutes(admin, h) + // 公告管理 + registerAnnouncementRoutes(admin, h) + // OpenAI OAuth registerOpenAIOAuthRoutes(admin, h) @@ -229,6 +232,18 @@ func registerAccountRoutes(admin *gin.RouterGroup, h *handler.Handlers) { } } +func registerAnnouncementRoutes(admin *gin.RouterGroup, h *handler.Handlers) { + announcements := admin.Group("/announcements") + { + announcements.GET("", h.Admin.Announcement.List) + announcements.POST("", h.Admin.Announcement.Create) + announcements.GET("/:id", h.Admin.Announcement.GetByID) + announcements.PUT("/:id", h.Admin.Announcement.Update) + announcements.DELETE("/:id", h.Admin.Announcement.Delete) + announcements.GET("/:id/read-status", h.Admin.Announcement.ListReadStatus) + } +} + func registerOpenAIOAuthRoutes(admin *gin.RouterGroup, h *handler.Handlers) { openai := admin.Group("/openai") { diff --git a/backend/internal/server/routes/user.go b/backend/internal/server/routes/user.go index 83cf31c4..5581e1e1 100644 --- a/backend/internal/server/routes/user.go +++ b/backend/internal/server/routes/user.go @@ -64,6 +64,13 @@ func RegisterUserRoutes( usage.POST("/dashboard/api-keys-usage", h.Usage.DashboardAPIKeysUsage) } + // 公告（用户可见） + announcements := authenticated.Group("/announcements") + { + announcements.GET("", h.Announcement.List) + announcements.POST("/:id/read", h.Announcement.MarkRead) + } + // 卡密兑换 redeem := authenticated.Group("/redeem") { diff --git a/backend/internal/service/announcement.go b/backend/internal/service/announcement.go new file mode 100644 index 00000000..2ba5af5d --- /dev/null +++ b/backend/internal/service/announcement.go @@ -0,0 +1,64 @@ +package service + +import ( + "context" + "time" + + "github.com/Wei-Shaw/sub2api/internal/domain" + "github.com/Wei-Shaw/sub2api/internal/pkg/pagination" +) + +const ( + AnnouncementStatusDraft = domain.AnnouncementStatusDraft + AnnouncementStatusActive = domain.AnnouncementStatusActive + AnnouncementStatusArchived = domain.AnnouncementStatusArchived +) + +const ( + AnnouncementConditionTypeSubscription = domain.AnnouncementConditionTypeSubscription + AnnouncementConditionTypeBalance = domain.AnnouncementConditionTypeBalance +) + +const ( + AnnouncementOperatorIn = domain.AnnouncementOperatorIn + AnnouncementOperatorGT = domain.AnnouncementOperatorGT + AnnouncementOperatorGTE = domain.AnnouncementOperatorGTE + AnnouncementOperatorLT = domain.AnnouncementOperatorLT + AnnouncementOperatorLTE = domain.AnnouncementOperatorLTE + AnnouncementOperatorEQ = domain.AnnouncementOperatorEQ +) + +var ( + ErrAnnouncementNotFound = domain.ErrAnnouncementNotFound + ErrAnnouncementInvalidTarget = domain.ErrAnnouncementInvalidTarget +) + +type AnnouncementTargeting = domain.AnnouncementTargeting + +type AnnouncementConditionGroup = domain.AnnouncementConditionGroup + +type AnnouncementCondition = domain.AnnouncementCondition + +type Announcement = domain.Announcement + +type AnnouncementListFilters struct { + Status string + Search string +} + +type AnnouncementRepository interface { + Create(ctx context.Context, a *Announcement) error + GetByID(ctx context.Context, id int64) (*Announcement, error) + Update(ctx context.Context, a *Announcement) error + Delete(ctx context.Context, id int64) error + + List(ctx context.Context, params pagination.PaginationParams, filters AnnouncementListFilters) ([]Announcement, *pagination.PaginationResult, error) + ListActive(ctx context.Context, now time.Time) ([]Announcement, error) +} + +type AnnouncementReadRepository interface { + MarkRead(ctx context.Context, announcementID, userID int64, readAt time.Time) error + GetReadMapByUser(ctx context.Context, userID int64, announcementIDs []int64) (map[int64]time.Time, error) + GetReadMapByUsers(ctx context.Context, announcementID int64, userIDs []int64) (map[int64]time.Time, error) + CountByAnnouncementID(ctx context.Context, announcementID int64) (int64, error) +} diff --git a/backend/internal/service/announcement_service.go b/backend/internal/service/announcement_service.go new file mode 100644 index 00000000..c2588e6c --- /dev/null +++ b/backend/internal/service/announcement_service.go @@ -0,0 +1,378 @@ +package service + +import ( + "context" + "fmt" + "sort" + "strings" + "time" + + "github.com/Wei-Shaw/sub2api/internal/domain" + "github.com/Wei-Shaw/sub2api/internal/pkg/pagination" +) + +type AnnouncementService struct { + announcementRepo AnnouncementRepository + readRepo AnnouncementReadRepository + userRepo UserRepository + userSubRepo UserSubscriptionRepository +} + +func NewAnnouncementService( + announcementRepo AnnouncementRepository, + readRepo AnnouncementReadRepository, + userRepo UserRepository, + userSubRepo UserSubscriptionRepository, +) *AnnouncementService { + return &AnnouncementService{ + announcementRepo: announcementRepo, + readRepo: readRepo, + userRepo: userRepo, + userSubRepo: userSubRepo, + } +} + +type CreateAnnouncementInput struct { + Title string + Content string + Status string + Targeting AnnouncementTargeting + StartsAt *time.Time + EndsAt *time.Time + ActorID *int64 // 管理员用户ID +} + +type UpdateAnnouncementInput struct { + Title *string + Content *string + Status *string + Targeting *AnnouncementTargeting + StartsAt **time.Time + EndsAt **time.Time + ActorID *int64 // 管理员用户ID +} + +type UserAnnouncement struct { + Announcement Announcement + ReadAt *time.Time +} + +type AnnouncementUserReadStatus struct { + UserID int64 `json:"user_id"` + Email string `json:"email"` + Username string `json:"username"` + Balance float64 `json:"balance"` + Eligible bool `json:"eligible"` + ReadAt *time.Time `json:"read_at,omitempty"` +} + +func (s *AnnouncementService) Create(ctx context.Context, input *CreateAnnouncementInput) (*Announcement, error) { + if input == nil { + return nil, fmt.Errorf("create announcement: nil input") + } + + title := strings.TrimSpace(input.Title) + content := strings.TrimSpace(input.Content) + if title == "" || len(title) > 200 { + return nil, fmt.Errorf("create announcement: invalid title") + } + if content == "" { + return nil, fmt.Errorf("create announcement: content is required") + } + + status := strings.TrimSpace(input.Status) + if status == "" { + status = AnnouncementStatusDraft + } + if !isValidAnnouncementStatus(status) { + return nil, fmt.Errorf("create announcement: invalid status") + } + + targeting, err := domain.AnnouncementTargeting(input.Targeting).NormalizeAndValidate() + if err != nil { + return nil, err + } + + if input.StartsAt != nil && input.EndsAt != nil { + if !input.StartsAt.Before(*input.EndsAt) { + return nil, fmt.Errorf("create announcement: starts_at must be before ends_at") + } + } + + a := &Announcement{ + Title: title, + Content: content, + Status: status, + Targeting: targeting, + StartsAt: input.StartsAt, + EndsAt: input.EndsAt, + } + if input.ActorID != nil && *input.ActorID > 0 { + a.CreatedBy = input.ActorID + a.UpdatedBy = input.ActorID + } + + if err := s.announcementRepo.Create(ctx, a); err != nil { + return nil, fmt.Errorf("create announcement: %w", err) + } + return a, nil +} + +func (s *AnnouncementService) Update(ctx context.Context, id int64, input *UpdateAnnouncementInput) (*Announcement, error) { + if input == nil { + return nil, fmt.Errorf("update announcement: nil input") + } + + a, err := s.announcementRepo.GetByID(ctx, id) + if err != nil { + return nil, err + } + + if input.Title != nil { + title := strings.TrimSpace(*input.Title) + if title == "" || len(title) > 200 { + return nil, fmt.Errorf("update announcement: invalid title") + } + a.Title = title + } + if input.Content != nil { + content := strings.TrimSpace(*input.Content) + if content == "" { + return nil, fmt.Errorf("update announcement: content is required") + } + a.Content = content + } + if input.Status != nil { + status := strings.TrimSpace(*input.Status) + if !isValidAnnouncementStatus(status) { + return nil, fmt.Errorf("update announcement: invalid status") + } + a.Status = status + } + + if input.Targeting != nil { + targeting, err := domain.AnnouncementTargeting(*input.Targeting).NormalizeAndValidate() + if err != nil { + return nil, err + } + a.Targeting = targeting + } + + if input.StartsAt != nil { + a.StartsAt = *input.StartsAt + } + if input.EndsAt != nil { + a.EndsAt = *input.EndsAt + } + + if a.StartsAt != nil && a.EndsAt != nil { + if !a.StartsAt.Before(*a.EndsAt) { + return nil, fmt.Errorf("update announcement: starts_at must be before ends_at") + } + } + + if input.ActorID != nil && *input.ActorID > 0 { + a.UpdatedBy = input.ActorID + } + + if err := s.announcementRepo.Update(ctx, a); err != nil { + return nil, fmt.Errorf("update announcement: %w", err) + } + return a, nil +} + +func (s *AnnouncementService) Delete(ctx context.Context, id int64) error { + if err := s.announcementRepo.Delete(ctx, id); err != nil { + return fmt.Errorf("delete announcement: %w", err) + } + return nil +} + +func (s *AnnouncementService) GetByID(ctx context.Context, id int64) (*Announcement, error) { + return s.announcementRepo.GetByID(ctx, id) +} + +func (s *AnnouncementService) List(ctx context.Context, params pagination.PaginationParams, filters AnnouncementListFilters) ([]Announcement, *pagination.PaginationResult, error) { + return s.announcementRepo.List(ctx, params, filters) +} + +func (s *AnnouncementService) ListForUser(ctx context.Context, userID int64, unreadOnly bool) ([]UserAnnouncement, error) { + user, err := s.userRepo.GetByID(ctx, userID) + if err != nil { + return nil, fmt.Errorf("get user: %w", err) + } + + activeSubs, err := s.userSubRepo.ListActiveByUserID(ctx, userID) + if err != nil { + return nil, fmt.Errorf("list active subscriptions: %w", err) + } + activeGroupIDs := make(map[int64]struct{}, len(activeSubs)) + for i := range activeSubs { + activeGroupIDs[activeSubs[i].GroupID] = struct{}{} + } + + now := time.Now() + anns, err := s.announcementRepo.ListActive(ctx, now) + if err != nil { + return nil, fmt.Errorf("list active announcements: %w", err) + } + + visible := make([]Announcement, 0, len(anns)) + ids := make([]int64, 0, len(anns)) + for i := range anns { + a := anns[i] + if !a.IsActiveAt(now) { + continue + } + if !a.Targeting.Matches(user.Balance, activeGroupIDs) { + continue + } + visible = append(visible, a) + ids = append(ids, a.ID) + } + + if len(visible) == 0 { + return []UserAnnouncement{}, nil + } + + readMap, err := s.readRepo.GetReadMapByUser(ctx, userID, ids) + if err != nil { + return nil, fmt.Errorf("get read map: %w", err) + } + + out := make([]UserAnnouncement, 0, len(visible)) + for i := range visible { + a := visible[i] + readAt, ok := readMap[a.ID] + if unreadOnly && ok { + continue + } + var ptr *time.Time + if ok { + t := readAt + ptr = &t + } + out = append(out, UserAnnouncement{ + Announcement: a, + ReadAt: ptr, + }) + } + + // 未读优先、同状态按创建时间倒序 + sort.Slice(out, func(i, j int) bool { + ai, aj := out[i], out[j] + if (ai.ReadAt == nil) != (aj.ReadAt == nil) { + return ai.ReadAt == nil + } + return ai.Announcement.ID > aj.Announcement.ID + }) + + return out, nil +} + +func (s *AnnouncementService) MarkRead(ctx context.Context, userID, announcementID int64) error { + // 安全：仅允许标记当前用户“可见”的公告 + user, err := s.userRepo.GetByID(ctx, userID) + if err != nil { + return fmt.Errorf("get user: %w", err) + } + + a, err := s.announcementRepo.GetByID(ctx, announcementID) + if err != nil { + return err + } + + now := time.Now() + if !a.IsActiveAt(now) { + return ErrAnnouncementNotFound + } + + activeSubs, err := s.userSubRepo.ListActiveByUserID(ctx, userID) + if err != nil { + return fmt.Errorf("list active subscriptions: %w", err) + } + activeGroupIDs := make(map[int64]struct{}, len(activeSubs)) + for i := range activeSubs { + activeGroupIDs[activeSubs[i].GroupID] = struct{}{} + } + + if !a.Targeting.Matches(user.Balance, activeGroupIDs) { + return ErrAnnouncementNotFound + } + + if err := s.readRepo.MarkRead(ctx, announcementID, userID, now); err != nil { + return fmt.Errorf("mark read: %w", err) + } + return nil +} + +func (s *AnnouncementService) ListUserReadStatus( + ctx context.Context, + announcementID int64, + params pagination.PaginationParams, + search string, +) ([]AnnouncementUserReadStatus, *pagination.PaginationResult, error) { + ann, err := s.announcementRepo.GetByID(ctx, announcementID) + if err != nil { + return nil, nil, err + } + + filters := UserListFilters{ + Search: strings.TrimSpace(search), + } + + users, page, err := s.userRepo.ListWithFilters(ctx, params, filters) + if err != nil { + return nil, nil, fmt.Errorf("list users: %w", err) + } + + userIDs := make([]int64, 0, len(users)) + for i := range users { + userIDs = append(userIDs, users[i].ID) + } + + readMap, err := s.readRepo.GetReadMapByUsers(ctx, announcementID, userIDs) + if err != nil { + return nil, nil, fmt.Errorf("get read map: %w", err) + } + + out := make([]AnnouncementUserReadStatus, 0, len(users)) + for i := range users { + u := users[i] + subs, err := s.userSubRepo.ListActiveByUserID(ctx, u.ID) + if err != nil { + return nil, nil, fmt.Errorf("list active subscriptions: %w", err) + } + activeGroupIDs := make(map[int64]struct{}, len(subs)) + for j := range subs { + activeGroupIDs[subs[j].GroupID] = struct{}{} + } + + readAt, ok := readMap[u.ID] + var ptr *time.Time + if ok { + t := readAt + ptr = &t + } + + out = append(out, AnnouncementUserReadStatus{ + UserID: u.ID, + Email: u.Email, + Username: u.Username, + Balance: u.Balance, + Eligible: domain.AnnouncementTargeting(ann.Targeting).Matches(u.Balance, activeGroupIDs), + ReadAt: ptr, + }) + } + + return out, page, nil +} + +func isValidAnnouncementStatus(status string) bool { + switch status { + case AnnouncementStatusDraft, AnnouncementStatusActive, AnnouncementStatusArchived: + return true + default: + return false + } +} diff --git a/backend/internal/service/announcement_targeting_test.go b/backend/internal/service/announcement_targeting_test.go new file mode 100644 index 00000000..fffea26b --- /dev/null +++ b/backend/internal/service/announcement_targeting_test.go @@ -0,0 +1,67 @@ +package service + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestAnnouncementTargeting_Matches_EmptyMatchesAll(t *testing.T) { + var targeting AnnouncementTargeting + require.True(t, targeting.Matches(0, nil)) + require.True(t, targeting.Matches(123.45, map[int64]struct{}{1: {}})) +} + +func TestAnnouncementTargeting_NormalizeAndValidate_RejectsEmptyGroup(t *testing.T) { + targeting := AnnouncementTargeting{ + AnyOf: []AnnouncementConditionGroup{ + {AllOf: nil}, + }, + } + _, err := targeting.NormalizeAndValidate() + require.Error(t, err) + require.ErrorIs(t, err, ErrAnnouncementInvalidTarget) +} + +func TestAnnouncementTargeting_NormalizeAndValidate_RejectsInvalidCondition(t *testing.T) { + targeting := AnnouncementTargeting{ + AnyOf: []AnnouncementConditionGroup{ + { + AllOf: []AnnouncementCondition{ + {Type: "balance", Operator: "between", Value: 10}, + }, + }, + }, + } + _, err := targeting.NormalizeAndValidate() + require.Error(t, err) + require.ErrorIs(t, err, ErrAnnouncementInvalidTarget) +} + +func TestAnnouncementTargeting_Matches_AndOrSemantics(t *testing.T) { + targeting := AnnouncementTargeting{ + AnyOf: []AnnouncementConditionGroup{ + { + AllOf: []AnnouncementCondition{ + {Type: AnnouncementConditionTypeBalance, Operator: AnnouncementOperatorGTE, Value: 100}, + {Type: AnnouncementConditionTypeSubscription, Operator: AnnouncementOperatorIn, GroupIDs: []int64{10}}, + }, + }, + { + AllOf: []AnnouncementCondition{ + {Type: AnnouncementConditionTypeBalance, Operator: AnnouncementOperatorLT, Value: 5}, + }, + }, + }, + } + + // 命中第 2 组（balance < 5） + require.True(t, targeting.Matches(4.99, nil)) + require.False(t, targeting.Matches(5, nil)) + + // 命中第 1 组（balance >= 100 AND 订阅 in [10]） + require.False(t, targeting.Matches(100, map[int64]struct{}{})) + require.False(t, targeting.Matches(99.9, map[int64]struct{}{10: {}})) + require.True(t, targeting.Matches(100, map[int64]struct{}{10: {}})) +} + diff --git a/backend/internal/service/domain_constants.go b/backend/internal/service/domain_constants.go index 44df9073..eee8bddd 100644 --- a/backend/internal/service/domain_constants.go +++ b/backend/internal/service/domain_constants.go @@ -1,66 +1,68 @@ package service +import "github.com/Wei-Shaw/sub2api/internal/domain" + // Status constants const ( - StatusActive = "active" - StatusDisabled = "disabled" - StatusError = "error" - StatusUnused = "unused" - StatusUsed = "used" - StatusExpired = "expired" + StatusActive = domain.StatusActive + StatusDisabled = domain.StatusDisabled + StatusError = domain.StatusError + StatusUnused = domain.StatusUnused + StatusUsed = domain.StatusUsed + StatusExpired = domain.StatusExpired ) // Role constants const ( - RoleAdmin = "admin" - RoleUser = "user" + RoleAdmin = domain.RoleAdmin + RoleUser = domain.RoleUser ) // Platform constants const ( - PlatformAnthropic = "anthropic" - PlatformOpenAI = "openai" - PlatformGemini = "gemini" - PlatformAntigravity = "antigravity" + PlatformAnthropic = domain.PlatformAnthropic + PlatformOpenAI = domain.PlatformOpenAI + PlatformGemini = domain.PlatformGemini + PlatformAntigravity = domain.PlatformAntigravity ) // Account type constants const ( - AccountTypeOAuth = "oauth" // OAuth类型账号（full scope: profile + inference） - AccountTypeSetupToken = "setup-token" // Setup Token类型账号（inference only scope） - AccountTypeAPIKey = "apikey" // API Key类型账号 + AccountTypeOAuth = domain.AccountTypeOAuth // OAuth类型账号（full scope: profile + inference） + AccountTypeSetupToken = domain.AccountTypeSetupToken // Setup Token类型账号（inference only scope） + AccountTypeAPIKey = domain.AccountTypeAPIKey // API Key类型账号 ) // Redeem type constants const ( - RedeemTypeBalance = "balance" - RedeemTypeConcurrency = "concurrency" - RedeemTypeSubscription = "subscription" + RedeemTypeBalance = domain.RedeemTypeBalance + RedeemTypeConcurrency = domain.RedeemTypeConcurrency + RedeemTypeSubscription = domain.RedeemTypeSubscription ) // PromoCode status constants const ( - PromoCodeStatusActive = "active" - PromoCodeStatusDisabled = "disabled" + PromoCodeStatusActive = domain.PromoCodeStatusActive + PromoCodeStatusDisabled = domain.PromoCodeStatusDisabled ) // Admin adjustment type constants const ( - AdjustmentTypeAdminBalance = "admin_balance" // 管理员调整余额 - AdjustmentTypeAdminConcurrency = "admin_concurrency" // 管理员调整并发数 + AdjustmentTypeAdminBalance = domain.AdjustmentTypeAdminBalance // 管理员调整余额 + AdjustmentTypeAdminConcurrency = domain.AdjustmentTypeAdminConcurrency // 管理员调整并发数 ) // Group subscription type constants const ( - SubscriptionTypeStandard = "standard" // 标准计费模式（按余额扣费） - SubscriptionTypeSubscription = "subscription" // 订阅模式（按限额控制） + SubscriptionTypeStandard = domain.SubscriptionTypeStandard // 标准计费模式（按余额扣费） + SubscriptionTypeSubscription = domain.SubscriptionTypeSubscription // 订阅模式（按限额控制） ) // Subscription status constants const ( - SubscriptionStatusActive = "active" - SubscriptionStatusExpired = "expired" - SubscriptionStatusSuspended = "suspended" + SubscriptionStatusActive = domain.SubscriptionStatusActive + SubscriptionStatusExpired = domain.SubscriptionStatusExpired + SubscriptionStatusSuspended = domain.SubscriptionStatusSuspended ) // LinuxDoConnectSyntheticEmailDomain 是 LinuxDo Connect 用户的合成邮箱后缀（RFC 保留域名）。 diff --git a/backend/internal/service/wire.go b/backend/internal/service/wire.go index df86b2e7..096e15a0 100644 --- a/backend/internal/service/wire.go +++ b/backend/internal/service/wire.go @@ -226,6 +226,7 @@ var ProviderSet = wire.NewSet( ProvidePricingService, NewBillingService, NewBillingCacheService, + NewAnnouncementService, NewAdminService, NewGatewayService, NewOpenAIGatewayService, diff --git a/backend/migrations/045_add_announcements.sql b/backend/migrations/045_add_announcements.sql new file mode 100644 index 00000000..cfb9b4b5 --- /dev/null +++ b/backend/migrations/045_add_announcements.sql @@ -0,0 +1,44 @@ +-- 创建公告表 +CREATE TABLE IF NOT EXISTS announcements ( + id BIGSERIAL PRIMARY KEY, + title VARCHAR(200) NOT NULL, + content TEXT NOT NULL, + status VARCHAR(20) NOT NULL DEFAULT 'draft', + targeting JSONB NOT NULL DEFAULT '{}'::jsonb, + starts_at TIMESTAMPTZ DEFAULT NULL, + ends_at TIMESTAMPTZ DEFAULT NULL, + created_by BIGINT DEFAULT NULL REFERENCES users(id) ON DELETE SET NULL, + updated_by BIGINT DEFAULT NULL REFERENCES users(id) ON DELETE SET NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- 公告已读表 +CREATE TABLE IF NOT EXISTS announcement_reads ( + id BIGSERIAL PRIMARY KEY, + announcement_id BIGINT NOT NULL REFERENCES announcements(id) ON DELETE CASCADE, + user_id BIGINT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + read_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + UNIQUE(announcement_id, user_id) +); + +-- 索引 +CREATE INDEX IF NOT EXISTS idx_announcements_status ON announcements(status); +CREATE INDEX IF NOT EXISTS idx_announcements_starts_at ON announcements(starts_at); +CREATE INDEX IF NOT EXISTS idx_announcements_ends_at ON announcements(ends_at); +CREATE INDEX IF NOT EXISTS idx_announcements_created_at ON announcements(created_at); + +CREATE INDEX IF NOT EXISTS idx_announcement_reads_announcement_id ON announcement_reads(announcement_id); +CREATE INDEX IF NOT EXISTS idx_announcement_reads_user_id ON announcement_reads(user_id); +CREATE INDEX IF NOT EXISTS idx_announcement_reads_read_at ON announcement_reads(read_at); + +COMMENT ON TABLE announcements IS '系统公告'; +COMMENT ON COLUMN announcements.status IS '状态: draft, active, archived'; +COMMENT ON COLUMN announcements.targeting IS '展示条件（JSON 规则）'; +COMMENT ON COLUMN announcements.starts_at IS '开始展示时间（为空表示立即生效）'; +COMMENT ON COLUMN announcements.ends_at IS '结束展示时间（为空表示永久生效）'; + +COMMENT ON TABLE announcement_reads IS '公告已读记录'; +COMMENT ON COLUMN announcement_reads.read_at IS '用户首次已读时间'; + diff --git a/frontend/src/api/admin/announcements.ts b/frontend/src/api/admin/announcements.ts new file mode 100644 index 00000000..d02fdda7 --- /dev/null +++ b/frontend/src/api/admin/announcements.ts @@ -0,0 +1,71 @@ +/** + * Admin Announcements API endpoints + */ + +import { apiClient } from '../client' +import type { + Announcement, + AnnouncementUserReadStatus, + BasePaginationResponse, + CreateAnnouncementRequest, + UpdateAnnouncementRequest +} from '@/types' + +export async function list( + page: number = 1, + pageSize: number = 20, + filters?: { + status?: string + search?: string + } +): Promise> { + const { data } = await apiClient.get>('/admin/announcements', { + params: { page, page_size: pageSize, ...filters } + }) + return data +} + +export async function getById(id: number): Promise { + const { data } = await apiClient.get(`/admin/announcements/${id}`) + return data +} + +export async function create(request: CreateAnnouncementRequest): Promise { + const { data } = await apiClient.post('/admin/announcements', request) + return data +} + +export async function update(id: number, request: UpdateAnnouncementRequest): Promise { + const { data } = await apiClient.put(`/admin/announcements/${id}`, request) + return data +} + +export async function deleteAnnouncement(id: number): Promise<{ message: string }> { + const { data } = await apiClient.delete<{ message: string }>(`/admin/announcements/${id}`) + return data +} + +export async function getReadStatus( + id: number, + page: number = 1, + pageSize: number = 20, + search: string = '' +): Promise> { + const { data } = await apiClient.get>( + `/admin/announcements/${id}/read-status`, + { params: { page, page_size: pageSize, search } } + ) + return data +} + +const announcementsAPI = { + list, + getById, + create, + update, + delete: deleteAnnouncement, + getReadStatus +} + +export default announcementsAPI + diff --git a/frontend/src/api/admin/index.ts b/frontend/src/api/admin/index.ts index e86f6348..a88b02c6 100644 --- a/frontend/src/api/admin/index.ts +++ b/frontend/src/api/admin/index.ts @@ -10,6 +10,7 @@ import accountsAPI from './accounts' import proxiesAPI from './proxies' import redeemAPI from './redeem' import promoAPI from './promo' +import announcementsAPI from './announcements' import settingsAPI from './settings' import systemAPI from './system' import subscriptionsAPI from './subscriptions' @@ -30,6 +31,7 @@ export const adminAPI = { proxies: proxiesAPI, redeem: redeemAPI, promo: promoAPI, + announcements: announcementsAPI, settings: settingsAPI, system: systemAPI, subscriptions: subscriptionsAPI, @@ -48,6 +50,7 @@ export { proxiesAPI, redeemAPI, promoAPI, + announcementsAPI, settingsAPI, systemAPI, subscriptionsAPI, diff --git a/frontend/src/api/announcements.ts b/frontend/src/api/announcements.ts new file mode 100644 index 00000000..a9034e2a --- /dev/null +++ b/frontend/src/api/announcements.ts @@ -0,0 +1,26 @@ +/** + * User Announcements API endpoints + */ + +import { apiClient } from './client' +import type { UserAnnouncement } from '@/types' + +export async function list(unreadOnly: boolean = false): Promise { + const { data } = await apiClient.get('/announcements', { + params: unreadOnly ? { unread_only: 1 } : {} + }) + return data +} + +export async function markRead(id: number): Promise<{ message: string }> { + const { data } = await apiClient.post<{ message: string }>(`/announcements/${id}/read`) + return data +} + +const announcementsAPI = { + list, + markRead +} + +export default announcementsAPI + diff --git a/frontend/src/api/index.ts b/frontend/src/api/index.ts index 347d0b94..070ce648 100644 --- a/frontend/src/api/index.ts +++ b/frontend/src/api/index.ts @@ -16,6 +16,7 @@ export { userAPI } from './user' export { redeemAPI, type RedeemHistoryItem } from './redeem' export { userGroupsAPI } from './groups' export { totpAPI } from './totp' +export { default as announcementsAPI } from './announcements' // Admin APIs export { adminAPI } from './admin' diff --git a/frontend/src/components/admin/announcements/AnnouncementReadStatusDialog.vue b/frontend/src/components/admin/announcements/AnnouncementReadStatusDialog.vue new file mode 100644 index 00000000..e7d991a8 --- /dev/null +++ b/frontend/src/components/admin/announcements/AnnouncementReadStatusDialog.vue @@ -0,0 +1,186 @@ + + + diff --git a/frontend/src/components/admin/announcements/AnnouncementTargetingEditor.vue b/frontend/src/components/admin/announcements/AnnouncementTargetingEditor.vue new file mode 100644 index 00000000..bd90af42 --- /dev/null +++ b/frontend/src/components/admin/announcements/AnnouncementTargetingEditor.vue @@ -0,0 +1,388 @@ + + + diff --git a/frontend/src/components/layout/AppSidebar.vue b/frontend/src/components/layout/AppSidebar.vue index 474e4390..c685a2fa 100644 --- a/frontend/src/components/layout/AppSidebar.vue +++ b/frontend/src/components/layout/AppSidebar.vue @@ -319,6 +319,21 @@ const ServerIcon = { ) } +const BellIcon = { + render: () => + h( + 'svg', + { fill: 'none', viewBox: '0 0 24 24', stroke: 'currentColor', 'stroke-width': '1.5' }, + [ + h('path', { + 'stroke-linecap': 'round', + 'stroke-linejoin': 'round', + d: 'M14.857 17.082a23.848 23.848 0 005.454-1.31A8.967 8.967 0 0118 9.75V9a6 6 0 10-12 0v.75a8.967 8.967 0 01-2.312 6.022c1.733.64 3.56 1.085 5.455 1.31m5.714 0a24.255 24.255 0 01-5.714 0m5.714 0a3 3 0 11-5.714 0' + }) + ] + ) +} + const TicketIcon = { render: () => h( @@ -418,6 +433,7 @@ const ChevronDoubleRightIcon = { const userNavItems = computed(() => { const items = [ { path: '/dashboard', label: t('nav.dashboard'), icon: DashboardIcon }, + { path: '/announcements', label: t('nav.announcements'), icon: BellIcon }, { path: '/keys', label: t('nav.apiKeys'), icon: KeyIcon }, { path: '/usage', label: t('nav.usage'), icon: ChartIcon, hideInSimpleMode: true }, { path: '/subscriptions', label: t('nav.mySubscriptions'), icon: CreditCardIcon, hideInSimpleMode: true }, @@ -440,6 +456,7 @@ const userNavItems = computed(() => { // Personal navigation items (for admin's "My Account" section, without Dashboard) const personalNavItems = computed(() => { const items = [ + { path: '/announcements', label: t('nav.announcements'), icon: BellIcon }, { path: '/keys', label: t('nav.apiKeys'), icon: KeyIcon }, { path: '/usage', label: t('nav.usage'), icon: ChartIcon, hideInSimpleMode: true }, { path: '/subscriptions', label: t('nav.mySubscriptions'), icon: CreditCardIcon, hideInSimpleMode: true }, @@ -470,6 +487,7 @@ const adminNavItems = computed(() => { { path: '/admin/groups', label: t('nav.groups'), icon: FolderIcon, hideInSimpleMode: true }, { path: '/admin/subscriptions', label: t('nav.subscriptions'), icon: CreditCardIcon, hideInSimpleMode: true }, { path: '/admin/accounts', label: t('nav.accounts'), icon: GlobeIcon }, + { path: '/admin/announcements', label: t('nav.announcements'), icon: BellIcon }, { path: '/admin/proxies', label: t('nav.proxies'), icon: ServerIcon }, { path: '/admin/redeem', label: t('nav.redeemCodes'), icon: TicketIcon, hideInSimpleMode: true }, { path: '/admin/promo-codes', label: t('nav.promoCodes'), icon: GiftIcon, hideInSimpleMode: true }, diff --git a/frontend/src/i18n/locales/en.ts b/frontend/src/i18n/locales/en.ts index dc93d37c..3ceaa063 100644 --- a/frontend/src/i18n/locales/en.ts +++ b/frontend/src/i18n/locales/en.ts @@ -185,6 +185,7 @@ export default { // Navigation nav: { dashboard: 'Dashboard', + announcements: 'Announcements', apiKeys: 'API Keys', usage: 'Usage', redeem: 'Redeem', @@ -1951,6 +1952,73 @@ export default { } }, + // Announcements + announcements: { + title: 'Announcements', + description: 'Create announcements and target by conditions', + createAnnouncement: 'Create Announcement', + editAnnouncement: 'Edit Announcement', + deleteAnnouncement: 'Delete Announcement', + searchAnnouncements: 'Search announcements...', + status: 'Status', + allStatus: 'All Status', + columns: { + title: 'Title', + status: 'Status', + targeting: 'Targeting', + timeRange: 'Schedule', + createdAt: 'Created At', + actions: 'Actions' + }, + statusLabels: { + draft: 'Draft', + active: 'Active', + archived: 'Archived' + }, + form: { + title: 'Title', + content: 'Content (Markdown supported)', + status: 'Status', + startsAt: 'Starts At', + endsAt: 'Ends At', + startsAtHint: 'Leave empty to start immediately', + endsAtHint: 'Leave empty to never expire', + targetingMode: 'Targeting', + targetingAll: 'All users', + targetingCustom: 'Custom rules', + addOrGroup: 'Add OR group', + addAndCondition: 'Add AND condition', + conditionType: 'Condition type', + conditionSubscription: 'Subscription', + conditionBalance: 'Balance', + operator: 'Operator', + balanceValue: 'Balance threshold', + selectPackages: 'Select packages' + }, + operators: { + gt: '>', + gte: '≥', + lt: '<', + lte: '≤', + eq: '=' + }, + targetingSummaryAll: 'All users', + targetingSummaryCustom: 'Custom ({groups} groups)', + timeImmediate: 'Immediate', + timeNever: 'Never', + readStatus: 'Read Status', + eligible: 'Eligible', + readAt: 'Read at', + unread: 'Unread', + searchUsers: 'Search users...', + failedToLoad: 'Failed to load announcements', + failedToCreate: 'Failed to create announcement', + failedToUpdate: 'Failed to update announcement', + failedToDelete: 'Failed to delete announcement', + failedToLoadReadStatus: 'Failed to load read status', + deleteConfirm: 'Are you sure you want to delete this announcement? This action cannot be undone.' + }, + // Promo Codes promo: { title: 'Promo Code Management', @@ -3063,6 +3131,21 @@ export default { 'The administrator enabled the entry but has not configured a purchase URL. Please contact admin.' }, + // Announcements Page + announcements: { + title: 'Announcements', + description: 'View system announcements', + unreadOnly: 'Show unread only', + markRead: 'Mark as read', + readAt: 'Read at', + read: 'Read', + unread: 'Unread', + startsAt: 'Starts at', + endsAt: 'Ends at', + empty: 'No announcements', + emptyUnread: 'No unread announcements' + }, + // User Subscriptions Page userSubscriptions: { title: 'My Subscriptions', diff --git a/frontend/src/i18n/locales/zh.ts b/frontend/src/i18n/locales/zh.ts index 4b6a9be6..0b456624 100644 --- a/frontend/src/i18n/locales/zh.ts +++ b/frontend/src/i18n/locales/zh.ts @@ -182,6 +182,7 @@ export default { // Navigation nav: { dashboard: '仪表盘', + announcements: '公告', apiKeys: 'API 密钥', usage: '使用记录', redeem: '兑换', @@ -2098,6 +2099,73 @@ export default { failedToDelete: '删除兑换码失败' }, + // Announcements + announcements: { + title: '公告管理', + description: '创建公告并按条件投放', + createAnnouncement: '创建公告', + editAnnouncement: '编辑公告', + deleteAnnouncement: '删除公告', + searchAnnouncements: '搜索公告...', + status: '状态', + allStatus: '全部状态', + columns: { + title: '标题', + status: '状态', + targeting: '展示条件', + timeRange: '有效期', + createdAt: '创建时间', + actions: '操作' + }, + statusLabels: { + draft: '草稿', + active: '展示中', + archived: '已归档' + }, + form: { + title: '标题', + content: '内容（支持 Markdown）', + status: '状态', + startsAt: '开始时间', + endsAt: '结束时间', + startsAtHint: '留空表示立即生效', + endsAtHint: '留空表示永久生效', + targetingMode: '展示条件', + targetingAll: '所有用户', + targetingCustom: '按条件', + addOrGroup: '添加 OR 条件组', + addAndCondition: '添加 AND 条件', + conditionType: '条件类型', + conditionSubscription: '订阅套餐', + conditionBalance: '余额', + operator: '运算符', + balanceValue: '余额阈值', + selectPackages: '选择套餐' + }, + operators: { + gt: '>', + gte: '≥', + lt: '<', + lte: '≤', + eq: '=' + }, + targetingSummaryAll: '全部用户', + targetingSummaryCustom: '自定义（{groups} 组）', + timeImmediate: '立即', + timeNever: '永久', + readStatus: '已读情况', + eligible: '符合条件', + readAt: '已读时间', + unread: '未读', + searchUsers: '搜索用户...', + failedToLoad: '加载公告失败', + failedToCreate: '创建公告失败', + failedToUpdate: '更新公告失败', + failedToDelete: '删除公告失败', + failedToLoadReadStatus: '加载已读情况失败', + deleteConfirm: '确定要删除该公告吗？此操作无法撤销。' + }, + // Promo Codes promo: { title: '优惠码管理', @@ -3212,6 +3280,21 @@ export default { notConfiguredDesc: '管理员已开启入口，但尚未配置购买订阅链接，请联系管理员。' }, + // Announcements Page + announcements: { + title: '公告', + description: '查看系统公告', + unreadOnly: '仅显示未读', + markRead: '标记已读', + readAt: '已读时间', + read: '已读', + unread: '未读', + startsAt: '开始时间', + endsAt: '结束时间', + empty: '暂无公告', + emptyUnread: '暂无未读公告' + }, + // User Subscriptions Page userSubscriptions: { title: '我的订阅', diff --git a/frontend/src/router/index.ts b/frontend/src/router/index.ts index a8ddc67f..4e2c1147 100644 --- a/frontend/src/router/index.ts +++ b/frontend/src/router/index.ts @@ -187,6 +187,18 @@ const routes: RouteRecordRaw[] = [ descriptionKey: 'purchase.description' } }, + { + path: '/announcements', + name: 'Announcements', + component: () => import('@/views/user/AnnouncementsView.vue'), + meta: { + requiresAuth: true, + requiresAdmin: false, + title: 'Announcements', + titleKey: 'announcements.title', + descriptionKey: 'announcements.description' + } + }, // ==================== Admin Routes ==================== { @@ -265,6 +277,18 @@ const routes: RouteRecordRaw[] = [ descriptionKey: 'admin.accounts.description' } }, + { + path: '/admin/announcements', + name: 'AdminAnnouncements', + component: () => import('@/views/admin/AnnouncementsView.vue'), + meta: { + requiresAuth: true, + requiresAdmin: true, + title: 'Announcements', + titleKey: 'admin.announcements.title', + descriptionKey: 'admin.announcements.description' + } + }, { path: '/admin/proxies', name: 'AdminProxies', diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts index 6f3b972e..9802d5c8 100644 --- a/frontend/src/types/index.ts +++ b/frontend/src/types/index.ts @@ -129,6 +129,81 @@ export interface UpdateSubscriptionRequest { is_active?: boolean } +// ==================== Announcement Types ==================== + +export type AnnouncementStatus = 'draft' | 'active' | 'archived' + +export type AnnouncementConditionType = 'subscription' | 'balance' + +export type AnnouncementOperator = 'in' | 'gt' | 'gte' | 'lt' | 'lte' | 'eq' + +export interface AnnouncementCondition { + type: AnnouncementConditionType + operator: AnnouncementOperator + group_ids?: number[] + value?: number +} + +export interface AnnouncementConditionGroup { + all_of?: AnnouncementCondition[] +} + +export interface AnnouncementTargeting { + any_of?: AnnouncementConditionGroup[] +} + +export interface Announcement { + id: number + title: string + content: string + status: AnnouncementStatus + targeting: AnnouncementTargeting + starts_at?: string + ends_at?: string + created_by?: number + updated_by?: number + created_at: string + updated_at: string +} + +export interface UserAnnouncement { + id: number + title: string + content: string + starts_at?: string + ends_at?: string + read_at?: string + created_at: string + updated_at: string +} + +export interface CreateAnnouncementRequest { + title: string + content: string + status?: AnnouncementStatus + targeting: AnnouncementTargeting + starts_at?: number + ends_at?: number +} + +export interface UpdateAnnouncementRequest { + title?: string + content?: string + status?: AnnouncementStatus + targeting?: AnnouncementTargeting + starts_at?: number + ends_at?: number +} + +export interface AnnouncementUserReadStatus { + user_id: number + email: string + username: string + balance: number + eligible: boolean + read_at?: string +} + // ==================== Proxy Node Types ==================== export interface ProxyNode { diff --git a/frontend/src/views/admin/AnnouncementsView.vue b/frontend/src/views/admin/AnnouncementsView.vue new file mode 100644 index 00000000..38574454 --- /dev/null +++ b/frontend/src/views/admin/AnnouncementsView.vue @@ -0,0 +1,538 @@ + + + diff --git a/frontend/src/views/user/AnnouncementsView.vue b/frontend/src/views/user/AnnouncementsView.vue new file mode 100644 index 00000000..99ea253e --- /dev/null +++ b/frontend/src/views/user/AnnouncementsView.vue @@ -0,0 +1,140 @@ + + + From 9bee0a20713322adca3c7a0bf3d53b9b338cba74 Mon Sep 17 00:00:00 2001 From: ducky Date: Fri, 30 Jan 2026 17:28:53 +0800 Subject: [PATCH 2/2] chore: gofmt for golangci-lint --- backend/ent/schema/announcement.go | 1 - backend/ent/schema/announcement_read.go | 1 - .../internal/handler/admin/announcement_handler.go | 11 +++++------ backend/internal/handler/announcement_handler.go | 1 - backend/internal/handler/dto/announcement.go | 1 - backend/internal/repository/announcement_read_repo.go | 1 - backend/internal/repository/announcement_repo.go | 1 - .../internal/service/announcement_targeting_test.go | 1 - 8 files changed, 5 insertions(+), 13 deletions(-) diff --git a/backend/ent/schema/announcement.go b/backend/ent/schema/announcement.go index 3b534831..1568778f 100644 --- a/backend/ent/schema/announcement.go +++ b/backend/ent/schema/announcement.go @@ -88,4 +88,3 @@ func (Announcement) Indexes() []ent.Index { index.Fields("ends_at"), } } - diff --git a/backend/ent/schema/announcement_read.go b/backend/ent/schema/announcement_read.go index 2f80d8b2..e0b50777 100644 --- a/backend/ent/schema/announcement_read.go +++ b/backend/ent/schema/announcement_read.go @@ -63,4 +63,3 @@ func (AnnouncementRead) Indexes() []ent.Index { index.Fields("announcement_id", "user_id").Unique(), } } - diff --git a/backend/internal/handler/admin/announcement_handler.go b/backend/internal/handler/admin/announcement_handler.go index a4e9f2f0..0b5d0fbc 100644 --- a/backend/internal/handler/admin/announcement_handler.go +++ b/backend/internal/handler/admin/announcement_handler.go @@ -27,12 +27,12 @@ func NewAnnouncementHandler(announcementService *service.AnnouncementService) *A } type CreateAnnouncementRequest struct { - Title string `json:"title" binding:"required"` - Content string `json:"content" binding:"required"` - Status string `json:"status" binding:"omitempty,oneof=draft active archived"` + Title string `json:"title" binding:"required"` + Content string `json:"content" binding:"required"` + Status string `json:"status" binding:"omitempty,oneof=draft active archived"` Targeting service.AnnouncementTargeting `json:"targeting"` - StartsAt *int64 `json:"starts_at"` // Unix seconds, 0/empty = immediate - EndsAt *int64 `json:"ends_at"` // Unix seconds, 0/empty = never + StartsAt *int64 `json:"starts_at"` // Unix seconds, 0/empty = immediate + EndsAt *int64 `json:"ends_at"` // Unix seconds, 0/empty = never } type UpdateAnnouncementRequest struct { @@ -244,4 +244,3 @@ func (h *AnnouncementHandler) ListReadStatus(c *gin.Context) { response.Paginated(c, items, paginationResult.Total, page, pageSize) } - diff --git a/backend/internal/handler/announcement_handler.go b/backend/internal/handler/announcement_handler.go index 1e1424eb..72823eaf 100644 --- a/backend/internal/handler/announcement_handler.go +++ b/backend/internal/handler/announcement_handler.go @@ -79,4 +79,3 @@ func parseBoolQuery(v string) bool { return false } } - diff --git a/backend/internal/handler/dto/announcement.go b/backend/internal/handler/dto/announcement.go index ec2a8ca7..bc0db1b2 100644 --- a/backend/internal/handler/dto/announcement.go +++ b/backend/internal/handler/dto/announcement.go @@ -72,4 +72,3 @@ func UserAnnouncementFromService(a *service.UserAnnouncement) *UserAnnouncement UpdatedAt: a.Announcement.UpdatedAt, } } - diff --git a/backend/internal/repository/announcement_read_repo.go b/backend/internal/repository/announcement_read_repo.go index 1c6b480a..2dc346b1 100644 --- a/backend/internal/repository/announcement_read_repo.go +++ b/backend/internal/repository/announcement_read_repo.go @@ -81,4 +81,3 @@ func (r *announcementReadRepository) CountByAnnouncementID(ctx context.Context, } return int64(count), nil } - diff --git a/backend/internal/repository/announcement_repo.go b/backend/internal/repository/announcement_repo.go index edeb82e6..52029e4e 100644 --- a/backend/internal/repository/announcement_repo.go +++ b/backend/internal/repository/announcement_repo.go @@ -192,4 +192,3 @@ func announcementEntitiesToService(models []*dbent.Announcement) []service.Annou } return out } - diff --git a/backend/internal/service/announcement_targeting_test.go b/backend/internal/service/announcement_targeting_test.go index fffea26b..4d904c7d 100644 --- a/backend/internal/service/announcement_targeting_test.go +++ b/backend/internal/service/announcement_targeting_test.go @@ -64,4 +64,3 @@ func TestAnnouncementTargeting_Matches_AndOrSemantics(t *testing.T) { require.False(t, targeting.Matches(99.9, map[int64]struct{}{10: {}})) require.True(t, targeting.Matches(100, map[int64]struct{}{10: {}})) } -