MOQ Tutorial .NET Core: A Comprehensive Guide to Minimum Order Quantity Setup

Welcome to this comprehensive guide on implementing Minimum Order Quantity (MOQ) in a .NET Core application. As a developer or a business owner, understanding and effectively managing MOQ is crucial to maintaining a healthy supply chain and inventory. This tutorial will walk you through the process of creating a simple yet functional MOQ system using .NET Core.

Before we dive into the implementation, let's ensure you have the right tools. You'll need to have .NET Core SDK installed on your machine, along with a text editor or IDE such as Visual Studio Code or Visual Studio. We'll also use Entity Framework Core for database operations and ASP.NET Core for creating a simple web API.

Setting Up the Project

The first step is to set up a new .NET Core Web API project. You can do this using the .NET Core CLI with the following command:

$ dotnet new webapi -n MoqTutorial

Creating the Database Model

For this tutorial, we'll use a simple Product entity with attributes like Name, Price, and MinimumOrderQuantity. Start by creating a new folder named 'Models' in your project root and add a Product.cs file with the following content:

Product.cs

```csharp using System.ComponentModel.DataAnnotations; using System.ComponentModel.DataAnnotations.Schema; namespace MoqTutorial.Models { public class Product { public int Id { get; set; } [Required] [MaxLength(100)] public string Name { get; set; } [Required] public decimal Price { get; set; } [Required] public int MinimumOrderQuantity { get; set; } } } ```

Configuring Entity Framework Core

Next, configure Entity Framework Core to work with our Product model. In the 'appsettings.json' file, add the following connection string:

```json "ConnectionStrings": { "DefaultConnection": "Server=your_server;Database=your_database;Trusted_Connection=True;MultipleActiveResultSets=true" } ```

Then, install the Microsoft.EntityFrameworkCore.SqlServer package and create a new class named 'ApplicationDbContext' to set up the DbContext.

Implementing the MOQ Functionality

Now that we have the basic setup, we can implement the MOQ functionality. In your API controller, add an action method to place an order:

OrderController.cs

```csharp using Microsoft.AspNetCore.Mvc; using MoqTutorial.Models; using System.Linq; namespace MoqTutorial.Controllers { [Route("api/[controller]")] [ApiController] public class OrderController : ControllerBase { private readonly ApplicationDbContext _context; public OrderController(ApplicationDbContext context) { _context = context; } [HttpPost("place-order")] public IActionResult PlaceOrder(int productId, int quantity) { var product = _context.Products.FirstOrDefault(p => p.Id == productId); if (product == null) { return NotFound(); } if (quantity < product.MinimumOrderQuantity) { return BadRequest($"Minimum order quantity is {product.MinimumOrderQuantity}."); } // Process the order... return Ok($"Order placed successfully for {product.Name}."); } } } ```

In this example, the 'PlaceOrder' action first retrieves the desired product. It then checks if the requested quantity meets the MOQ. If not, it returns a 400 Bad Request status code with an appropriate error message. If the quantity is sufficient, it proceeds with processing the order.

Testing the MOQ System

To test the MOQ functionality, send a POST request to the 'api/order/place-order' endpoint with the desired product ID and quantity. You can use tools like Postman or curl for this. Ensure to include an MOQ violation to test the error handling:

PUT your API base URL here/api/order/place-order

Content-Type: application/json

```json { "productId": 1, "quantity": 9 } ```

If the quantity is less than the MOQ, the API should respond with a 400 Bad Request status code and an appropriate error message.

Congratulations! You've just created a simple yet effective MOQ system using .NET Core. This implementation can be customized and expanded to fit your specific business needs. Happy coding!