ISC.MongoDB.Extensions.DependencyInjection 1.0.1

ISC.MongoDB.Extensions.DependencyInjection

A lightweight library that registers IMongoDBConnection into Dependency Injection for MongoDB access in .NET applications.

Installation

dotnet add package ISC.MongoDB.Extensions.DependencyInjection

Requirements

• .NET 8+
• MongoDB.Driver (already referenced by this package)

Usage

1) Quick registration with connection string

using ISC.MongoDB.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddMongoDB(
    connectionString: builder.Configuration.GetConnectionString("MongoDB")!,
    database: "MyDatabase",
    timeout: 10);

2) Customize MongoClientSettings during registration

using ISC.MongoDB.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddMongoDB(
    connectionString: builder.Configuration.GetConnectionString("MongoDB")!,
    database: "MyDatabase",
    timeout: 10,
    configureSettings: settings =>
    {
        settings.RetryReads = true;
        settings.RetryWrites = true;
        settings.MaxConnectionPoolSize = 200;
        settings.ApplicationName = "MyApi";
    });

3) Create MongoClientSettings manually and pass it in

using ISC.MongoDB.Extensions.DependencyInjection;
using MongoDB.Driver;

var builder = WebApplication.CreateBuilder(args);

var settings = MongoClientSettings.FromConnectionString(
    builder.Configuration.GetConnectionString("MongoDB")!);

builder.Services.AddMongoDB(
    settings: settings,
    database: "MyDatabase",
    timeout: 10,
    configureSettings: s =>
    {
        s.ConnectTimeout = TimeSpan.FromSeconds(5);
        s.ServerSelectionTimeout = TimeSpan.FromSeconds(5);
        s.SocketTimeout = TimeSpan.FromSeconds(30);
    });

Sample appsettings.json

{
  "ConnectionStrings": {
    "MongoDB": "mongodb://localhost:27017"
  }
}

IMongoDBConnection API

• InsertDocumentAsync
• InsertListDocumentsAsync
• GetDocumentAsync
• GetListDocumentsAsync
• GetAggregateAsync
• CountDocumentsAsync
• DeleteDocumentsAsync
• DeleteAsync

Notes

• timeout is the default connection timeout used by this package.
• You can override or extend advanced client options through configureSettings.

Ponus Function get GetAggregateAsync

