BizzelTech.QuickBooks 1.0.1

BizzelTools - Business Data Processing Libraries

A comprehensive suite of .NET libraries for business data processing, Excel generation, and QuickBooks integration. The BizzelTools ecosystem provides powerful, easy-to-use tools for working with business data formats.

📦 Packages

🔷 BizzelTech.Excel

A powerful, customizable Excel library with a fluent API for creating and reading Excel documents. Alternative to EPPlus and ClosedXML with full control over implementation.

Key Features:

• Fluent API for Excel file creation
• Rich formatting and styling support
• Formula support with automatic calculation
• Multi-framework support (.NET 8, 9, 10)
• Type-safe operations with IntelliSense

dotnet add package BizzelTech.Excel

📊 BizzelTech.QuickBooks

Comprehensive QuickBooks data processing library with models, file reading framework, and export capabilities. Integrates seamlessly with BizzelTech.Excel for beautiful data exports.

Key Features:

• Complete QuickBooks data models (Customers, Vendors, Items, etc.)
• Excel export using BizzelTech.Excel integration
• CSV export for data integration
• Framework for QuickBooks file reading
• Multi-framework support (.NET 8, 9, 10)

dotnet add package BizzelTech.QuickBooks

🚀 Quick Start Examples

Excel Creation with BizzelTech.Excel

using BizzelTools.Excel;

var workbook = Excel.Create()
    .WithProperties(title: "Sales Report", author: "BizzelTools")
    .ConfigureWorksheet("Data", ws => ws
        .SetValue("A1", "Product")
        .SetValue("B1", "Revenue")
        .ApplyStyle("A1:B1", style => style.Bold().BackgroundColor(Color.LightGray))
        .SetValue("A2", "Software")
        .SetValue("B2", 50000)
        .ApplyStyle("B2", style => style.NumberFormat("$#,##0.00")))
    .SaveAs("report.xlsx");

QuickBooks Data Export

using BizzelTech.QuickBooks.Models;
using BizzelTech.QuickBooks.Services;

var exporter = new DataExporter(logger);
var quickBooksData = new QuickBooksData
{
    CompanyName = "My Company",
    Customers = new List<Customer>
    {
        new Customer { Name = "Acme Corp", Balance = 15000.00m }
    }
};

// Export to Excel using BizzelTech.Excel integration
await exporter.ExportToExcelAsync(quickBooksData, "quickbooks_data.xlsx");

// Export to CSV files
await exporter.ExportToCsvAsync(quickBooksData, "csv_export/");

📁 Project Structure

BizzelTools/
├── src/
│   ├── BizzelTools.Excel/           # Excel library source
│   └── BizzelTech.QuickBooks/       # QuickBooks library source
├── tests/
│   └── BizzelTools.Excel.Tests/     # Unit tests
├── samples/
│   ├── BizzelTools.Excel.Sample/    # Excel sample application
│   └── BizzelTools.QuickBooks.Sample/ # QuickBooks sample application
├── nupkg/                           # NuGet packages output
└── README.md                        # This file

🔬 Sample Applications

Excel Sample

Located in samples/BizzelTools.Excel.Sample/

Demonstrates:

• Fluent API usage
• Advanced styling and formatting
• Formula calculations
• Data import from collections
• Multi-worksheet creation

cd samples/BizzelTools.Excel.Sample
dotnet run

QuickBooks Sample

Located in samples/BizzelTools.QuickBooks.Sample/

Demonstrates:

• QuickBooks data models
• Excel export with professional formatting
• CSV export capabilities
• Dependency injection patterns
• Logging integration

cd samples/BizzelTools.QuickBooks.Sample
dotnet run

🏗️ Architecture Overview

BizzelTech.Excel Architecture

• Fluent API: Chainable builder pattern for intuitive Excel creation
• Model-based: Strong typing with IntelliSense support
• OpenXML Foundation: Built on DocumentFormat.OpenXml for reliability
• Extensible: Clean interfaces for extending functionality

