mapleopentech/monorepo
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial commit: Open sourcing all of the Maple Open Technologies code.

Browse source
This commit is contained in:
Bartlomiej Mika 2025-12-02 14:33:08 -05:00
commit 755d54a99d
2010 changed files with 448675 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

91
cloud/maplefile-backend/internal/service/storageusageevent/create_event.go Normal file
View file

@ -0,0 +1,91 @@
// monorepo/cloud/maplefile-backend/internal/maplefile/service/storageusageevent/create_event.go
package storageusageevent
import (
"context"
"go.uber.org/zap"
"github.com/gocql/gocql"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config/constants"
uc_storageusageevent "codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/usecase/storageusageevent"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/pkg/httperror"
)
type CreateStorageUsageEventRequestDTO struct {
FileSize int64 `json:"file_size"`
Operation string `json:"operation"` // "add" or "remove"
}
type CreateStorageUsageEventResponseDTO struct {
Success bool `json:"success"`
Message string `json:"message"`
}
type CreateStorageUsageEventService interface {
Execute(ctx context.Context, req *CreateStorageUsageEventRequestDTO) (*CreateStorageUsageEventResponseDTO, error)
}
type createStorageUsageEventServiceImpl struct {
config *config.Configuration
logger *zap.Logger
createStorageUsageEventUseCase uc_storageusageevent.CreateStorageUsageEventUseCase
}
func NewCreateStorageUsageEventService(
config *config.Configuration,
logger *zap.Logger,
createStorageUsageEventUseCase uc_storageusageevent.CreateStorageUsageEventUseCase,
) CreateStorageUsageEventService {
logger = logger.Named("CreateStorageUsageEventService")
return &createStorageUsageEventServiceImpl{
config: config,
logger: logger,
createStorageUsageEventUseCase: createStorageUsageEventUseCase,
}
}
func (svc *createStorageUsageEventServiceImpl) Execute(ctx context.Context, req *CreateStorageUsageEventRequestDTO) (*CreateStorageUsageEventResponseDTO, error) {
//
// STEP 1: Validation
//
if req == nil {
svc.logger.Warn("Failed validation with nil request")
return nil, httperror.NewForBadRequestWithSingleField("non_field_error", "Event details are required")
}
//
// STEP 2: Get user ID from context
//
userID, ok := ctx.Value(constants.SessionUserID).(gocql.UUID)
if !ok {
svc.logger.Error("Failed getting user ID from context")
return nil, httperror.NewForInternalServerErrorWithSingleField("message", "Authentication context error")
}
//
// STEP 3: Execute use case
//
err := svc.createStorageUsageEventUseCase.Execute(ctx, userID, req.FileSize, req.Operation)
if err != nil {
svc.logger.Error("Failed to create storage usage event",
zap.String("user_id", userID.String()),
zap.Int64("file_size", req.FileSize),
zap.String("operation", req.Operation),
zap.Error(err))
return nil, err
}
response := &CreateStorageUsageEventResponseDTO{
Success: true,
Message: "Storage usage event created successfully",
}
svc.logger.Debug("Storage usage event created successfully",
zap.String("user_id", userID.String()),
zap.Int64("file_size", req.FileSize),
zap.String("operation", req.Operation))
return response, nil
}

138
cloud/maplefile-backend/internal/service/storageusageevent/get_events.go Normal file
View file

