controller

package
v0.2.0 Latest Latest
Warning

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

 Go to latest Published: May 5, 2026 License: MIT Imports: 28 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	HeaderTenantCode      = "X-Tenant-Code"
	HeaderWorkspaceCode   = "X-Workspace-Code"
	HeaderDocumentType    = "X-Document-Type"
	HeaderExternalID      = "X-External-ID"
	HeaderTransactionalID = "X-Transactional-ID"
	HeaderEnvironment     = "X-Environment"
	HeaderProcess         = "X-Process"
	HeaderProcessType     = "X-Process-Type"
)

Internal API header constants.

Variables

This section is empty.

Functions

func HandleError 

func HandleError(ctx *gin.Context, err error)

HandleError maps domain errors to HTTP status codes. This is a centralized error handler that consolidates all error handling logic from the various controller-specific error handlers.

Types

type AdminController 

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

AdminController handles admin-related HTTP requests. All routes require system-level roles (SUPERADMIN or PLATFORM_ADMIN).

func NewAdminController 

func NewAdminController(
	tenantUC organizationuc.TenantUseCase,
	systemRoleUC accessuc.SystemRoleUseCase,
	systemInjectableUC injectableuc.SystemInjectableUseCase,
) *AdminController

NewAdminController creates a new admin controller.

func (*AdminController) ActivateInjectable 

func (c *AdminController) ActivateInjectable(ctx *gin.Context)

ActivateInjectable activates a system injectable globally. @Summary Activate system injectable @Tags System - Injectables @Accept json @Produce json @Param key path string true "Injectable key" @Success 204 "No Content" @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/injectables/{key}/activate [patch] @Security BearerAuth

func (*AdminController) AddSystemRole 

func (c *AdminController) AddSystemRole(ctx *gin.Context)

AddSystemRole finds or creates a user by email and assigns a system role. Requires SUPERADMIN role. @Summary Add system member @Tags System - Users @Accept json @Produce json @Param request body dto.AddSystemRoleRequest true "System member data" @Success 200 {object} dto.SystemRoleResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/system/users [post] @Security BearerAuth

func (*AdminController) AssignSystemRole 

func (c *AdminController) AssignSystemRole(ctx *gin.Context)

AssignSystemRole assigns a system role to a user. Requires SUPERADMIN role. @Summary Assign system role @Tags System - Users @Accept json @Produce json @Param userId path string true "User ID" @Param request body dto.AssignSystemRoleRequest true "Role data" @Success 200 {object} dto.SystemRoleResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/users/{userId}/role [post] @Security BearerAuth

func (*AdminController) BulkCreatePublicAssignments 

func (c *AdminController) BulkCreatePublicAssignments(ctx *gin.Context)

BulkCreatePublicAssignments creates PUBLIC assignments for multiple injectables. @Summary Bulk create PUBLIC assignments @Tags System - Injectables @Accept json @Produce json @Param request body dto.BulkPublicAssignmentsRequest true "Keys to make public" @Success 200 {object} dto.BulkPublicAssignmentsResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/system/injectables/bulk/public [post] @Security BearerAuth

func (*AdminController) BulkDeletePublicAssignments 

func (c *AdminController) BulkDeletePublicAssignments(ctx *gin.Context)

BulkDeletePublicAssignments deletes PUBLIC assignments for multiple injectables. @Summary Bulk delete PUBLIC assignments @Tags System - Injectables @Accept json @Produce json @Param request body dto.BulkPublicAssignmentsRequest true "Keys to remove from public" @Success 200 {object} dto.BulkPublicAssignmentsResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/system/injectables/bulk/public [delete] @Security BearerAuth

func (*AdminController) CreateAssignment 

func (c *AdminController) CreateAssignment(ctx *gin.Context)

CreateAssignment creates a new assignment for a system injectable. @Summary Create injectable assignment @Tags System - Injectables @Accept json @Produce json @Param key path string true "Injectable key" @Param request body dto.CreateAssignmentRequest true "Assignment data" @Success 201 {object} dto.SystemInjectableAssignmentResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/injectables/{key}/assignments [post] @Security BearerAuth

func (*AdminController) CreateTenant 

func (c *AdminController) CreateTenant(ctx *gin.Context)

CreateTenant creates a new tenant. Requires SUPERADMIN role. @Summary Create tenant @Tags System - Tenants @Accept json @Produce json @Param request body dto.CreateTenantRequest true "Tenant data" @Success 201 {object} dto.TenantResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 409 {object} dto.ErrorResponse @Router /api/v1/system/tenants [post] @Security BearerAuth

func (*AdminController) DeactivateInjectable 

func (c *AdminController) DeactivateInjectable(ctx *gin.Context)

DeactivateInjectable deactivates a system injectable globally. @Summary Deactivate system injectable @Tags System - Injectables @Accept json @Produce json @Param key path string true "Injectable key" @Success 204 "No Content" @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/injectables/{key}/deactivate [patch] @Security BearerAuth

func (*AdminController) DeleteAssignment 

func (c *AdminController) DeleteAssignment(ctx *gin.Context)

DeleteAssignment deletes an assignment. @Summary Delete injectable assignment @Tags System - Injectables @Accept json @Produce json @Param key path string true "Injectable key" @Param assignmentId path string true "Assignment ID" @Success 204 "No Content" @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/injectables/{key}/assignments/{assignmentId} [delete] @Security BearerAuth

func (*AdminController) DeleteTenant 

func (c *AdminController) DeleteTenant(ctx *gin.Context)

DeleteTenant deletes a tenant. @Summary Delete tenant @Tags System - Tenants @Accept json @Produce json @Param tenantId path string true "Tenant ID" @Success 204 "No Content" @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/tenants/{tenantId} [delete] @Security BearerAuth

func (*AdminController) ExcludeAssignment 

func (c *AdminController) ExcludeAssignment(ctx *gin.Context)

ExcludeAssignment excludes an assignment (sets is_active=false). @Summary Exclude injectable assignment @Tags System - Injectables @Accept json @Produce json @Param key path string true "Injectable key" @Param assignmentId path string true "Assignment ID" @Success 204 "No Content" @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/injectables/{key}/assignments/{assignmentId}/exclude [patch] @Security BearerAuth

func (*AdminController) GetTenant 

func (c *AdminController) GetTenant(ctx *gin.Context)

GetTenant retrieves a tenant by ID. @Summary Get tenant @Tags System - Tenants @Accept json @Produce json @Param tenantId path string true "Tenant ID" @Success 200 {object} dto.TenantResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/tenants/{tenantId} [get] @Security BearerAuth

func (*AdminController) IncludeAssignment 

func (c *AdminController) IncludeAssignment(ctx *gin.Context)

IncludeAssignment includes an assignment (sets is_active=true). @Summary Include injectable assignment @Tags System - Injectables @Accept json @Produce json @Param key path string true "Injectable key" @Param assignmentId path string true "Assignment ID" @Success 204 "No Content" @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/injectables/{key}/assignments/{assignmentId}/include [patch] @Security BearerAuth

func (*AdminController) ListAssignments 

func (c *AdminController) ListAssignments(ctx *gin.Context)

ListAssignments lists all assignments for a system injectable. @Summary List injectable assignments @Tags System - Injectables @Accept json @Produce json @Param key path string true "Injectable key" @Success 200 {object} dto.ListAssignmentsResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/injectables/{key}/assignments [get] @Security BearerAuth

func (*AdminController) ListSystemInjectables 

func (c *AdminController) ListSystemInjectables(ctx *gin.Context)

ListSystemInjectables lists all system injectables with their active state. @Summary List system injectables @Tags System - Injectables @Accept json @Produce json @Success 200 {object} dto.ListSystemInjectablesResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/system/injectables [get] @Security BearerAuth

func (*AdminController) ListSystemUsers 

func (c *AdminController) ListSystemUsers(ctx *gin.Context)

ListSystemUsers lists all users with system roles. Requires SUPERADMIN role. @Summary List users with system roles @Tags System - Users @Accept json @Produce json @Success 200 {object} dto.ListResponse[dto.SystemRoleWithUserResponse] @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/system/users [get] @Security BearerAuth

func (*AdminController) ListTenantWorkspaces 

func (c *AdminController) ListTenantWorkspaces(ctx *gin.Context)

ListTenantWorkspaces lists workspaces for a specific tenant with optional search. @Summary List tenant workspaces @Tags System - Tenants @Accept json @Produce json @Param tenantId path string true "Tenant ID" @Param page query int false "Page number" default(1) @Param perPage query int false "Items per page" default(10) @Param q query string false "Search query (name)" @Success 200 {object} dto.PaginatedWorkspacesResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/tenants/{tenantId}/workspaces [get] @Security BearerAuth

func (*AdminController) ListTenantsPaginated 

func (c *AdminController) ListTenantsPaginated(ctx *gin.Context)

ListTenantsPaginated lists tenants with pagination and optional search. @Summary List tenants with pagination @Tags System - Tenants @Accept json @Produce json @Param page query int false "Page number" default(1) @Param perPage query int false "Items per page" default(10) @Param q query string false "Search query (name or code)" @Success 200 {object} dto.PaginatedTenantsResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/system/tenants [get] @Security BearerAuth

