model

package
v0.0.0-...-aaa2f95 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 23, 2025 License: AGPL-3.0 Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ActionItem 

type ActionItem struct {
	ActionItemID  uuid.UUID
	TalkSessionID uuid.UUID
	Sequence      int32
	Content       string
	Status        string
	CreatedAt     time.Time
	UpdatedAt     time.Time
}

type AddGeneratedImagesParams 

type AddGeneratedImagesParams struct {
	TalkSessionID uuid.UUID
	WordmapUrl    string
	TsncUrl       string
}

type AuthState 

type AuthState struct {
	ID              int32
	State           string
	Provider        string
	RedirectUrl     string
	CreatedAt       time.Time
	ExpiresAt       time.Time
	RegistrationUrl sql.NullString
	OrganizationID  uuid.NullUUID
}

type ChangeSubjectParams 

type ChangeSubjectParams struct {
	UserID  uuid.UUID
	Subject string
}

type CheckAliasNameExistsParams 

type CheckAliasNameExistsParams struct {
	OrganizationID uuid.UUID
	AliasName      string
}

type CountOpinionsParams 

type CountOpinionsParams struct {
	UserID          uuid.NullUUID
	TalkSessionID   uuid.NullUUID
	ParentOpinionID uuid.NullUUID
}

type CountReportsByTalkSessionParams 

type CountReportsByTalkSessionParams struct {
	TalkSessionID uuid.NullUUID
	Status        sql.NullString
}

type CountSwipeableOpinionsParams 

type CountSwipeableOpinionsParams struct {
	UserID        uuid.UUID
	TalkSessionID uuid.UUID
}

type CountTalkSessionsParams 

type CountTalkSessionsParams struct {
	Status sql.NullString
	UserID uuid.NullUUID
	Theme  sql.NullString
}

type CountTalkSessionsRow 

type CountTalkSessionsRow struct {
	TalkSessionCount int64
	Status           string
}

type CreateActionItemParams 

type CreateActionItemParams struct {
	ActionItemID  uuid.UUID
	TalkSessionID uuid.UUID
	Sequence      int32
	Content       string
	Status        string
	CreatedAt     time.Time
	UpdatedAt     time.Time
}

type CreateAuthStateParams 

type CreateAuthStateParams struct {
	State           string
	Provider        string
	RedirectUrl     string
	ExpiresAt       time.Time
	RegistrationUrl sql.NullString
	OrganizationID  uuid.NullUUID
}

type CreateDeviceParams 

type CreateDeviceParams struct {
	DeviceID    uuid.UUID
	UserID      uuid.UUID
	DeviceToken string
	Platform    string
	DeviceName  sql.NullString
	AppVersion  sql.NullString
	OsVersion   sql.NullString
	Enabled     bool
	CreatedAt   time.Time
	UpdatedAt   time.Time
}

type CreateDomainEventParams 

type CreateDomainEventParams struct {
	ID            uuid.UUID
	EventType     string
	EventData     json.RawMessage
	AggregateID   string
	AggregateType string
	Status        string
	OccurredAt    time.Time
	RetryCount    int32
}

type CreateNotificationPreferenceParams 

type CreateNotificationPreferenceParams struct {
	UserID                  uuid.UUID
	PushNotificationEnabled bool
}

type CreateOpinionParams 

type CreateOpinionParams struct {
	OpinionID       uuid.UUID
	TalkSessionID   uuid.UUID
	UserID          uuid.UUID
	ParentOpinionID uuid.NullUUID
	Title           sql.NullString
	Content         string
	ReferenceUrl    sql.NullString
	PictureUrl      sql.NullString
	CreatedAt       time.Time
}

type CreateOrgUserParams 

type CreateOrgUserParams struct {
	OrganizationUserID uuid.UUID
	UserID             uuid.UUID
	OrganizationID     uuid.UUID
	Role               int32
	CreatedAt          time.Time
	UpdatedAt          time.Time
}

type CreateOrganizationAliasParams 

type CreateOrganizationAliasParams struct {
	AliasID        uuid.UUID
	OrganizationID uuid.UUID
	AliasName      string
	CreatedBy      uuid.UUID
}

type CreateOrganizationParams 

type CreateOrganizationParams struct {
	OrganizationID   uuid.UUID
	OrganizationType int32
	Name             string
	OwnerID          uuid.UUID
	Code             string
	IconUrl          sql.NullString
}

type CreatePasswordAuthParams 

type CreatePasswordAuthParams struct {
	PasswordAuthID         uuid.UUID
	UserID                 uuid.UUID
	PasswordHash           string
	Salt                   sql.NullString
	RequiredPasswordChange bool
	LastChanged            time.Time
	CreatedAt              time.Time
	UpdatedAt              time.Time
}

type CreatePolicyConsentParams 

type CreatePolicyConsentParams struct {
	PolicyConsentID uuid.UUID
	UserID          uuid.UUID
	PolicyVersion   string
	ConsentedAt     time.Time
	IpAddress       string
	UserAgent       string
}

type CreatePolicyParams 

type CreatePolicyParams struct {
	Version   string
	CreatedAt time.Time
}

type CreateReportParams 

type CreateReportParams struct {
	OpinionReportID uuid.UUID
	OpinionID       uuid.UUID
	TalkSessionID   uuid.UUID
	ReporterID      uuid.UUID
	Reason          int32
	Status          string
}

type CreateSessionParams 

type CreateSessionParams struct {
	SessionID      uuid.UUID
	UserID         uuid.UUID
	Provider       string
	SessionStatus  int32
	CreatedAt      time.Time
	ExpiresAt      time.Time
	LastActivityAt time.Time
	OrganizationID uuid.NullUUID
}

type CreateTSConsentParams 

type CreateTSConsentParams struct {
	TalksessionID uuid.UUID
	UserID        uuid.UUID
	ConsentedAt   time.Time
	Restrictions  talksession.Restrictions
}

type CreateTalkSessionConclusionParams 

type CreateTalkSessionConclusionParams struct {
	TalkSessionID uuid.UUID
	Content       string
	CreatedBy     uuid.UUID
}

type CreateTalkSessionLocationParams 

type CreateTalkSessionLocationParams struct {
	TalkSessionID       uuid.UUID
	StGeographyfromtext interface{}
}

type CreateTalkSessionParams 

type CreateTalkSessionParams struct {
	TalkSessionID       uuid.UUID
	Theme               string
	Description         sql.NullString
	ThumbnailUrl        sql.NullString
	OwnerID             uuid.UUID
	ScheduledEndTime    time.Time
	CreatedAt           time.Time
	City                sql.NullString
	Prefecture          sql.NullString
	Restrictions        talksession.Restrictions
	HideReport          sql.NullBool
	OrganizationID      uuid.NullUUID
	OrganizationAliasID uuid.NullUUID
	HideTop             bool
}

type CreateUserAuthParams 

type CreateUserAuthParams struct {
	UserAuthID uuid.UUID
	UserID     uuid.UUID
	Provider   string
	Subject    string
	CreatedAt  time.Time
}

type CreateUserImageParams 

type CreateUserImageParams struct {
	UserImagesID uuid.UUID
	UserID       uuid.UUID
	Key          string
	Width        int32
	Height       int32
	Extension    string
	Archived     bool
	Url          string
}

type CreateUserParams 

type CreateUserParams struct {
	UserID        uuid.UUID
	CreatedAt     time.Time
	Email         sql.NullString
	EmailVerified bool
}

type CreateUserStatusChangeLogParams 

type CreateUserStatusChangeLogParams struct {
	UserStatusChangeLogsID uuid.UUID
	UserID                 uuid.UUID
	Status                 string
	Reason                 sql.NullString
	ChangedAt              time.Time
	ChangedBy              string
	IpAddress              pqtype.Inet
	UserAgent              sql.NullString
	AdditionalData         pqtype.NullRawMessage
}

type CreateVoteParams 

type CreateVoteParams struct {
	VoteID        uuid.UUID
	OpinionID     uuid.UUID
	TalkSessionID uuid.UUID
	UserID        uuid.UUID
	VoteType      int16
	CreatedAt     time.Time
}

type DBTX 

type DBTX interface {
	ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
	PrepareContext(context.Context, string) (*sql.Stmt, error)
	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
}

type DeactivateOrganizationAliasParams 

type DeactivateOrganizationAliasParams struct {
	AliasID       uuid.UUID
	DeactivatedBy uuid.NullUUID
}

type DeleteDeviceByUserIDParams 

type DeleteDeviceByUserIDParams struct {
	DeviceID uuid.UUID
	UserID   uuid.UUID
}

type Device 

type Device struct {
	DeviceID     uuid.UUID
	UserID       uuid.UUID
	DeviceToken  string
	Platform     string
	Enabled      bool
	CreatedAt    time.Time
	UpdatedAt    time.Time
	DeviceName   sql.NullString
	AppVersion   sql.NullString
	OsVersion    sql.NullString
	LastActiveAt sql.NullTime
}

type DomainEvent 

type DomainEvent struct {
	ID            uuid.UUID
	EventType     string
	EventData     json.RawMessage
	AggregateID   string
	AggregateType string
	Status        string
	OccurredAt    time.Time
	ProcessedAt   sql.NullTime
	FailedAt      sql.NullTime
	FailureReason sql.NullString
	RetryCount    int32
}

type EditTalkSessionParams 

type EditTalkSessionParams struct {
	TalkSessionID       uuid.UUID
	Theme               string
	Description         sql.NullString
	ScheduledEndTime    time.Time
	ThumbnailUrl        sql.NullString
	City                sql.NullString
	Prefecture          sql.NullString
	Restrictions        talksession.Restrictions
	HideReport          sql.NullBool
	OrganizationID      uuid.NullUUID
	OrganizationAliasID uuid.NullUUID
	HideTop             bool
}

type ExistsByDeviceTokenAndPlatformParams 

type ExistsByDeviceTokenAndPlatformParams struct {
	DeviceToken string
	Platform    string
}

type FindConsentByUserAndVersionParams 

type FindConsentByUserAndVersionParams struct {
	UserID        uuid.UUID
	PolicyVersion string
}

type FindConsentByUserAndVersionRow 

type FindConsentByUserAndVersionRow struct {
	PolicyConsent PolicyConsent
}

type FindOpinionsByOpinionIDsRow 

type FindOpinionsByOpinionIDsRow struct {
	Opinion Opinion
	User    User
}

type FindOrgUserByOrganizationIDAndUserIDParams 

type FindOrgUserByOrganizationIDAndUserIDParams struct {
	OrganizationID uuid.UUID
	UserID         uuid.UUID
}

type FindOrgUserByOrganizationIDAndUserIDRow 

type FindOrgUserByOrganizationIDAndUserIDRow struct {
	OrganizationUser OrganizationUser
}

type FindOrgUserByOrganizationIDRow 

type FindOrgUserByOrganizationIDRow struct {
	OrganizationUser OrganizationUser
}

type FindOrgUserByUserIDRow 

type FindOrgUserByUserIDRow struct {
	OrganizationUser OrganizationUser
}

type FindOrgUserByUserIDWithOrganizationRow 

type FindOrgUserByUserIDWithOrganizationRow struct {
	User             User
	OrganizationUser OrganizationUser
	Organization     Organization
}

type FindOrganizationByCodeRow 

type FindOrganizationByCodeRow struct {
	Organization Organization
}

type FindOrganizationByIDRow 

type FindOrganizationByIDRow struct {
	Organization Organization
}

type FindOrganizationByNameRow 

type FindOrganizationByNameRow struct {
	Organization Organization
}

type FindOrganizationUsersWithDetailsRow 

type FindOrganizationUsersWithDetailsRow struct {
	OrganizationUser OrganizationUser
	User             User
	Organization     Organization
}

type FindOrganizationsByIDsRow 

type FindOrganizationsByIDsRow struct {
	Organization Organization
}

type FindPolicyByVersionRow 

type FindPolicyByVersionRow struct {
	PolicyVersion PolicyVersion
}

type FindReportByIDRow 

type FindReportByIDRow struct {
	TalkSessionID uuid.UUID
	Report        string
	CreatedAt     time.Time
}

type FindReportByOpinionIDRow 

type FindReportByOpinionIDRow struct {
	OpinionReport OpinionReport
}

type FindReportByOpinionIDsParams 

type FindReportByOpinionIDsParams struct {
	OpinionIds []uuid.UUID
	Status     string
}

type FindReportByOpinionIDsRow 

type FindReportByOpinionIDsRow struct {
	OpinionReport OpinionReport
	Opinion       Opinion
}

type FindReportsByTalkSessionParams 

type FindReportsByTalkSessionParams struct {
	TalkSessionID uuid.NullUUID
	Status        sql.NullString
}

type FindReportsByTalkSessionRow 

type FindReportsByTalkSessionRow struct {
	OpinionReport OpinionReport
}

type FindTSConsentByTalksessionIdAndUserIdParams 

type FindTSConsentByTalksessionIdAndUserIdParams struct {
	TalksessionID uuid.UUID
	UserID        uuid.UUID
}

type FindTSConsentByTalksessionIdAndUserIdRow 

type FindTSConsentByTalksessionIdAndUserIdRow struct {
	TalksessionConsent TalksessionConsent
}

type FindVoteByUserIDAndOpinionIDParams 

type FindVoteByUserIDAndOpinionIDParams struct {
	UserID    uuid.UUID
	OpinionID uuid.UUID
}

type GetActionItemByIDRow 

type GetActionItemByIDRow struct {
	ActionItemID  uuid.UUID
	TalkSessionID uuid.UUID
	Sequence      int32
	Content       string
	Status        string
	CreatedAt     time.Time
	UpdatedAt     time.Time
	DisplayName   sql.NullString
	DisplayID     sql.NullString
	IconUrl       sql.NullString
}

type GetActionItemsByTalkSessionIDRow 

type GetActionItemsByTalkSessionIDRow struct {
	ActionItemID  uuid.UUID
	TalkSessionID uuid.UUID
	Sequence      int32
	Content       string
	Status        string
	CreatedAt     time.Time
	UpdatedAt     time.Time
	DisplayName   sql.NullString
	Display       sql.NullString
	IconUrl       sql.NullString
}

type GetConclusionByIDRow 

type GetConclusionByIDRow struct {
	TalkSessionConclusion TalkSessionConclusion
	User                  User
}

type GetDailyUserStatsParams 

type GetDailyUserStatsParams struct {
	Offset int32
	Limit  int32
}

type GetDailyUserStatsRow 

type GetDailyUserStatsRow struct {
	ActivityDate   time.Time
	TotalUsers     int32
	UsersWithVotes interface{}
	UsersWithPosts interface{}
	ActiveUsers    int32
}

type GetEventsByAggregateIDParams 

type GetEventsByAggregateIDParams struct {
	AggregateID   string
	AggregateType string
}

type GetFeedbackByReportHistoryIDRow 

type GetFeedbackByReportHistoryIDRow struct {
	ReportFeedbackID uuid.UUID
	UserID           uuid.UUID
	FeedbackType     int32
	CreatedAt        time.Time
}

type GetGroupInfoByTalkSessionIdRow 

type GetGroupInfoByTalkSessionIdRow struct {
	PosX           float64
	PosY           float64
	GroupID        int32
	PerimeterIndex sql.NullInt32
	DisplayID      sql.NullString
	DisplayName    sql.NullString
	IconUrl        sql.NullString
	UserID         uuid.UUID
}

