7b6624ecc3
redesigned the project sharing popup to be a multi select dropdown that populates the options by using the input as a fuzzy search filter on the current users & invited users. users can now also be directly invited by email from the project share window. if invited this way, then the user will receive an email that sends them to a registration page, then a confirmation page. the initial registration was always redone so that it uses a similar system to the above in that it now will accept the first registered user if there are no other accounts (besides 'system').
516 lines
15 KiB
Go
516 lines
15 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// source: project.sql
|
|
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
const createPersonalProject = `-- name: CreatePersonalProject :one
|
|
INSERT INTO project(team_id, created_at, name) VALUES (null, $1, $2) RETURNING project_id, team_id, created_at, name
|
|
`
|
|
|
|
type CreatePersonalProjectParams struct {
|
|
CreatedAt time.Time `json:"created_at"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
func (q *Queries) CreatePersonalProject(ctx context.Context, arg CreatePersonalProjectParams) (Project, error) {
|
|
row := q.db.QueryRowContext(ctx, createPersonalProject, arg.CreatedAt, arg.Name)
|
|
var i Project
|
|
err := row.Scan(
|
|
&i.ProjectID,
|
|
&i.TeamID,
|
|
&i.CreatedAt,
|
|
&i.Name,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createPersonalProjectLink = `-- name: CreatePersonalProjectLink :one
|
|
INSERT INTO personal_project (project_id, user_id) VALUES ($1, $2) RETURNING personal_project_id, project_id, user_id
|
|
`
|
|
|
|
type CreatePersonalProjectLinkParams struct {
|
|
ProjectID uuid.UUID `json:"project_id"`
|
|
UserID uuid.UUID `json:"user_id"`
|
|
}
|
|
|
|
func (q *Queries) CreatePersonalProjectLink(ctx context.Context, arg CreatePersonalProjectLinkParams) (PersonalProject, error) {
|
|
row := q.db.QueryRowContext(ctx, createPersonalProjectLink, arg.ProjectID, arg.UserID)
|
|
var i PersonalProject
|
|
err := row.Scan(&i.PersonalProjectID, &i.ProjectID, &i.UserID)
|
|
return i, err
|
|
}
|
|
|
|
const createProjectMember = `-- name: CreateProjectMember :one
|
|
INSERT INTO project_member (project_id, user_id, role_code, added_at) VALUES ($1, $2, $3, $4)
|
|
RETURNING project_member_id, project_id, user_id, added_at, role_code
|
|
`
|
|
|
|
type CreateProjectMemberParams struct {
|
|
ProjectID uuid.UUID `json:"project_id"`
|
|
UserID uuid.UUID `json:"user_id"`
|
|
RoleCode string `json:"role_code"`
|
|
AddedAt time.Time `json:"added_at"`
|
|
}
|
|
|
|
func (q *Queries) CreateProjectMember(ctx context.Context, arg CreateProjectMemberParams) (ProjectMember, error) {
|
|
row := q.db.QueryRowContext(ctx, createProjectMember,
|
|
arg.ProjectID,
|
|
arg.UserID,
|
|
arg.RoleCode,
|
|
arg.AddedAt,
|
|
)
|
|
var i ProjectMember
|
|
err := row.Scan(
|
|
&i.ProjectMemberID,
|
|
&i.ProjectID,
|
|
&i.UserID,
|
|
&i.AddedAt,
|
|
&i.RoleCode,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createTeamProject = `-- name: CreateTeamProject :one
|
|
INSERT INTO project(team_id, created_at, name) VALUES ($1, $2, $3) RETURNING project_id, team_id, created_at, name
|
|
`
|
|
|
|
type CreateTeamProjectParams struct {
|
|
TeamID uuid.UUID `json:"team_id"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
func (q *Queries) CreateTeamProject(ctx context.Context, arg CreateTeamProjectParams) (Project, error) {
|
|
row := q.db.QueryRowContext(ctx, createTeamProject, arg.TeamID, arg.CreatedAt, arg.Name)
|
|
var i Project
|
|
err := row.Scan(
|
|
&i.ProjectID,
|
|
&i.TeamID,
|
|
&i.CreatedAt,
|
|
&i.Name,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const deleteInvitedProjectMemberByID = `-- name: DeleteInvitedProjectMemberByID :exec
|
|
DELETE FROM project_member_invited WHERE project_member_invited_id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteInvitedProjectMemberByID(ctx context.Context, projectMemberInvitedID uuid.UUID) error {
|
|
_, err := q.db.ExecContext(ctx, deleteInvitedProjectMemberByID, projectMemberInvitedID)
|
|
return err
|
|
}
|
|
|
|
const deleteProjectByID = `-- name: DeleteProjectByID :exec
|
|
DELETE FROM project WHERE project_id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteProjectByID(ctx context.Context, projectID uuid.UUID) error {
|
|
_, err := q.db.ExecContext(ctx, deleteProjectByID, projectID)
|
|
return err
|
|
}
|
|
|
|
const deleteProjectMember = `-- name: DeleteProjectMember :exec
|
|
DELETE FROM project_member WHERE user_id = $1 AND project_id = $2
|
|
`
|
|
|
|
type DeleteProjectMemberParams struct {
|
|
UserID uuid.UUID `json:"user_id"`
|
|
ProjectID uuid.UUID `json:"project_id"`
|
|
}
|
|
|
|
func (q *Queries) DeleteProjectMember(ctx context.Context, arg DeleteProjectMemberParams) error {
|
|
_, err := q.db.ExecContext(ctx, deleteProjectMember, arg.UserID, arg.ProjectID)
|
|
return err
|
|
}
|
|
|
|
const getAllProjectsForTeam = `-- name: GetAllProjectsForTeam :many
|
|
SELECT project_id, team_id, created_at, name FROM project WHERE team_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetAllProjectsForTeam(ctx context.Context, teamID uuid.UUID) ([]Project, error) {
|
|
rows, err := q.db.QueryContext(ctx, getAllProjectsForTeam, teamID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Project
|
|
for rows.Next() {
|
|
var i Project
|
|
if err := rows.Scan(
|
|
&i.ProjectID,
|
|
&i.TeamID,
|
|
&i.CreatedAt,
|
|
&i.Name,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getAllTeamProjects = `-- name: GetAllTeamProjects :many
|
|
SELECT project_id, team_id, created_at, name FROM project WHERE team_id IS NOT null
|
|
`
|
|
|
|
func (q *Queries) GetAllTeamProjects(ctx context.Context) ([]Project, error) {
|
|
rows, err := q.db.QueryContext(ctx, getAllTeamProjects)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Project
|
|
for rows.Next() {
|
|
var i Project
|
|
if err := rows.Scan(
|
|
&i.ProjectID,
|
|
&i.TeamID,
|
|
&i.CreatedAt,
|
|
&i.Name,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getAllVisibleProjectsForUserID = `-- name: GetAllVisibleProjectsForUserID :many
|
|
SELECT project.project_id, project.team_id, project.created_at, project.name FROM project LEFT JOIN
|
|
project_member ON project_member.project_id = project.project_id WHERE project_member.user_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetAllVisibleProjectsForUserID(ctx context.Context, userID uuid.UUID) ([]Project, error) {
|
|
rows, err := q.db.QueryContext(ctx, getAllVisibleProjectsForUserID, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Project
|
|
for rows.Next() {
|
|
var i Project
|
|
if err := rows.Scan(
|
|
&i.ProjectID,
|
|
&i.TeamID,
|
|
&i.CreatedAt,
|
|
&i.Name,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getInvitedMembersForProjectID = `-- name: GetInvitedMembersForProjectID :many
|
|
SELECT uai.user_account_invited_id, email, invited_on FROM project_member_invited AS pmi
|
|
INNER JOIN user_account_invited AS uai
|
|
ON uai.user_account_invited_id = pmi.user_account_invited_id
|
|
WHERE project_id = $1
|
|
`
|
|
|
|
type GetInvitedMembersForProjectIDRow struct {
|
|
UserAccountInvitedID uuid.UUID `json:"user_account_invited_id"`
|
|
Email string `json:"email"`
|
|
InvitedOn time.Time `json:"invited_on"`
|
|
}
|
|
|
|
func (q *Queries) GetInvitedMembersForProjectID(ctx context.Context, projectID uuid.UUID) ([]GetInvitedMembersForProjectIDRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getInvitedMembersForProjectID, projectID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetInvitedMembersForProjectIDRow
|
|
for rows.Next() {
|
|
var i GetInvitedMembersForProjectIDRow
|
|
if err := rows.Scan(&i.UserAccountInvitedID, &i.Email, &i.InvitedOn); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getMemberProjectIDsForUserID = `-- name: GetMemberProjectIDsForUserID :many
|
|
SELECT project_id FROM project_member WHERE user_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetMemberProjectIDsForUserID(ctx context.Context, userID uuid.UUID) ([]uuid.UUID, error) {
|
|
rows, err := q.db.QueryContext(ctx, getMemberProjectIDsForUserID, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []uuid.UUID
|
|
for rows.Next() {
|
|
var project_id uuid.UUID
|
|
if err := rows.Scan(&project_id); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, project_id)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getPersonalProjectsForUserID = `-- name: GetPersonalProjectsForUserID :many
|
|
SELECT project.project_id, project.team_id, project.created_at, project.name FROM project
|
|
LEFT JOIN personal_project ON personal_project.project_id = project.project_id
|
|
WHERE personal_project.user_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetPersonalProjectsForUserID(ctx context.Context, userID uuid.UUID) ([]Project, error) {
|
|
rows, err := q.db.QueryContext(ctx, getPersonalProjectsForUserID, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Project
|
|
for rows.Next() {
|
|
var i Project
|
|
if err := rows.Scan(
|
|
&i.ProjectID,
|
|
&i.TeamID,
|
|
&i.CreatedAt,
|
|
&i.Name,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getProjectByID = `-- name: GetProjectByID :one
|
|
SELECT project_id, team_id, created_at, name FROM project WHERE project_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetProjectByID(ctx context.Context, projectID uuid.UUID) (Project, error) {
|
|
row := q.db.QueryRowContext(ctx, getProjectByID, projectID)
|
|
var i Project
|
|
err := row.Scan(
|
|
&i.ProjectID,
|
|
&i.TeamID,
|
|
&i.CreatedAt,
|
|
&i.Name,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getProjectMemberInvitedIDByEmail = `-- name: GetProjectMemberInvitedIDByEmail :one
|
|
SELECT email, invited_on, project_member_invited_id FROM user_account_invited AS uai
|
|
inner join project_member_invited AS pmi
|
|
ON pmi.user_account_invited_id = uai.user_account_invited_id
|
|
WHERE email = $1
|
|
`
|
|
|
|
type GetProjectMemberInvitedIDByEmailRow struct {
|
|
Email string `json:"email"`
|
|
InvitedOn time.Time `json:"invited_on"`
|
|
ProjectMemberInvitedID uuid.UUID `json:"project_member_invited_id"`
|
|
}
|
|
|
|
func (q *Queries) GetProjectMemberInvitedIDByEmail(ctx context.Context, email string) (GetProjectMemberInvitedIDByEmailRow, error) {
|
|
row := q.db.QueryRowContext(ctx, getProjectMemberInvitedIDByEmail, email)
|
|
var i GetProjectMemberInvitedIDByEmailRow
|
|
err := row.Scan(&i.Email, &i.InvitedOn, &i.ProjectMemberInvitedID)
|
|
return i, err
|
|
}
|
|
|
|
const getProjectMembersForProjectID = `-- name: GetProjectMembersForProjectID :many
|
|
SELECT project_member_id, project_id, user_id, added_at, role_code FROM project_member WHERE project_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetProjectMembersForProjectID(ctx context.Context, projectID uuid.UUID) ([]ProjectMember, error) {
|
|
rows, err := q.db.QueryContext(ctx, getProjectMembersForProjectID, projectID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ProjectMember
|
|
for rows.Next() {
|
|
var i ProjectMember
|
|
if err := rows.Scan(
|
|
&i.ProjectMemberID,
|
|
&i.ProjectID,
|
|
&i.UserID,
|
|
&i.AddedAt,
|
|
&i.RoleCode,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getProjectRolesForUserID = `-- name: GetProjectRolesForUserID :many
|
|
SELECT project_id, role_code FROM project_member WHERE user_id = $1
|
|
`
|
|
|
|
type GetProjectRolesForUserIDRow struct {
|
|
ProjectID uuid.UUID `json:"project_id"`
|
|
RoleCode string `json:"role_code"`
|
|
}
|
|
|
|
func (q *Queries) GetProjectRolesForUserID(ctx context.Context, userID uuid.UUID) ([]GetProjectRolesForUserIDRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getProjectRolesForUserID, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetProjectRolesForUserIDRow
|
|
for rows.Next() {
|
|
var i GetProjectRolesForUserIDRow
|
|
if err := rows.Scan(&i.ProjectID, &i.RoleCode); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getRoleForProjectMemberByUserID = `-- name: GetRoleForProjectMemberByUserID :one
|
|
SELECT code, role.name FROM project_member INNER JOIN role ON role.code = project_member.role_code
|
|
WHERE user_id = $1 AND project_id = $2
|
|
`
|
|
|
|
type GetRoleForProjectMemberByUserIDParams struct {
|
|
UserID uuid.UUID `json:"user_id"`
|
|
ProjectID uuid.UUID `json:"project_id"`
|
|
}
|
|
|
|
func (q *Queries) GetRoleForProjectMemberByUserID(ctx context.Context, arg GetRoleForProjectMemberByUserIDParams) (Role, error) {
|
|
row := q.db.QueryRowContext(ctx, getRoleForProjectMemberByUserID, arg.UserID, arg.ProjectID)
|
|
var i Role
|
|
err := row.Scan(&i.Code, &i.Name)
|
|
return i, err
|
|
}
|
|
|
|
const getUserRolesForProject = `-- name: GetUserRolesForProject :one
|
|
SELECT p.team_id, COALESCE(tm.role_code, '') AS team_role, COALESCE(pm.role_code, '') AS project_role
|
|
FROM project AS p
|
|
LEFT JOIN project_member AS pm ON pm.project_id = p.project_id AND pm.user_id = $1
|
|
LEFT JOIN team_member AS tm ON tm.team_id = p.team_id AND tm.user_id = $1
|
|
WHERE p.project_id = $2
|
|
`
|
|
|
|
type GetUserRolesForProjectParams struct {
|
|
UserID uuid.UUID `json:"user_id"`
|
|
ProjectID uuid.UUID `json:"project_id"`
|
|
}
|
|
|
|
type GetUserRolesForProjectRow struct {
|
|
TeamID uuid.UUID `json:"team_id"`
|
|
TeamRole string `json:"team_role"`
|
|
ProjectRole string `json:"project_role"`
|
|
}
|
|
|
|
func (q *Queries) GetUserRolesForProject(ctx context.Context, arg GetUserRolesForProjectParams) (GetUserRolesForProjectRow, error) {
|
|
row := q.db.QueryRowContext(ctx, getUserRolesForProject, arg.UserID, arg.ProjectID)
|
|
var i GetUserRolesForProjectRow
|
|
err := row.Scan(&i.TeamID, &i.TeamRole, &i.ProjectRole)
|
|
return i, err
|
|
}
|
|
|
|
const updateProjectMemberRole = `-- name: UpdateProjectMemberRole :one
|
|
UPDATE project_member SET role_code = $3 WHERE project_id = $1 AND user_id = $2
|
|
RETURNING project_member_id, project_id, user_id, added_at, role_code
|
|
`
|
|
|
|
type UpdateProjectMemberRoleParams struct {
|
|
ProjectID uuid.UUID `json:"project_id"`
|
|
UserID uuid.UUID `json:"user_id"`
|
|
RoleCode string `json:"role_code"`
|
|
}
|
|
|
|
func (q *Queries) UpdateProjectMemberRole(ctx context.Context, arg UpdateProjectMemberRoleParams) (ProjectMember, error) {
|
|
row := q.db.QueryRowContext(ctx, updateProjectMemberRole, arg.ProjectID, arg.UserID, arg.RoleCode)
|
|
var i ProjectMember
|
|
err := row.Scan(
|
|
&i.ProjectMemberID,
|
|
&i.ProjectID,
|
|
&i.UserID,
|
|
&i.AddedAt,
|
|
&i.RoleCode,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const updateProjectNameByID = `-- name: UpdateProjectNameByID :one
|
|
UPDATE project SET name = $2 WHERE project_id = $1 RETURNING project_id, team_id, created_at, name
|
|
`
|
|
|
|
type UpdateProjectNameByIDParams struct {
|
|
ProjectID uuid.UUID `json:"project_id"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
func (q *Queries) UpdateProjectNameByID(ctx context.Context, arg UpdateProjectNameByIDParams) (Project, error) {
|
|
row := q.db.QueryRowContext(ctx, updateProjectNameByID, arg.ProjectID, arg.Name)
|
|
var i Project
|
|
err := row.Scan(
|
|
&i.ProjectID,
|
|
&i.TeamID,
|
|
&i.CreatedAt,
|
|
&i.Name,
|
|
)
|
|
return i, err
|
|
}
|