func (*AdminController) RegisterRoutes 

func (c *AdminController) RegisterRoutes(rg *gin.RouterGroup)

RegisterRoutes registers all admin routes. System routes do NOT require X-Workspace-ID or X-Tenant-ID headers.

func (*AdminController) RevokeSystemRole 

func (c *AdminController) RevokeSystemRole(ctx *gin.Context)

RevokeSystemRole revokes a user's system role. Requires SUPERADMIN role. @Summary Revoke system role @Tags System - Users @Accept json @Produce json @Param userId path string true "User ID" @Success 204 "No Content" @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/users/{userId}/role [delete] @Security BearerAuth

func (*AdminController) UpdateTenant 

func (c *AdminController) UpdateTenant(ctx *gin.Context)

UpdateTenant updates a tenant. @Summary Update tenant @Tags System - Tenants @Accept json @Produce json @Param tenantId path string true "Tenant ID" @Param request body dto.UpdateTenantRequest true "Tenant data" @Success 200 {object} dto.TenantResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/tenants/{tenantId} [put] @Security BearerAuth

func (*AdminController) UpdateTenantStatus 

func (c *AdminController) UpdateTenantStatus(ctx *gin.Context)

UpdateTenantStatus updates a tenant's status. Requires SUPERADMIN role. @Summary Update tenant status @Tags System - Tenants @Accept json @Produce json @Param tenantId path string true "Tenant ID" @Param request body dto.UpdateTenantStatusRequest true "Status data" @Success 200 {object} dto.TenantResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/system/tenants/{tenantId}/status [patch] @Security BearerAuth

type AutomationController 

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

