employeemanagementsystem

Tuesday, 9 July 2024 2:44 PM

Let's dive into a more advanced practical example: creating a multi-tier ASP.NET Core MVC a
database, Entity Framework Core for data access, and dependency injection for better maint
simple "Employee Management System" that includes features like authentication, role-base
testing.

### Step 1: Set Up the Project

1. *Install .NET Core SDK*: Make sure you have the .NET Core SDK installed on your machine
[here](https://dotnet.microsoft.com/download).

2. *Create a New ASP.NET Core MVC Project*:

bash
dotnet new mvc -o EmployeeManagement
cd EmployeeManagement

3. *Add Required Packages*:

bash
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools
dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore
dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer
dotnet add package xunit
dotnet add package xunit.runner.visualstudio
dotnet add package Microsoft.NET.Test.Sdk

### Step 2: Set Up the Database with Entity Framework Core

1. *Create Models*:
Create a Models folder and add Employee.cs and ApplicationUser.cs files.

Employee.cs:
csharp
public class Employee
{
public int Id { get; set; }
public string Name { get; set; }
application with a SQL Server
tainability. We'll build a
ed access control, and unit

e. You can download it from

 Employee.cs:
csharp
public class Employee
{
public int Id { get; set; }
public string Name { get; set; }
public string Department { get; set; }
public DateTime HireDate { get; set; }
}

ApplicationUser.cs:
csharp
using Microsoft.AspNetCore.Identity;

public class ApplicationUser : IdentityUser

{
// Additional properties can be added here
}

2. *Create the ApplicationDbContext*:

Create a Data folder and add ApplicationDbContext.cs.

ApplicationDbContext.cs:
csharp
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>

{
public DbSet<Employee> Employees { get; set; }

public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)

: base(options)
{
}

protected override void OnModelCreating(ModelBuilder builder)

{
base.OnModelCreating(builder);
// Customize the ASP.NET Identity model and override the defaults if needed.
// For example, you can rename the ASP.NET Identity table names and more.
}
}
 // Customize the ASP.NET Identity model and override the defaults if needed.
// For example, you can rename the ASP.NET Identity table names and more.
}
}

3. *Configure the Connection String*:

In appsettings.json, add the connection string for the SQL Server database.
json
"ConnectionStrings": {
"DefaultConnection":
"Server=(localdb)\\mssqllocaldb;Database=EmployeeDb;Trusted_Connection=True;Multiple
}

4. *Configure Services and Middleware*:

In Startup.cs, configure the services to use Entity Framework Core and Identity.

csharp
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

services.AddDefaultIdentity<ApplicationUser>()
.AddEntityFrameworkStores<ApplicationDbContext>();

services.AddControllersWithViews();
services.AddRazorPages();
}

### Step 3: Create Controllers and Views

1. *Create the EmployeeController*:

Create a Controllers folder and add EmployeeController.cs.

EmployeeController.cs:
csharp
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Threading.Tasks;

public class EmployeeController : Controller

{
private readonly ApplicationDbContext _context;
eActiveResultSets=true"
using Microsoft.EntityFrameworkCore;
using System.Threading.Tasks;

public class EmployeeController : Controller

{
private readonly ApplicationDbContext _context;

public EmployeeController(ApplicationDbContext context)

{
_context = context;
}

// GET: Employee
public async Task<IActionResult> Index()
{
return View(await _context.Employees.ToListAsync());
}

// GET: Employee/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}

var employee = await _context.Employees

.FirstOrDefaultAsync(m => m.Id == id);
if (employee == null)
{
return NotFound();
}

return View(employee);
}

// GET: Employee/Create
public IActionResult Create()
{
return View();
}

// POST: Employee/Create
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Create([Bind("Id,Name,Department,HireDate")] Emplo
{
oyee employee)
// POST: Employee/Create
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Create([Bind("Id,Name,Department,HireDate")] Emplo
{
if (ModelState.IsValid)
{
_context.Add(employee);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
return View(employee);
}

// GET: Employee/Edit/5
public async Task<IActionResult> Edit(int? id)
{
if (id == null)
{
return NotFound();
}

var employee = await _context.Employees.FindAsync(id);

if (employee == null)
{
return NotFound();
}
return View(employee);
}

// POST: Employee/Edit/5
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(int id, [Bind("Id,Name,Department,HireDate")] Em
{
if (id != employee.Id)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(employee);
await _context.SaveChangesAsync();
oyee employee)

mployee employee)
{
if (id != employee.Id)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(employee);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(employee.Id))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction(nameof(Index));
}
return View(employee);
}

// GET: Employee/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null)
{
return NotFound();
}

var employee = await _context.Employees

.FirstOrDefaultAsync(m => m.Id == id);
if (employee == null)
{
return NotFound();
}

return View(employee);
}
 return NotFound();
}