@ -0,0 +1,138 @@
// monorepo/cloud/maplefile-backend/internal/maplefile/service/storageusageevent/get_events.go
package storageusageevent
import (
"context"
"time"
"go.uber.org/zap"
"github.com/gocql/gocql"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config/constants"
uc_storageusageevent "codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/usecase/storageusageevent"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/pkg/httperror"
)
type GetStorageUsageEventsRequestDTO struct {
TrendPeriod string `json:"trend_period"` // "7days", "monthly", "yearly", "custom"
Year *int `json:"year,omitempty"`
Month *time.Month `json:"month,omitempty"`
Days *int `json:"days,omitempty"` // For custom day ranges
}
type StorageUsageEventResponseDTO struct {
UserID gocql.UUID `json:"user_id"`
EventDay time.Time `json:"event_day"`
EventTime time.Time `json:"event_time"`
FileSize int64 `json:"file_size"`
Operation string `json:"operation"`
}
type GetStorageUsageEventsResponseDTO struct {
UserID gocql.UUID `json:"user_id"`
TrendPeriod string `json:"trend_period"`
StartDate time.Time `json:"start_date"`
EndDate time.Time `json:"end_date"`
Events []*StorageUsageEventResponseDTO `json:"events"`
EventCount int `json:"event_count"`
Success bool `json:"success"`
Message string `json:"message"`
}
type GetStorageUsageEventsService interface {
Execute(ctx context.Context, req *GetStorageUsageEventsRequestDTO) (*GetStorageUsageEventsResponseDTO, error)
}
type getStorageUsageEventsServiceImpl struct {
config *config.Configuration
logger *zap.Logger
getStorageUsageEventsUseCase uc_storageusageevent.GetStorageUsageEventsUseCase
}
func NewGetStorageUsageEventsService(
config *config.Configuration,
logger *zap.Logger,
getStorageUsageEventsUseCase uc_storageusageevent.GetStorageUsageEventsUseCase,
) GetStorageUsageEventsService {
logger = logger.Named("GetStorageUsageEventsService")
return &getStorageUsageEventsServiceImpl{
config: config,
logger: logger,
getStorageUsageEventsUseCase: getStorageUsageEventsUseCase,
}
}
func (svc *getStorageUsageEventsServiceImpl) Execute(ctx context.Context, req *GetStorageUsageEventsRequestDTO) (*GetStorageUsageEventsResponseDTO, error) {
//
// STEP 1: Validation
//
if req == nil {
svc.logger.Warn("Failed validation with nil request")
return nil, httperror.NewForBadRequestWithSingleField("non_field_error", "Request details are required")
}
//
// STEP 2: Get user ID from context
//
userID, ok := ctx.Value(constants.SessionUserID).(gocql.UUID)
if !ok {
svc.logger.Error("Failed getting user ID from context")
return nil, httperror.NewForInternalServerErrorWithSingleField("message", "Authentication context error")
}
//
// STEP 3: Build use case request
//
useCaseReq := &uc_storageusageevent.GetStorageUsageEventsRequest{
UserID: userID,
TrendPeriod: req.TrendPeriod,
Year: req.Year,
Month: req.Month,
Days: req.Days,
}
//
// STEP 4: Execute use case
//
useCaseResp, err := svc.getStorageUsageEventsUseCase.Execute(ctx, useCaseReq)
if err != nil {
svc.logger.Error("Failed to get storage usage events",
zap.String("user_id", userID.String()),
zap.String("trend_period", req.TrendPeriod),
zap.Error(err))
return nil, err
}
//
// STEP 5: Map domain models to response DTOs
//
events := make([]*StorageUsageEventResponseDTO, len(useCaseResp.Events))
for i, event := range useCaseResp.Events {
events[i] = &StorageUsageEventResponseDTO{
UserID: event.UserID,
EventDay: event.EventDay,
EventTime: event.EventTime,
FileSize: event.FileSize,
Operation: event.Operation,
}
}
response := &GetStorageUsageEventsResponseDTO{
UserID: useCaseResp.UserID,
TrendPeriod: useCaseResp.TrendPeriod,
StartDate: useCaseResp.StartDate,
EndDate: useCaseResp.EndDate,
Events: events,
EventCount: useCaseResp.EventCount,
Success: true,
Message: "Storage usage events retrieved successfully",
}
svc.logger.Debug("Storage usage events retrieved successfully",
zap.String("user_id", userID.String()),
zap.String("trend_period", req.TrendPeriod),
zap.Int("event_count", len(events)))
return response, nil
}

159
cloud/maplefile-backend/internal/service/storageusageevent/get_trend_analysis.go Normal file
View file

