kra-new/app/system/internal/service/audit.go

package service

import (
	"context"

	"kra/app/system/internal/biz"
)

type AuditService struct{ uc *biz.AuditUsecase }

func NewAuditService(uc *biz.AuditUsecase) *AuditService { return &AuditService{uc: uc} }

type AuditRecorder struct{ uc *biz.AuditRecorderUsecase }

func NewAuditRecorder(uc *biz.AuditRecorderUsecase) *AuditRecorder { return &AuditRecorder{uc: uc} }

func (s *AuditRecorder) RecordOperation(ctx context.Context, v *biz.OperationRecord) error {
	return s.uc.RecordOperation(ctx, v)
}
func (s *AuditRecorder) RecordOperationRequest(ctx context.Context, value *OperationRecordRequest) error {
	return s.RecordOperation(ctx, &biz.OperationRecord{IP: value.IP, Method: value.Method, Path: value.Path, Status: value.Status, LatencyMS: value.LatencyMS, Agent: value.Agent, ErrorMessage: value.ErrorMessage, Body: value.Body, Response: value.Response, UserID: value.UserID, RequestID: value.RequestID, TraceID: value.TraceID, DeviceID: value.DeviceID})
}
func (s *AuditService) OperationsFilter(ctx context.Context, page, size int, path, method string, status int) ([]*OperationRecordResponse, int64, error) {
	return s.Operations(ctx, page, size, &biz.OperationRecord{Path: path, Method: method, Status: status})
}
func opDTO(v *biz.OperationRecord) *OperationRecordResponse {
	var user any = map[string]any{}
	if v.User != nil {
		user = convertUser(v.User)
	}
	return &OperationRecordResponse{ID: v.ID, CreatedAt: v.CreatedAt, UpdatedAt: v.UpdatedAt, DeletedAt: nil, IP: v.IP, Method: v.Method, Path: v.Path, Status: v.Status, LatencyMS: v.LatencyMS, Agent: v.Agent, ErrorMessage: v.ErrorMessage, Body: v.Body, Response: v.Response, UserID: v.UserID, RequestID: v.RequestID, TraceID: v.TraceID, DeviceID: v.DeviceID, User: user}
}
func (s *AuditService) Operations(ctx context.Context, page, size int, q *biz.OperationRecord) ([]*OperationRecordResponse, int64, error) {
	items, total, err := s.uc.ListOperations(ctx, page, size, q)
	if err != nil {
		return nil, 0, err
	}
	out := make([]*OperationRecordResponse, 0, len(items))
	for _, v := range items {
		out = append(out, opDTO(v))
	}
	return out, total, nil
}
func (s *AuditService) Operation(ctx context.Context, id uint) (*OperationRecordResponse, error) {
	v, err := s.uc.FindOperation(ctx, id)
	if err != nil {
		return nil, err
	}
	return opDTO(v), nil
}
func (s *AuditService) DeleteOperations(ctx context.Context, ids []int) error {
	return s.uc.DeleteOperations(ctx, ids)
}

func (s *AuditRecorder) RecordLogin(ctx context.Context, v *biz.LoginLog) error {
	return s.uc.RecordLogin(ctx, v)
}
func (s *AuditRecorder) RecordLoginRequest(ctx context.Context, value *LoginLogRequest) error {
	return s.RecordLogin(ctx, &biz.LoginLog{Username: value.Username, IP: value.IP, Status: value.Status, ErrorMessage: value.ErrorMessage, Agent: value.Agent, UserID: value.UserID})
}
func (s *AuditService) LoginsFilter(ctx context.Context, page, size int, username string, status bool) ([]*LoginLogResponse, int64, error) {
	return s.Logins(ctx, page, size, &biz.LoginLog{Username: username, Status: status, FilterByStatus: status})
}
func loginDTO(v *biz.LoginLog) *LoginLogResponse {
	var user any = map[string]any{}
	if v.User != nil {
		user = convertUser(v.User)
	}
	return &LoginLogResponse{ID: v.ID, CreatedAt: v.CreatedAt, UpdatedAt: v.UpdatedAt, DeletedAt: nil, Username: v.Username, IP: v.IP, Status: v.Status, ErrorMessage: v.ErrorMessage, Agent: v.Agent, UserID: v.UserID, User: user}
}
func (s *AuditService) Logins(ctx context.Context, page, size int, q *biz.LoginLog) ([]*LoginLogResponse, int64, error) {
	items, total, err := s.uc.ListLogins(ctx, page, size, q)
	if err != nil {
		return nil, 0, err
	}
	out := make([]*LoginLogResponse, 0, len(items))
	for _, v := range items {
		out = append(out, loginDTO(v))
	}
	return out, total, nil
}
func (s *AuditService) Login(ctx context.Context, id uint) (*LoginLogResponse, error) {
	v, err := s.uc.FindLogin(ctx, id)
	if err != nil {
		return nil, err
	}
	return loginDTO(v), nil
}
func (s *AuditService) DeleteLogins(ctx context.Context, ids []int) error {
	return s.uc.DeleteLogins(ctx, ids)
}

func (s *AuditRecorder) RecordDataAccess(ctx context.Context, v *biz.DataAccessLog) error {
	return s.uc.RecordDataAccess(ctx, v)
}
func (s *AuditRecorder) RecordDataAccessRequest(ctx context.Context, value *DataAccessRecordRequest) error {
	return s.RecordDataAccess(ctx, &biz.DataAccessLog{EventType: value.EventType, Operation: value.Operation, UserID: value.UserID, AuthorityID: value.AuthorityID, RequestID: value.RequestID, Method: value.Method, Path: value.Path, Detail: value.Detail})
}
func (s *AuditService) DataAccessRequest(ctx context.Context, req *DataAccessListRequest) ([]*DataAccessLogResponse, int64, error) {
	return s.DataAccess(ctx, req.Page, req.PageSize, &biz.DataAccessLog{EventType: req.EventType, TargetTable: req.TargetTable})
}
func dataAccessDTO(v *biz.DataAccessLog) *DataAccessLogResponse {
	return &DataAccessLogResponse{ID: v.ID, CreatedAt: v.CreatedAt, UpdatedAt: v.UpdatedAt, DeletedAt: nil, EventType: v.EventType, TargetTable: v.TargetTable, Operation: v.Operation, UserID: v.UserID, AuthorityID: v.AuthorityID, Scope: v.Scope, RequestID: v.RequestID, Method: v.Method, Path: v.Path, Detail: v.Detail}
}
func (s *AuditService) DataAccess(ctx context.Context, page, size int, q *biz.DataAccessLog) ([]*DataAccessLogResponse, int64, error) {
	items, total, err := s.uc.ListDataAccess(ctx, page, size, q)
	if err != nil {
		return nil, 0, err
	}
	out := make([]*DataAccessLogResponse, 0, len(items))
	for _, v := range items {
		out = append(out, dataAccessDTO(v))
	}
	return out, total, nil
}
func (s *AuditService) DeleteDataAccess(ctx context.Context, ids []uint) error {
	return s.uc.DeleteDataAccess(ctx, ids)
}