type GetGroupRatioByOpinionIDRow 

type GetGroupRatioByOpinionIDRow struct {
	RepresentativeOpinion RepresentativeOpinion
}

type GetLatestPolicyVersionRow 

type GetLatestPolicyVersionRow struct {
	PolicyVersion PolicyVersion
}

type GetOpinionByIDParams 

type GetOpinionByIDParams struct {
	OpinionID uuid.UUID
	UserID    uuid.NullUUID
}

type GetOpinionByIDRow 

type GetOpinionByIDRow struct {
	Opinion         Opinion
	User            User
	CurrentVoteType int16
	ParentVoteType  int16
	ReplyCount      int64
}

type GetOpinionRepliesParams 

type GetOpinionRepliesParams struct {
	OpinionID uuid.UUID
	UserID    uuid.NullUUID
}

type GetOpinionRepliesRow 

type GetOpinionRepliesRow struct {
	OpinionID       uuid.UUID
	Opinion         Opinion
	User            User
	ParentVoteType  int16
	CurrentVoteType int16
}

type GetOpinionsByRankParams 

type GetOpinionsByRankParams struct {
	UserID            uuid.UUID
	TalkSessionID     uuid.UUID
	ExcludeOpinionIds []uuid.UUID
	Rank              int32
	Limit             int32
}

type GetOpinionsByRankRow 

type GetOpinionsByRankRow struct {
	Opinion    Opinion
	User       User
	ReplyCount int64
}

type GetOpinionsByTalkSessionIDParams 

type GetOpinionsByTalkSessionIDParams struct {
	TalkSessionID uuid.UUID
	Limit         int32
	Offset        int32
	UserID        uuid.NullUUID
	IsSeed        sql.NullBool
	SortKey       sql.NullString
}

type GetOpinionsByTalkSessionIDRow 

type GetOpinionsByTalkSessionIDRow struct {
	Opinion         Opinion
	User            User
	ParentVoteType  int16
	ReplyCount      int64
	CurrentVoteType int16
}

type GetOpinionsByUserIDParams 

type GetOpinionsByUserIDParams struct {
	UserID  uuid.UUID
	Limit   int32
	Offset  int32
	SortKey sql.NullString
}

type GetOpinionsByUserIDRow 

type GetOpinionsByUserIDRow struct {
	Opinion        Opinion
	User           User
	ParentVoteType int16
	ReplyCount     int64
}

type GetOwnTalkSessionByDisplayIDWithCountParams 

type GetOwnTalkSessionByDisplayIDWithCountParams struct {
	Offset    sql.NullInt32
	Limit     sql.NullInt32
	DisplayID string
	Status    sql.NullString
	Theme     sql.NullString
}

type GetOwnTalkSessionByDisplayIDWithCountRow 

type GetOwnTalkSessionByDisplayIDWithCountRow struct {
	TalkSession    TalkSession
	OpinionCount   int64
	User           User
	AliasName      string
	AliasID        uuid.UUID
	OrganizationID uuid.UUID
	Latitude       float64
	Longitude      float64
	TotalCount     int64
}

type GetParentOpinionsParams 

type GetParentOpinionsParams struct {
	OpinionID uuid.UUID
	UserID    uuid.NullUUID
}

type GetParentOpinionsRow 

type GetParentOpinionsRow struct {
	Opinion         Opinion
	User            User
	ParentVoteType  int16
	ReplyCount      int64
	CurrentVoteType int16
	Level           int32
}

type GetPasswordAuthByUserIdRow 

type GetPasswordAuthByUserIdRow struct {
	PasswordAuth PasswordAuth
}

type GetRandomOpinionsParams 

type GetRandomOpinionsParams struct {
	UserID            uuid.UUID
	TalkSessionID     uuid.UUID
	Limit             int32
	ExcludeOpinionIds []uuid.UUID
}

type GetRandomOpinionsRow 

type GetRandomOpinionsRow struct {
	Opinion    Opinion
	User       User
	ReplyCount int64
}

type GetReportByTalkSessionIdRow 

type GetReportByTalkSessionIdRow struct {
	TalkSessionID uuid.UUID
	Report        string
	CreatedAt     time.Time
}

type GetRepresentativeOpinionsByTalkSessionIdRow 

type GetRepresentativeOpinionsByTalkSessionIdRow struct {
	RepresentativeOpinion RepresentativeOpinion
	Opinion               Opinion
	User                  User
	ReplyCount            int64
}

type GetRespondTalkSessionByUserIDParams 

type GetRespondTalkSessionByUserIDParams struct {
	Limit  int32
	Offset int32
	UserID uuid.NullUUID
	Status sql.NullString
	Theme  sql.NullString
}

type GetRespondTalkSessionByUserIDRow 

type GetRespondTalkSessionByUserIDRow struct {
	TalkSession    TalkSession
	OpinionCount   int64
	User           User
	AliasName      string
	AliasID        uuid.UUID
	OrganizationID uuid.UUID
	CreatedAt      sql.NullTime
	LocationID     uuid.NullUUID
	Latitude       float64
	Longitude      float64
}

type GetSeedOpinionsParams 

type GetSeedOpinionsParams struct {
	TalkSessionID uuid.UUID
	UserID        uuid.UUID
	Limit         int32
}

type GetSeedOpinionsRow 

type GetSeedOpinionsRow struct {
	Opinion    Opinion
	User       User
	ReplyCount int64
}

type GetTalkSessionByIDRow 

type GetTalkSessionByIDRow struct {
	TalkSession    TalkSession
	OpinionCount   int64
	User           User
	AliasName      string
	AliasID        uuid.UUID
	OrganizationID uuid.UUID
	LocationID     uuid.NullUUID
	Latitude       float64
	Longitude      float64
}

type GetTalkSessionConclusionByIDRow 

type GetTalkSessionConclusionByIDRow struct {
	TalkSessionID uuid.UUID
	Content       string
	CreatedBy     uuid.UUID
	CreatedAt     time.Time
	UpdatedAt     time.Time
	UserID        uuid.NullUUID
	DisplayName   sql.NullString
	DisplayID     sql.NullString
	IconUrl       sql.NullString
}

type GetUnprocessedEventsParams 

type GetUnprocessedEventsParams struct {
	RetryCount int32
	Column2    []string
	Limit      int32
}

type GetUserAuthByUserIDRow 

type GetUserAuthByUserIDRow struct {
	UserAuth UserAuth
}

type GetUserByIDRow 

type GetUserByIDRow struct {
	User User
}

type GetUserBySubjectRow 

type GetUserBySubjectRow struct {
	User     User
	UserAuth UserAuth
}

type GetUserDetailByIDRow 

type GetUserDetailByIDRow struct {
	User            User
	UserAuth        UserAuth
	UserDemographic UserDemographic
}

type GetUserStatsRow 

type GetUserStatsRow struct {
	TotalUsers     int64
	UsersWithVotes int64
	UsersWithPosts int64
	ActiveUsers    int64
}

type GetWeeklyUserStatsParams 

type GetWeeklyUserStatsParams struct {
	Offset int32
	Limit  int32
}

type GetWeeklyUserStatsRow 

type GetWeeklyUserStatsRow struct {
	ActivityDate   time.Time
	TotalUsers     int32
	UsersWithVotes interface{}
	UsersWithPosts interface{}
	ActiveUsers    int32
}

type InvalidateDeviceByTokenParams 

type InvalidateDeviceByTokenParams struct {
	DeviceToken string
	Platform    string
}

type ListTalkSessionsParams 

type ListTalkSessionsParams struct {
	Limit     int32
	Offset    int32
	Latitude  sql.NullFloat64
	Longitude sql.NullFloat64
	Status    sql.NullString
	Theme     sql.NullString
	SortKey   sql.NullString
}

type ListTalkSessionsRow 

type ListTalkSessionsRow struct {
	TalkSession    TalkSession
	OpinionCount   int64
	User           User
	AliasName      string
	AliasID        uuid.UUID
	OrganizationID uuid.UUID
	VoteCount      int64
	VoteUserCount  int64
	LocationID     uuid.NullUUID
	Latitude       float64
	Longitude      float64
	Distance       interface{}
}

type MarkEventAsFailedParams 

type MarkEventAsFailedParams struct {
	ID            uuid.UUID
	FailureReason sql.NullString
}

type NotificationHistory 

type NotificationHistory struct {
	ID               uuid.UUID
	UserID           uuid.UUID
	DeviceID         uuid.NullUUID
	NotificationType string
	Title            string
	Body             string
	Data             pqtype.NullRawMessage
	Status           string
	FailureReason    sql.NullString
	Read             bool
	ReadAt           sql.NullTime
	SentAt           time.Time
}

type NotificationPreference 

type NotificationPreference struct {
	ID                      uuid.UUID
	UserID                  uuid.UUID
	PushNotificationEnabled bool
	CreatedAt               time.Time
	UpdatedAt               time.Time
}

type Opinion 

type Opinion struct {
	OpinionID       uuid.UUID
	TalkSessionID   uuid.UUID
	UserID          uuid.UUID
	ParentOpinionID uuid.NullUUID
	Title           sql.NullString
	Content         string
	CreatedAt       time.Time
	PictureUrl      sql.NullString
	ReferenceUrl    sql.NullString
}

type OpinionReport 

type OpinionReport struct {
	OpinionReportID uuid.UUID
	OpinionID       uuid.UUID
	TalkSessionID   uuid.UUID
	ReporterID      uuid.UUID
	Reason          int32
	Status          string
	CreatedAt       time.Time
	UpdatedAt       time.Time
	ReasonText      sql.NullString
}

type Organization 

type Organization struct {
	OrganizationID   uuid.UUID
	OrganizationType int32
	Name             string
	OwnerID          uuid.UUID
	Code             string
	IconUrl          sql.NullString
}

type OrganizationAlias 

type OrganizationAlias struct {
	AliasID        uuid.UUID
	OrganizationID uuid.UUID
	AliasName      string
	CreatedAt      time.Time
	UpdatedAt      time.Time
	CreatedBy      uuid.UUID
	DeactivatedAt  sql.NullTime
	DeactivatedBy  uuid.NullUUID
}

type OrganizationUser 

type OrganizationUser struct {
	OrganizationUserID uuid.UUID
	UserID             uuid.UUID
	OrganizationID     uuid.UUID
	CreatedAt          time.Time
	UpdatedAt          time.Time
	Role               int32
}

type PasswordAuth 

type PasswordAuth struct {
	PasswordAuthID         uuid.UUID
	UserID                 uuid.UUID
	PasswordHash           string
	Salt                   sql.NullString
	RequiredPasswordChange bool
	LastChanged            time.Time
	CreatedAt              time.Time
	UpdatedAt              time.Time
}

type PolicyConsent 

type PolicyConsent struct {
	PolicyConsentID uuid.UUID
	UserID          uuid.UUID
	PolicyVersion   string
	ConsentedAt     time.Time
	IpAddress       string
	UserAgent       string
}

type PolicyVersion 

type PolicyVersion struct {
	Version   string
	CreatedAt time.Time
}

type Queries 

type Queries struct {
	// contains filtered or unexported fields
}

func New 

func New(db DBTX) *Queries

func (*Queries) AddGeneratedImages 

func (q *Queries) AddGeneratedImages(ctx context.Context, arg AddGeneratedImagesParams) error

AddGeneratedImages 

INSERT INTO talk_session_generated_images (talk_session_id, wordmap_url, tsnc_url) VALUES ($1, $2, $3)
ON CONFLICT (talk_session_id) DO UPDATE SET wordmap_url = $2, tsnc_url = $3, updated_at = NOW()

func (*Queries) ChangeSubject 

func (q *Queries) ChangeSubject(ctx context.Context, arg ChangeSubjectParams) error

ChangeSubject 

UPDATE "user_auths" SET subject = $2 WHERE user_id = $1

func (*Queries) CheckAliasNameExists 

func (q *Queries) CheckAliasNameExists(ctx context.Context, arg CheckAliasNameExistsParams) (bool, error)

CheckAliasNameExists 

SELECT EXISTS(
    SELECT 1 FROM organization_aliases
    WHERE organization_id = $1 AND alias_name = $2 AND deactivated_at IS NULL
)

func (*Queries) CountActiveAliasesByOrganization 

func (q *Queries) CountActiveAliasesByOrganization(ctx context.Context, organizationID uuid.UUID) (int64, error)

CountActiveAliasesByOrganization 

SELECT COUNT(*) FROM organization_aliases
WHERE organization_id = $1 AND deactivated_at IS NULL

func (*Queries) CountOpinions 

func (q *Queries) CountOpinions(ctx context.Context, arg CountOpinionsParams) (int64, error)

CountOpinions 

SELECT
    COUNT(opinions.*) AS opinion_count
FROM opinions
WHERE
    CASE
        WHEN $1::uuid IS NOT NULL THEN opinions.user_id = $1::uuid
        ELSE TRUE
    END
    AND
    CASE
        WHEN $2::uuid IS NOT NULL THEN opinions.talk_session_id = $2::uuid
        ELSE TRUE
    END
    AND
    CASE
        WHEN $3::uuid IS NOT NULL THEN opinions.parent_opinion_id = $3::uuid
        ELSE TRUE
    END

func (*Queries) CountReportsByTalkSession 

func (q *Queries) CountReportsByTalkSession(ctx context.Context, arg CountReportsByTalkSessionParams) (int64, error)

CountReportsByTalkSession 

SELECT
  COUNT(*) AS count
FROM
  opinion_reports
WHERE
  talk_session_id = $1::uuid
  AND
  CASE
    WHEN $2::text IS NOT NULL THEN opinion_reports.status = $2::text
    ELSE TRUE
  END

func (*Queries) CountSwipeableOpinions 

func (q *Queries) CountSwipeableOpinions(ctx context.Context, arg CountSwipeableOpinionsParams) (int64, error)

指定されたユーザーが投票していない意見のみを取得 通報された意見を除外 トークセッションに紐づく意見のみを取得 

SELECT COUNT(opinions.opinion_id) AS random_opinion_count
FROM opinions
LEFT JOIN (
    SELECT opinions.opinion_id
    FROM opinions
    LEFT JOIN votes
        ON opinions.opinion_id = votes.opinion_id
        AND votes.user_id = $1
    GROUP BY opinions.opinion_id
    HAVING COUNT(votes.vote_id) = 0
) vote_count ON opinions.opinion_id = vote_count.opinion_id
LEFT JOIN (
	SELECT DISTINCT opinion_reports.opinion_id, opinion_reports.status
	FROM opinion_reports
	WHERE opinion_reports.talk_session_id = $2
) opr ON opr.opinion_id = opinions.opinion_id
WHERE opinions.talk_session_id = $2
    AND vote_count.opinion_id = opinions.opinion_id
    AND opinions.parent_opinion_id IS NULL
    AND (opr.opinion_id IS NULL OR opr.status != 'deleted')

func (*Queries) CountTalkSessions 

func (q *Queries) CountTalkSessions(ctx context.Context, arg CountTalkSessionsParams) (CountTalkSessionsRow, error)

talk_session_locationsがない場合も考慮 

SELECT
    COUNT(DISTINCT talk_sessions.talk_session_id) AS talk_session_count,
    $1::text AS status
FROM talk_sessions
LEFT JOIN talk_session_locations
    ON talk_sessions.talk_session_id = talk_session_locations.talk_session_id
LEFT JOIN votes
    ON votes.talk_session_id = talk_sessions.talk_session_id