BizzelTech.QuickBooks Architecture

• Domain Models: Rich models representing QuickBooks entities
• Service Pattern: Clean separation with dependency injection support
• Excel Integration: Seamless integration with BizzelTech.Excel
• Export Framework: Extensible export system for multiple formats

🔄 Package Integration

The packages work seamlessly together:

// QuickBooks data automatically exports to Excel using BizzelTech.Excel
var exporter = new DataExporter(logger);
await exporter.ExportToExcelAsync(quickBooksData, "output.xlsx");

// Results in professional Excel files with:
// - Multiple worksheets for each data type
// - Formatted headers with styling
// - Currency formatting for monetary fields
// - Summary worksheets with company overview

🚀 Detailed Feature Overview

BizzelTech.Excel Features

• Fluent API: Easy-to-use, chainable methods for building Excel files
• Full Excel Support: Create, read, and modify Excel (.xlsx) files
• Rich Formatting: Support for fonts, colors, borders, alignment, and number formats
• Formula Support: Add Excel formulas to cells with automatic calculation
• Data Import: Easily import data from collections and arrays
• Worksheet Management: Create, rename, copy, and manage multiple worksheets
• Cell Ranges: Work with individual cells or ranges of cells
• Type Safety: Strongly typed API with full IntelliSense support
• Multi-Framework: .NET 8.0, 9.0, and 10.0 support

BizzelTech.QuickBooks Features

• Complete Data Models: All QuickBooks entities (Customers, Vendors, Items, Accounts, Transactions, Employees)
• Excel Export: Professional Excel files using BizzelTech.Excel integration
• CSV Export: Standard CSV files for data integration
• File Reading Framework: Extensible framework for QuickBooks file parsing
• Logging Integration: Built-in logging support
• Dependency Injection: Clean service patterns with DI support
• Multi-Framework: .NET 8.0, 9.0, and 10.0 support

📖 Comprehensive Examples

Excel Creation Examples

1. Simple Excel File

using BizzelTools.Excel;

var workbook = Excel.Create()
    .WithProperties(title: "My Report", author: "Your Name")
    .ConfigureWorksheet("Data", ws => ws
        .SetValue("A1", "Hello")
        .SetValue("B1", "World")
        .SetValue("A2", 42)
        .SetValue("B2", DateTime.Now))
    .SaveAs("example.xlsx");

2. Styled Business Report

var workbook = Excel.Create()
    .ConfigureWorksheet("Sales Report", ws => ws
        // Headers
        .CreateHeader(1, 1, new[] { "Product", "Price", "Quantity", "Total" },
            style => style.Bold().BackgroundColor(Color.DarkBlue).FontColor(Color.White))
        
        // Data
        .SetValue(2, 1, "Widget A")
        .SetValue(2, 2, 10.50)
        .SetValue(2, 3, 5)
        .SetFormula(2, 4, "B2*C2")
        
        // Formatting
        .ApplyStyle(2, 2, 10, 2, style => style.NumberFormat("$#,##0.00"))
        .ApplyStyle(2, 4, 10, 4, style => style.NumberFormat("$#,##0.00")))
    .SaveAs("sales_report.xlsx");

3. Data Import from Collections

var employees = new[]
{
    new { Name = "John Doe", Department = "IT", Salary = 75000 },
    new { Name = "Jane Smith", Department = "HR", Salary = 65000 }
};

var workbook = Excel.Create()
    .ConfigureWorksheet("Employees", ws => ws
        .InsertData(1, 1, employees, includeHeaders: true)
        .ApplyStyle(1, 1, 1, 3, style => style.Bold().BackgroundColor(Color.LightGray))
        .ApplyStyle(2, 3, employees.Length + 1, 3, style => style.NumberFormat("$#,##0")))
    .SaveAs("employees.xlsx");

