Add solution for Challenge 12 by longbui98 (RezaSi#297)

Author: longbui98

challenge-12/submissions/longbui98/solution-template.go

@@ -0,0 +1,297 @@
+// Package challenge12 contains the solution for Challenge 12.
+package challenge12
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	// Add any necessary imports here
+)
+
+// Reader defines an interface for data sources
+type Reader interface {
+	Read(ctx context.Context) ([]byte, error)
+}
+
+// Validator defines an interface for data validation
+type Validator interface {
+	Validate(data []byte) error
+}
+
+// Transformer defines an interface for data transformation
+type Transformer interface {
+	Transform(data []byte) ([]byte, error)
+}
+
+// Writer defines an interface for data destinations
+type Writer interface {
+	Write(ctx context.Context, data []byte) error
+}
+
+// ValidationError represents an error during data validation
+type ValidationError struct {
+	Field   string
+	Message string
+	Err     error
+}
+
+// Error returns a string representation of the ValidationError
+func (e *ValidationError) Error() string {
+	// TODO: Implement error message formatting
+	return fmt.Sprintf("%s: %s error : %s", e.Field, e.Message, e.Err.Error())
+}
+
+// Unwrap returns the underlying error
+func (e *ValidationError) Unwrap() error {
+	// TODO: Implement error unwrapping
+	return e.Err
+}
+
+// TransformError represents an error during data transformation
+type TransformError struct {
+	Stage string
+	Err   error
+}
+
+// Error returns a string representation of the TransformError
+func (e *TransformError) Error() string {
+	// TODO: Implement error message formatting
+	return fmt.Sprintf("%s: error %s", e.Stage, e.Err.Error())
+}
+
+// Unwrap returns the underlying error
+func (e *TransformError) Unwrap() error {
+	return e.Err
+}
+
+// PipelineError represents an error in the processing pipeline
+type PipelineError struct {
+	Stage string
+	Err   error
+}
+
+// Error returns a string representation of the PipelineError
+func (e *PipelineError) Error() string {
+	// TODO: Implement error message formatting
+	return fmt.Sprintf("%s: error %s", e.Stage, e.Err.Error())
+}
+
+// Unwrap returns the underlying error
+func (e *PipelineError) Unwrap() error {
+	// TODO: Implement error unwrapping
+	return e.Err
+}
+
+// Sentinel errors for common error conditions
+var (
+	ErrInvalidFormat    = errors.New("invalid data format")
+	ErrMissingField     = errors.New("required field missing")
+	ErrProcessingFailed = errors.New("processing failed")
+	ErrDestinationFull  = errors.New("destination is full")
+)
+
+// Pipeline orchestrates the data processing flow
+type Pipeline struct {
+	Reader       Reader
+	Validators   []Validator
+	Transformers []Transformer
+	Writer       Writer
+}
+
+// NewPipeline creates a new processing pipeline with specified components
+func NewPipeline(r Reader, v []Validator, t []Transformer, w Writer) *Pipeline {
+	// TODO: Implement pipeline initialization
+	if r == nil {
+		return nil
+	}
+	if w == nil {
+		return nil
+	}
+	return &Pipeline{
+		Reader:       r,
+		Validators:   v,
+		Transformers: t,
+		Writer:       w,
+	}
+}
+
+// Process runs the complete pipeline
+func (p *Pipeline) Process(ctx context.Context) error {
+	// TODO: Implement the complete pipeline process
+	data, err := p.Reader.Read(ctx)
+	if err != nil {
+		return err
+	}
+	for _, validator := range p.Validators {
+		if err = validator.Validate(data); err != nil {
+			return err
+		}
+	}
+	for _, transformer := range p.Transformers {
+		if data, err = transformer.Transform(data); err != nil {
+			return err
+		}
+		if data == nil {
+			return errors.New("error while transform")
+		}
+	}
+
+	if err = p.Writer.Write(ctx, nil); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// handleErrors consolidates errors from concurrent operations
+func (p *Pipeline) handleErrors(ctx context.Context, errs <-chan error) error {
+	// TODO: Implement concurrent error handling
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case err, ok := <-errs:
+			if !ok {
+				return nil
+			}
+			if err != nil {
+				return err
+			}
+		}
+	}
+}
+
+// FileReader implements the Reader interface for file sources
+type FileReader struct {
+	Filename string
+}
+
+// NewFileReader creates a new file reader
+func NewFileReader(filename string) *FileReader {
+	// TODO: Implement file reader initialization
+	return &FileReader{filename}
+}
+
+// Read reads data from a file
+func (fr *FileReader) Read(ctx context.Context) ([]byte, error) {
+	// TODO: Implement file reading with context support
+	resultChan := make(chan []byte)
+	errChan := make(chan error)
+
+	go func() {
+		data, err := os.ReadFile(fr.Filename)
+		if err != nil {
+			errChan <- err
+			return
+		}
+		resultChan <- data
+	}()
+
+	select {
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	case err := <-errChan:
+		return nil, err
+	case data := <-resultChan:
+		return data, nil
+	}
+}
+
+// JSONValidator implements the Validator interface for JSON validation
+type JSONValidator struct{}
+
+// NewJSONValidator creates a new JSON validator
+func NewJSONValidator() *JSONValidator {
+	// TODO: Implement JSON validator initialization
+	return &JSONValidator{}
+}
+
+// Validate validates JSON data
+func (jv *JSONValidator) Validate(data []byte) error {
+	// TODO: Implement JSON validation
+	if !json.Valid(data) {
+		return ErrInvalidFormat
+	}
+	return nil
+}
+
+// SchemaValidator implements the Validator interface for schema validation
+type SchemaValidator struct {
+	Schema []byte
+}
+
+// NewSchemaValidator creates a new schema validator
+func NewSchemaValidator(schema []byte) *SchemaValidator {
+	// TODO: Implement schema validator initialization
+	return &SchemaValidator{Schema: schema}
+}
+
+// Validate validates data against a schema
+func (sv *SchemaValidator) Validate(data []byte) error {
+	res := bytes.Equal(sv.Schema, data)
+	if !res {
+		return fmt.Errorf("%w: %s", ErrInvalidFormat, string(data))
+	}
+	return nil
+}
+
+// FieldTransformer implements the Transformer interface for field transformations
+type FieldTransformer struct {
+	FieldName     string
+	TransformFunc func(string) string
+}
+
+// NewFieldTransformer creates a new field transformer
+func NewFieldTransformer(fieldName string, transformFunc func(string) string) *FieldTransformer {
+	// TODO: Implement field transformer initialization
+	return &FieldTransformer{fieldName, transformFunc}
+}
+
+// Transform transforms a specific field in the data
+func (ft *FieldTransformer) Transform(data []byte) ([]byte, error) {
+	payload := make(map[string]interface{})
+	if err := json.Unmarshal(data, &payload); err != nil {
+		return nil, err
+	}
+
+	val, ok := payload[ft.FieldName]
+	if !ok {
+		return nil, fmt.Errorf("field '%s' not found in input", ft.FieldName)
+	}
+
+	strVal, ok := val.(string)
+	if !ok {
+		return nil, errors.New("field value is not a string")
+	}
+
+	payload[ft.FieldName] = ft.TransformFunc(strVal)
+	data, err := json.Marshal(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+// FileWriter implements the Writer interface for file destinations
+type FileWriter struct {
+	Filename string
+}
+
+// NewFileWriter creates a new file writer
+func NewFileWriter(filename string) *FileWriter {
+	// TODO: Implement file writer initialization
+	return &FileWriter{Filename: filename}
+}
+
+// Write writes data to a file
+func (fw *FileWriter) Write(ctx context.Context, data []byte) error {
+	err := os.WriteFile(fw.Filename, data, 0644)
+	if err != nil {
+		return err
+	}
+	return nil
+}