WHERE
    talk_sessions.hide_top = FALSE AND
    CASE
        WHEN $2::uuid IS NOT NULL
            THEN votes.user_id = $2::uuid
        ELSE TRUE
    END
    AND
    CASE $1::text
        WHEN 'open' THEN talk_sessions.scheduled_end_time > now()
        WHEN 'finished' THEN talk_sessions.scheduled_end_time <= now()
        ELSE TRUE
    END
    AND
    CASE
        WHEN $3::text IS NOT NULL
        THEN talk_sessions.theme LIKE '%' || $3::text || '%'
        ELSE TRUE
    END

func (*Queries) CreateActionItem 

func (q *Queries) CreateActionItem(ctx context.Context, arg CreateActionItemParams) error

CreateActionItem 

INSERT INTO action_items (
    action_item_id,
    talk_session_id,
    sequence,
    content,
    status,
    created_at,
    updated_at
) VALUES ($1, $2, $3, $4, $5, $6, $7)

func (*Queries) CreateAuthState 

func (q *Queries) CreateAuthState(ctx context.Context, arg CreateAuthStateParams) (AuthState, error)

CreateAuthState 

INSERT INTO auth_states (
    state,
    provider,
    redirect_url,
    expires_at,
    registration_url,
    organization_id
) VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6
) RETURNING id, state, provider, redirect_url, created_at, expires_at, registration_url, organization_id

func (*Queries) CreateDevice 

func (q *Queries) CreateDevice(ctx context.Context, arg CreateDeviceParams) (Device, error)

CreateDevice 

INSERT INTO devices (
    device_id,
    user_id,
    device_token,
    platform,
    device_name,
    app_version,
    os_version,
    enabled,
    created_at,
    updated_at
) VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6,
    $7,
    $8,
    $9,
    $10
) RETURNING device_id, user_id, device_token, platform, enabled, created_at, updated_at, device_name, app_version, os_version, last_active_at

func (*Queries) CreateDomainEvent 

func (q *Queries) CreateDomainEvent(ctx context.Context, arg CreateDomainEventParams) (DomainEvent, error)

CreateDomainEvent 

INSERT INTO domain_events (
    id,
    event_type,
    event_data,
    aggregate_id,
    aggregate_type,
    status,
    occurred_at,
    retry_count
) VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6,
    $7,
    $8
) RETURNING id, event_type, event_data, aggregate_id, aggregate_type, status, occurred_at, processed_at, failed_at, failure_reason, retry_count

func (*Queries) CreateNotificationPreference 

func (q *Queries) CreateNotificationPreference(ctx context.Context, arg CreateNotificationPreferenceParams) (NotificationPreference, error)

CreateNotificationPreference 

INSERT INTO notification_preferences (
    user_id,
    push_notification_enabled
) VALUES (
    $1, $2
) RETURNING id, user_id, push_notification_enabled, created_at, updated_at

func (*Queries) CreateOpinion 

func (q *Queries) CreateOpinion(ctx context.Context, arg CreateOpinionParams) error

CreateOpinion 

INSERT INTO opinions (
    opinion_id,
    talk_session_id,
    user_id,
    parent_opinion_id,
    title,
    content,
    reference_url,
    picture_url,
    created_at
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)

func (*Queries) CreateOrgUser 

func (q *Queries) CreateOrgUser(ctx context.Context, arg CreateOrgUserParams) error

CreateOrgUser 

INSERT INTO organization_users (
    organization_user_id,
    user_id,
    organization_id,
    role,
    created_at,
    updated_at
) VALUES ($1, $2, $3, $4, $5, $6)

func (*Queries) CreateOrganization 

func (q *Queries) CreateOrganization(ctx context.Context, arg CreateOrganizationParams) error

CreateOrganization 

INSERT INTO organizations (
    organization_id,
    organization_type,
    name,
    owner_id,
    code,
    icon_url
) VALUES ($1, $2, $3, $4, $5, $6)

func (*Queries) CreateOrganizationAlias 

func (q *Queries) CreateOrganizationAlias(ctx context.Context, arg CreateOrganizationAliasParams) (OrganizationAlias, error)

CreateOrganizationAlias 

INSERT INTO organization_aliases (
    alias_id,
    organization_id,
    alias_name,
    created_by
) VALUES ($1, $2, $3, $4)
RETURNING alias_id, organization_id, alias_name, created_at, updated_at, created_by, deactivated_at, deactivated_by

func (*Queries) CreatePasswordAuth 

func (q *Queries) CreatePasswordAuth(ctx context.Context, arg CreatePasswordAuthParams) error

CreatePasswordAuth 

INSERT INTO password_auth (
  password_auth_id,
  user_id,
  password_hash,
  salt,
  required_password_change,
  last_changed,
  created_at,
  updated_at
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)

func (*Queries) CreatePolicy 

func (q *Queries) CreatePolicy(ctx context.Context, arg CreatePolicyParams) error

CreatePolicy 

INSERT INTO policy_versions (
    version,
    created_at
) VALUES ($1, $2)

func (*Queries) CreatePolicyConsent 

func (q *Queries) CreatePolicyConsent(ctx context.Context, arg CreatePolicyConsentParams) error

CreatePolicyConsent 

INSERT INTO policy_consents (
    policy_consent_id,
    user_id,
    policy_version,
    consented_at,
    ip_address,
    user_agent
) VALUES ($1, $2, $3, $4, $5, $6)

func (*Queries) CreateReport 

func (q *Queries) CreateReport(ctx context.Context, arg CreateReportParams) error

CreateReport 

INSERT INTO opinion_reports (
    opinion_report_id,
    opinion_id,
    talk_session_id,
    reporter_id,
    reason,
    status,
    created_at,
    updated_at
) VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6,
    NOW(),
    NOW()
) RETURNING opinion_report_id, opinion_id, talk_session_id, reporter_id, reason, status, created_at, updated_at, reason_text

func (*Queries) CreateSession 

func (q *Queries) CreateSession(ctx context.Context, arg CreateSessionParams) error

CreateSession 

INSERT INTO sessions (session_id, user_id, provider, session_status, created_at, expires_at, last_activity_at, organization_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)

func (*Queries) CreateTSConsent 

func (q *Queries) CreateTSConsent(ctx context.Context, arg CreateTSConsentParams) error

CreateTSConsent 

INSERT INTO talksession_consents (
    talksession_id,
    user_id,
    consented_at,
    restrictions
) VALUES (
    $1,
    $2,
    $3,
    $4
)

func (*Queries) CreateTalkSession 

func (q *Queries) CreateTalkSession(ctx context.Context, arg CreateTalkSessionParams) error

CreateTalkSession 

INSERT INTO talk_sessions (talk_session_id, theme, description, thumbnail_url, owner_id, scheduled_end_time, created_at, city, prefecture, restrictions, hide_report, organization_id, organization_alias_id, hide_top) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)

func (*Queries) CreateTalkSessionConclusion 

func (q *Queries) CreateTalkSessionConclusion(ctx context.Context, arg CreateTalkSessionConclusionParams) error

CreateTalkSessionConclusion 

INSERT INTO talk_session_conclusions (
    talk_session_id,
    content,
    created_by
) VALUES ($1, $2, $3)

func (*Queries) CreateTalkSessionLocation 

func (q *Queries) CreateTalkSessionLocation(ctx context.Context, arg CreateTalkSessionLocationParams) error

CreateTalkSessionLocation 

INSERT INTO talk_session_locations (talk_session_id, location) VALUES ($1, ST_GeographyFromText($2))

func (*Queries) CreateUser 

func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) error

CreateUser 

INSERT INTO users (user_id, created_at, email, email_verified) VALUES ($1, $2, $3, $4)

func (*Queries) CreateUserAuth 

func (q *Queries) CreateUserAuth(ctx context.Context, arg CreateUserAuthParams) error

CreateUserAuth 

INSERT INTO user_auths (user_auth_id, user_id, provider, subject, created_at, is_verified) VALUES ($1, $2, $3, $4, $5, false)

func (*Queries) CreateUserImage 

func (q *Queries) CreateUserImage(ctx context.Context, arg CreateUserImageParams) error

CreateUserImage 

INSERT INTO user_images (
    user_images_id,
    user_id,
    key,
    width,
    height,
    extension,
    archived,
    url
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)

func (*Queries) CreateUserStatusChangeLog 

func (q *Queries) CreateUserStatusChangeLog(ctx context.Context, arg CreateUserStatusChangeLogParams) error

CreateUserStatusChangeLog 

INSERT INTO user_status_change_logs (
    user_status_change_logs_id,
    user_id,
    status,
    reason,
    changed_at,
    changed_by,
    ip_address,
    user_agent,
    additional_data
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)

func (*Queries) CreateVote 

func (q *Queries) CreateVote(ctx context.Context, arg CreateVoteParams) error

CreateVote 

INSERT INTO votes (
    vote_id,
    opinion_id,
    talk_session_id,
    user_id,
    vote_type,
    created_at
) VALUES ($1, $2, $3, $4, $5, $6)

func (*Queries) DeactivateOrganizationAlias 

func (q *Queries) DeactivateOrganizationAlias(ctx context.Context, arg DeactivateOrganizationAliasParams) error

DeactivateOrganizationAlias 

UPDATE organization_aliases
SET deactivated_at = CURRENT_TIMESTAMP,
    deactivated_by = $2,
    updated_at = CURRENT_TIMESTAMP
WHERE alias_id = $1 AND deactivated_at IS NULL

func (*Queries) DeactivateSessions 

func (q *Queries) DeactivateSessions(ctx context.Context, userID uuid.UUID) error

DeactivateSessions 

UPDATE sessions
SET session_status = 1, last_activity_at = NOW()
WHERE session_id IN (
    SELECT
        session_id
    FROM sessions
    WHERE sessions.user_id = $1
    AND session_status = 0
)

func (*Queries) DeleteAuthState 

func (q *Queries) DeleteAuthState(ctx context.Context, state string) error

DeleteAuthState 

DELETE FROM auth_states
WHERE state = $1

func (*Queries) DeleteDevice 

func (q *Queries) DeleteDevice(ctx context.Context, deviceID uuid.UUID) error

DeleteDevice 

DELETE FROM devices
WHERE device_id = $1

func (*Queries) DeleteDeviceByUserID 

func (q *Queries) DeleteDeviceByUserID(ctx context.Context, arg DeleteDeviceByUserIDParams) error

DeleteDeviceByUserID 

DELETE FROM devices
WHERE device_id = $1 AND user_id = $2

func (*Queries) DeleteDevicesByUserID 

func (q *Queries) DeleteDevicesByUserID(ctx context.Context, userID uuid.UUID) error

DeleteDevicesByUserID 

DELETE FROM devices
WHERE user_id = $1

func (*Queries) DeleteExpiredAuthStates 

func (q *Queries) DeleteExpiredAuthStates(ctx context.Context) error

DeleteExpiredAuthStates 

DELETE FROM auth_states
WHERE expires_at <= CURRENT_TIMESTAMP

func (*Queries) DeletePasswordAuth 

func (q *Queries) DeletePasswordAuth(ctx context.Context, userID uuid.UUID) error

DeletePasswordAuth 

DELETE FROM password_auth
WHERE user_id = $1

func (*Queries) EditTalkSession 

func (q *Queries) EditTalkSession(ctx context.Context, arg EditTalkSessionParams) error

EditTalkSession 

UPDATE talk_sessions
    SET theme = $2,
        description = $3,
        scheduled_end_time = $4,
        thumbnail_url = $5,
        city = $6,
        prefecture = $7,
        restrictions = $8,
        hide_report = $9,
        updated_at = NOW(),
        organization_id = $10,
        organization_alias_id = $11,
        hide_top = $12
    WHERE talk_session_id = $1

func (*Queries) ExistsByDeviceTokenAndPlatform 

func (q *Queries) ExistsByDeviceTokenAndPlatform(ctx context.Context, arg ExistsByDeviceTokenAndPlatformParams) (bool, error)

ExistsByDeviceTokenAndPlatform 

SELECT EXISTS (
    SELECT 1 FROM devices
    WHERE device_token = $1 AND platform = $2
) AS exists

func (*Queries) FindActiveSessionsByUserID 

func (q *Queries) FindActiveSessionsByUserID(ctx context.Context, userID uuid.UUID) ([]Session, error)

FindActiveSessionsByUserID 

SELECT session_id, user_id, provider, session_status, expires_at, created_at, last_activity_at, organization_id
FROM sessions
    WHERE user_id = $1
    AND session_status = 0

func (*Queries) FindConsentByUserAndVersion 

func (q *Queries) FindConsentByUserAndVersion(ctx context.Context, arg FindConsentByUserAndVersionParams) (FindConsentByUserAndVersionRow, error)

FindConsentByUserAndVersion 

SELECT
    policy_consents.policy_consent_id, policy_consents.user_id, policy_consents.policy_version, policy_consents.consented_at, policy_consents.ip_address, policy_consents.user_agent
FROM
    policy_consents
WHERE
    user_id = $1
    AND policy_version = $2

func (*Queries) FindOpinionsByOpinionIDs 

func (q *Queries) FindOpinionsByOpinionIDs(ctx context.Context, opinionIds []uuid.UUID) ([]FindOpinionsByOpinionIDsRow, error)

FindOpinionsByOpinionIDs 

SELECT
    opinions.opinion_id, opinions.talk_session_id, opinions.user_id, opinions.parent_opinion_id, opinions.title, opinions.content, opinions.created_at, opinions.picture_url, opinions.reference_url,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date
FROM
    opinions
LEFT JOIN users
    ON opinions.user_id = users.user_id
WHERE
    opinions.opinion_id IN($1)
ORDER BY opinions.created_at DESC

func (*Queries) FindOrgUserByOrganizationID 

func (q *Queries) FindOrgUserByOrganizationID(ctx context.Context, organizationID uuid.UUID) ([]FindOrgUserByOrganizationIDRow, error)

FindOrgUserByOrganizationID 

SELECT
    organization_users.organization_user_id, organization_users.user_id, organization_users.organization_id, organization_users.created_at, organization_users.updated_at, organization_users.role
FROM organization_users
WHERE organization_id = $1

func (*Queries) FindOrgUserByOrganizationIDAndUserID 

func (q *Queries) FindOrgUserByOrganizationIDAndUserID(ctx context.Context, arg FindOrgUserByOrganizationIDAndUserIDParams) (FindOrgUserByOrganizationIDAndUserIDRow, error)

FindOrgUserByOrganizationIDAndUserID 

SELECT
    organization_users.organization_user_id, organization_users.user_id, organization_users.organization_id, organization_users.created_at, organization_users.updated_at, organization_users.role
FROM organization_users
WHERE organization_id = $1
  AND user_id = $2

func (*Queries) FindOrgUserByUserID 

func (q *Queries) FindOrgUserByUserID(ctx context.Context, userID uuid.UUID) ([]FindOrgUserByUserIDRow, error)

FindOrgUserByUserID 

SELECT
    organization_users.organization_user_id, organization_users.user_id, organization_users.organization_id, organization_users.created_at, organization_users.updated_at, organization_users.role
FROM organization_users
WHERE organization_users.user_id = $1

func (*Queries) FindOrgUserByUserIDWithOrganization 

func (q *Queries) FindOrgUserByUserIDWithOrganization(ctx context.Context, userID uuid.UUID) ([]FindOrgUserByUserIDWithOrganizationRow, error)