@ -0,0 +1,159 @@
// monorepo/cloud/maplefile-backend/internal/maplefile/service/storageusageevent/get_trend_analysis.go
package storageusageevent
import (
"context"
"time"
"go.uber.org/zap"
"github.com/gocql/gocql"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config/constants"
uc_storageusageevent "codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/usecase/storageusageevent"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/pkg/httperror"
)
type GetStorageUsageEventsTrendAnalysisRequestDTO struct {
TrendPeriod string `json:"trend_period"` // "7days", "monthly", "yearly", "custom"
Year *int `json:"year,omitempty"`
Month *time.Month `json:"month,omitempty"`
Days *int `json:"days,omitempty"` // For custom day ranges
}
type DailyStatsResponseDTO struct {
Date time.Time `json:"date"`
AddEvents int `json:"add_events"`
RemoveEvents int `json:"remove_events"`
BytesAdded int64 `json:"bytes_added"`
BytesRemoved int64 `json:"bytes_removed"`
NetChange int64 `json:"net_change"`
}
type GetStorageUsageEventsTrendAnalysisResponseDTO struct {
UserID gocql.UUID `json:"user_id"`
TrendPeriod string `json:"trend_period"`
StartDate time.Time `json:"start_date"`
EndDate time.Time `json:"end_date"`
TotalEvents int `json:"total_events"`
AddEvents int `json:"add_events"`
RemoveEvents int `json:"remove_events"`
TotalBytesAdded int64 `json:"total_bytes_added"`
TotalBytesRemoved int64 `json:"total_bytes_removed"`
NetBytesChange int64 `json:"net_bytes_change"`
AverageBytesPerAdd float64 `json:"average_bytes_per_add"`
AverageBytesPerRemove float64 `json:"average_bytes_per_remove"`
LargestAddEvent int64 `json:"largest_add_event"`
LargestRemoveEvent int64 `json:"largest_remove_event"`
DailyBreakdown []*DailyStatsResponseDTO `json:"daily_breakdown,omitempty"`
Success bool `json:"success"`
Message string `json:"message"`
}
type GetStorageUsageEventsTrendAnalysisService interface {
Execute(ctx context.Context, req *GetStorageUsageEventsTrendAnalysisRequestDTO) (*GetStorageUsageEventsTrendAnalysisResponseDTO, error)
}
type getStorageUsageEventsTrendAnalysisServiceImpl struct {
config *config.Configuration
logger *zap.Logger
getStorageUsageEventsTrendAnalysisUseCase uc_storageusageevent.GetStorageUsageEventsTrendAnalysisUseCase
}
func NewGetStorageUsageEventsTrendAnalysisService(
config *config.Configuration,
logger *zap.Logger,
getStorageUsageEventsTrendAnalysisUseCase uc_storageusageevent.GetStorageUsageEventsTrendAnalysisUseCase,
) GetStorageUsageEventsTrendAnalysisService {
logger = logger.Named("GetStorageUsageEventsTrendAnalysisService")
return &getStorageUsageEventsTrendAnalysisServiceImpl{
config: config,
logger: logger,
getStorageUsageEventsTrendAnalysisUseCase: getStorageUsageEventsTrendAnalysisUseCase,
}
}
func (svc *getStorageUsageEventsTrendAnalysisServiceImpl) Execute(ctx context.Context, req *GetStorageUsageEventsTrendAnalysisRequestDTO) (*GetStorageUsageEventsTrendAnalysisResponseDTO, error) {
//
// STEP 1: Validation
//
if req == nil {
svc.logger.Warn("Failed validation with nil request")
return nil, httperror.NewForBadRequestWithSingleField("non_field_error", "Request details are required")
}
//
// STEP 2: Get user ID from context
//
userID, ok := ctx.Value(constants.SessionUserID).(gocql.UUID)
if !ok {
svc.logger.Error("Failed getting user ID from context")
return nil, httperror.NewForInternalServerErrorWithSingleField("message", "Authentication context error")
}
//
// STEP 3: Build use case request
//
useCaseReq := &uc_storageusageevent.GetStorageUsageEventsRequest{
UserID: userID,
TrendPeriod: req.TrendPeriod,
Year: req.Year,
Month: req.Month,
Days: req.Days,
}
//
// STEP 4: Execute use case
//
analysis, err := svc.getStorageUsageEventsTrendAnalysisUseCase.Execute(ctx, useCaseReq)
if err != nil {
svc.logger.Error("Failed to get storage usage events trend analysis",
zap.String("user_id", userID.String()),
zap.String("trend_period", req.TrendPeriod),
zap.Error(err))
return nil, err
}
//
// STEP 5: Map domain models to response DTOs
//
dailyBreakdown := make([]*DailyStatsResponseDTO, len(analysis.DailyBreakdown))
for i, daily := range analysis.DailyBreakdown {
dailyBreakdown[i] = &DailyStatsResponseDTO{
Date: daily.Date,
AddEvents: daily.AddEvents,
RemoveEvents: daily.RemoveEvents,
BytesAdded: daily.BytesAdded,
BytesRemoved: daily.BytesRemoved,
NetChange: daily.NetChange,
}
}
response := &GetStorageUsageEventsTrendAnalysisResponseDTO{
UserID: analysis.UserID,
TrendPeriod: analysis.TrendPeriod,
StartDate: analysis.StartDate,
EndDate: analysis.EndDate,
TotalEvents: analysis.TotalEvents,
AddEvents: analysis.AddEvents,
RemoveEvents: analysis.RemoveEvents,
TotalBytesAdded: analysis.TotalBytesAdded,
TotalBytesRemoved: analysis.TotalBytesRemoved,
NetBytesChange: analysis.NetBytesChange,
AverageBytesPerAdd: analysis.AverageBytesPerAdd,
AverageBytesPerRemove: analysis.AverageBytesPerRemove,
LargestAddEvent: analysis.LargestAddEvent,
LargestRemoveEvent: analysis.LargestRemoveEvent,
DailyBreakdown: dailyBreakdown,
Success: true,
Message: "Storage usage events trend analysis completed successfully",
}
svc.logger.Debug("Storage usage events trend analysis completed successfully",
zap.String("user_id", userID.String()),
zap.String("trend_period", req.TrendPeriod),
zap.Int("total_events", analysis.TotalEvents),
zap.Int64("net_bytes_change", analysis.NetBytesChange))
return response, nil
}