public async Task<(List<OutputMessageDTO> Data, int Total)> GetPipelineMessageDeliveriesAsync(int pageNumber,
            int pageSize, string channel, string? state, List<Guid> clientId, string? Vendor, DateTimeOffset? fromDate, DateTimeOffset? toDate,
            List<Guid>? validClientIds = null, List<Guid>? validVendorIds = null, List<Guid>? validVendorAccountIds = null)
        {
            try
            {
                string colectionName = GetCollectionName(channel);
                var pipeline = new List<BsonDocument>();

                // MATCH filter
                var matchConditions = new BsonDocument();
                
                // Merge clientId parameter with validClientIds for filtering
                var finalClientIds = new List<Guid>();
                if (clientId != null && clientId.Count > 0)
                    finalClientIds.AddRange(clientId);
                if (validClientIds != null && validClientIds.Count > 0)
                {
                    if (finalClientIds.Count > 0)
                        finalClientIds = finalClientIds.Intersect(validClientIds).ToList();
                    else
                        finalClientIds = validClientIds;
                }
                if (finalClientIds.Count > 0)
                {
                    matchConditions.Add("ClientId", new BsonDocument("$in", new BsonArray(finalClientIds)));
                }
                
                if (!string.IsNullOrEmpty(channel))
                    matchConditions.Add("Channel", channel);
                if (!string.IsNullOrEmpty(state))
                    matchConditions.Add("State", state);
                    
                // Handle Vendor with validVendorIds
                if (!string.IsNullOrEmpty(Vendor))
                {
                    if (validVendorIds != null && validVendorIds.Count > 0)
                    {
                        // Check if Vendor parameter is in validVendorIds
                        if (Guid.TryParse(Vendor, out Guid vendorGuid) && validVendorIds.Contains(vendorGuid))
                            matchConditions.Add("Vendor", Vendor);
                        // else: skip this condition as vendor is not valid
                    }
                    else
                    {
                        matchConditions.Add("Vendor", Vendor);
                    }
                }
                else if (validVendorIds != null && validVendorIds.Count > 0)
                {
                    matchConditions.Add("Vendor", new BsonDocument("$in", new BsonArray(validVendorIds)));
                }
                
                // Handle VendorAccountId with validVendorAccountIds
                if (validVendorAccountIds != null && validVendorAccountIds.Count > 0)
                {
                    matchConditions.Add("VendorAccountId", new BsonDocument("$in", new BsonArray(validVendorAccountIds)));
                }

                // Collect all $expr conditions to combine them
                var exprConditions = new List<BsonDocument>();

                // Filter date range
                if (fromDate != null || toDate != null)
                {
                    if (fromDate != null && toDate != null)
                    {
                        // When both dates are provided, check if date is between them (inclusive)
                        exprConditions.Add(
                            new BsonDocument("$and", new BsonArray
                            {
                                new BsonDocument("$gte", new BsonArray
                                {
                                    new BsonDocument("$dateToString", new BsonDocument
                                    {
                                        { "format", "%Y-%m-%d" },
                                        { "date", "$RequestTime" }
                                    }),
                                    fromDate.Value.ToString("yyyy-MM-dd")
                                }),
                                new BsonDocument("$lte", new BsonArray
                                {
                                    new BsonDocument("$dateToString", new BsonDocument
                                    {
                                        { "format", "%Y-%m-%d" },
                                        { "date", "$RequestTime" }
                                    }),
                                    toDate.Value.ToString("yyyy-MM-dd")
                                })
                            })
                        );
                    }
                    else if (fromDate != null)
                    {
                        // When only fromDate is provided
                        exprConditions.Add(
                            new BsonDocument("$gte", new BsonArray
                            {
                                new BsonDocument("$dateToString", new BsonDocument
                                {
                                    { "format", "%Y-%m-%d" },
                                    { "date", "$RequestTime" }
                                }),
                                fromDate.Value.ToString("yyyy-MM-dd")
                            })
                        );
                    }
                    else if (toDate != null)
                    {
                        // When only toDate is provided
                        exprConditions.Add(
                            new BsonDocument("$lte", new BsonArray
                            {
                                new BsonDocument("$dateToString", new BsonDocument
                                {
                                    { "format", "%Y-%m-%d" },
                                    { "date", "$RequestTime" }
                                }),
                                toDate.Value.ToString("yyyy-MM-dd")
                            })
                        );
                    }
                }

                // Add combined $expr condition if we have any
                if (exprConditions.Count > 0)
                {
                    if (exprConditions.Count == 1)
                    {
                        matchConditions.Add("$expr", exprConditions[0]);
                    }
                    else
                    {
                        matchConditions.Add("$expr", new BsonDocument("$and", new BsonArray(exprConditions)));
                    }
                }


                pipeline.Add(new BsonDocument("$match", matchConditions));

                // 2) $facet Total + Data
                pipeline.Add(
                    new BsonDocument("$facet",
                        new BsonDocument
                        {
                            {
                                "Items",
                                new BsonArray
                                {
                                    // GROUP
                                    new BsonDocument("$group",
                                        new BsonDocument
                                        {
                                            { "_id",
                                                new BsonDocument
                                                {
                                                    { "ClientId", "$ClientId" },
                                                    { "Vendor", "$Vendor" },
                                                    { "VendorAccountId",
                                                        new BsonDocument("$ifNull", new BsonArray { "$VendorAccountId", "" })
                                                    }
                                                }
                                            },
                                            { "TotalMessage", new BsonDocument("$sum", 1) },
                                            { "TotalMessageSuccess",
                                                new BsonDocument("$sum",
                                                    new BsonDocument("$cond",
                                                        new BsonArray { new BsonDocument("$eq", new BsonArray { "$State", "Success" }), 1, 0 }
                                                    )
                                                )
                                            },
                                            { "TotalMessageFail",
                                                new BsonDocument("$sum",
                                                    new BsonDocument("$cond",
                                                        new BsonArray { new BsonDocument("$eq", new BsonArray { "$State", "False" }), 1, 0 }
                                                    )
                                                )
                                            }
                                        }
                                    ),

                                    // PROJECT
                                    new BsonDocument("$project",
                                        new BsonDocument
                                        {
                                            { "_id", 0 },
                                            { "ClientId", "$_id.ClientId" },
                                            { "Vendor", "$_id.Vendor" },
                                            { "VendorAccountId", "$_id.VendorAccountId" },
                                            { "TotalMessage", 1 },
                                            { "TotalMessageSuccess", 1 },
                                            { "TotalMessageFail", 1 }
                                        }
                                    ),

                                    // SORT
                                    new BsonDocument("$sort", new BsonDocument("TotalMessage", -1)),

                                    // Paging
                                    new BsonDocument("$skip", (pageNumber - 1) * pageSize),
                                    new BsonDocument("$limit", pageSize)
                                }
                            },

                            {
                                "Total",
                                new BsonArray
                                {
                                    new BsonDocument("$group",
                                        new BsonDocument
                                        {
                                            { "_id",
                                                new BsonDocument
                                                {
                                                    { "ClientId", "$ClientId" },
                                                    { "Vendor", "$Vendor" },
                                                    { "VendorAccountId",
                                                        new BsonDocument("$ifNull", new BsonArray { "$VendorAccountId", "" })
                                                    }
                                                }
                                            }
                                        }
                                    ),
                                    new BsonDocument("$count", "Total")
                                }
                            }
                        }
                    )
                );

                var resultDocs = await _mongoDBConnection.GetAggregateAsync(pipeline, colectionName);

                if (resultDocs.Count == 0)
                    return (new List<OutputMessageDTO>(), 0);

                var facetResult = resultDocs[0];

                // ITEMS
                var items = facetResult["Items"].AsBsonArray
                    .Select(doc =>
                    {
                        int total = doc["TotalMessage"].ToInt32();
                        int success = doc["TotalMessageSuccess"].ToInt32();

                        double rateSuccess = total == 0
                            ? 0
                            : Math.Round((double)success / total * 100, 2);

                        return new OutputMessageDTO(
                            channel,
                            AsGuidSafe(doc["Vendor"]),
                            AsGuidSafe(doc["ClientId"]),
                            AsGuidSafe(doc["VendorAccountId"]),
                            total,
                            success,
                            doc["TotalMessageFail"].ToInt32(),
                            0,
                            (rateSuccess + "%")
                        );
                    }).ToList();

                // TOTAL
                int total = 0;
                var totalArray = facetResult["Total"].AsBsonArray;
                if (totalArray.Count > 0)
                    total = totalArray[0]["Total"].ToInt32();

                return (items, total);
            }
            catch (Exception ex)
            {
                throw new Exception("Function GetMessageDeliveriesAsync error:" + ex.Message);
            }
        }