FindOrgUserByUserIDWithOrganization 

SELECT
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    organization_users.organization_user_id, organization_users.user_id, organization_users.organization_id, organization_users.created_at, organization_users.updated_at, organization_users.role,
    organizations.organization_id, organizations.organization_type, organizations.name, organizations.owner_id, organizations.code, organizations.icon_url
FROM organization_users
LEFT JOIN organizations ON organization_users.organization_id = organizations.organization_id
LEFT JOIN users ON organization_users.user_id = users.user_id
WHERE organization_users.user_id = $1
    AND users.withdrawal_date IS NULL

func (*Queries) FindOrganizationByCode 

func (q *Queries) FindOrganizationByCode(ctx context.Context, code string) (FindOrganizationByCodeRow, error)

FindOrganizationByCode 

SELECT
    organizations.organization_id, organizations.organization_type, organizations.name, organizations.owner_id, organizations.code, organizations.icon_url
FROM organizations
WHERE code = $1

func (*Queries) FindOrganizationByID 

func (q *Queries) FindOrganizationByID(ctx context.Context, organizationID uuid.UUID) (FindOrganizationByIDRow, error)

FindOrganizationByID 

SELECT
    organizations.organization_id, organizations.organization_type, organizations.name, organizations.owner_id, organizations.code, organizations.icon_url
FROM organizations
WHERE organization_id = $1

func (*Queries) FindOrganizationByName 

func (q *Queries) FindOrganizationByName(ctx context.Context, name string) (FindOrganizationByNameRow, error)

FindOrganizationByName 

SELECT
    organizations.organization_id, organizations.organization_type, organizations.name, organizations.owner_id, organizations.code, organizations.icon_url
FROM organizations
WHERE name = $1

func (*Queries) FindOrganizationUsersWithDetails 

func (q *Queries) FindOrganizationUsersWithDetails(ctx context.Context, organizationID uuid.UUID) ([]FindOrganizationUsersWithDetailsRow, error)

退会ユーザーは表示しない 

SELECT
    ou.organization_user_id, ou.user_id, ou.organization_id, ou.created_at, ou.updated_at, ou.role,
    u.user_id, u.display_id, u.display_name, u.icon_url, u.created_at, u.updated_at, u.email, u.email_verified, u.withdrawal_date,
    o.organization_id, o.organization_type, o.name, o.owner_id, o.code, o.icon_url
FROM organizations o
LEFT JOIN organization_users ou ON o.organization_id = ou.organization_id
LEFT JOIN users u ON ou.user_id = u.user_id
WHERE o.organization_id = $1
AND u.withdrawal_date IS NULL
ORDER BY ou.role ASC, u.user_id ASC

func (*Queries) FindOrganizationsByIDs 

func (q *Queries) FindOrganizationsByIDs(ctx context.Context, dollar_1 []uuid.UUID) ([]FindOrganizationsByIDsRow, error)

FindOrganizationsByIDs 

SELECT
    organizations.organization_id, organizations.organization_type, organizations.name, organizations.owner_id, organizations.code, organizations.icon_url
FROM organizations
WHERE organization_id = ANY($1::uuid[])

func (*Queries) FindPolicyByVersion 

func (q *Queries) FindPolicyByVersion(ctx context.Context, version string) (FindPolicyByVersionRow, error)

FindPolicyByVersion 

SELECT
    policy_versions.version, policy_versions.created_at
FROM
    policy_versions
WHERE
    version = $1
LIMIT 1

func (*Queries) FindReportByID 

func (q *Queries) FindReportByID(ctx context.Context, talkSessionID uuid.UUID) (FindReportByIDRow, error)

FindReportByID 

SELECT
    -- talk_session_report_history_id as analysis_report_history_id,
    talk_session_id,
    report,
    created_at
FROM talk_session_reports
WHERE talk_session_id = $1

func (*Queries) FindReportByOpinionID 

func (q *Queries) FindReportByOpinionID(ctx context.Context, opinionID uuid.NullUUID) ([]FindReportByOpinionIDRow, error)

FindReportByOpinionID 

SELECT
    opinion_reports.opinion_report_id, opinion_reports.opinion_id, opinion_reports.talk_session_id, opinion_reports.reporter_id, opinion_reports.reason, opinion_reports.status, opinion_reports.created_at, opinion_reports.updated_at, opinion_reports.reason_text
FROM
    opinion_reports
WHERE
    opinion_id = $1::uuid
ORDER BY created_at DESC

func (*Queries) FindReportByOpinionIDs 

func (q *Queries) FindReportByOpinionIDs(ctx context.Context, arg FindReportByOpinionIDsParams) ([]FindReportByOpinionIDsRow, error)

FindReportByOpinionIDs 

SELECT
    opinion_reports.opinion_report_id, opinion_reports.opinion_id, opinion_reports.talk_session_id, opinion_reports.reporter_id, opinion_reports.reason, opinion_reports.status, opinion_reports.created_at, opinion_reports.updated_at, opinion_reports.reason_text,
    opinions.opinion_id, opinions.talk_session_id, opinions.user_id, opinions.parent_opinion_id, opinions.title, opinions.content, opinions.created_at, opinions.picture_url, opinions.reference_url
FROM
    opinion_reports
LEFT JOIN opinions
    ON opinion_reports.opinion_id = opinions.opinion_id
WHERE
    opinion_reports.opinion_id = ANY($1::uuid[])
    AND opinion_reports.status = $2
ORDER BY opinion_reports.created_at DESC

func (*Queries) FindReportsByTalkSession 

func (q *Queries) FindReportsByTalkSession(ctx context.Context, arg FindReportsByTalkSessionParams) ([]FindReportsByTalkSessionRow, error)

FindReportsByTalkSession 

SELECT
  opinion_reports.opinion_report_id, opinion_reports.opinion_id, opinion_reports.talk_session_id, opinion_reports.reporter_id, opinion_reports.reason, opinion_reports.status, opinion_reports.created_at, opinion_reports.updated_at, opinion_reports.reason_text
FROM
  opinion_reports
WHERE
  talk_session_id = $1::uuid
  AND
  CASE
    WHEN $2::text IS NOT NULL THEN opinion_reports.status = $2::text
    ELSE TRUE
  END
  ORDER BY created_at DESC

func (*Queries) FindSessionBySessionID 

func (q *Queries) FindSessionBySessionID(ctx context.Context, sessionID uuid.UUID) (Session, error)

FindSessionBySessionID 

SELECT session_id, user_id, provider, session_status, expires_at, created_at, last_activity_at, organization_id
FROM sessions
WHERE session_id = $1

func (*Queries) FindTSConsentByTalksessionIdAndUserId 

func (q *Queries) FindTSConsentByTalksessionIdAndUserId(ctx context.Context, arg FindTSConsentByTalksessionIdAndUserIdParams) (FindTSConsentByTalksessionIdAndUserIdRow, error)

FindTSConsentByTalksessionIdAndUserId 

SELECT
    talksession_consents.talksession_id, talksession_consents.user_id, talksession_consents.restrictions, talksession_consents.consented_at
FROM
    talksession_consents
WHERE
    talksession_id = $1
    AND user_id = $2

func (*Queries) FindUserStatusChangeLogsByUserID 

func (q *Queries) FindUserStatusChangeLogsByUserID(ctx context.Context, userID uuid.UUID) ([]UserStatusChangeLog, error)

FindUserStatusChangeLogsByUserID 

SELECT
    user_status_change_logs_id,
    user_id,
    status,
    reason,
    changed_at,
    changed_by,
    ip_address,
    user_agent,
    additional_data,
    created_at
FROM user_status_change_logs
WHERE user_id = $1
ORDER BY changed_at DESC

func (*Queries) FindVoteByUserIDAndOpinionID 

func (q *Queries) FindVoteByUserIDAndOpinionID(ctx context.Context, arg FindVoteByUserIDAndOpinionIDParams) (Vote, error)

FindVoteByUserIDAndOpinionID 

SELECT vote_id, opinion_id, user_id, vote_type, created_at, talk_session_id FROM votes WHERE user_id = $1 AND opinion_id = $2

func (*Queries) GetActionItemByID 

func (q *Queries) GetActionItemByID(ctx context.Context, actionItemID uuid.UUID) (GetActionItemByIDRow, error)

GetActionItemByID 

SELECT
    action_items.action_item_id,
    action_items.talk_session_id,
    action_items.sequence,
    action_items.content,
    action_items.status,
    action_items.created_at,
    action_items.updated_at,
    users.display_name AS display_name,
    users.display_id AS display_id,
    users.icon_url AS icon_url
FROM action_items
LEFT JOIN talk_sessions
    ON talk_sessions.talk_session_id = action_items.talk_session_id
LEFT JOIN users
    ON talk_sessions.owner_id = users.user_id
WHERE action_item_id = $1
ORDER BY action_items.sequence

func (*Queries) GetActionItemsByTalkSessionID 

func (q *Queries) GetActionItemsByTalkSessionID(ctx context.Context, talkSessionID uuid.UUID) ([]GetActionItemsByTalkSessionIDRow, error)

GetActionItemsByTalkSessionID 

SELECT
    action_items.action_item_id,
    action_items.talk_session_id,
    action_items.sequence,
    action_items.content,
    action_items.status,
    action_items.created_at,
    action_items.updated_at,
    users.display_name AS display_name,
    users.display_id AS display,
    users.icon_url AS icon_url
FROM action_items
LEFT JOIN talk_sessions
    ON talk_sessions.talk_session_id = action_items.talk_session_id
LEFT JOIN users
    ON talk_sessions.owner_id = users.user_id
WHERE action_items.talk_session_id = $1
ORDER BY action_items.sequence

func (*Queries) GetActiveDevicesByUserID 

func (q *Queries) GetActiveDevicesByUserID(ctx context.Context, userID uuid.UUID) ([]Device, error)

GetActiveDevicesByUserID 

SELECT device_id, user_id, device_token, platform, enabled, created_at, updated_at, device_name, app_version, os_version, last_active_at FROM devices
WHERE user_id = $1 AND enabled = true
ORDER BY created_at DESC

func (*Queries) GetActiveDevicesByUserIDs 

func (q *Queries) GetActiveDevicesByUserIDs(ctx context.Context, dollar_1 []uuid.UUID) ([]Device, error)

GetActiveDevicesByUserIDs 

SELECT device_id, user_id, device_token, platform, enabled, created_at, updated_at, device_name, app_version, os_version, last_active_at FROM devices
WHERE user_id = ANY($1::uuid[]) AND enabled = true
ORDER BY user_id, created_at DESC

func (*Queries) GetActiveOrganizationAliases 

func (q *Queries) GetActiveOrganizationAliases(ctx context.Context, organizationID uuid.UUID) ([]OrganizationAlias, error)

GetActiveOrganizationAliases 

SELECT alias_id, organization_id, alias_name, created_at, updated_at, created_by, deactivated_at, deactivated_by FROM organization_aliases
WHERE organization_id = $1 AND deactivated_at IS NULL
ORDER BY created_at ASC

func (*Queries) GetAllActiveDevices 

func (q *Queries) GetAllActiveDevices(ctx context.Context) ([]Device, error)

GetAllActiveDevices 

SELECT device_id, user_id, device_token, platform, enabled, created_at, updated_at, device_name, app_version, os_version, last_active_at FROM devices
WHERE enabled = true
ORDER BY user_id, created_at DESC

func (*Queries) GetAllTalkSessionCount 

func (q *Queries) GetAllTalkSessionCount(ctx context.Context) (int64, error)

GetAllTalkSessionCount 

SELECT
    COUNT(DISTINCT talk_sessions.talk_session_id) AS talk_session_count
FROM talk_sessions

func (*Queries) GetAuthState 

func (q *Queries) GetAuthState(ctx context.Context, state string) (AuthState, error)

GetAuthState 

SELECT id, state, provider, redirect_url, created_at, expires_at, registration_url, organization_id FROM auth_states
WHERE state = $1 AND expires_at > CURRENT_TIMESTAMP
LIMIT 1

func (*Queries) GetConclusionByID 

func (q *Queries) GetConclusionByID(ctx context.Context, talkSessionID uuid.UUID) (GetConclusionByIDRow, error)

GetConclusionByID 

SELECT
    conclusion.talk_session_id, conclusion.content, conclusion.created_by, conclusion.created_at, conclusion.updated_at,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date
FROM talk_session_conclusions as conclusion
LEFT JOIN users
    ON conclusion.created_by = users.user_id
WHERE talk_session_id = $1

func (*Queries) GetDailyUserStats 

func (q *Queries) GetDailyUserStats(ctx context.Context, arg GetDailyUserStatsParams) ([]GetDailyUserStatsRow, error)

GetDailyUserStats 

WITH params AS (
    SELECT
        $1::integer AS offset,
        $2::integer AS limit
),
date_bounds AS (
    SELECT
        CURRENT_DATE - ((params.offset + params.limit - 1) * INTERVAL '1 day') AS start_date,
        CURRENT_DATE - (params.offset * INTERVAL '1 day') AS end_date
    FROM params
),
date_range AS (
    SELECT generate_series(
        date_bounds.start_date,
        date_bounds.end_date,
        INTERVAL '1 day'
    )::date as activity_date
    FROM date_bounds
),
user_activity AS (
    SELECT DISTINCT
        users.user_id,
        DATE_TRUNC('day', COALESCE(votes.created_at, opinions.created_at))::date as activity_date,
        CASE WHEN votes.user_id IS NOT NULL THEN 1 ELSE 0 END as has_voted,
        CASE WHEN opinions.user_id IS NOT NULL THEN 1 ELSE 0 END as has_posted
    FROM users
    LEFT JOIN votes ON users.user_id = votes.user_id
    LEFT JOIN opinions ON users.user_id = opinions.user_id
    WHERE users.user_id != '00000000-0000-0000-0000-000000000001'::uuid
    AND COALESCE(votes.created_at, opinions.created_at) IS NOT NULL
    AND users.display_id IS NOT NULL
)
SELECT
    date_range.activity_date,
    COALESCE(COUNT(user_activity.user_id), 0)::integer as total_users,
    COALESCE(SUM(has_voted), 0) as users_with_votes,
    COALESCE(SUM(has_posted), 0) as users_with_posts,
    COALESCE(SUM(CASE WHEN has_voted = 1 OR has_posted = 1 THEN 1 ELSE 0 END), 0)::integer as active_users
FROM date_range
LEFT JOIN user_activity ON date_range.activity_date = user_activity.activity_date
GROUP BY date_range.activity_date
ORDER BY date_range.activity_date DESC

func (*Queries) GetDeviceByID 

func (q *Queries) GetDeviceByID(ctx context.Context, deviceID uuid.UUID) (Device, error)

GetDeviceByID 

SELECT device_id, user_id, device_token, platform, enabled, created_at, updated_at, device_name, app_version, os_version, last_active_at FROM devices
WHERE device_id = $1

func (*Queries) GetDeviceByToken 

func (q *Queries) GetDeviceByToken(ctx context.Context, deviceToken string) (Device, error)

GetDeviceByToken 

SELECT device_id, user_id, device_token, platform, enabled, created_at, updated_at, device_name, app_version, os_version, last_active_at FROM devices
WHERE device_token = $1

func (*Queries) GetDevicesByUserID 

func (q *Queries) GetDevicesByUserID(ctx context.Context, userID uuid.UUID) ([]Device, error)

