model

package
v0.0.0-...-6b90acb Latest Latest
Warning

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

 Go to latest Published: Feb 11, 2026 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 AddUserAuthForMergeParams 

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

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
	DisableAnalysis     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
	DisplayID     sql.NullString
	DisplayName   sql.NullString
}

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
	DisableAnalysis     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) AddUserAuthForMerge 

func (q *Queries) AddUserAuthForMerge(ctx context.Context, arg AddUserAuthForMergeParams) error

ゲストユーザーがOAuth認証した際にAuthを追加する（is_verified=true） 

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

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, disable_analysis) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)

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, display_id, display_name) VALUES ($1, $2, $3, $4, $5, $6)

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,
        disable_analysis = $13
    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, ts.disable_analysis,
    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, ts.disable_analysis,
    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, ts.disable_analysis,
    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, disable_analysis 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, ts.disable_analysis,
    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) UpdateUserAuthProvider 

func (q *Queries) UpdateUserAuthProvider(ctx context.Context, arg UpdateUserAuthProviderParams) error

ユーザーのプロバイダーを更新する（ゲスト昇格用） 

UPDATE user_auths SET provider = $2 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
	DisableAnalysis     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 UpdateUserAuthProviderParams 

type UpdateUserAuthProviderParams struct {
	UserID   uuid.UUID
	Provider string
}

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.