425 lines
14 KiB
Go
425 lines
14 KiB
Go
package controller
|
|
|
|
import (
|
|
"narasi-ahli-be/app/module/chat_history/request"
|
|
"narasi-ahli-be/app/module/chat_history/service"
|
|
"narasi-ahli-be/utils/paginator"
|
|
utilRes "narasi-ahli-be/utils/response"
|
|
utilVal "narasi-ahli-be/utils/validator"
|
|
"strconv"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
"github.com/rs/zerolog"
|
|
)
|
|
|
|
type chatHistoryController struct {
|
|
chatHistoryService service.ChatHistoryService
|
|
Log zerolog.Logger
|
|
}
|
|
|
|
type ChatHistoryController interface {
|
|
// Chat History Sessions
|
|
GetUserSessions(c *fiber.Ctx) error
|
|
GetSession(c *fiber.Ctx) error
|
|
CreateSession(c *fiber.Ctx) error
|
|
UpdateSession(c *fiber.Ctx) error
|
|
DeleteSession(c *fiber.Ctx) error
|
|
|
|
// Chat History Messages
|
|
GetSessionMessages(c *fiber.Ctx) error
|
|
CreateMessage(c *fiber.Ctx) error
|
|
UpdateMessage(c *fiber.Ctx) error
|
|
DeleteMessage(c *fiber.Ctx) error
|
|
|
|
// Combined operations
|
|
SaveChatHistory(c *fiber.Ctx) error
|
|
}
|
|
|
|
func NewChatHistoryController(chatHistoryService service.ChatHistoryService, log zerolog.Logger) ChatHistoryController {
|
|
return &chatHistoryController{
|
|
chatHistoryService: chatHistoryService,
|
|
Log: log,
|
|
}
|
|
}
|
|
|
|
// Get User Sessions
|
|
// @Summary Get user chat history sessions
|
|
// @Description API for getting all chat history sessions for authenticated user
|
|
// @Tags Chat History
|
|
// @Security Bearer
|
|
// @Param X-Client-Key header string false "Insert the X-Client-Key"
|
|
// @Param req query request.ChatHistorySessionsQueryRequest false "query parameters"
|
|
// @Param req query paginator.Pagination false "pagination parameters"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 400 {object} response.BadRequestError
|
|
// @Failure 401 {object} response.UnauthorizedError
|
|
// @Failure 500 {object} response.InternalServerError
|
|
// @Router /chat-history/sessions [get]
|
|
func (_i *chatHistoryController) GetUserSessions(c *fiber.Ctx) error {
|
|
paginate, err := paginator.Paginate(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
authHeader := c.Get("Authorization")
|
|
|
|
reqContext := request.ChatHistorySessionsQueryRequestContext{
|
|
AgentID: c.Query("agent_id"),
|
|
SessionID: c.Query("session_id"),
|
|
}
|
|
req := reqContext.ToParamRequest()
|
|
req.Pagination = paginate
|
|
|
|
sessionsData, paging, err := _i.chatHistoryService.GetUserSessions(authHeader, req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: true,
|
|
Messages: utilRes.Messages{"Chat history sessions successfully retrieved"},
|
|
Data: sessionsData,
|
|
Meta: paging,
|
|
})
|
|
}
|
|
|
|
// Get Session
|
|
// @Summary Get one chat history session with messages
|
|
// @Description API for getting one chat history session with all its messages
|
|
// @Tags Chat History
|
|
// @Security Bearer
|
|
// @Param X-Client-Key header string false "Insert the X-Client-Key"
|
|
// @Param sessionId path string true "Session ID"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 400 {object} response.BadRequestError
|
|
// @Failure 401 {object} response.UnauthorizedError
|
|
// @Failure 500 {object} response.InternalServerError
|
|
// @Router /chat-history/sessions/{sessionId} [get]
|
|
func (_i *chatHistoryController) GetSession(c *fiber.Ctx) error {
|
|
sessionID := c.Params("sessionId")
|
|
if sessionID == "" {
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: false,
|
|
Messages: utilRes.Messages{"Session ID is required"},
|
|
})
|
|
}
|
|
|
|
authHeader := c.Get("Authorization")
|
|
|
|
sessionData, err := _i.chatHistoryService.GetSession(authHeader, sessionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: true,
|
|
Messages: utilRes.Messages{"Chat history session successfully retrieved"},
|
|
Data: sessionData,
|
|
})
|
|
}
|
|
|
|
// Create Session
|
|
// @Summary Create chat history session
|
|
// @Description API for create chat history session
|
|
// @Tags Chat History
|
|
// @Security Bearer
|
|
// @Param X-Client-Key header string false "Insert the X-Client-Key"
|
|
// @Param X-Csrf-Token header string true "Insert the X-Csrf-Token"
|
|
// @Param Authorization header string false "Insert your access token" default(Bearer <Add access token here>)
|
|
// @Param payload body request.ChatHistorySessionsCreateRequest true "Required payload"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 400 {object} response.BadRequestError
|
|
// @Failure 401 {object} response.UnauthorizedError
|
|
// @Failure 500 {object} response.InternalServerError
|
|
// @Router /chat-history/sessions [post]
|
|
func (_i *chatHistoryController) CreateSession(c *fiber.Ctx) error {
|
|
req := new(request.ChatHistorySessionsCreateRequest)
|
|
if err := utilVal.ParseAndValidate(c, req); err != nil {
|
|
return err
|
|
}
|
|
|
|
authHeader := c.Get("Authorization")
|
|
|
|
dataResult, err := _i.chatHistoryService.CreateSession(authHeader, *req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: true,
|
|
Messages: utilRes.Messages{"Chat history session successfully created"},
|
|
Data: dataResult,
|
|
})
|
|
}
|
|
|
|
// Update Session
|
|
// @Summary Update chat history session
|
|
// @Description API for update chat history session
|
|
// @Tags Chat History
|
|
// @Security Bearer
|
|
// @Param X-Client-Key header string false "Insert the X-Client-Key"
|
|
// @Param X-Csrf-Token header string true "Insert the X-Csrf-Token"
|
|
// @Param sessionId path string true "Session ID"
|
|
// @Param payload body request.ChatHistorySessionsUpdateRequest true "Required payload"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 400 {object} response.BadRequestError
|
|
// @Failure 401 {object} response.UnauthorizedError
|
|
// @Failure 500 {object} response.InternalServerError
|
|
// @Router /chat-history/sessions/{sessionId} [put]
|
|
func (_i *chatHistoryController) UpdateSession(c *fiber.Ctx) error {
|
|
sessionID := c.Params("sessionId")
|
|
if sessionID == "" {
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: false,
|
|
Messages: utilRes.Messages{"Session ID is required"},
|
|
})
|
|
}
|
|
|
|
req := new(request.ChatHistorySessionsUpdateRequest)
|
|
if err := utilVal.ParseAndValidate(c, req); err != nil {
|
|
return err
|
|
}
|
|
|
|
authHeader := c.Get("Authorization")
|
|
|
|
err := _i.chatHistoryService.UpdateSession(authHeader, sessionID, *req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: true,
|
|
Messages: utilRes.Messages{"Chat history session successfully updated"},
|
|
})
|
|
}
|
|
|
|
// Delete Session
|
|
// @Summary Delete chat history session
|
|
// @Description API for delete chat history session
|
|
// @Tags Chat History
|
|
// @Security Bearer
|
|
// @Param X-Client-Key header string false "Insert the X-Client-Key"
|
|
// @Param X-Csrf-Token header string true "Insert the X-Csrf-Token"
|
|
// @Param sessionId path string true "Session ID"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 400 {object} response.BadRequestError
|
|
// @Failure 401 {object} response.UnauthorizedError
|
|
// @Failure 500 {object} response.InternalServerError
|
|
// @Router /chat-history/sessions/{sessionId} [delete]
|
|
func (_i *chatHistoryController) DeleteSession(c *fiber.Ctx) error {
|
|
sessionID := c.Params("sessionId")
|
|
if sessionID == "" {
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: false,
|
|
Messages: utilRes.Messages{"Session ID is required"},
|
|
})
|
|
}
|
|
|
|
authHeader := c.Get("Authorization")
|
|
|
|
err := _i.chatHistoryService.DeleteSession(authHeader, sessionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: true,
|
|
Messages: utilRes.Messages{"Chat history session successfully deleted"},
|
|
})
|
|
}
|
|
|
|
// Get Session Messages
|
|
// @Summary Get chat history session messages
|
|
// @Description API for getting all messages in a chat history session
|
|
// @Tags Chat History
|
|
// @Security Bearer
|
|
// @Param X-Client-Key header string false "Insert the X-Client-Key"
|
|
// @Param sessionId path string true "Session ID"
|
|
// @Param req query request.ChatHistoryMessagesQueryRequest false "query parameters"
|
|
// @Param req query paginator.Pagination false "pagination parameters"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 400 {object} response.BadRequestError
|
|
// @Failure 401 {object} response.UnauthorizedError
|
|
// @Failure 500 {object} response.InternalServerError
|
|
// @Router /chat-history/sessions/{sessionId}/messages [get]
|
|
func (_i *chatHistoryController) GetSessionMessages(c *fiber.Ctx) error {
|
|
sessionID := c.Params("sessionId")
|
|
if sessionID == "" {
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: false,
|
|
Messages: utilRes.Messages{"Session ID is required"},
|
|
})
|
|
}
|
|
|
|
paginate, err := paginator.Paginate(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
authHeader := c.Get("Authorization")
|
|
|
|
req := request.ChatHistoryMessagesQueryRequest{
|
|
SessionID: sessionID,
|
|
Pagination: paginate,
|
|
}
|
|
|
|
messagesData, paging, err := _i.chatHistoryService.GetSessionMessages(authHeader, sessionID, req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: true,
|
|
Messages: utilRes.Messages{"Chat history messages successfully retrieved"},
|
|
Data: messagesData,
|
|
Meta: paging,
|
|
})
|
|
}
|
|
|
|
// Create Message
|
|
// @Summary Create chat history message
|
|
// @Description API for creating a message in a chat history session
|
|
// @Tags Chat History
|
|
// @Security Bearer
|
|
// @Param X-Client-Key header string false "Insert the X-Client-Key"
|
|
// @Param X-Csrf-Token header string true "Insert the X-Csrf-Token"
|
|
// @Param sessionId path string true "Session ID"
|
|
// @Param payload body request.ChatHistoryMessagesCreateRequest true "Required payload"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 400 {object} response.BadRequestError
|
|
// @Failure 401 {object} response.UnauthorizedError
|
|
// @Failure 500 {object} response.InternalServerError
|
|
// @Router /chat-history/sessions/{sessionId}/messages [post]
|
|
func (_i *chatHistoryController) CreateMessage(c *fiber.Ctx) error {
|
|
sessionID := c.Params("sessionId")
|
|
if sessionID == "" {
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: false,
|
|
Messages: utilRes.Messages{"Session ID is required"},
|
|
})
|
|
}
|
|
|
|
req := new(request.ChatHistoryMessagesCreateRequest)
|
|
if err := utilVal.ParseAndValidate(c, req); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Set session ID from URL parameter
|
|
req.SessionID = sessionID
|
|
|
|
authHeader := c.Get("Authorization")
|
|
|
|
dataResult, err := _i.chatHistoryService.CreateMessage(authHeader, *req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: true,
|
|
Messages: utilRes.Messages{"Chat history message successfully created"},
|
|
Data: dataResult,
|
|
})
|
|
}
|
|
|
|
// Update Message
|
|
// @Summary Update chat history message
|
|
// @Description API for update chat history message
|
|
// @Tags Chat History
|
|
// @Security Bearer
|
|
// @Param X-Client-Key header string false "Insert the X-Client-Key"
|
|
// @Param X-Csrf-Token header string true "Insert the X-Csrf-Token"
|
|
// @Param messageId path int true "Message ID"
|
|
// @Param payload body request.ChatHistoryMessagesUpdateRequest true "Required payload"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 400 {object} response.BadRequestError
|
|
// @Failure 401 {object} response.UnauthorizedError
|
|
// @Failure 500 {object} response.InternalServerError
|
|
// @Router /chat-history/messages/{messageId} [put]
|
|
func (_i *chatHistoryController) UpdateMessage(c *fiber.Ctx) error {
|
|
messageId, err := strconv.ParseUint(c.Params("messageId"), 10, 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
req := new(request.ChatHistoryMessagesUpdateRequest)
|
|
if err := utilVal.ParseAndValidate(c, req); err != nil {
|
|
return err
|
|
}
|
|
|
|
authHeader := c.Get("Authorization")
|
|
|
|
if err := _i.chatHistoryService.UpdateMessage(authHeader, uint(messageId), *req); err != nil {
|
|
return err
|
|
}
|
|
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: true,
|
|
Messages: utilRes.Messages{"Chat history message successfully updated"},
|
|
})
|
|
}
|
|
|
|
// Delete Message
|
|
// @Summary Delete chat history message
|
|
// @Description API for delete chat history message
|
|
// @Tags Chat History
|
|
// @Security Bearer
|
|
// @Param X-Client-Key header string false "Insert the X-Client-Key"
|
|
// @Param X-Csrf-Token header string true "Insert the X-Csrf-Token"
|
|
// @Param messageId path int true "Message ID"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 400 {object} response.BadRequestError
|
|
// @Failure 401 {object} response.UnauthorizedError
|
|
// @Failure 500 {object} response.InternalServerError
|
|
// @Router /chat-history/messages/{messageId} [delete]
|
|
func (_i *chatHistoryController) DeleteMessage(c *fiber.Ctx) error {
|
|
messageId, err := strconv.ParseUint(c.Params("messageId"), 10, 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
authHeader := c.Get("Authorization")
|
|
|
|
if err := _i.chatHistoryService.DeleteMessage(authHeader, uint(messageId)); err != nil {
|
|
return err
|
|
}
|
|
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: true,
|
|
Messages: utilRes.Messages{"Chat history message successfully deleted"},
|
|
})
|
|
}
|
|
|
|
// Save Chat History
|
|
// @Summary Save chat history (sessions and messages)
|
|
// @Description API for saving complete chat history including sessions and messages
|
|
// @Tags Chat History
|
|
// @Security Bearer
|
|
// @Param X-Client-Key header string false "Insert the X-Client-Key"
|
|
// @Param X-Csrf-Token header string true "Insert the X-Csrf-Token"
|
|
// @Param Authorization header string false "Insert your access token" default(Bearer <Add access token here>)
|
|
// @Param payload body request.ChatHistorySessionsCreateRequest true "Required payload"
|
|
// @Success 200 {object} response.Response
|
|
// @Failure 400 {object} response.BadRequestError
|
|
// @Failure 401 {object} response.UnauthorizedError
|
|
// @Failure 500 {object} response.InternalServerError
|
|
// @Router /chat-history/save [post]
|
|
func (_i *chatHistoryController) SaveChatHistory(c *fiber.Ctx) error {
|
|
req := new(request.ChatHistorySessionsCreateRequest)
|
|
if err := utilVal.ParseAndValidate(c, req); err != nil {
|
|
return err
|
|
}
|
|
|
|
authHeader := c.Get("Authorization")
|
|
|
|
dataResult, err := _i.chatHistoryService.SaveChatHistory(authHeader, *req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return utilRes.Resp(c, utilRes.Response{
|
|
Success: true,
|
|
Messages: utilRes.Messages{"Chat history saved successfully"},
|
|
Data: dataResult,
|
|
})
|
|
}
|