GetDevicesByUserID 

SELECT device_id, user_id, device_token, platform, enabled, created_at, updated_at, device_name, app_version, os_version, last_active_at FROM devices
WHERE user_id = $1
ORDER BY created_at DESC

func (*Queries) GetEventsByAggregateID 

func (q *Queries) GetEventsByAggregateID(ctx context.Context, arg GetEventsByAggregateIDParams) ([]DomainEvent, error)

GetEventsByAggregateID 

SELECT id, event_type, event_data, aggregate_id, aggregate_type, status, occurred_at, processed_at, failed_at, failure_reason, retry_count FROM domain_events
WHERE aggregate_id = $1
  AND aggregate_type = $2
ORDER BY occurred_at ASC

func (*Queries) GetFeedbackByReportHistoryID 

func (q *Queries) GetFeedbackByReportHistoryID(ctx context.Context, talkSessionReportHistoryID uuid.UUID) ([]GetFeedbackByReportHistoryIDRow, error)

GetFeedbackByReportHistoryID 

SELECT
    report_feedback_id,
    user_id,
    feedback_type,
    created_at
FROM report_feedback
WHERE talk_session_report_history_id = $1

func (*Queries) GetGeneratedImages 

func (q *Queries) GetGeneratedImages(ctx context.Context, dollar_1 uuid.UUID) (TalkSessionGeneratedImage, error)

GetGeneratedImages 

SELECT
    talk_session_id,
    wordmap_url,
    tsnc_url,
    created_at,
    updated_at
FROM talk_session_generated_images
WHERE talk_session_id = $1::uuid

func (*Queries) GetGroupInfoByTalkSessionId 

func (q *Queries) GetGroupInfoByTalkSessionId(ctx context.Context, talkSessionID uuid.UUID) ([]GetGroupInfoByTalkSessionIdRow, error)

GetGroupInfoByTalkSessionId 

SELECT
    user_group_info.pos_x,
    user_group_info.pos_y,
    user_group_info.group_id,
    user_group_info.perimeter_index,
    users.display_id AS display_id,
    users.display_name AS display_name,
    users.icon_url AS icon_url,
    user_group_info.user_id
FROM user_group_info
LEFT JOIN users
    ON user_group_info.user_id = users.user_id
WHERE talk_session_id = $1

func (*Queries) GetGroupListByTalkSessionId 

func (q *Queries) GetGroupListByTalkSessionId(ctx context.Context, talkSessionID uuid.UUID) ([]int32, error)

GetGroupListByTalkSessionId 

SELECT
    DISTINCT user_group_info.group_id
FROM user_group_info
WHERE talk_session_id = $1

func (*Queries) GetGroupRatioByOpinionID 

func (q *Queries) GetGroupRatioByOpinionID(ctx context.Context, opinionID uuid.NullUUID) ([]GetGroupRatioByOpinionIDRow, error)

GetGroupRatioByOpinionID 

SELECT
  representative_opinions.talk_session_id, representative_opinions.opinion_id, representative_opinions.group_id, representative_opinions.rank, representative_opinions.updated_at, representative_opinions.created_at, representative_opinions.agree_count, representative_opinions.disagree_count, representative_opinions.pass_count
FROM representative_opinions
WHERE representative_opinions.opinion_id = $1::uuid
ORDER BY representative_opinions.created_at DESC

func (*Queries) GetLatestPolicyVersion 

func (q *Queries) GetLatestPolicyVersion(ctx context.Context) (GetLatestPolicyVersionRow, error)

GetLatestPolicyVersion 

SELECT
    policy_versions.version, policy_versions.created_at
FROM
    policy_versions
ORDER BY created_at DESC
LIMIT 1

func (*Queries) GetNotificationPreference 

func (q *Queries) GetNotificationPreference(ctx context.Context, userID uuid.UUID) (NotificationPreference, error)

GetNotificationPreference 

SELECT id, user_id, push_notification_enabled, created_at, updated_at FROM notification_preferences
WHERE user_id = $1

func (*Queries) GetNotificationPreferencesByUserIDs 

func (q *Queries) GetNotificationPreferencesByUserIDs(ctx context.Context, dollar_1 []uuid.UUID) ([]NotificationPreference, error)

GetNotificationPreferencesByUserIDs 

SELECT id, user_id, push_notification_enabled, created_at, updated_at FROM notification_preferences
WHERE user_id = ANY($1::uuid[])

func (*Queries) GetOpinionByID 

func (q *Queries) GetOpinionByID(ctx context.Context, arg GetOpinionByIDParams) (GetOpinionByIDRow, error)

親意見に対するユーザーの投票を取得 この意見に対するリプライ数 ユーザーIDが提供された場合、そのユーザーの投票ステータスを一緒に取得 

SELECT
    opinions.opinion_id, opinions.talk_session_id, opinions.user_id, opinions.parent_opinion_id, opinions.title, opinions.content, opinions.created_at, opinions.picture_url, opinions.reference_url,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(cv.vote_type, 0) AS current_vote_type,
    COALESCE(pv.vote_type, 0) AS parent_vote_type,
    COALESCE(rc.reply_count, 0) AS reply_count
FROM opinions
LEFT JOIN users
    ON opinions.user_id = users.user_id
LEFT JOIN (
    SELECT votes.vote_type, votes.user_id, votes.opinion_id
    FROM votes
) pv ON pv.opinion_id = opinions.parent_opinion_id
    AND  pv.user_id = opinions.user_id
LEFT JOIN (
    SELECT COUNT(opinion_id) AS reply_count, parent_opinion_id as opinion_id
    FROM opinions
    GROUP BY parent_opinion_id
) rc ON rc.opinion_id = opinions.opinion_id
LEFT JOIN (
    SELECT votes.vote_type, votes.user_id, votes.opinion_id
    FROM votes
    WHERE votes.user_id = $2::uuid
) cv ON opinions.opinion_id = cv.opinion_id
WHERE opinions.opinion_id = $1

func (*Queries) GetOpinionReplies 

func (q *Queries) GetOpinionReplies(ctx context.Context, arg GetOpinionRepliesParams) ([]GetOpinionRepliesRow, error)

親意見に対する子意見主の投票を取得 ユーザーIDが提供された場合、そのユーザーの投票ステータスを取得 

SELECT
    DISTINCT opinions.opinion_id,
    opinions.opinion_id, opinions.talk_session_id, opinions.user_id, opinions.parent_opinion_id, opinions.title, opinions.content, opinions.created_at, opinions.picture_url, opinions.reference_url,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(pv.vote_type, 0) AS parent_vote_type,
    COALESCE(cv.vote_type, 0) AS current_vote_type
FROM opinions
LEFT JOIN users
    ON opinions.user_id = users.user_id
LEFT JOIN (
    SELECT votes.vote_type, votes.user_id, votes.opinion_id
    FROM votes
    WHERE votes.opinion_id = $1
) pv ON opinions.user_id = pv.user_id
    AND opinions.opinion_id = pv.opinion_id
LEFT JOIN (
    SELECT votes.vote_type, votes.opinion_id
    FROM votes
    WHERE votes.user_id = $2::uuid
) cv ON opinions.opinion_id = cv.opinion_id
WHERE opinions.parent_opinion_id = $1
GROUP BY opinions.opinion_id,users.user_id, users.display_name, users.display_id, users.icon_url, pv.vote_type, cv.vote_type
ORDER BY opinions.created_at DESC

func (*Queries) GetOpinionsByRank 

func (q *Queries) GetOpinionsByRank(ctx context.Context, arg GetOpinionsByRankParams) ([]GetOpinionsByRankRow, error)

指定されたユーザーが投票していない意見のみを取得 親意見に対するユーザーの投票を取得 この意見に対するリプライ数 通報された意見を除外 

SELECT
    opinions.opinion_id, opinions.talk_session_id, opinions.user_id, opinions.parent_opinion_id, opinions.title, opinions.content, opinions.created_at, opinions.picture_url, opinions.reference_url,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(rc.reply_count, 0) AS reply_count
FROM opinions
LEFT JOIN users
    ON opinions.user_id = users.user_id
LEFT JOIN (
    SELECT opinions.opinion_id
    FROM opinions
    LEFT JOIN votes
        ON opinions.opinion_id = votes.opinion_id
        AND votes.user_id = $1::uuid
    GROUP BY opinions.opinion_id
    HAVING COUNT(votes.vote_id) = 0
) vote_count ON opinions.opinion_id = vote_count.opinion_id
LEFT JOIN (
    SELECT votes.vote_type, votes.user_id, votes.opinion_id
    FROM votes
) pv ON opinions.parent_opinion_id = pv.opinion_id
    AND  pv.user_id = opinions.user_id
LEFT JOIN (
    SELECT COUNT(opinion_id) AS reply_count, parent_opinion_id as opinion_id
    FROM opinions
    GROUP BY parent_opinion_id
) rc ON rc.opinion_id = opinions.opinion_id
LEFT JOIN (
	SELECT DISTINCT opinion_reports.opinion_id, opinion_reports.status
	FROM opinion_reports
	WHERE opinion_reports.talk_session_id = $2::uuid
) opr ON opr.opinion_id = opinions.opinion_id
LEFT JOIN representative_opinions ON opinions.opinion_id = representative_opinions.opinion_id
WHERE opinions.talk_session_id = $2::uuid
    AND vote_count.opinion_id = opinions.opinion_id
    AND opinions.opinion_id NOT IN (
        SELECT opinions.opinion_id
        FROM opinions
        WHERE opinions.opinion_id = ANY($3::uuid[])
    )
    AND opinions.parent_opinion_id IS NULL
    -- 削除されたものはスワイプ意見から除外
    AND (opr.opinion_id IS NULL OR opr.status != 'deleted')
    AND representative_opinions.rank = $4::int
LIMIT $5::int

func (*Queries) GetOpinionsByTalkSessionID 

func (q *Queries) GetOpinionsByTalkSessionID(ctx context.Context, arg GetOpinionsByTalkSessionIDParams) ([]GetOpinionsByTalkSessionIDRow, error)

GetOpinionsByTalkSessionID 

WITH unique_opinions AS (
    SELECT DISTINCT ON (opinions.opinion_id)
        opinions.opinion_id, opinions.talk_session_id, opinions.user_id, opinions.parent_opinion_id, opinions.title, opinions.content, opinions.created_at, opinions.picture_url, opinions.reference_url
    FROM opinions
    WHERE opinions.talk_session_id = $1
)
SELECT
    opinions.opinion_id, opinions.talk_session_id, opinions.user_id, opinions.parent_opinion_id, opinions.title, opinions.content, opinions.created_at, opinions.picture_url, opinions.reference_url,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(pv.vote_type, 0) AS parent_vote_type,
    COALESCE(rc.reply_count, 0) AS reply_count,
    COALESCE(cv.vote_type, 0) AS current_vote_type
FROM unique_opinions opinions
LEFT JOIN users ON opinions.user_id = users.user_id
LEFT JOIN (
    SELECT DISTINCT ON (opinion_id) vote_type, user_id, opinion_id
    FROM votes
) pv ON opinions.parent_opinion_id = pv.opinion_id
    AND opinions.user_id = pv.user_id
LEFT JOIN (
    SELECT COUNT(opinion_id) AS reply_count, parent_opinion_id
    FROM opinions
    GROUP BY parent_opinion_id
) rc ON opinions.opinion_id = rc.parent_opinion_id
LEFT JOIN (
    SELECT DISTINCT ON (opinion_id) vote_type, user_id, opinion_id
    FROM votes
    WHERE user_id = $4::uuid
) cv ON opinions.opinion_id = cv.opinion_id
WHERE opinions.parent_opinion_id IS NULL
    -- IsSeedがtrueの場合、ユーザーIDが00000000-0000-0000-0000-000000000001の意見のみを取得
    AND (
        CASE
            WHEN $5::boolean IS TRUE THEN opinions.user_id = '00000000-0000-0000-0000-000000000001'::uuid
            ELSE TRUE
        END
    )
ORDER BY
    CASE $6::text
        WHEN 'latest' THEN EXTRACT(EPOCH FROM opinions.created_at)
        WHEN 'oldest' THEN EXTRACT(EPOCH FROM TIMESTAMP '2199-12-31 23:59:59') - EXTRACT(EPOCH FROM opinions.created_at)
        WHEN 'mostReplies' THEN COALESCE(rc.reply_count, 0)
    END DESC
LIMIT $2 OFFSET $3

func (*Queries) GetOpinionsByUserID 

func (q *Queries) GetOpinionsByUserID(ctx context.Context, arg GetOpinionsByUserIDParams) ([]GetOpinionsByUserIDRow, error)

latest, mostReply, oldestでソート 

SELECT
    opinions.opinion_id, opinions.talk_session_id, opinions.user_id, opinions.parent_opinion_id, opinions.title, opinions.content, opinions.created_at, opinions.picture_url, opinions.reference_url,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(pv.vote_type, 0) AS parent_vote_type,
    -- 意見に対するリプライ数（再帰）
    COALESCE(rc.reply_count, 0) AS reply_count
FROM opinions
LEFT JOIN users
    ON opinions.user_id = users.user_id
LEFT JOIN (
    SELECT votes.vote_type, votes.user_id, votes.opinion_id
    FROM votes
) pv ON opinions.parent_opinion_id = pv.opinion_id
    AND opinions.user_id = pv.user_id
LEFT JOIN (
    SELECT COUNT(opinion_id) AS reply_count, parent_opinion_id
    FROM opinions
    GROUP BY parent_opinion_id
) rc ON opinions.opinion_id = rc.parent_opinion_id
WHERE opinions.user_id = $1
ORDER BY
    CASE $4::text
        WHEN 'latest' THEN EXTRACT(EPOCH FROM opinions.created_at)
        WHEN 'oldest' THEN EXTRACT(EPOCH FROM TIMESTAMP '2199-12-31 23:59:59') - EXTRACT(EPOCH FROM opinions.created_at)
        WHEN 'mostReplies' THEN reply_count
    END DESC
LIMIT $2 OFFSET $3

func (*Queries) GetOrganizationAliasById 

func (q *Queries) GetOrganizationAliasById(ctx context.Context, aliasID uuid.UUID) (OrganizationAlias, error)

GetOrganizationAliasById 

SELECT alias_id, organization_id, alias_name, created_at, updated_at, created_by, deactivated_at, deactivated_by FROM organization_aliases
WHERE alias_id = $1

func (*Queries) GetOwnTalkSessionByDisplayIDWithCount 

func (q *Queries) GetOwnTalkSessionByDisplayIDWithCount(ctx context.Context, arg GetOwnTalkSessionByDisplayIDWithCountParams) ([]GetOwnTalkSessionByDisplayIDWithCountRow, error)

GetOwnTalkSessionByDisplayIDWithCount 