return View(employee);
}

// POST: Employee/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var employee = await _context.Employees.FindAsync(id);
_context.Employees.Remove(employee);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}

private bool EmployeeExists(int id)

{
return _context.Employees.Any(e => e.Id == id);
}
}

2. *Create the Views*:

Create views for the Employee entity under the Views/Employee folder:
Index.cshtml, Details.cshtml, Create.cshtml, Edit.cshtml, and Delete.cshtml. Here's
a simple example of Index.cshtml:

Index.cshtml:
html
@model IEnumerable<EmployeeManagement.Models.Employee>

<h2>Employee List</h2>

<table class="table">
<thead>
<tr>
<th>Name</th>
<th>Department</th>
<th>Hire Date</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model)
{
 <th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model)
{
<tr>
<td>@Html.DisplayFor(modelItem => item.Name)</td>
<td>@Html.DisplayFor(modelItem => item.Department)</td>
<td>@Html.DisplayFor(modelItem => item.HireDate)</td>
<td>
<a asp-action="Edit" asp-route-id="@item.Id">Edit</a> |
<a asp-action="Details" asp-route-id="@item.Id">Details</a> |
<a asp-action="Delete" asp-route-id="@item.Id">Delete</a>
</td>
</tr>
}
</tbody>
</table>

<a asp-action="Create">Create New</a>

### Step 4: Add Authentication and Authorization

1. *Enable Authentication*:
In Startup.cs, configure the app to use authentication and authorization.
csharp
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthentication();
app.UseAuthorization();
 app.UseStaticFiles();

app.UseRouting();

app.UseAuthentication();
app.UseAuthorization();

app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
endpoints.MapRazorPages();
});
}

2. *Create Account and Manage Roles*:

Implement account creation and role management for users. This involves
creating views and controllers for registration, login, and role management.

### Step 5: Add Unit Tests

1. *Create a Test Project*:

```bash
dotnet

new xunit -o EmployeeManagement.Tests

cd EmployeeManagement.Tests
dotnet add reference ../EmployeeManagement/EmployeeManagement.csproj

2. **Add Unit Tests**:

Create unit tests for the `EmployeeController` in the test project.

`EmployeeControllerTests.cs`:
csharp
public class EmployeeControllerTests
{
private readonly EmployeeController _controller;
private readonly ApplicationDbContext _context;

public EmployeeControllerTests()
{
var options = new DbContextOptionsBuilder<ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "TestDatabase")
.Options;
 public EmployeeControllerTests()
{
var options = new DbContextOptionsBuilder<ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "TestDatabase")
.Options;
_context = new ApplicationDbContext(options);

_controller = new EmployeeController(_context);

}

[Fact]
public async Task Index_ReturnsViewResult_WithListOfEmployees()
{
// Arrange
_context.Employees.Add(new Employee { Name = "Test Employee",
Department = "HR", HireDate = DateTime.Now });
_context.SaveChanges();

// Act
var result = await _controller.Index();

// Assert
var viewResult = Assert.IsType<ViewResult>(result);
var model = Assert.IsAssignableFrom<IEnumerable<Employee>>
(viewResult.ViewData.Model);
Assert.Single(model);
}
}
```

### Conclusion

This advanced practical example covers setting up an ASP.NET Core MVC

application with Entity Framework Core, authentication, role-based access control,
and unit testing. You can further extend this application by adding more features
such as email notifications, file uploads, or integrating with external APIs.