QuickBooks Integration Examples

1. Creating QuickBooks Data

using BizzelTech.QuickBooks.Models;

var quickBooksData = new QuickBooksData
{
    CompanyName = "Sample Company Inc",
    DateRange_Start = DateTime.Now.AddYears(-1),
    DateRange_End = DateTime.Now,
    Customers = new List<Customer>
    {
        new Customer
        {
            Name = "Acme Corporation",
            ContactPerson = "John Smith",
            Email = "john@acme.com",
            Balance = 15750.50m,
            IsActive = true
        }
    },
    Transactions = new List<Transaction>
    {
        new Transaction
        {
            Date = DateTime.Now.AddDays(-30),
            Type = "Invoice",
            Customer = "Acme Corporation",
            Amount = 15000.00m,
            Description = "Consulting services"
        }
    }
};

2. Excel Export with Professional Formatting

using BizzelTech.QuickBooks.Services;

var exporter = new DataExporter(logger);

// Creates beautiful Excel file with:
// - Separate worksheets for each data type
// - Formatted headers with bold text and background colors
// - Currency formatting for monetary fields
// - Date formatting for transactions
// - Summary worksheet with company overview
await exporter.ExportToExcelAsync(quickBooksData, "company_data.xlsx");

3. CSV Export for Integration

// Exports to separate CSV files:
// - Company_Customers.csv
// - Company_Vendors.csv  
// - Company_Transactions.csv
// - etc.
await exporter.ExportToCsvAsync(quickBooksData, "csv_export_directory");

4. Service Integration with Dependency Injection

// Startup.cs or Program.cs
services.AddTransient<IQuickBooksReader, QuickBooksFileReader>();
services.AddTransient<IDataExporter, DataExporter>();

// Usage
public class BusinessService
{
    private readonly IDataExporter _exporter;
    
    public BusinessService(IDataExporter exporter)
    {
        _exporter = exporter;
    }
    
    public async Task ExportCompanyDataAsync(QuickBooksData data)
    {
        await _exporter.ExportToExcelAsync(data, "report.xlsx");
    }
}

🧪 Testing

Both libraries include comprehensive unit tests:

# Run all tests
dotnet test

# Run specific project tests
dotnet test tests/BizzelTools.Excel.Tests/

🔧 Building from Source

1. Clone the repository

   git clone https://github.com/yourusername/BizzelTools.git
   cd BizzelTools
   

2. Restore dependencies

   dotnet restore
   

3. Build the solution

   dotnet build
   

4. Run tests

   dotnet test
   

5. Create NuGet packages

   dotnet pack --configuration Release
   

� Requirements

• .NET 8.0 or later (supports .NET 8, 9, and 10)
• DocumentFormat.OpenXml 3.1.0 (for Excel operations)
• CsvHelper 33.1.0 (for CSV operations in QuickBooks package)

🤝 Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Make your changes
4. Add tests for new functionality
5. Ensure all tests pass (dotnet test)
6. Commit your changes (git commit -m 'Add amazing feature')
7. Push to the branch (git push origin feature/amazing-feature)
8. Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• BizzelTech.Excel is built on top of DocumentFormat.OpenXml
• BizzelTech.QuickBooks uses CsvHelper for CSV operations
• Inspired by popular libraries like EPPlus and ClosedXML, but designed for full developer control
• Thanks to the .NET community for continuous inspiration and feedback

📞 Support & Links

Package Links

• BizzelTech.Excel on NuGet
• BizzelTech.QuickBooks on NuGet

Documentation

• Excel Package Documentation
• QuickBooks Package Documentation
• Excel Sample Application
• QuickBooks Sample Application

Support

For questions, issues, or feature requests:

• 🐛 Report Issues
• 💡 Request Features
• 📧 Contact the maintainers

BizzelTools - Making business data processing simple, powerful, and integrated.

🔷 Excel • 📊 QuickBooks • 🚀 Productivity