WITH filtered_sessions AS (
    SELECT ts.talk_session_id
    FROM talk_sessions ts
    LEFT JOIN users ON ts.owner_id = users.user_id
    WHERE
        users.display_id = $3::text
        AND
        CASE $4::text
            WHEN 'finished' THEN ts.scheduled_end_time <= now()
            WHEN 'open' THEN ts.scheduled_end_time > now()
            ELSE TRUE
        END
        AND
        CASE
            WHEN $5::text IS NOT NULL
                THEN ts.theme LIKE '%' || $5::text || '%'
            ELSE TRUE
        END
)
SELECT
    ts.talk_session_id, ts.owner_id, ts.theme, ts.scheduled_end_time, ts.created_at, ts.city, ts.prefecture, ts.description, ts.thumbnail_url, ts.restrictions, ts.updated_at, ts.hide_report, ts.organization_id, ts.organization_alias_id, ts.hide_top,
    COALESCE(oc.opinion_count, 0) AS opinion_count,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(organization_aliases.alias_name, '') AS alias_name,
    COALESCE(organization_aliases.alias_id, '00000000-0000-0000-0000-000000000000'::uuid) AS alias_id,
    COALESCE(organization_aliases.organization_id, '00000000-0000-0000-0000-000000000000'::uuid) AS organization_id,
    COALESCE(ST_Y(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location))),0)::float AS latitude,
    COALESCE(ST_X(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location))),0)::float AS longitude,
    (SELECT COUNT(*) FROM filtered_sessions) AS total_count
FROM talk_sessions ts
INNER JOIN filtered_sessions fs ON fs.talk_session_id = ts.talk_session_id
LEFT JOIN (
    SELECT talk_session_id, COUNT(opinion_id) AS opinion_count
    FROM opinions
    GROUP BY talk_session_id
) oc ON oc.talk_session_id = ts.talk_session_id
LEFT JOIN users ON ts.owner_id = users.user_id
LEFT JOIN talk_session_locations ON talk_session_locations.talk_session_id = ts.talk_session_id
LEFT JOIN organization_aliases ON ts.organization_alias_id = organization_aliases.alias_id
ORDER BY ts.created_at DESC
LIMIT $2 OFFSET $1

func (*Queries) GetParentOpinions 

func (q *Queries) GetParentOpinions(ctx context.Context, arg GetParentOpinionsParams) ([]GetParentOpinionsRow, error)

GetParentOpinions 

WITH RECURSIVE opinion_tree AS (
    -- ベースケース：指定された意見から開始
    SELECT
        o.opinion_id,
        o.parent_opinion_id,
        1 as level
    FROM opinions o
    WHERE o.opinion_id = $1

    UNION ALL

    SELECT
        p.opinion_id,
        p.parent_opinion_id,
        t.level + 1
    FROM opinions p
    INNER JOIN opinion_tree t ON t.parent_opinion_id = p.opinion_id
)
SELECT
    o.opinion_id, o.talk_session_id, o.user_id, o.parent_opinion_id, o.title, o.content, o.created_at, o.picture_url, o.reference_url,
    u.user_id, u.display_id, u.display_name, u.icon_url, u.created_at, u.updated_at, u.email, u.email_verified, u.withdrawal_date,
    COALESCE(pv.vote_type, 0) AS parent_vote_type,
    COALESCE(rc.reply_count, 0) AS reply_count,
    COALESCE(cv.vote_type, 0) AS current_vote_type,
    ot.level
FROM opinion_tree ot
JOIN opinions o ON ot.opinion_id = o.opinion_id
LEFT JOIN users u ON o.user_id = u.user_id
LEFT JOIN (
    SELECT votes.vote_type, votes.user_id, votes.opinion_id
    FROM votes
) pv ON o.parent_opinion_id = pv.opinion_id
    AND o.user_id = pv.user_id
LEFT JOIN (
    SELECT votes.vote_type, votes.user_id, votes.opinion_id
    FROM votes
) cv ON o.opinion_id = cv.opinion_id
    AND cv.user_id = $2::uuid
LEFT JOIN (
    SELECT COUNT(opinion_id) AS reply_count, parent_opinion_id
    FROM opinions
    GROUP BY parent_opinion_id
) rc ON o.opinion_id = rc.parent_opinion_id
ORDER BY ot.level DESC

func (*Queries) GetPasswordAuthByUserId 

func (q *Queries) GetPasswordAuthByUserId(ctx context.Context, userID uuid.UUID) (GetPasswordAuthByUserIdRow, error)

GetPasswordAuthByUserId 

SELECT
  password_auth.password_auth_id, password_auth.user_id, password_auth.password_hash, password_auth.salt, password_auth.required_password_change, password_auth.last_changed, password_auth.created_at, password_auth.updated_at
FROM password_auth
WHERE user_id = $1

func (*Queries) GetRandomOpinions 

func (q *Queries) GetRandomOpinions(ctx context.Context, arg GetRandomOpinionsParams) ([]GetRandomOpinionsRow, error)

指定されたユーザーが投票していない意見のみを取得 この意見に対するリプライ数 通報された意見を除外 トークセッションに紐づく意見のみを取得 

SELECT
    opinions.opinion_id, opinions.talk_session_id, opinions.user_id, opinions.parent_opinion_id, opinions.title, opinions.content, opinions.created_at, opinions.picture_url, opinions.reference_url,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(rc.reply_count, 0) AS reply_count
FROM opinions
LEFT JOIN users
    ON opinions.user_id = users.user_id
LEFT JOIN (
    SELECT opinions.opinion_id
    FROM opinions
    LEFT JOIN votes
        ON opinions.opinion_id = votes.opinion_id
        AND votes.user_id = $1
    GROUP BY opinions.opinion_id
    HAVING COUNT(votes.vote_id) = 0
) vote_count ON opinions.opinion_id = vote_count.opinion_id
LEFT JOIN (
    SELECT COUNT(opinion_id) AS reply_count, parent_opinion_id as opinion_id
    FROM opinions
    GROUP BY parent_opinion_id
) rc ON rc.opinion_id = opinions.opinion_id
LEFT JOIN (
	SELECT DISTINCT opinion_reports.opinion_id, opinion_reports.status
	FROM opinion_reports
	WHERE opinion_reports.talk_session_id = $2
) opr ON opr.opinion_id = opinions.opinion_id
WHERE opinions.talk_session_id = $2
    AND vote_count.opinion_id = opinions.opinion_id
    -- exclude_opinion_idsが空でない場合、除外する意見を指定
    AND opinions.opinion_id NOT IN (
        SELECT opinions.opinion_id
        FROM opinions
        WHERE opinions.opinion_id = ANY($4::uuid[])
    )
    -- 親意見がないものを取得
    AND opinions.parent_opinion_id IS NULL
    -- 削除されたものはスワイプ意見から除外
    AND (opr.opinion_id IS NULL OR opr.status != 'deleted')
ORDER BY RANDOM()
LIMIT $3

func (*Queries) GetReportByTalkSessionId 

func (q *Queries) GetReportByTalkSessionId(ctx context.Context, talkSessionID uuid.UUID) (GetReportByTalkSessionIdRow, error)

GetReportByTalkSessionId 

SELECT
    -- talk_session_report_history_id as analysis_report_history_id,
    talk_session_id,
    report,
    created_at
FROM talk_session_reports
WHERE talk_session_id = $1

func (*Queries) GetRepresentativeOpinionsByTalkSessionId 

func (q *Queries) GetRepresentativeOpinionsByTalkSessionId(ctx context.Context, talkSessionID uuid.UUID) ([]GetRepresentativeOpinionsByTalkSessionIdRow, error)

GetRepresentativeOpinionsByTalkSessionId 

SELECT
    representative_opinions.talk_session_id, representative_opinions.opinion_id, representative_opinions.group_id, representative_opinions.rank, representative_opinions.updated_at, representative_opinions.created_at, representative_opinions.agree_count, representative_opinions.disagree_count, representative_opinions.pass_count,
    opinions.opinion_id, opinions.talk_session_id, opinions.user_id, opinions.parent_opinion_id, opinions.title, opinions.content, opinions.created_at, opinions.picture_url, opinions.reference_url,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(rc.reply_count, 0) AS reply_count
FROM representative_opinions
LEFT JOIN opinions
    ON representative_opinions.opinion_id = opinions.opinion_id
LEFT JOIN users
    ON opinions.user_id = users.user_id
LEFT JOIN (
    SELECT COUNT(opinion_id) AS reply_count, parent_opinion_id
    FROM opinions
    GROUP BY parent_opinion_id
) rc ON opinions.opinion_id = rc.parent_opinion_id
WHERE representative_opinions.rank < 4
    AND opinions.talk_session_id = $1
ORDER BY representative_opinions.rank

func (*Queries) GetRespondTalkSessionByUserID 

func (q *Queries) GetRespondTalkSessionByUserID(ctx context.Context, arg GetRespondTalkSessionByUserIDParams) ([]GetRespondTalkSessionByUserIDRow, error)

GetRespondTalkSessionByUserID 

SELECT
    ts.talk_session_id, ts.owner_id, ts.theme, ts.scheduled_end_time, ts.created_at, ts.city, ts.prefecture, ts.description, ts.thumbnail_url, ts.restrictions, ts.updated_at, ts.hide_report, ts.organization_id, ts.organization_alias_id, ts.hide_top,
    COALESCE(oc.opinion_count, 0) AS opinion_count,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(organization_aliases.alias_name, '') AS alias_name,
    COALESCE(organization_aliases.alias_id, '00000000-0000-0000-0000-000000000000'::uuid) AS alias_id,
    COALESCE(organization_aliases.organization_id, '00000000-0000-0000-0000-000000000000'::uuid) AS organization_id,
    organization_aliases.created_at,
    talk_session_locations.talk_session_id as location_id,
    COALESCE(ST_Y(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location))),0)::float AS latitude,
    COALESCE(ST_X(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location))),0)::float AS longitude
FROM talk_sessions ts
LEFT JOIN (
    SELECT talk_session_id, COUNT(opinion_id) AS opinion_count
    FROM opinions
    GROUP BY talk_session_id
) oc ON  oc.talk_session_id = ts.talk_session_id
LEFT JOIN users
    ON ts.owner_id = users.user_id
LEFT JOIN votes
    ON votes.talk_session_id = ts.talk_session_id
LEFT JOIN talk_session_locations
    ON talk_session_locations.talk_session_id = ts.talk_session_id
LEFT JOIN organization_aliases
    ON ts.organization_alias_id = organization_aliases.alias_id
WHERE
    votes.user_id = $3::uuid
    AND
    CASE $4::text IS NOT NULL
        WHEN $4::text = 'finished' THEN ts.scheduled_end_time <= now()
        WHEN $4::text = 'open' THEN ts.scheduled_end_time > now()
        ELSE TRUE
    END
    AND
    CASE
        WHEN $5::text IS NOT NULL
            THEN ts.theme LIKE '%' || $5::text || '%'
        ELSE TRUE
    END
GROUP BY ts.talk_session_id, oc.opinion_count, users.user_id, users.display_name, users.display_id, users.icon_url, talk_session_locations.talk_session_id
ORDER BY ts.created_at DESC
LIMIT $1 OFFSET $2

func (*Queries) GetSeedOpinions 

func (q *Queries) GetSeedOpinions(ctx context.Context, arg GetSeedOpinionsParams) ([]GetSeedOpinionsRow, error)

指定されたユーザーが投票していない意見のみを取得 この意見に対するリプライ数 トークセッションに紐づく意見のみを取得 

SELECT
    opinions.opinion_id, opinions.talk_session_id, opinions.user_id, opinions.parent_opinion_id, opinions.title, opinions.content, opinions.created_at, opinions.picture_url, opinions.reference_url,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(rc.reply_count, 0) AS reply_count
FROM opinions
LEFT JOIN users
    ON opinions.user_id = users.user_id
LEFT JOIN (
    SELECT opinions.opinion_id
    FROM opinions
    LEFT JOIN votes
        ON opinions.opinion_id = votes.opinion_id
        AND votes.user_id = $2
    GROUP BY opinions.opinion_id
    HAVING COUNT(votes.vote_id) = 0
) vote_count ON opinions.opinion_id = vote_count.opinion_id
LEFT JOIN (
    SELECT COUNT(opinion_id) AS reply_count, parent_opinion_id as opinion_id
    FROM opinions
    GROUP BY parent_opinion_id
) rc ON rc.opinion_id = opinions.opinion_id
WHERE opinions.talk_session_id = $1
    AND vote_count.opinion_id = opinions.opinion_id
    AND opinions.parent_opinion_id IS NULL
    AND opinions.user_id = '00000000-0000-0000-0000-000000000001'::uuid
LIMIT $3

func (*Queries) GetTalkSessionByID 

func (q *Queries) GetTalkSessionByID(ctx context.Context, talkSessionID uuid.UUID) (GetTalkSessionByIDRow, error)

GetTalkSessionByID 

SELECT
    ts.talk_session_id, ts.owner_id, ts.theme, ts.scheduled_end_time, ts.created_at, ts.city, ts.prefecture, ts.description, ts.thumbnail_url, ts.restrictions, ts.updated_at, ts.hide_report, ts.organization_id, ts.organization_alias_id, ts.hide_top,
    COALESCE(oc.opinion_count, 0) AS opinion_count,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(organization_aliases.alias_name, '') AS alias_name,
    COALESCE(organization_aliases.alias_id, '00000000-0000-0000-0000-000000000000'::uuid) AS alias_id,
    COALESCE(organization_aliases.organization_id, '00000000-0000-0000-0000-000000000000'::uuid) AS organization_id,
    talk_session_locations.talk_session_id as location_id,
    COALESCE(ST_Y(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location))),0)::float AS latitude,
    COALESCE(ST_X(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location))),0)::float AS longitude
FROM talk_sessions ts
LEFT JOIN users
    ON ts.owner_id = users.user_id
LEFT JOIN (
    SELECT opinions.talk_session_id, COUNT(opinions.opinion_id) AS opinion_count
    FROM opinions
    GROUP BY opinions.talk_session_id
) oc ON ts.talk_session_id = oc.talk_session_id
LEFT JOIN organization_aliases
    ON ts.organization_alias_id = organization_aliases.alias_id
LEFT JOIN talk_session_locations
    ON ts.talk_session_id = talk_session_locations.talk_session_id
WHERE ts.talk_session_id = $1

func (*Queries) GetTalkSessionConclusionByID 

func (q *Queries) GetTalkSessionConclusionByID(ctx context.Context, talkSessionID uuid.UUID) (GetTalkSessionConclusionByIDRow, error)

GetTalkSessionConclusionByID 

SELECT
    talk_session_conclusions.talk_session_id,
    talk_session_conclusions.content,
    talk_session_conclusions.created_by,
    talk_session_conclusions.created_at,
    talk_session_conclusions.updated_at,
    users.user_id AS user_id,
    users.display_name AS display_name,
    users.display_id AS display_id,
    users.icon_url AS icon_url
FROM talk_session_conclusions
LEFT JOIN users
    ON talk_session_conclusions.created_by = users.user_id
WHERE talk_session_id = $1

func (*Queries) GetTalkSessionParticipants 

func (q *Queries) GetTalkSessionParticipants(ctx context.Context, talkSessionID uuid.UUID) ([]uuid.UUID, error)

GetTalkSessionParticipants 

SELECT DISTINCT u.user_id
FROM users u
INNER JOIN opinions o ON u.user_id = o.user_id
WHERE o.talk_session_id = $1

func (*Queries) GetUnprocessedEndedSessions 

func (q *Queries) GetUnprocessedEndedSessions(ctx context.Context, limit int32) ([]TalkSession, error)

GetUnprocessedEndedSessions 

SELECT talk_session_id, owner_id, theme, scheduled_end_time, created_at, city, prefecture, description, thumbnail_url, restrictions, updated_at, hide_report, organization_id, organization_alias_id, hide_top FROM talk_sessions
WHERE scheduled_end_time < NOW()
  AND NOT EXISTS (
    SELECT 1 FROM domain_events
    WHERE aggregate_id = talk_sessions.talk_session_id::text
      AND aggregate_type = 'TalkSession'
      AND event_type = 'talksession.ended'
  )
