# Tender Management System

A comprehensive tender management backend system built with Go, following Clean Architecture principles with Domain-Driven Design (DDD) patterns.

## 📚 Documentation

All documentation has been organized in the [`docs/`](./docs/) directory for better structure and maintainability.

### Quick Links
- **[📖 Main Documentation](./docs/README.md)** - Comprehensive project overview and guidelines
- **[🔧 Setup Guides](./docs/setup/)** - HTTP server and Swagger setup
- **[🚀 Implementation Details](./docs/implementation/)** - Architecture and implementation overview
- **[📡 API Examples](./docs/examples/)** - API usage examples and endpoints

## 🚀 Quick Start

1. **Setup Environment**
   ```bash
   # Follow setup guides in docs/setup/
   ```

2. **Run the Application**
   ```bash
   make run
   ```

3. **Access API Documentation**
   - Swagger UI: `http://localhost:8081/swagger/index.html`
   - API Base URL: `http://localhost:8081/api/v1`

## 🏗️ Architecture

This system implements **Clean Architecture** with:
- **Domain Layer**: Business entities and core rules
- **Service Layer**: Business logic and use cases
- **Handler Layer**: HTTP controllers and request handling
- **Repository Layer**: Data access implementations
- **Infrastructure Layer**: External dependencies

## 📋 Key Features

- **Clean Architecture**: DDD principles with clear separation of concerns
- **MongoDB Integration**: Robust data persistence with proper indexing
- **Structured Logging**: Comprehensive logging with context
- **Input Validation**: Govalidator integration for request validation
- **Error Handling**: Consistent error responses and logging
- **Time Handling**: Unix timestamps throughout the application
- **Generic XML Parser**: Parse any XML structure into Go structs using generics

## 🔧 New Features

### Generic XML Parser

A powerful, generic XML parser built with Go generics that can parse any XML structure into Go structs. Perfect for handling complex XML formats like TED (Tenders Electronic Daily) notices.

#### Features
- **Generic Support**: Parse any XML structure that implements the `Parseable` interface
- **Flexible Configuration**: Customizable parsing options for different use cases
- **Built-in Validation**: Automatic validation of parsed structures
- **Metadata Extraction**: Extract XML metadata and parsing information
- **TED XML Support**: Pre-built models for TED contract notices
- **Error Reporting**: Detailed error and warning reporting

#### Quick Example
```go
// Define your XML structure
type Contract struct {
    XMLName xml.Name `xml:"Contract"`
    ID      string   `xml:"id,attr"`
    Name    string   `xml:"name"`
    Value   string   `xml:"value"`
}

func (c Contract) Validate() error { /* validation logic */ }
func (c Contract) GetID() string { return c.ID }

// Parse XML
parser := xmlparser.NewParser[Contract](nil)
contract, err := parser.ParseString(xmlData)
```

See [pkg/xmlparser/README.md](pkg/xmlparser/README.md) for complete documentation and examples.

## 📦 Package Structure

```
├── cmd/                    # Application entry points
├── internal/               # Private application code
│   ├── company/           # Company domain
│   ├── customer/          # Customer domain
│   └── user/              # User domain
├── pkg/                   # Public packages
│   ├── authorization/     # Authorization utilities
│   ├── logger/           # Structured logging
│   ├── mongo/            # MongoDB utilities
│   ├── redis/            # Redis utilities
│   ├── response/         # HTTP response utilities
│   └── xmlparser/        # Generic XML parser
├── infra/                # Infrastructure configuration
└── docs/                 # Documentation
```

## 🧪 Testing

```bash
# Run all tests
make test

# Test specific package
go test ./pkg/xmlparser/...

# Test with coverage
make test-coverage
```

## 🛠️ Development

### Prerequisites
- Go 1.23+
- MongoDB
- Redis (optional)

### Local Development
```bash
# Clone repository
git clone <repository-url>
cd tm_back

# Install dependencies
go mod tidy

# Run tests
make test

# Start development server
make dev
```

### Adding New Features
1. Follow Clean Architecture principles
2. Implement proper logging in service layer
3. Add comprehensive validation
4. Write unit tests
5. Update documentation

## 📝 Contributing

1. Fork the repository
2. Create a feature branch
3. Follow coding standards
4. Add tests for new features
5. Update documentation
6. Submit a pull request

## 📄 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.