AutomationController handles all /api/v1/automation/* routes. It uses automation API key authentication and audit logging.

func NewAutomationController 

func NewAutomationController(
	tenantUC organizationuc.TenantUseCase,
	workspaceUC organizationuc.WorkspaceUseCase,
	injectableUC injectableuc.InjectableUseCase,
	templateUC templateuc.TemplateUseCase,
	templateVersionUC templateuc.TemplateVersionUseCase,
	documentTypeUC cataloguc.DocumentTypeUseCase,
	keyRepo port.AutomationAPIKeyRepository,
	auditRepo port.AutomationAuditLogRepository,
	templateMapper *mapper.TemplateMapper,
	versionMapper *mapper.TemplateVersionMapper,
	injectableMapper *mapper.InjectableMapper,
	docTypeMapper *mapper.DocumentTypeMapper,
) *AutomationController

NewAutomationController creates a new AutomationController.

func (*AutomationController) RegisterRoutes 

func (ctrl *AutomationController) RegisterRoutes(base *gin.Engine, middlewareProvider *middleware.Provider)

RegisterRoutes sets up the /api/v1/automation route group with its own middleware chain.

type AutomationKeyController 

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

AutomationKeyController handles SUPERADMIN routes for API key management.

func NewAutomationKeyController 

func NewAutomationKeyController(apiKeyUseCase automationuc.APIKeyUseCase) *AutomationKeyController

NewAutomationKeyController creates a new AutomationKeyController.

func (*AutomationKeyController) RegisterRoutes 

func (ctrl *AutomationKeyController) RegisterRoutes(adminGroup *gin.RouterGroup)

RegisterRoutes registers SUPERADMIN routes for API key management. The group passed in should already have JWT auth applied. This method adds RequireSuperAdmin guard internally.

type ContentInjectableController 

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

ContentInjectableController handles injectable-related HTTP requests.

func NewContentInjectableController 

func NewContentInjectableController(
	injectableUC injectableuc.InjectableUseCase,
	injectableMapper *mapper.InjectableMapper,
) *ContentInjectableController

NewContentInjectableController creates a new injectable controller.

func (*ContentInjectableController) GetInjectable 

func (c *ContentInjectableController) GetInjectable(ctx *gin.Context)

GetInjectable retrieves an injectable by ID. @Summary Get injectable @Tags Injectables @Accept json @Produce json @Param injectableId path string true "Injectable ID" @Success 200 {object} dto.InjectableResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/injectables/{injectableId} [get]

func (*ContentInjectableController) ListInjectables 

func (c *ContentInjectableController) ListInjectables(ctx *gin.Context)

ListInjectables lists all injectable definitions for a workspace. @Summary List injectables @Tags Injectables @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Success 200 {object} dto.ListInjectablesResponse @Failure 401 {object} dto.ErrorResponse @Router /api/v1/content/injectables [get]

func (*ContentInjectableController) RegisterRoutes 

func (c *ContentInjectableController) RegisterRoutes(rg *gin.RouterGroup, middlewareProvider *middleware.Provider)

RegisterRoutes registers all injectable routes. All injectable routes require X-Workspace-ID header. Note: Injectables are read-only - they are managed via database migrations/seeds.

type ContentTemplateController 

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

ContentTemplateController handles template-related HTTP requests.

func NewContentTemplateController 

func NewContentTemplateController(
	templateUC templateuc.TemplateUseCase,
	templateMapper *mapper.TemplateMapper,
	versionController *TemplateVersionController,
) *ContentTemplateController

NewContentTemplateController creates a new template controller.

func (*ContentTemplateController) AddTemplateTags 

func (c *ContentTemplateController) AddTemplateTags(ctx *gin.Context)

AddTemplateTags adds tags to a template. @Summary Add tags to template @Tags Templates @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param request body dto.AddTagsRequest true "Tag IDs" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/tags [post]

func (*ContentTemplateController) AssignDocumentType 

func (c *ContentTemplateController) AssignDocumentType(ctx *gin.Context)

AssignDocumentType assigns or unassigns a document type to a template. @Summary Assign document type to template @Description Assigns a document type to a template. If the type is already assigned to another template in the workspace and force=false, returns conflict info. Use force=true to reassign the type (previous template will have its type unassigned). @Tags Templates @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param request body dto.AssignDocumentTypeRequest true "Document type assignment data" @Success 200 {object} dto.AssignDocumentTypeResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Failure 409 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/document-type [put]

func (*ContentTemplateController) CloneTemplate 

func (c *ContentTemplateController) CloneTemplate(ctx *gin.Context)

CloneTemplate creates a copy of an existing template from a specific version. @Summary Clone template from specific version @Description Clones a template using the content from a specific version (identified by versionId in request body). The versionId must belong to the specified templateId. @Tags Templates @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param request body dto.CloneTemplateRequest true "Clone data (versionId is required and must belong to the template)" @Success 201 {object} dto.TemplateCreateResponse @Failure 400 {object} dto.ErrorResponse "Bad request (invalid versionId, version doesn't belong to template, validation error)" @Failure 404 {object} dto.ErrorResponse "Template or version not found" @Failure 409 {object} dto.ErrorResponse "Template title already exists" @Router /api/v1/content/templates/{templateId}/clone [post]

func (*ContentTemplateController) CreateTemplate 

func (c *ContentTemplateController) CreateTemplate(ctx *gin.Context)

CreateTemplate creates a new template with an initial draft version. @Summary Create template @Tags Templates @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param request body dto.CreateTemplateRequest true "Template data" @Success 201 {object} dto.TemplateCreateResponse @Failure 400 {object} dto.ErrorResponse @Failure 409 {object} dto.ErrorResponse @Router /api/v1/content/templates [post]

func (*ContentTemplateController) DeleteTemplate 

func (c *ContentTemplateController) DeleteTemplate(ctx *gin.Context)

DeleteTemplate deletes a template and all its versions. @Summary Delete template @Tags Templates @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Success 204 "No Content" @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId} [delete]

func (*ContentTemplateController) GetTemplate 

func (c *ContentTemplateController) GetTemplate(ctx *gin.Context)

GetTemplate retrieves a template by ID with published version details. @Summary Get template @Tags Templates @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Success 200 {object} dto.TemplateWithDetailsResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId} [get]

func (*ContentTemplateController) GetTemplateWithAllVersions 

func (c *ContentTemplateController) GetTemplateWithAllVersions(ctx *gin.Context)

GetTemplateWithAllVersions retrieves a template with all its versions. @Summary Get template with all versions @Tags Templates @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Success 200 {object} dto.TemplateWithAllVersionsResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/all-versions [get]

func (*ContentTemplateController) ListTemplates 

func (c *ContentTemplateController) ListTemplates(ctx *gin.Context)

ListTemplates lists all templates in a workspace. @Summary List templates @Tags Templates @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param folderId query string false "Filter by folder ID. Use 'root' to get only root-level templates (no folder)" @Param hasPublishedVersion query bool false "Filter by published status" @Param tagIds query []string false "Filter by tag IDs" @Param search query string false "Search by title" @Param limit query int false "Limit results" @Param offset query int false "Offset results" @Success 200 {object} dto.ListTemplatesResponse @Failure 401 {object} dto.ErrorResponse @Router /api/v1/content/templates [get]

func (*ContentTemplateController) RegisterRoutes 

func (c *ContentTemplateController) RegisterRoutes(rg *gin.RouterGroup, middlewareProvider *middleware.Provider)

RegisterRoutes registers all template routes. All template routes require X-Workspace-ID header. Template and version routes support sandbox mode via X-Sandbox-Mode header.

func (*ContentTemplateController) RemoveTemplateTag 

func (c *ContentTemplateController) RemoveTemplateTag(ctx *gin.Context)

RemoveTemplateTag removes a tag from a template. @Summary Remove tag from template @Tags Templates @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param tagId path string true "Tag ID" @Success 204 "No Content" @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/tags/{tagId} [delete]

func (*ContentTemplateController) SetProcessFields 

func (c *ContentTemplateController) SetProcessFields(ctx *gin.Context)

SetProcessFields sets the process and processType on a template. @Summary Set process fields on template @Tags Templates @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param request body dto.SetProcessFieldsRequest true "Process fields" @Success 200 {object} dto.TemplateResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Failure 409 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/process [put]

func (*ContentTemplateController) UpdateTemplate 

func (c *ContentTemplateController) UpdateTemplate(ctx *gin.Context)

UpdateTemplate updates a template's metadata. @Summary Update template @Description Updates a template's metadata. Use folderId="root" to move the template to the root folder. @Tags Templates @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param request body dto.UpdateTemplateRequest true "Template data (folderId can be a folder UUID or 'root' to move to root)" @Success 200 {object} dto.TemplateResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId} [put]

type DocumentController 

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

DocumentController handles document HTTP requests.

func NewDocumentController 

func NewDocumentController(
	documentUC documentuc.DocumentUseCase,
	preSigningUC documentuc.PreSigningUseCase,
	eventEmitter *documentsvc.EventEmitter,
) *DocumentController

NewDocumentController creates a new document controller.

func (*DocumentController) CancelDocument 

func (c *DocumentController) CancelDocument(ctx *gin.Context)

CancelDocument cancels a pending document. @Summary Cancel document @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param documentId path string true "Document ID" @Success 200 {object} map[string]string @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents/{documentId}/cancel [post]

func (*DocumentController) CreateDocument 

func (c *DocumentController) CreateDocument(ctx *gin.Context)

CreateDocument creates and sends a document for signing. @Summary Create and send document @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param request body dto.CreateDocumentRequest true "Document creation request" @Success 201 {object} dto.DocumentResponse @Failure 400 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents [post]

func (*DocumentController) CreateDocumentsBatch 

func (c *DocumentController) CreateDocumentsBatch(ctx *gin.Context)

CreateDocumentsBatch creates multiple documents in a single batch. @Summary Batch create documents @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param request body dto.BatchCreateDocumentRequest true "Batch document creation request" @Success 200 {object} dto.BatchCreateDocumentResponse @Failure 400 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents/batch [post]

func (*DocumentController) GetDocument 

func (c *DocumentController) GetDocument(ctx *gin.Context)

GetDocument returns a single document with recipients. @Summary Get document @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param documentId path string true "Document ID" @Success 200 {object} dto.DocumentResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents/{documentId} [get]

func (*DocumentController) GetDocumentEvents 

func (c *DocumentController) GetDocumentEvents(ctx *gin.Context)

GetDocumentEvents returns the audit event trail for a document. @Summary Get document events @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param documentId path string true "Document ID" @Param limit query int false "Limit results" default(50) @Param offset query int false "Offset for pagination" default(0) @Success 200 {array} dto.DocumentEventResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents/{documentId}/events [get]

func (*DocumentController) GetDocumentPDF 

func (c *DocumentController) GetDocumentPDF(ctx *gin.Context)

GetDocumentPDF returns the signed PDF for a completed document. @Summary Download signed PDF @Tags Documents @Produce application/pdf @Param X-Workspace-ID header string true "Workspace ID" @Param documentId path string true "Document ID" @Success 200 {file} file @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents/{documentId}/pdf [get]

func (*DocumentController) GetRecipients 

func (c *DocumentController) GetRecipients(ctx *gin.Context)

GetRecipients returns recipients for a document. @Summary Get document recipients @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param documentId path string true "Document ID" @Success 200 {array} dto.RecipientResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents/{documentId}/recipients [get]

func (*DocumentController) GetSigningURL 

func (c *DocumentController) GetSigningURL(ctx *gin.Context)

GetSigningURL returns the signing URL for a recipient. @Summary Get signing URL @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param documentId path string true "Document ID" @Param recipientId path string true "Recipient ID" @Success 200 {object} dto.SigningURLResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents/{documentId}/recipients/{recipientId}/signing-url [get]

func (*DocumentController) GetStatistics 

func (c *DocumentController) GetStatistics(ctx *gin.Context)

GetStatistics returns document statistics for the workspace. @Summary Get document statistics @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Success 200 {object} documentuc.DocumentStatistics @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents/statistics [get]

func (*DocumentController) InvalidateTokens 

func (c *DocumentController) InvalidateTokens(ctx *gin.Context)

InvalidateTokens invalidates all active access tokens for a document. @Summary Invalidate all access tokens for a document @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param documentId path string true "Document ID" @Success 200 {object} map[string]any @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents/{documentId}/invalidate-tokens [post]

func (*DocumentController) ListDocuments 

func (c *DocumentController) ListDocuments(ctx *gin.Context)

ListDocuments returns all documents in the workspace. @Summary List documents @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param status query string false "Filter by status" @Param search query string false "Search by title" @Param limit query int false "Limit results" @Param offset query int false "Offset for pagination" @Success 200 {array} dto.DocumentListResponse @Failure 400 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents [get]

func (*DocumentController) RefreshStatus 

func (c *DocumentController) RefreshStatus(ctx *gin.Context)

RefreshStatus refreshes document status from the signing provider. @Summary Refresh document status @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param documentId path string true "Document ID" @Success 200 {object} dto.DocumentResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents/{documentId}/refresh [post]

func (*DocumentController) RegisterRoutes 

func (c *DocumentController) RegisterRoutes(api *gin.RouterGroup)

RegisterRoutes registers all document routes.

func (*DocumentController) SendReminder 

func (c *DocumentController) SendReminder(ctx *gin.Context)

SendReminder sends reminder notifications to pending recipients of a document. @Summary Send document reminder @Tags Documents @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param documentId path string true "Document ID" @Success 200 {object} map[string]string @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/documents/{documentId}/remind [post]

type DocumentTypeController 

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

DocumentTypeController handles document type HTTP requests. All routes require X-Tenant-ID header and appropriate tenant role.

func NewDocumentTypeController 

func NewDocumentTypeController(
	docTypeUC cataloguc.DocumentTypeUseCase,
	templateUC templateuc.TemplateUseCase,
	templateMapper *mapper.TemplateMapper,
) *DocumentTypeController

NewDocumentTypeController creates a new document type controller.

func (*DocumentTypeController) CreateDocumentType 

func (c *DocumentTypeController) CreateDocumentType(ctx *gin.Context)

CreateDocumentType creates a new document type. @Summary Create document type @Tags Tenant - Document Types @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param request body dto.CreateDocumentTypeRequest true "Document type data" @Success 201 {object} dto.DocumentTypeResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 409 {object} dto.ErrorResponse @Router /api/v1/tenant/document-types [post] @Security BearerAuth

func (*DocumentTypeController) DeleteDocumentType 

func (c *DocumentTypeController) DeleteDocumentType(ctx *gin.Context)

DeleteDocumentType attempts to delete a document type. If templates are assigned, returns information about them without deleting. Use force=true to delete anyway (templates will have their type set to null). Use replaceWithId to replace the type in all templates before deleting. @Summary Delete document type @Tags Tenant - Document Types @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param id path string true "Document Type ID" @Param request body dto.DeleteDocumentTypeRequest false "Delete options" @Success 200 {object} dto.DeleteDocumentTypeResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/document-types/{id} [delete] @Security BearerAuth

func (*DocumentTypeController) GetDocumentType 

func (c *DocumentTypeController) GetDocumentType(ctx *gin.Context)

GetDocumentType retrieves a document type by ID. @Summary Get document type by ID @Tags Tenant - Document Types @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param id path string true "Document Type ID" @Success 200 {object} dto.DocumentTypeResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/document-types/{id} [get] @Security BearerAuth

func (*DocumentTypeController) GetDocumentTypeByCode 

func (c *DocumentTypeController) GetDocumentTypeByCode(ctx *gin.Context)

GetDocumentTypeByCode retrieves a document type by code within the current tenant. @Summary Get document type by code @Tags Tenant - Document Types @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param code path string true "Document Type Code" @Success 200 {object} dto.DocumentTypeResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/document-types/code/{code} [get] @Security BearerAuth

func (*DocumentTypeController) ListDocumentTypes 

func (c *DocumentTypeController) ListDocumentTypes(ctx *gin.Context)

ListDocumentTypes lists all document types for the current tenant with pagination. @Summary List document types @Tags Tenant - Document Types @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param page query int false "Page number" default(1) @Param perPage query int false "Items per page" default(10) @Param q query string false "Search query for document type name or code" @Success 200 {object} dto.PaginatedDocumentTypesResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/tenant/document-types [get] @Security BearerAuth

func (*DocumentTypeController) ListTemplatesByTypeCode 

func (c *DocumentTypeController) ListTemplatesByTypeCode(ctx *gin.Context)

ListTemplatesByTypeCode lists all templates using a specific document type code across the tenant. @Summary List templates by document type code @Tags Tenant - Document Types @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param code path string true "Document Type Code" @Success 200 {object} dto.ListTemplatesResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/document-types/code/{code}/templates [get] @Security BearerAuth

func (*DocumentTypeController) RegisterRoutes 

func (c *DocumentTypeController) RegisterRoutes(rg *gin.RouterGroup, middlewareProvider *middleware.Provider)

RegisterRoutes registers all /tenant/document-types routes. These routes require X-Tenant-ID header and tenant context.

func (*DocumentTypeController) UpdateDocumentType 

func (c *DocumentTypeController) UpdateDocumentType(ctx *gin.Context)

UpdateDocumentType updates a document type's name and description. @Summary Update document type @Tags Tenant - Document Types @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param id path string true "Document Type ID" @Param request body dto.UpdateDocumentTypeRequest true "Document type data" @Success 200 {object} dto.DocumentTypeResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/document-types/{id} [put] @Security BearerAuth

type GalleryController 

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

GalleryController handles image gallery HTTP requests.

func NewGalleryController 

func NewGalleryController(galleryUC galleryuc.GalleryUseCase) *GalleryController

NewGalleryController creates a new gallery controller.

func (*GalleryController) DeleteAsset 

func (c *GalleryController) DeleteAsset(ctx *gin.Context)

DeleteAsset removes an asset from the gallery. @Summary Delete gallery asset @Tags Gallery @Produce json @Security BearerAuth @Param X-Workspace-ID header string true "Workspace ID" @Param key query string true "Asset key" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/workspace/gallery [delete]

func (*GalleryController) GetAssetURL 

func (c *GalleryController) GetAssetURL(ctx *gin.Context)

GetAssetURL resolves a gallery key to an HTTP URL. @Summary Get gallery asset URL @Tags Gallery @Produce json @Security BearerAuth @Param X-Workspace-ID header string true "Workspace ID" @Param key query string true "Asset key" @Success 200 {object} dto.GalleryURLResponse @Failure 400 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/workspace/gallery/url [get]

func (*GalleryController) ListAssets 

func (c *GalleryController) ListAssets(ctx *gin.Context)

ListAssets returns a paginated list of gallery assets. @Summary List gallery assets @Tags Gallery @Produce json @Security BearerAuth @Param X-Workspace-ID header string true "Workspace ID" @Param page query int false "Page number (default 1)" @Param perPage query int false "Items per page (default 20)" @Success 200 {object} dto.GalleryListResponse @Failure 400 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/workspace/gallery [get]

func (*GalleryController) RegisterRoutes 

func (c *GalleryController) RegisterRoutes(rg *gin.RouterGroup, middlewareProvider *middleware.Provider)

RegisterRoutes registers all gallery routes under /workspace/gallery.

func (*GalleryController) SearchAssets 

func (c *GalleryController) SearchAssets(ctx *gin.Context)

SearchAssets returns gallery assets matching a query string. @Summary Search gallery assets @Tags Gallery @Produce json @Security BearerAuth @Param X-Workspace-ID header string true "Workspace ID" @Param q query string true "Search query" @Param page query int false "Page number (default 1)" @Param perPage query int false "Items per page (default 20)" @Success 200 {object} dto.GalleryListResponse @Failure 400 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/workspace/gallery/search [get]

func (*GalleryController) ServeAsset 

func (c *GalleryController) ServeAsset(ctx *gin.Context)

ServeAsset streams a gallery asset directly from storage. Used as fallback when local storage (file://) is configured instead of S3. @Summary Serve gallery asset bytes @Tags Gallery @Produce application/octet-stream @Security BearerAuth @Param X-Workspace-ID header string true "Workspace ID" @Param key query string true "Asset key" @Success 200 {file} binary @Failure 400 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/workspace/gallery/serve [get]

func (*GalleryController) UploadAsset 

func (c *GalleryController) UploadAsset(ctx *gin.Context)

UploadAsset accepts a multipart file upload and stores it in the gallery. @Summary Upload gallery asset @Tags Gallery @Accept mpfd @Produce json @Security BearerAuth @Param X-Tenant-ID header string true "Tenant ID" @Param X-Workspace-ID header string true "Workspace ID" @Param file formData file true "Image file" @Success 201 {object} dto.GalleryAssetResponse @Failure 400 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/workspace/gallery [post]

type InternalDocumentController 

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

InternalDocumentController handles internal API document requests. These endpoints are used for service-to-service communication.

func NewInternalDocumentController 

func NewInternalDocumentController(
	internalDocUC documentuc.InternalDocumentUseCase,
) *InternalDocumentController

NewInternalDocumentController creates a new internal document controller.

func (*InternalDocumentController) CreateDocument 

func (c *InternalDocumentController) CreateDocument(ctx *gin.Context)

CreateDocument creates a document via internal API. @Summary Create document via internal API @Description Creates or replays a document using the extension system (Mapper, Init, Injectors) @Tags Internal @Accept json @Produce json @Param X-API-Key header string true "API Key for authentication" @Param X-Tenant-Code header string true "Tenant business code" @Param X-Workspace-Code header string true "Workspace business code" @Param X-Document-Type header string true "Document type code" @Param X-External-ID header string true "External ID (e.g., CRM entity ID)" @Param X-Transactional-ID header string true "Transactional ID for idempotency" @Param request body dto.InternalCreateDocumentRequest true "Internal create request" @Success 201 {object} dto.InternalCreateDocumentWithRecipientsResponse @Success 200 {object} dto.InternalCreateDocumentWithRecipientsResponse @Failure 400 {object} dto.InternalErrorResponse @Failure 401 {object} dto.InternalErrorResponse @Failure 404 {object} dto.InternalErrorResponse @Failure 500 {object} dto.InternalErrorResponse @Router /api/v1/internal/documents/create [post]

func (*InternalDocumentController) RegisterRoutes 

func (c *InternalDocumentController) RegisterRoutes(api *gin.RouterGroup, authMiddleware gin.HandlerFunc)

RegisterRoutes registers all internal document routes. The API key is validated via middleware.

type MeController 

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

MeController handles user-specific HTTP requests. These routes don't require X-Tenant-ID or X-Workspace-ID headers.

func NewMeController 

func NewMeController(
	tenantUC organizationuc.TenantUseCase,
	tenantMemberRepo port.TenantMemberRepository,
	workspaceMemberRepo port.WorkspaceMemberRepository,
	workspaceRepo port.WorkspaceRepository,
	accessHistoryUC accessuc.UserAccessHistoryUseCase,
) *MeController

NewMeController creates a new me controller.

func (*MeController) GetMyRoles 

func (c *MeController) GetMyRoles(ctx *gin.Context)

GetMyRoles returns the roles of the current user. Optionally includes tenant role and effective workspace role if X-Tenant-ID / X-Workspace-ID headers are provided. @Summary Get my roles @Description Returns the current user's roles. Always includes system role if assigned. @Description Optionally includes tenant role if X-Tenant-ID header is provided. @Description Optionally includes workspace role if X-Workspace-ID header is provided. @Tags Me @Accept json @Produce json @Param X-Tenant-ID header string false "Tenant ID to check role for" @Param X-Workspace-ID header string false "Workspace ID to check role for" @Success 200 {object} dto.MyRolesResponse @Failure 401 {object} dto.ErrorResponse @Router /api/v1/me/roles [get] @Security BearerAuth

func (*MeController) ListMyTenants 

func (c *MeController) ListMyTenants(ctx *gin.Context)

ListMyTenants lists tenants the current user is a member of with pagination and optional search. @Summary List my tenants with pagination and optional search @Description Lists tenants where the user is an active member. Supports pagination and optional search by name/code. @Tags Me @Accept json @Produce json @Param page query int false "Page number" default(1) @Param perPage query int false "Items per page" default(10) @Param q query string false "Search query for tenant name or code" @Success 200 {object} dto.PaginatedTenantsWithRoleResponse @Failure 401 {object} dto.ErrorResponse @Router /api/v1/me/tenants [get] @Security BearerAuth

func (*MeController) RecordAccess 

func (c *MeController) RecordAccess(ctx *gin.Context)

RecordAccess records that the user accessed a tenant or workspace. @Summary Record resource access @Description Records that the user accessed a tenant or workspace for quick access history @Tags Me @Accept json @Produce json @Param request body dto.RecordAccessRequest true "Access details" @Success 204 "Access recorded" @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/me/access [post] @Security BearerAuth

func (*MeController) RegisterRoutes 

func (c *MeController) RegisterRoutes(rg *gin.RouterGroup)

RegisterRoutes registers all /me routes. These routes only require authentication, no tenant or workspace context.

type ProcessController 

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

ProcessController handles process HTTP requests. All routes require X-Tenant-ID header and appropriate tenant role.

func NewProcessController 

func NewProcessController(
	processUC cataloguc.ProcessUseCase,
	processMapper *mapper.ProcessMapper,
) *ProcessController

NewProcessController creates a new process controller.

func (*ProcessController) CreateProcess 

func (c *ProcessController) CreateProcess(ctx *gin.Context)

CreateProcess creates a new process. @Summary Create process @Tags Tenant - Processes @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param request body dto.CreateProcessRequest true "Process data" @Success 201 {object} dto.ProcessResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 409 {object} dto.ErrorResponse @Router /api/v1/tenant/processes [post] @Security BearerAuth

func (*ProcessController) DeleteProcess 

func (c *ProcessController) DeleteProcess(ctx *gin.Context)

DeleteProcess attempts to delete a process. If templates are assigned, returns information about them without deleting. Use force=true to delete anyway (templates will have their process reset to DEFAULT). Use replaceWithCode to replace the process in all templates before deleting. @Summary Delete process @Tags Tenant - Processes @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param id path string true "Process ID" @Param request body dto.DeleteProcessRequest false "Delete options" @Success 200 {object} dto.DeleteProcessResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/processes/{id} [delete] @Security BearerAuth

func (*ProcessController) GetProcess 

func (c *ProcessController) GetProcess(ctx *gin.Context)

GetProcess retrieves a process by ID. @Summary Get process by ID @Tags Tenant - Processes @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param id path string true "Process ID" @Success 200 {object} dto.ProcessResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/processes/{id} [get] @Security BearerAuth

func (*ProcessController) GetProcessByCode 

func (c *ProcessController) GetProcessByCode(ctx *gin.Context)

GetProcessByCode retrieves a process by code within the current tenant. @Summary Get process by code @Tags Tenant - Processes @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param code path string true "Process Code" @Success 200 {object} dto.ProcessResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/processes/code/{code} [get] @Security BearerAuth

func (*ProcessController) ListProcesses 

func (c *ProcessController) ListProcesses(ctx *gin.Context)

ListProcesses lists all processes for the current tenant with pagination. @Summary List processes @Tags Tenant - Processes @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param page query int false "Page number" default(1) @Param perPage query int false "Items per page" default(10) @Param q query string false "Search query for process name or code" @Success 200 {object} dto.PaginatedProcessesResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/tenant/processes [get] @Security BearerAuth

func (*ProcessController) ListTemplatesByProcessCode 

func (c *ProcessController) ListTemplatesByProcessCode(ctx *gin.Context)

ListTemplatesByProcessCode lists all templates using a specific process code across the tenant. @Summary List templates by process code @Tags Tenant - Processes @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param code path string true "Process Code" @Success 200 {array} dto.ProcessTemplateInfoResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/processes/code/{code}/templates [get] @Security BearerAuth

func (*ProcessController) RegisterRoutes 

func (c *ProcessController) RegisterRoutes(rg *gin.RouterGroup, middlewareProvider *middleware.Provider)

RegisterRoutes registers all /tenant/processes routes. These routes require X-Tenant-ID header and tenant context.

func (*ProcessController) UpdateProcess 

func (c *ProcessController) UpdateProcess(ctx *gin.Context)

UpdateProcess updates a process's name and description. @Summary Update process @Tags Tenant - Processes @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param id path string true "Process ID" @Param request body dto.UpdateProcessRequest true "Process data" @Success 200 {object} dto.ProcessResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/processes/{id} [put] @Security BearerAuth

type PublicDocumentAccessController 

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

PublicDocumentAccessController handles public document access endpoints. These endpoints implement the email-verification gate for public signing.

func NewPublicDocumentAccessController 

func NewPublicDocumentAccessController(accessUC documentuc.DocumentAccessUseCase) *PublicDocumentAccessController

NewPublicDocumentAccessController creates a new public document access controller.

func (*PublicDocumentAccessController) GetPublicDocumentInfo 

func (c *PublicDocumentAccessController) GetPublicDocumentInfo(ctx *gin.Context)

GetPublicDocumentInfo returns minimal public info about a document. @Summary Get public document info @Description Returns document title and status for the public access page. @Tags Public Document Access @Produce json @Param documentId path string true "Document ID" @Success 200 {object} documentuc.PublicDocumentInfoResponse @Failure 404 {object} map[string]string @Router /public/doc/{documentId} [get]

func (*PublicDocumentAccessController) RegisterRoutes 

func (c *PublicDocumentAccessController) RegisterRoutes(router gin.IRouter, authMiddlewares ...gin.HandlerFunc)

RegisterRoutes registers public document access routes. These routes are NOT behind the auth middleware chain. authMiddlewares (e.g. CustomPublicDocumentAccess) are applied to both GET and POST.

func (*PublicDocumentAccessController) RequestAccess 

func (c *PublicDocumentAccessController) RequestAccess(ctx *gin.Context)

RequestAccess validates email and sends an access link. If custom auth claims are present (via CustomPublicDocumentAccess middleware), returns a signing URL directly without sending email. Always returns 200 to prevent email enumeration. @Summary Request document access @Description Validates email against document recipients and sends an access link via email. With valid auth, returns signing URL directly. Always returns 200. @Tags Public Document Access @Accept json @Produce json @Param documentId path string true "Document ID" @Param request body requestAccessBody false "Email address (not required when auth is provided)" @Success 200 {object} map[string]string @Router /public/doc/{documentId}/request-access [post]

type PublicSigningController 

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

PublicSigningController handles public signing endpoints. These endpoints do not require JWT authentication; they are validated by access token only.

func NewPublicSigningController 

func NewPublicSigningController(
	preSigningUC documentuc.PreSigningUseCase,
	accessUC documentuc.DocumentAccessUseCase,
	publicURL string,
) *PublicSigningController

NewPublicSigningController creates a new public signing controller.

func (*PublicSigningController) CompleteEmbeddedSigning 

func (c *PublicSigningController) CompleteEmbeddedSigning(ctx *gin.Context)

CompleteEmbeddedSigning marks the token as used after signing completion. @Summary Complete embedded signing @Description Marks the access token as used after the signer completes signing in the iframe. @Tags Public Signing @Produce json @Param token path string true "Access token" @Success 200 {object} map[string]string @Failure 401 {object} map[string]string @Failure 500 {object} map[string]string @Router /public/sign/{token}/complete [post]

func (*PublicSigningController) DownloadCompletedPDF 

func (c *PublicSigningController) DownloadCompletedPDF(ctx *gin.Context)

DownloadCompletedPDF downloads the signed PDF for completed documents. @Summary Download completed PDF @Description Downloads the completed/signed PDF when the token recipient is authorized. @Tags Public Signing @Produce application/pdf @Param token path string true "Access token" @Success 200 {file} binary @Failure 401 {object} map[string]string @Failure 403 {object} map[string]string @Failure 500 {object} map[string]string @Router /public/sign/{token}/download [get]

func (*PublicSigningController) GetPublicSigningPage 

func (c *PublicSigningController) GetPublicSigningPage(ctx *gin.Context)

GetPublicSigningPage returns the current signing page state for a given access token. @Summary Get public signing page @Description Returns document state and content based on token type and document status. @Tags Public Signing @Produce json @Param token path string true "Access token" @Success 200 {object} documentuc.PublicSigningResponse @Failure 401 {object} map[string]string @Failure 500 {object} map[string]string @Router /public/sign/{token} [get]

func (*PublicSigningController) ProceedToSigning 

func (c *PublicSigningController) ProceedToSigning(ctx *gin.Context)

ProceedToSigning transitions a Path A document from preview to embedded signing. @Summary Proceed to signing @Description For Path A (SIGNING token), transitions from PDF preview to embedded signing iframe. @Tags Public Signing @Produce json @Param token path string true "Access token" @Success 200 {object} documentuc.PublicSigningResponse @Failure 401 {object} map[string]string @Failure 500 {object} map[string]string @Router /public/sign/{token}/proceed [post]

func (*PublicSigningController) RefreshEmbeddedURL 

func (c *PublicSigningController) RefreshEmbeddedURL(ctx *gin.Context)

RefreshEmbeddedURL refreshes an expired embedded signing URL. @Summary Refresh embedded URL @Description Gets a fresh embedded signing URL when the previous one has expired. @Tags Public Signing @Produce json @Param token path string true "Access token" @Success 200 {object} documentuc.PublicSigningResponse @Failure 401 {object} map[string]string @Failure 500 {object} map[string]string @Router /public/sign/{token}/refresh [get]

func (*PublicSigningController) RegisterRoutes 

func (c *PublicSigningController) RegisterRoutes(router gin.IRouter)

RegisterRoutes registers public signing routes. These routes are NOT behind the auth middleware chain.

func (*PublicSigningController) RenderPreviewPDF 

func (c *PublicSigningController) RenderPreviewPDF(ctx *gin.Context)

RenderPreviewPDF renders the document PDF on-demand for preview. @Summary Render preview PDF @Description Renders the document PDF on-demand using the access token. Used for previewing before signing. @Tags Public Signing @Produce application/pdf @Param token path string true "Access token" @Success 200 {file} binary @Failure 401 {object} map[string]string @Failure 500 {object} map[string]string @Router /public/sign/{token}/pdf [get]

func (*PublicSigningController) RequestAccessFromToken 

func (c *PublicSigningController) RequestAccessFromToken(ctx *gin.Context)

RequestAccessFromToken requests a new access email using a token entrypoint (expired-link recovery). Always returns 200 to prevent enumeration. @Summary Request access from token @Description Requests a new signing link by email using a token entrypoint. Always returns 200. @Tags Public Signing @Accept json @Produce json @Param token path string true "Access token" @Param request body requestAccessFromTokenBody true "Email address" @Success 200 {object} map[string]string @Router /public/sign/{token}/request-access [post]

func (*PublicSigningController) SigningCallback 

func (c *PublicSigningController) SigningCallback(ctx *gin.Context)

SigningCallback serves the callback bridge page for provider-agnostic signing completion. When a signing provider redirects the iframe here, this page sends a postMessage to the parent window with a standardized event — the parent never listens to the provider's domain, only to its own origin. @Summary Signing callback bridge @Description Serves an HTML page that posts SIGNING_EVENT to parent window. @Tags Public Signing @Produce html @Param token path string true "Access token" @Param status query string false "Signing status" default(signed) @Router /public/sign/{token}/signing-callback [get]

func (*PublicSigningController) SubmitPreSigningForm 

func (c *PublicSigningController) SubmitPreSigningForm(ctx *gin.Context)

SubmitPreSigningForm submits field responses and returns the signing state with embedded URL. @Summary Submit pre-signing form @Description Validates and saves field responses, renders PDF, sends for signing, returns embedded URL. @Tags Public Signing @Accept json @Produce json @Param token path string true "Access token" @Param request body submitFormRequest true "Field responses" @Success 200 {object} documentuc.PublicSigningResponse @Failure 400 {object} map[string]string @Failure 401 {object} map[string]string @Failure 500 {object} map[string]string @Router /public/sign/{token} [post]

type RenderController 

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

RenderController handles document rendering HTTP requests.

func NewRenderController 

func NewRenderController(
	versionUC templateuc.TemplateVersionUseCase,
	pdfRenderer port.PDFRenderer,
) *RenderController

NewRenderController creates a new render controller.

func (*RenderController) PreviewVersion 

func (c *RenderController) PreviewVersion(ctx *gin.Context)

PreviewVersion generates a preview PDF for a template version. @Summary Generate preview PDF @Tags Template Versions @Accept json @Produce application/pdf @Param X-Workspace-ID header string true "Workspace ID" @Param templateId path string true "Template ID" @Param versionId path string true "Version ID" @Param request body dto.RenderPreviewRequest true "Injectable values" @Success 200 {file} application/pdf @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId}/preview [post]

func (*RenderController) RegisterRoutes 

func (c *RenderController) RegisterRoutes(versions *gin.RouterGroup)

RegisterRoutes registers all render routes. These routes are nested under /content/templates/:templateId/versions/:versionId

type SigningSessionController 

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

SigningSessionController handles authenticated signing-session creation for embedded iframe flows.

func NewSigningSessionController 

func NewSigningSessionController(signingSessionUC documentuc.SigningSessionUseCase) *SigningSessionController

NewSigningSessionController creates a new signing session controller.

func (*SigningSessionController) CreateOrGetSession 

func (c *SigningSessionController) CreateOrGetSession(ctx *gin.Context)

CreateOrGetSession creates or reuses a tokenized signing session URL for the authenticated recipient. @Summary Create or get signing session @Description Returns a reusable /public/sign/{token} URL and signing page state for an authenticated recipient. @Tags Signing Sessions @Produce json @Param documentId path string true "Document ID" @Success 200 {object} documentuc.SigningSessionResponse @Failure 401 {object} map[string]string @Failure 403 {object} map[string]string @Failure 409 {object} map[string]string @Failure 429 {object} map[string]string @Router /api/v1/signing-sessions/{documentId} [post]

func (*SigningSessionController) RegisterRoutes 

func (c *SigningSessionController) RegisterRoutes(router gin.IRouter, authMiddlewares ...gin.HandlerFunc)

RegisterRoutes registers signing session routes under /api/v1.

type TemplateVersionController 

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

TemplateVersionController handles template version HTTP requests.

func NewTemplateVersionController 

func NewTemplateVersionController(
	versionUC templateuc.TemplateVersionUseCase,
	versionMapper *mapper.TemplateVersionMapper,
	templateMapper *mapper.TemplateMapper,
	renderController *RenderController,
) *TemplateVersionController

NewTemplateVersionController creates a new template version controller.

func (*TemplateVersionController) AddInjectable 

func (c *TemplateVersionController) AddInjectable(ctx *gin.Context)

AddInjectable adds an injectable to a version. @Summary Add injectable to version @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param versionId path string true "Version ID" @Param request body dto.AddVersionInjectableRequest true "Injectable data" @Success 201 {object} dto.TemplateVersionInjectableResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId}/injectables [post]

func (*TemplateVersionController) ArchiveVersion 

func (c *TemplateVersionController) ArchiveVersion(ctx *gin.Context)

ArchiveVersion archives a published version. @Summary Archive template version @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param versionId path string true "Version ID" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId}/archive [post]

func (*TemplateVersionController) CancelSchedule 

func (c *TemplateVersionController) CancelSchedule(ctx *gin.Context)

CancelSchedule cancels any scheduled publication or archival. @Summary Cancel scheduled action @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param versionId path string true "Version ID" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId}/schedule [delete]

func (*TemplateVersionController) CreateVersion 

func (c *TemplateVersionController) CreateVersion(ctx *gin.Context)

CreateVersion creates a new version for a template. @Summary Create template version @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param request body dto.CreateVersionRequest true "Version data" @Success 201 {object} dto.TemplateVersionResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions [post]

func (*TemplateVersionController) CreateVersionFromExisting 

func (c *TemplateVersionController) CreateVersionFromExisting(ctx *gin.Context)

CreateVersionFromExisting creates a new version copying content from an existing one. @Summary Create version from existing @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param request body dto.CreateVersionFromExistingRequest true "Version data" @Success 201 {object} dto.TemplateVersionResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/from-existing [post]

func (*TemplateVersionController) DeleteVersion 

func (c *TemplateVersionController) DeleteVersion(ctx *gin.Context)

DeleteVersion deletes a draft version. @Summary Delete template version @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param versionId path string true "Version ID" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId} [delete]

func (*TemplateVersionController) GetVersion 

func (c *TemplateVersionController) GetVersion(ctx *gin.Context)

GetVersion retrieves a version by ID with details. @Summary Get template version @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param versionId path string true "Version ID" @Success 200 {object} dto.TemplateVersionDetailResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId} [get]

func (*TemplateVersionController) ListVersions 

func (c *TemplateVersionController) ListVersions(ctx *gin.Context)

ListVersions lists all versions for a template. @Summary List template versions @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Success 200 {object} dto.ListTemplateVersionsResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions [get]

func (*TemplateVersionController) PromoteVersion 

func (c *TemplateVersionController) PromoteVersion(ctx *gin.Context)

PromoteVersion promotes a published version from sandbox to production. @Summary Promote version to production @Description Promotes a PUBLISHED version from sandbox to production workspace. Can create a new template (NEW_TEMPLATE mode) or add as a new version to an existing template (NEW_VERSION mode). **Important**: The target workspace (X-Workspace-ID) must be a production workspace, not a sandbox. Promoting to sandbox workspaces is not allowed. @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Target Production Workspace ID (cannot be a sandbox workspace)" @Param templateId path string true "Source Template ID (in sandbox)" @Param versionId path string true "Source Version ID (must be PUBLISHED)" @Param request body dto.PromoteVersionRequest true "Promotion configuration" @Success 201 {object} dto.PromoteAsNewTemplateResponse "When mode=NEW_TEMPLATE" @Success 201 {object} dto.PromoteAsNewVersionResponse "When mode=NEW_VERSION" @Failure 400 {object} dto.ErrorResponse "Bad request or target workspace is a sandbox" @Failure 404 {object} dto.ErrorResponse @Failure 409 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId}/promote [post]

func (*TemplateVersionController) PublishVersion 

func (c *TemplateVersionController) PublishVersion(ctx *gin.Context)

PublishVersion publishes a version. @Summary Publish template version @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param versionId path string true "Version ID" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId}/publish [post]

func (*TemplateVersionController) RegisterRoutes 

func (c *TemplateVersionController) RegisterRoutes(templates *gin.RouterGroup)

RegisterRoutes registers all template version routes. These routes are nested under /content/templates/:templateId/versions

func (*TemplateVersionController) RemoveInjectable 

func (c *TemplateVersionController) RemoveInjectable(ctx *gin.Context)

RemoveInjectable removes an injectable from a version. @Summary Remove injectable from version @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param versionId path string true "Version ID" @Param injectableId path string true "Injectable ID" @Success 204 "No Content" @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId}/injectables/{injectableId} [delete]

func (*TemplateVersionController) ScheduleArchive 

func (c *TemplateVersionController) ScheduleArchive(ctx *gin.Context)

ScheduleArchive schedules the published version for future archival. @Summary Schedule version archival @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param versionId path string true "Version ID" @Param request body dto.ScheduleArchiveRequest true "Schedule data" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId}/schedule-archive [post]

func (*TemplateVersionController) SchedulePublish 

func (c *TemplateVersionController) SchedulePublish(ctx *gin.Context)

SchedulePublish schedules a version for future publication. @Summary Schedule version publication @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param versionId path string true "Version ID" @Param request body dto.SchedulePublishRequest true "Schedule data" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId}/schedule-publish [post]

func (*TemplateVersionController) UpdateVersion 

func (c *TemplateVersionController) UpdateVersion(ctx *gin.Context)

UpdateVersion updates a version. @Summary Update template version @Tags Template Versions @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param templateId path string true "Template ID" @Param versionId path string true "Version ID" @Param request body dto.UpdateVersionRequest true "Version data" @Success 200 {object} dto.TemplateVersionResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/content/templates/{templateId}/versions/{versionId} [put]

type TenantController 

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

TenantController handles tenant-scoped HTTP requests. All routes require X-Tenant-ID header and appropriate tenant role.

func NewTenantController 

func NewTenantController(
	tenantUC organizationuc.TenantUseCase,
	workspaceUC organizationuc.WorkspaceUseCase,
	tenantMemberUC organizationuc.TenantMemberUseCase,
) *TenantController

NewTenantController creates a new tenant controller.

func (*TenantController) AddTenantMember 

func (c *TenantController) AddTenantMember(ctx *gin.Context)

AddTenantMember adds a user to the current tenant. @Summary Add tenant member @Tags Tenant - Members @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param request body dto.AddTenantMemberRequest true "Member data" @Success 201 {object} dto.TenantMemberResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 409 {object} dto.ErrorResponse @Router /api/v1/tenant/members [post] @Security BearerAuth

func (*TenantController) CreateWorkspace 

func (c *TenantController) CreateWorkspace(ctx *gin.Context)

CreateWorkspace creates a new workspace in the current tenant. @Summary Create workspace in tenant @Tags Tenant - Workspaces @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param request body dto.CreateWorkspaceRequest true "Workspace data" @Success 201 {object} dto.WorkspaceResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/tenant/workspaces [post] @Security BearerAuth

func (*TenantController) DeleteWorkspace 

func (c *TenantController) DeleteWorkspace(ctx *gin.Context)

DeleteWorkspace deletes a workspace from the current tenant. @Summary Delete workspace from tenant @Tags Tenant - Workspaces @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param workspaceId path string true "Workspace ID" @Success 204 "No Content" @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/workspaces/{workspaceId} [delete] @Security BearerAuth

func (*TenantController) GetTenant 

func (c *TenantController) GetTenant(ctx *gin.Context)

GetTenant retrieves the current tenant info. @Summary Get current tenant @Tags Tenant @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Success 200 {object} dto.TenantResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant [get] @Security BearerAuth

func (*TenantController) GetTenantMember 

func (c *TenantController) GetTenantMember(ctx *gin.Context)

GetTenantMember retrieves a specific tenant member. @Summary Get tenant member @Tags Tenant - Members @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param memberId path string true "Member ID" @Success 200 {object} dto.TenantMemberResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/members/{memberId} [get] @Security BearerAuth

func (*TenantController) ListTenantMembers 

func (c *TenantController) ListTenantMembers(ctx *gin.Context)

ListTenantMembers lists all members of the current tenant. @Summary List tenant members @Tags Tenant - Members @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Success 200 {object} dto.ListResponse[dto.TenantMemberResponse] @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/tenant/members [get] @Security BearerAuth

func (*TenantController) ListWorkspaces 

func (c *TenantController) ListWorkspaces(ctx *gin.Context)

ListWorkspaces lists workspaces with pagination and optional search in the current tenant. @Summary List workspaces with pagination and optional search @Tags Tenant - Workspaces @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param page query int false "Page number" default(1) @Param perPage query int false "Items per page" default(10) @Param q query string false "Search query for workspace name" @Param status query string false "Filter by status (ACTIVE, SUSPENDED, ARCHIVED)" @Success 200 {object} dto.PaginatedWorkspacesResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Router /api/v1/tenant/workspaces [get] @Security BearerAuth

func (*TenantController) RegisterRoutes 

func (c *TenantController) RegisterRoutes(rg *gin.RouterGroup, middlewareProvider *middleware.Provider)

RegisterRoutes registers all /tenant routes. These routes require X-Tenant-ID header and tenant context.

func (*TenantController) RemoveTenantMember 

func (c *TenantController) RemoveTenantMember(ctx *gin.Context)

RemoveTenantMember removes a member from the current tenant. @Summary Remove tenant member @Tags Tenant - Members @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param memberId path string true "Member ID" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/members/{memberId} [delete] @Security BearerAuth

func (*TenantController) UpdateCurrentTenant 

func (c *TenantController) UpdateCurrentTenant(ctx *gin.Context)

UpdateCurrentTenant updates the current tenant's info. @Summary Update current tenant @Tags Tenant @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param request body dto.UpdateTenantRequest true "Tenant data" @Success 200 {object} dto.TenantResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant [put] @Security BearerAuth

func (*TenantController) UpdateTenantMemberRole 

func (c *TenantController) UpdateTenantMemberRole(ctx *gin.Context)

UpdateTenantMemberRole updates a tenant member's role. @Summary Update tenant member role @Tags Tenant - Members @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param memberId path string true "Member ID" @Param request body dto.UpdateTenantMemberRoleRequest true "Role data" @Success 200 {object} dto.TenantMemberResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/members/{memberId} [put] @Security BearerAuth

func (*TenantController) UpdateWorkspaceStatus 

func (c *TenantController) UpdateWorkspaceStatus(ctx *gin.Context)

UpdateWorkspaceStatus updates a workspace's status in the current tenant. @Summary Update workspace status @Tags Tenant - Workspaces @Accept json @Produce json @Param X-Tenant-ID header string true "Tenant ID" @Param workspaceId path string true "Workspace ID" @Param request body dto.UpdateWorkspaceStatusRequest true "Status data" @Success 200 {object} dto.WorkspaceResponse @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 403 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/tenant/workspaces/{workspaceId}/status [patch] @Security BearerAuth

type WebhookController 

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

WebhookController handles incoming webhooks from signing providers.

func NewWebhookController 

func NewWebhookController(
	documentUC documentuc.DocumentUseCase,
	webhookHandlers map[string]port.WebhookHandler,
) *WebhookController

NewWebhookController creates a new webhook controller.

func (*WebhookController) HandleSigningWebhook 

func (c *WebhookController) HandleSigningWebhook(ctx *gin.Context)

HandleSigningWebhook processes incoming webhooks from signing providers. @Summary Handle signing provider webhook @Tags Webhooks @Accept json @Produce json @Param provider path string true "Provider name (e.g., documenso)" @Param X-Documenso-Secret header string false "Webhook signature (for Documenso)" @Param X-Webhook-Signature header string false "Webhook signature (generic)" @Success 200 {object} map[string]string @Failure 400 {object} dto.ErrorResponse @Failure 401 {object} dto.ErrorResponse @Failure 500 {object} dto.ErrorResponse @Router /webhooks/signing/{provider} [post]

func (*WebhookController) RegisterRoutes 

func (c *WebhookController) RegisterRoutes(router gin.IRouter)

RegisterRoutes registers webhook routes. Webhooks are not protected by auth middleware as they come from external providers.

type WorkspaceController 

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

WorkspaceController handles workspace-related HTTP requests.

func NewWorkspaceController 

func NewWorkspaceController(
	workspaceUC organizationuc.WorkspaceUseCase,
	folderUC cataloguc.FolderUseCase,
	tagUC cataloguc.TagUseCase,
	memberUC organizationuc.WorkspaceMemberUseCase,
	workspaceInjectableUC injectableuc.WorkspaceInjectableUseCase,
	injectableMapper *mapper.InjectableMapper,
) *WorkspaceController

NewWorkspaceController creates a new workspace controller.

func (*WorkspaceController) ActivateInjectable 

func (c *WorkspaceController) ActivateInjectable(ctx *gin.Context)

ActivateInjectable activates an injectable. @Summary Activate injectable @Tags Injectables @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param injectableId path string true "Injectable ID" @Success 200 {object} dto.WorkspaceInjectableResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/injectables/{injectableId}/activate [post]

func (*WorkspaceController) ArchiveWorkspace 

func (c *WorkspaceController) ArchiveWorkspace(ctx *gin.Context)

ArchiveWorkspace archives the current workspace. @Summary Archive current workspace @Tags Workspaces @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace [delete]

func (*WorkspaceController) CreateFolder 

func (c *WorkspaceController) CreateFolder(ctx *gin.Context)

CreateFolder creates a new folder in the current workspace. @Summary Create folder @Tags Folders @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param request body dto.CreateFolderRequest true "Folder data" @Success 201 {object} dto.FolderResponse @Failure 400 {object} dto.ErrorResponse @Router /api/v1/workspace/folders [post]

func (*WorkspaceController) CreateTag 

func (c *WorkspaceController) CreateTag(ctx *gin.Context)

CreateTag creates a new tag in the current workspace. @Summary Create tag @Tags Tags @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param request body dto.CreateTagRequest true "Tag data" @Success 201 {object} dto.TagResponse @Failure 400 {object} dto.ErrorResponse @Router /api/v1/workspace/tags [post]

func (*WorkspaceController) CreateWorkspaceInjectable 

func (c *WorkspaceController) CreateWorkspaceInjectable(ctx *gin.Context)

CreateWorkspaceInjectable creates a new injectable in the current workspace. @Summary Create workspace injectable @Tags Injectables @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param request body dto.CreateWorkspaceInjectableRequest true "Injectable data" @Success 201 {object} dto.WorkspaceInjectableResponse @Failure 400 {object} dto.ErrorResponse @Router /api/v1/workspace/injectables [post]

func (*WorkspaceController) DeactivateInjectable 

func (c *WorkspaceController) DeactivateInjectable(ctx *gin.Context)

DeactivateInjectable deactivates an injectable. @Summary Deactivate injectable @Tags Injectables @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param injectableId path string true "Injectable ID" @Success 200 {object} dto.WorkspaceInjectableResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/injectables/{injectableId}/deactivate [post]

func (*WorkspaceController) DeleteFolder 

func (c *WorkspaceController) DeleteFolder(ctx *gin.Context)

DeleteFolder deletes a folder. @Summary Delete folder @Tags Folders @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param folderId path string true "Folder ID" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/folders/{folderId} [delete]

func (*WorkspaceController) DeleteTag 

func (c *WorkspaceController) DeleteTag(ctx *gin.Context)

DeleteTag deletes a tag. @Summary Delete tag @Tags Tags @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param tagId path string true "Tag ID" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/tags/{tagId} [delete]

func (*WorkspaceController) DeleteWorkspaceInjectable 

func (c *WorkspaceController) DeleteWorkspaceInjectable(ctx *gin.Context)

DeleteWorkspaceInjectable soft-deletes an injectable. @Summary Delete workspace injectable @Tags Injectables @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param injectableId path string true "Injectable ID" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/injectables/{injectableId} [delete]

func (*WorkspaceController) GetFolder 

func (c *WorkspaceController) GetFolder(ctx *gin.Context)

GetFolder retrieves a folder by ID. @Summary Get folder @Tags Folders @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param folderId path string true "Folder ID" @Success 200 {object} dto.FolderResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/folders/{folderId} [get]

func (*WorkspaceController) GetFolderTree 

func (c *WorkspaceController) GetFolderTree(ctx *gin.Context)

GetFolderTree gets the folder tree for the current workspace. @Summary Get folder tree @Tags Folders @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Success 200 {array} dto.FolderTreeResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/folders/tree [get]

func (*WorkspaceController) GetMember 

func (c *WorkspaceController) GetMember(ctx *gin.Context)

GetMember retrieves a member by ID. @Summary Get member @Tags Members @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param memberId path string true "Member ID" @Success 200 {object} dto.MemberResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/members/{memberId} [get]

func (*WorkspaceController) GetTag 

func (c *WorkspaceController) GetTag(ctx *gin.Context)

GetTag retrieves a tag by ID. @Summary Get tag @Tags Tags @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param tagId path string true "Tag ID" @Success 200 {object} dto.TagResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/tags/{tagId} [get]

func (*WorkspaceController) GetWorkspace 

func (c *WorkspaceController) GetWorkspace(ctx *gin.Context)

GetWorkspace retrieves the current workspace. @Summary Get current workspace @Tags Workspaces @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Success 200 {object} dto.WorkspaceResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace [get]

func (*WorkspaceController) GetWorkspaceInjectable 

func (c *WorkspaceController) GetWorkspaceInjectable(ctx *gin.Context)

GetWorkspaceInjectable retrieves an injectable by ID. @Summary Get workspace injectable @Tags Injectables @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param injectableId path string true "Injectable ID" @Success 200 {object} dto.WorkspaceInjectableResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/injectables/{injectableId} [get]

func (*WorkspaceController) InviteMember 

func (c *WorkspaceController) InviteMember(ctx *gin.Context)

InviteMember invites a user to the current workspace. @Summary Invite member @Tags Members @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param request body dto.InviteMemberRequest true "Member invitation data" @Success 201 {object} dto.MemberResponse @Failure 400 {object} dto.ErrorResponse @Failure 409 {object} dto.ErrorResponse @Router /api/v1/workspace/members [post]

func (*WorkspaceController) ListFolders 

func (c *WorkspaceController) ListFolders(ctx *gin.Context)

ListFolders lists all folders in the current workspace. @Summary List folders @Tags Folders @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Success 200 {object} dto.ListResponse[dto.FolderResponse] @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/folders [get]

func (*WorkspaceController) ListMembers 

func (c *WorkspaceController) ListMembers(ctx *gin.Context)

ListMembers lists all members of the current workspace. @Summary List workspace members @Tags Members @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Success 200 {object} dto.ListResponse[dto.MemberResponse] @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/members [get]

func (*WorkspaceController) ListTags 

func (c *WorkspaceController) ListTags(ctx *gin.Context)

ListTags lists all tags in the current workspace. @Summary List tags @Tags Tags @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Success 200 {object} dto.ListResponse[dto.TagWithCountResponse] @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/tags [get]

func (*WorkspaceController) ListWorkspaceInjectables 

func (c *WorkspaceController) ListWorkspaceInjectables(ctx *gin.Context)

ListWorkspaceInjectables lists all injectables owned by the current workspace. @Summary List workspace injectables @Tags Injectables @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Success 200 {object} dto.ListWorkspaceInjectablesResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/injectables [get]

func (*WorkspaceController) MoveFolder 

func (c *WorkspaceController) MoveFolder(ctx *gin.Context)

MoveFolder moves a folder to a new parent. @Summary Move folder @Tags Folders @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param folderId path string true "Folder ID" @Param request body dto.MoveFolderRequest true "Move data" @Success 200 {object} dto.FolderResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/folders/{folderId}/move [patch]

func (*WorkspaceController) RegisterRoutes 

func (c *WorkspaceController) RegisterRoutes(rg *gin.RouterGroup, middlewareProvider *middleware.Provider)

RegisterRoutes registers all workspace routes. Note: Workspace listing and creation are now handled by TenantController under /tenant/workspaces. This controller only handles operations within a specific workspace (requiring X-Workspace-ID).

func (*WorkspaceController) RemoveMember 

func (c *WorkspaceController) RemoveMember(ctx *gin.Context)

RemoveMember removes a member from the workspace. @Summary Remove member @Tags Members @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param memberId path string true "Member ID" @Success 204 "No Content" @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/members/{memberId} [delete]

func (*WorkspaceController) UpdateFolder 

func (c *WorkspaceController) UpdateFolder(ctx *gin.Context)

UpdateFolder updates a folder. @Summary Update folder @Tags Folders @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param X-Sandbox-Mode header string false "Enable sandbox mode (operates on sandbox workspace)" @Param folderId path string true "Folder ID" @Param request body dto.UpdateFolderRequest true "Folder data" @Success 200 {object} dto.FolderResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/folders/{folderId} [put]

func (*WorkspaceController) UpdateMemberRole 

func (c *WorkspaceController) UpdateMemberRole(ctx *gin.Context)

UpdateMemberRole updates a member's role. @Summary Update member role @Tags Members @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param memberId path string true "Member ID" @Param request body dto.UpdateMemberRoleRequest true "Role update data" @Success 200 {object} dto.MemberResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/members/{memberId} [put]

func (*WorkspaceController) UpdateTag 

func (c *WorkspaceController) UpdateTag(ctx *gin.Context)

UpdateTag updates a tag. @Summary Update tag @Tags Tags @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param tagId path string true "Tag ID" @Param request body dto.UpdateTagRequest true "Tag data" @Success 200 {object} dto.TagResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/tags/{tagId} [put]

func (*WorkspaceController) UpdateWorkspace 

func (c *WorkspaceController) UpdateWorkspace(ctx *gin.Context)

UpdateWorkspace updates the current workspace. @Summary Update current workspace @Tags Workspaces @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param request body dto.UpdateWorkspaceRequest true "Workspace data" @Success 200 {object} dto.WorkspaceResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace [put]

func (*WorkspaceController) UpdateWorkspaceInjectable 

func (c *WorkspaceController) UpdateWorkspaceInjectable(ctx *gin.Context)

UpdateWorkspaceInjectable updates an injectable. @Summary Update workspace injectable @Tags Injectables @Accept json @Produce json @Param X-Workspace-ID header string true "Workspace ID" @Param injectableId path string true "Injectable ID" @Param request body dto.UpdateWorkspaceInjectableRequest true "Injectable data" @Success 200 {object} dto.WorkspaceInjectableResponse @Failure 400 {object} dto.ErrorResponse @Failure 404 {object} dto.ErrorResponse @Router /api/v1/workspace/injectables/{injectableId} [put]

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.