ORDER BY scheduled_end_time ASC
LIMIT $1
FOR UPDATE SKIP LOCKED

func (*Queries) GetUnprocessedEvents 

func (q *Queries) GetUnprocessedEvents(ctx context.Context, arg GetUnprocessedEventsParams) ([]DomainEvent, error)

GetUnprocessedEvents 

SELECT id, event_type, event_data, aggregate_id, aggregate_type, status, occurred_at, processed_at, failed_at, failure_reason, retry_count FROM domain_events
WHERE status IN ('pending', 'failed')
  AND (status != 'failed' OR retry_count < $1)
  AND ($2::text[] IS NULL OR event_type = ANY($2::text[]))
ORDER BY occurred_at ASC
LIMIT $3
FOR UPDATE SKIP LOCKED

func (*Queries) GetUserAuthByUserID 

func (q *Queries) GetUserAuthByUserID(ctx context.Context, userID uuid.UUID) (GetUserAuthByUserIDRow, error)

GetUserAuthByUserID 

SELECT
    user_auths.user_auth_id, user_auths.user_id, user_auths.provider, user_auths.subject, user_auths.is_verified, user_auths.created_at
FROM
    "user_auths"
WHERE
    user_id = $1

func (*Queries) GetUserByID 

func (q *Queries) GetUserByID(ctx context.Context, userID uuid.UUID) (GetUserByIDRow, error)

GetUserByID 

SELECT
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date
FROM
    "users"
WHERE
    users.user_id = $1

func (*Queries) GetUserBySubject 

func (q *Queries) GetUserBySubject(ctx context.Context, subject string) (GetUserBySubjectRow, error)

GetUserBySubject 

SELECT
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    user_auths.user_auth_id, user_auths.user_id, user_auths.provider, user_auths.subject, user_auths.is_verified, user_auths.created_at
FROM
    "users"
    JOIN "user_auths" ON "users".user_id = "user_auths".user_id
WHERE
    "user_auths".subject = $1

func (*Queries) GetUserDemographicByUserID 

func (q *Queries) GetUserDemographicByUserID(ctx context.Context, userID uuid.UUID) (UserDemographic, error)

GetUserDemographicByUserID 

SELECT
    user_demographics_id, user_id, date_of_birth, gender, city, created_at, updated_at, prefecture
FROM
    "user_demographics"
WHERE
    user_id = $1

func (*Queries) GetUserDetailByID 

func (q *Queries) GetUserDetailByID(ctx context.Context, userID uuid.UUID) (GetUserDetailByIDRow, error)

GetUserDetailByID 

SELECT
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    user_auths.user_auth_id, user_auths.user_id, user_auths.provider, user_auths.subject, user_auths.is_verified, user_auths.created_at,
    user_demographics.user_demographics_id, user_demographics.user_id, user_demographics.date_of_birth, user_demographics.gender, user_demographics.city, user_demographics.created_at, user_demographics.updated_at, user_demographics.prefecture
FROM
    users
LEFT JOIN user_auths ON users.user_id = user_auths.user_id
LEFT JOIN user_demographics ON users.user_id = user_demographics.user_id
WHERE
    users.user_id = $1

func (*Queries) GetUserStats 

func (q *Queries) GetUserStats(ctx context.Context) (GetUserStatsRow, error)

GetUserStats 

WITH user_activity AS (
    SELECT DISTINCT users.user_id,
        CASE WHEN votes.user_id IS NOT NULL THEN 1 ELSE 0 END as has_voted,
        CASE WHEN opinions.user_id IS NOT NULL THEN 1 ELSE 0 END as has_posted
    FROM users
    LEFT JOIN votes ON users.user_id = votes.user_id
    LEFT JOIN opinions ON users.user_id = opinions.user_id
    WHERE users.user_id != '00000000-0000-0000-0000-000000000001'::uuid
    AND users.display_id IS NOT NULL
)
SELECT
    COUNT(*) as total_users,
    SUM(has_voted) as users_with_votes,
    SUM(has_posted) as users_with_posts,
    SUM(CASE WHEN has_voted = 1 OR has_posted = 1 THEN 1 ELSE 0 END) as active_users
FROM user_activity

func (*Queries) GetWeeklyUserStats 

func (q *Queries) GetWeeklyUserStats(ctx context.Context, arg GetWeeklyUserStatsParams) ([]GetWeeklyUserStatsRow, error)

GetWeeklyUserStats 

WITH params AS (
    SELECT
        $1::integer AS offset,
        $2::integer AS limit
),
date_bounds AS (
    SELECT
        DATE_TRUNC('week', CURRENT_DATE - ((params.offset + params.limit - 1) * INTERVAL '1 week')) AS start_date,
        DATE_TRUNC('week', CURRENT_DATE - (params.offset * INTERVAL '1 week')) AS end_date
    FROM params
),
date_range AS (
    SELECT generate_series(
        date_bounds.start_date,
        date_bounds.end_date,
        INTERVAL '1 week'
    )::date as activity_date
    FROM date_bounds
),
user_activity AS (
    SELECT DISTINCT
        users.user_id,
        DATE_TRUNC('week', COALESCE(votes.created_at, opinions.created_at))::date as activity_date,
        CASE WHEN votes.user_id IS NOT NULL THEN 1 ELSE 0 END as has_voted,
        CASE WHEN opinions.user_id IS NOT NULL THEN 1 ELSE 0 END as has_posted
    FROM users
    LEFT JOIN votes ON users.user_id = votes.user_id
    LEFT JOIN opinions ON users.user_id = opinions.user_id
    WHERE users.user_id != '00000000-0000-0000-0000-000000000001'::uuid
    AND COALESCE(votes.created_at, opinions.created_at) IS NOT NULL
    AND users.display_id IS NOT NULL
)
SELECT
    date_range.activity_date,
    COALESCE(COUNT(user_activity.user_id), 0)::integer as total_users,
    COALESCE(SUM(has_voted), 0) as users_with_votes,
    COALESCE(SUM(has_posted), 0) as users_with_posts,
    COALESCE(SUM(CASE WHEN has_voted = 1 OR has_posted = 1 THEN 1 ELSE 0 END), 0)::integer as active_users
FROM date_range
LEFT JOIN user_activity ON date_range.activity_date = user_activity.activity_date
GROUP BY date_range.activity_date
ORDER BY date_range.activity_date DESC

func (*Queries) InvalidateDevice 

func (q *Queries) InvalidateDevice(ctx context.Context, deviceID uuid.UUID) error

InvalidateDevice 

UPDATE devices SET
    enabled = false,
    updated_at = CURRENT_TIMESTAMP
WHERE device_id = $1

func (*Queries) InvalidateDeviceByToken 

func (q *Queries) InvalidateDeviceByToken(ctx context.Context, arg InvalidateDeviceByTokenParams) error

InvalidateDeviceByToken 

UPDATE devices SET
    enabled = false,
    updated_at = CURRENT_TIMESTAMP
WHERE device_token = $1 AND platform = $2

func (*Queries) ListTalkSessions 

func (q *Queries) ListTalkSessions(ctx context.Context, arg ListTalkSessionsParams) ([]ListTalkSessionsRow, error)

ListTalkSessions 

SELECT
    ts.talk_session_id, ts.owner_id, ts.theme, ts.scheduled_end_time, ts.created_at, ts.city, ts.prefecture, ts.description, ts.thumbnail_url, ts.restrictions, ts.updated_at, ts.hide_report, ts.organization_id, ts.organization_alias_id, ts.hide_top,
    COALESCE(oc.opinion_count, 0) AS opinion_count,
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date,
    COALESCE(organization_aliases.alias_name, '') AS alias_name,
    COALESCE(organization_aliases.alias_id, '00000000-0000-0000-0000-000000000000'::uuid) AS alias_id,
    COALESCE(organization_aliases.organization_id, '00000000-0000-0000-0000-000000000000'::uuid) AS organization_id,
    COALESCE(votes.vote_count, 0) AS vote_count,
    COALESCE(vote_users.vote_count, 0) AS vote_user_count,
    talk_session_locations.talk_session_id as location_id,
    COALESCE(ST_Y(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location))),0)::float AS latitude,
    COALESCE(ST_X(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location))),0)::float AS longitude,
    CASE
        WHEN $3::float IS NOT NULL AND $4::float IS NOT NULL AND talk_session_locations.location IS NOT NULL
            THEN ('SRID=4326;POINT(' ||
            ST_Y(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location),4326)) || ' ' ||
            ST_X(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location),4326)) || ')')::geometry
            <->
            ('SRID=4326;POINT(' || $3::float || ' ' || $4::float || ')')::geometry
        ELSE NULL
    END AS distance
FROM talk_sessions ts
LEFT JOIN (
    SELECT talk_session_id, COUNT(opinion_id) AS opinion_count
    FROM opinions
    GROUP BY talk_session_id
) oc ON ts.talk_session_id = oc.talk_session_id
LEFT JOIN users
    ON ts.owner_id = users.user_id
LEFT JOIN (
    SELECT talk_session_id, COUNT(DISTINCT vote_id) AS vote_count
    FROM votes
    GROUP BY talk_session_id
) votes ON ts.talk_session_id = votes.talk_session_id
LEFT JOIN (
    SELECT talk_session_id, COUNT(DISTINCT user_id) AS vote_count
    FROM votes
    GROUP BY talk_session_id
) vote_users ON ts.talk_session_id = vote_users.talk_session_id
LEFT JOIN organization_aliases
    ON ts.organization_alias_id = organization_aliases.alias_id
LEFT JOIN talk_session_locations
    ON ts.talk_session_id = talk_session_locations.talk_session_id
WHERE
    ts.hide_top = FALSE AND
    CASE $5::text
        WHEN 'finished' THEN ts.scheduled_end_time <= now()
        WHEN 'open' THEN ts.scheduled_end_time > now()
        ELSE TRUE
    END
    AND
    (CASE
        WHEN $6::text IS NOT NULL
        THEN ts.theme LIKE '%' || $6::text || '%'
        ELSE TRUE
    END)
    AND
    (CASE $7::text
            WHEN 'nearlest' THEN
                $3::float IS NOT NULL AND $4::float IS NOT NULL
                AND
                ('SRID=4326;POINT(' ||
                ST_Y(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location),4326)) || ' ' ||
                ST_X(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location),4326)) || ')')::geometry
                <->
                ('SRID=4326;POINT(' || $3::float || ' ' || $4::float || ')')::geometry <= 100000
            ELSE TRUE
    END)
ORDER BY
    CASE $7::text
        WHEN 'oldest' THEN (EXTRACT(EPOCH FROM TIMESTAMP '2199-12-31 23:59:59') - EXTRACT(EPOCH FROM ts.created_at))*-1
        WHEN 'mostReplies' THEN -oc.opinion_count
        WHEN 'nearest' THEN (
        CASE
            WHEN $3::float IS NOT NULL AND $4::float IS NOT NULL AND talk_session_locations.location IS NOT NULL
                THEN ('SRID=4326;POINT(' ||
                ST_Y(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location),4326)) || ' ' ||
                ST_X(ST_GeomFromWKB(ST_AsBinary(talk_session_locations.location),4326)) || ')')::geometry
                <->
                ('SRID=4326;POINT(' || $3::float || ' ' || $4::float || ')')::geometry
            ELSE NULL
        END
        )
        ELSE EXTRACT(EPOCH FROM ts.created_at)*-1
    END ASC
LIMIT $1 OFFSET $2

func (*Queries) MarkEventAsFailed 

func (q *Queries) MarkEventAsFailed(ctx context.Context, arg MarkEventAsFailedParams) (DomainEvent, error)

MarkEventAsFailed 

UPDATE domain_events
SET status = 'failed',
    failed_at = NOW(),
    failure_reason = $2,
    retry_count = retry_count + 1
WHERE id = $1
  AND status IN ('pending', 'processing')
RETURNING id, event_type, event_data, aggregate_id, aggregate_type, status, occurred_at, processed_at, failed_at, failure_reason, retry_count

func (*Queries) MarkEventAsProcessed 

func (q *Queries) MarkEventAsProcessed(ctx context.Context, id uuid.UUID) (DomainEvent, error)

MarkEventAsProcessed 

UPDATE domain_events
SET status = 'processed',
    processed_at = NOW()
WHERE id = $1
  AND status IN ('pending', 'processing', 'failed')
RETURNING id, event_type, event_data, aggregate_id, aggregate_type, status, occurred_at, processed_at, failed_at, failure_reason, retry_count

func (*Queries) ReactivateUser 

func (q *Queries) ReactivateUser(ctx context.Context, userID uuid.UUID) error

ReactivateUser 

UPDATE "users" SET withdrawal_date = NULL WHERE user_id = $1

func (*Queries) SaveReportFeedback 

func (q *Queries) SaveReportFeedback(ctx context.Context, arg SaveReportFeedbackParams) error

SaveReportFeedback 

INSERT INTO report_feedback (
    report_feedback_id,
    talk_session_report_history_id,
    user_id,
    feedback_type,
    created_at
) VALUES (
    $1,
    $2,
    $3,
    $4,
    $5
) ON CONFLICT (user_id, talk_session_report_history_id) DO NOTHING

func (*Queries) UpdateActionItem 

func (q *Queries) UpdateActionItem(ctx context.Context, arg UpdateActionItemParams) error

UpdateActionItem 

UPDATE action_items
SET
    content = $2,
    status = $3,
    sequence = $4,
    updated_at = CURRENT_TIMESTAMP
WHERE action_item_id = $1

func (*Queries) UpdateDevice 

func (q *Queries) UpdateDevice(ctx context.Context, arg UpdateDeviceParams) (Device, error)

UpdateDevice 

UPDATE devices SET
    device_token = $2,
    platform = $3,
    device_name = COALESCE($4, device_name),
    app_version = COALESCE($5, app_version),
    os_version = COALESCE($6, os_version),
    enabled = $7,
    last_active_at = CURRENT_TIMESTAMP,
    updated_at = $8
WHERE device_id = $1
RETURNING device_id, user_id, device_token, platform, enabled, created_at, updated_at, device_name, app_version, os_version, last_active_at

func (*Queries) UpdateDeviceActivity 

func (q *Queries) UpdateDeviceActivity(ctx context.Context, deviceID uuid.UUID) error

UpdateDeviceActivity 

UPDATE devices SET
    last_active_at = CURRENT_TIMESTAMP
WHERE device_id = $1

func (*Queries) UpdateNotificationPreference 

func (q *Queries) UpdateNotificationPreference(ctx context.Context, arg UpdateNotificationPreferenceParams) (NotificationPreference, error)

UpdateNotificationPreference 

UPDATE notification_preferences SET
    push_notification_enabled = $2
WHERE user_id = $1
RETURNING id, user_id, push_notification_enabled, created_at, updated_at

func (*Queries) UpdateOrCreateUserDemographic 

func (q *Queries) UpdateOrCreateUserDemographic(ctx context.Context, arg UpdateOrCreateUserDemographicParams) error

UpdateOrCreateUserDemographic 

INSERT INTO user_demographics (
    user_demographics_id,
    user_id,
    date_of_birth,
    gender,
    city,
    prefecture,
    created_at,
    updated_at
) VALUES ($1, $2, $3, $4, $5, $6,  now(), now())
ON CONFLICT (user_id)
DO UPDATE SET
    date_of_birth = $3,
    gender = $4,
    city = $5,
    prefecture = $6,
    updated_at = now()

func (*Queries) UpdateOrganization 

func (q *Queries) UpdateOrganization(ctx context.Context, arg UpdateOrganizationParams) error

UpdateOrganization 

UPDATE organizations SET
    name = $2,
    icon_url = $3
WHERE organization_id = $1

func (*Queries) UpdatePasswordAuth 

func (q *Queries) UpdatePasswordAuth(ctx context.Context, arg UpdatePasswordAuthParams) error

UpdatePasswordAuth 

UPDATE password_auth
SET
  password_hash = $2,
  salt = $3,
  required_password_change = $4,
  last_changed = $5,
  updated_at = $6
WHERE user_id = $1

func (*Queries) UpdateReportStatus 

func (q *Queries) UpdateReportStatus(ctx context.Context, arg UpdateReportStatusParams) error

UpdateReportStatus 

UPDATE opinion_reports
SET status = $1
WHERE opinion_report_id = $2
RETURNING opinion_report_id, opinion_id, talk_session_id, reporter_id, reason, status, created_at, updated_at, reason_text

func (*Queries) UpdateSequencesByActionItemID 

func (q *Queries) UpdateSequencesByActionItemID(ctx context.Context, arg UpdateSequencesByActionItemIDParams) error

指定したActionItemいよりSequenceが大きいものをすべて+1する 

UPDATE action_items
SET
    sequence = sequence + 1
WHERE talk_session_id = $1
    AND sequence >= $2

func (*Queries) UpdateSession 

func (q *Queries) UpdateSession(ctx context.Context, arg UpdateSessionParams) error

UpdateSession 

UPDATE sessions
SET session_status = $2, last_activity_at = $3
WHERE session_id = $1

func (*Queries) UpdateTalkSessionConclusion 

func (q *Queries) UpdateTalkSessionConclusion(ctx context.Context, arg UpdateTalkSessionConclusionParams) error

UpdateTalkSessionConclusion 

UPDATE talk_session_conclusions
SET
    content = $2,
    updated_at = CURRENT_TIMESTAMP
WHERE talk_session_id = $1

func (*Queries) UpdateTalkSessionHideReport 

func (q *Queries) UpdateTalkSessionHideReport(ctx context.Context, arg UpdateTalkSessionHideReportParams) error

UpdateTalkSessionHideReport 

UPDATE talk_sessions SET hide_report = $2 WHERE talk_session_id = $1

func (*Queries) UpdateTalkSessionLocation 

func (q *Queries) UpdateTalkSessionLocation(ctx context.Context, arg UpdateTalkSessionLocationParams) error

UpdateTalkSessionLocation 

UPDATE talk_session_locations SET location = ST_GeographyFromText($2) WHERE talk_session_id = $1

func (*Queries) UpdateUser 

func (q *Queries) UpdateUser(ctx context.Context, arg UpdateUserParams) error

UpdateUser 

UPDATE "users" SET display_id = $2, display_name = $3, icon_url = $4, email = $5, email_verified = $6, withdrawal_date = $7 WHERE user_id = $1

func (*Queries) UpdateUserEmailAndSubject 

func (q *Queries) UpdateUserEmailAndSubject(ctx context.Context, arg UpdateUserEmailAndSubjectParams) error

UpdateUserEmailAndSubject 

UPDATE "users" SET email = $2 WHERE user_id = $1

func (*Queries) UpdateVote 

func (q *Queries) UpdateVote(ctx context.Context, arg UpdateVoteParams) error

UpdateVote 

UPDATE votes SET vote_type = $3 WHERE user_id = $1 AND opinion_id = $2

func (*Queries) UpsertDevice 

func (q *Queries) UpsertDevice(ctx context.Context, arg UpsertDeviceParams) (Device, error)

UpsertDevice 

INSERT INTO devices (
    device_id,
    user_id,
    device_token,
    platform,
    device_name,
    app_version,
    os_version,
    enabled,
    created_at,
    updated_at
) VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6,
    $7,
    $8,
    $9,
    $10
) ON CONFLICT (user_id, device_token, platform) DO UPDATE SET
    device_name = COALESCE(EXCLUDED.device_name, devices.device_name),
    app_version = COALESCE(EXCLUDED.app_version, devices.app_version),
    os_version = COALESCE(EXCLUDED.os_version, devices.os_version),
    enabled = EXCLUDED.enabled,
    last_active_at = CURRENT_TIMESTAMP,
    updated_at = EXCLUDED.updated_at
RETURNING device_id, user_id, device_token, platform, enabled, created_at, updated_at, device_name, app_version, os_version, last_active_at

func (*Queries) UpsertNotificationPreference 

func (q *Queries) UpsertNotificationPreference(ctx context.Context, arg UpsertNotificationPreferenceParams) (NotificationPreference, error)

UpsertNotificationPreference 

INSERT INTO notification_preferences (
    user_id,
    push_notification_enabled
) VALUES (
    $1, $2
) ON CONFLICT (user_id) DO UPDATE SET
    push_notification_enabled = EXCLUDED.push_notification_enabled
RETURNING id, user_id, push_notification_enabled, created_at, updated_at

func (*Queries) UserFindByDisplayID 

func (q *Queries) UserFindByDisplayID(ctx context.Context, displayID sql.NullString) (UserFindByDisplayIDRow, error)

UserFindByDisplayID 

SELECT
    users.user_id, users.display_id, users.display_name, users.icon_url, users.created_at, users.updated_at, users.email, users.email_verified, users.withdrawal_date
FROM
    "users"
WHERE
    display_id = $1

func (*Queries) VerifyUser 

func (q *Queries) VerifyUser(ctx context.Context, userID uuid.UUID) error

VerifyUser 

UPDATE "user_auths" SET is_verified = true WHERE user_id = $1

func (*Queries) WithTx 

func (q *Queries) WithTx(tx *sql.Tx) *Queries

func (*Queries) WithdrawUser 

func (q *Queries) WithdrawUser(ctx context.Context, arg WithdrawUserParams) error

WithdrawUser 

UPDATE "users" SET withdrawal_date = $2 WHERE user_id = $1

type ReportFeedback 

type ReportFeedback struct {
	ReportFeedbackID           uuid.UUID
	TalkSessionReportHistoryID uuid.UUID
	UserID                     uuid.UUID
	FeedbackType               int32
	CreatedAt                  time.Time
}

type RepresentativeOpinion 

type RepresentativeOpinion struct {
	TalkSessionID uuid.UUID
	OpinionID     uuid.UUID
	GroupID       int32
	Rank          int32
	UpdatedAt     time.Time
	CreatedAt     time.Time
	AgreeCount    int32
	DisagreeCount int32
	PassCount     int32
}

type SaveReportFeedbackParams 

type SaveReportFeedbackParams struct {
	ReportFeedbackID           uuid.UUID
	TalkSessionReportHistoryID uuid.UUID
	UserID                     uuid.UUID
	FeedbackType               int32
	CreatedAt                  time.Time
}

type Session 

type Session struct {
	SessionID      uuid.UUID
	UserID         uuid.UUID
	Provider       string
	SessionStatus  int32
	ExpiresAt      time.Time
	CreatedAt      time.Time
	LastActivityAt time.Time
	OrganizationID uuid.NullUUID
}

type TalkSession 

type TalkSession struct {
	TalkSessionID       uuid.UUID
	OwnerID             uuid.UUID
	Theme               string
	ScheduledEndTime    time.Time
	CreatedAt           time.Time
	City                sql.NullString
	Prefecture          sql.NullString
	Description         sql.NullString
	ThumbnailUrl        sql.NullString
	Restrictions        talksession.Restrictions
	UpdatedAt           time.Time
	HideReport          sql.NullBool
	OrganizationID      uuid.NullUUID
	OrganizationAliasID uuid.NullUUID
	HideTop             bool
}

type TalkSessionConclusion 

type TalkSessionConclusion struct {
	TalkSessionID uuid.UUID
	Content       string
	CreatedBy     uuid.UUID
	CreatedAt     time.Time
	UpdatedAt     time.Time
}

type TalkSessionGeneratedImage 

type TalkSessionGeneratedImage struct {
	TalkSessionID uuid.UUID
	WordmapUrl    string
	TsncUrl       string
	CreatedAt     time.Time
	UpdatedAt     time.Time
}

type TalkSessionLocation 

type TalkSessionLocation struct {
	TalkSessionID uuid.UUID
	Location      interface{}
}

type TalkSessionReport 

type TalkSessionReport struct {
	TalkSessionID uuid.UUID
	Report        string
	CreatedAt     time.Time
	UpdatedAt     time.Time
}

type TalkSessionReportHistory 

type TalkSessionReportHistory struct {
	TalkSessionReportHistoryID uuid.UUID
	TalkSessionID              uuid.UUID
	Report                     string
	CreatedAt                  time.Time
}

type TalksessionConsent 

type TalksessionConsent struct {
	TalksessionID uuid.UUID
	UserID        uuid.UUID
	Restrictions  talksession.Restrictions
	ConsentedAt   time.Time
}

type UpdateActionItemParams 

type UpdateActionItemParams struct {
	ActionItemID uuid.UUID
	Content      string
	Status       string
	Sequence     int32
}

type UpdateDeviceParams 

type UpdateDeviceParams struct {
	DeviceID    uuid.UUID
	DeviceToken string
	Platform    string
	DeviceName  sql.NullString
	AppVersion  sql.NullString
	OsVersion   sql.NullString
	Enabled     bool
	UpdatedAt   time.Time
}

type UpdateNotificationPreferenceParams 

type UpdateNotificationPreferenceParams struct {
	UserID                  uuid.UUID
	PushNotificationEnabled bool
}

type UpdateOrCreateUserDemographicParams 

type UpdateOrCreateUserDemographicParams struct {
	UserDemographicsID uuid.UUID
	UserID             uuid.UUID
	DateOfBirth        sql.NullString
	Gender             sql.NullString
	City               sql.NullString
	Prefecture         sql.NullString
}

type UpdateOrganizationParams 

type UpdateOrganizationParams struct {
	OrganizationID uuid.UUID
	Name           string
	IconUrl        sql.NullString
}

type UpdatePasswordAuthParams 

type UpdatePasswordAuthParams struct {
	UserID                 uuid.UUID
	PasswordHash           string
	Salt                   sql.NullString
	RequiredPasswordChange bool
	LastChanged            time.Time
	UpdatedAt              time.Time
}

type UpdateReportStatusParams 

type UpdateReportStatusParams struct {
	Status          string
	OpinionReportID uuid.UUID
}

type UpdateSequencesByActionItemIDParams 

type UpdateSequencesByActionItemIDParams struct {
	TalkSessionID uuid.UUID
	Sequence      int32
}

type UpdateSessionParams 

type UpdateSessionParams struct {
	SessionID      uuid.UUID
	SessionStatus  int32
	LastActivityAt time.Time
}

type UpdateTalkSessionConclusionParams 

type UpdateTalkSessionConclusionParams struct {
	TalkSessionID uuid.UUID
	Content       string
}

type UpdateTalkSessionHideReportParams 

type UpdateTalkSessionHideReportParams struct {
	TalkSessionID uuid.UUID
	HideReport    sql.NullBool
}

type UpdateTalkSessionLocationParams 

type UpdateTalkSessionLocationParams struct {
	TalkSessionID       uuid.UUID
	StGeographyfromtext interface{}
}

type UpdateUserEmailAndSubjectParams 

type UpdateUserEmailAndSubjectParams struct {
	UserID uuid.UUID
	Email  sql.NullString
}

type UpdateUserParams 

type UpdateUserParams struct {
	UserID         uuid.UUID
	DisplayID      sql.NullString
	DisplayName    sql.NullString
	IconUrl        sql.NullString
	Email          sql.NullString
	EmailVerified  bool
	WithdrawalDate sql.NullTime
}

type UpdateVoteParams 

type UpdateVoteParams struct {
	UserID    uuid.UUID
	OpinionID uuid.UUID
	VoteType  int16
}

type UpsertDeviceParams 

type UpsertDeviceParams struct {
	DeviceID    uuid.UUID
	UserID      uuid.UUID
	DeviceToken string
	Platform    string
	DeviceName  sql.NullString
	AppVersion  sql.NullString
	OsVersion   sql.NullString
	Enabled     bool
	CreatedAt   time.Time
	UpdatedAt   time.Time
}

type UpsertNotificationPreferenceParams 

type UpsertNotificationPreferenceParams struct {
	UserID                  uuid.UUID
	PushNotificationEnabled bool
}

type User 

type User struct {
	UserID        uuid.UUID
	DisplayID     sql.NullString
	DisplayName   sql.NullString
	IconUrl       sql.NullString
	CreatedAt     time.Time
	UpdatedAt     time.Time
	Email         sql.NullString
	EmailVerified bool
	// ユーザーの退会日時。NULLの場合はアクティブユーザー
	WithdrawalDate sql.NullTime
}

type UserAuth 

type UserAuth struct {
	UserAuthID uuid.UUID
	UserID     uuid.UUID
	Provider   string
	Subject    string
	IsVerified bool
	CreatedAt  time.Time
}

type UserDemographic 

type UserDemographic struct {
	UserDemographicsID uuid.UUID
	UserID             uuid.UUID
	DateOfBirth        sql.NullString
	Gender             sql.NullString
	City               sql.NullString
	CreatedAt          time.Time
	UpdatedAt          time.Time
	Prefecture         sql.NullString
}

type UserFindByDisplayIDRow 

type UserFindByDisplayIDRow struct {
	User User
}

type UserGroupDimensionReductionInfo 

type UserGroupDimensionReductionInfo struct {
	TalkSessionID          uuid.UUID
	CreatedAt              time.Time
	UpdatedAt              time.Time
	DimensionReductionType string
	Summary                string
	XDesc                  string
	YDesc                  string
}

type UserGroupInfo 

type UserGroupInfo struct {
	TalkSessionID  uuid.UUID
	UserID         uuid.UUID
	GroupID        int32
	PosX           float64
	PosY           float64
	UpdatedAt      time.Time
	CreatedAt      time.Time
	PerimeterIndex sql.NullInt32
}

type UserImage 

type UserImage struct {
	UserImagesID uuid.UUID
	UserID       uuid.UUID
	Key          string
	Width        int32
	Height       int32
	Extension    string
	Archived     bool
	Url          string
	CreatedAt    time.Time
	UpdatedAt    time.Time
}

type UserStatusChangeLog 

type UserStatusChangeLog struct {
	UserStatusChangeLogsID uuid.UUID
	UserID                 uuid.UUID
	Status                 string
	Reason                 sql.NullString
	ChangedAt              time.Time
	ChangedBy              string
	IpAddress              pqtype.Inet
	UserAgent              sql.NullString
	AdditionalData         pqtype.NullRawMessage
	CreatedAt              time.Time
}

ユーザーのステータス変更履歴（退会・復活など）

type Vote 

type Vote struct {
	VoteID        uuid.UUID
	OpinionID     uuid.UUID
	UserID        uuid.UUID
	VoteType      int16
	CreatedAt     time.Time
	TalkSessionID uuid.UUID
}

type WithdrawUserParams 

type WithdrawUserParams struct {
	UserID         uuid.UUID
	WithdrawalDate sql.NullTime
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.