📘 MonitorMapper Service Documentation


Table of Contents

  1. Overview & Purpose
  2. Key Functional Areas
  3. Dependencies & Technologies
  4. Data & View Models
  5. Interface & Public API
  6. Helper Methods & Utilities
  7. Error Handling & Return Types
  8. Third‑party Integrations
  9. Sample Code Blocks & Usage Examples
  10. UML Class Diagram
  11. Conclusion

1. Overview & Purpose

🖥️ MonitorMapper is a service in the IrbyImaging.UI assembly responsible for translating between domain entities (Monitor, AssetHistory) and view models used in the UI layer. By centralizing mapping logic, this service:

  • Ensures separation of concerns: Controllers focus on HTTP and routing, while mapping logic lives here.
  • Provides consistency: All monitor‑related views use the same mapping patterns.
  • Simplifies testing: Mappings can be unit‑tested in isolation.

2. Key Functional Areas

Area Responsibilities
Create - Generate default MonitorCreateViewModel- Map MonitorCreateViewModel → Monitor
Read - Map Monitor → MonitorDetailViewModel- Build filtered MonitorListViewModel
Update - Map Monitor → MonitorEditViewModel- Map MonitorEditViewModel → Monitor
History - Map AssetHistory → HistoryViewModel- Build HistoryListViewModel from a sequence of histories

3. Dependencies & Technologies

  • .NET/C#
  • ASP.NET MVC patterns (View Models, SelectLists)
  • Newtonsoft.Json for (de)serialization
  • IrbyImaging.BusinessLogic
  • IrbyImaging.DomainClasses
  • IrbyImaging.Models (view‑model definitions)
  • IrbyImaging.Utility (Helpers.GenerateSelectListFor)

4. Data & View Models

Domain Model Description Corresponding View Models
Monitor Represents a physical monitor asset. - MonitorCreateViewModel- MonitorDetailViewModel- MonitorEditViewModel- MonitorListViewModel
AssetHistory Tracks changes to any asset over time. - HistoryViewModel- HistoryListViewModel

Sample ViewModel Properties

public class MonitorCreateViewModel {
  public IEnumerable<SelectListItem> ModelList { get; set; }
  public IEnumerable<SelectListItem> OwnerList { get; set; }
  public DateTimeOffset PurchaseDate { get; set; }
  public string SerialNumber { get; set; }
  public AssetStatus Status { get; set; }
  public Guid ModelId { get; set; }
  public Guid OwnerId { get; set; }
  public string Notes { get; set; }
}

5. Interface & Public API

IMonitorMapper Interface

public interface IMonitorMapper {
  // Create
  MonitorCreateViewModel GenerateMonitorCreateViewModel();
  Monitor               CreateViewModelToMonitor(MonitorCreateViewModel vm);

  // Read
  MonitorDetailViewModel GenerateMonitorDetailViewModel(Monitor monitor);
  MonitorListViewModel   GenerateMonitorListViewModel(IEnumerable<Monitor> monitors, AssetStatus status);

  // Update
  MonitorEditViewModel   MonitorToEditViewModel(Monitor monitor);
  Monitor                 EditViewModelToMonitor(MonitorEditViewModel vm);

  // History
  HistoryViewModel       GenerateMonitorHistoryViewModel(AssetHistory history);
  HistoryListViewModel   GenerateMonitorHistoryListViewModel(IEnumerable<AssetHistory> histories);
}

Method Summary

Method Description Returns
GenerateMonitorCreateViewModel() Builds a new Create view model with select lists & default date. MonitorCreateViewModel
CreateViewModelToMonitor(MonitorCreateViewModel vm) Maps user input → Monitor entity. Monitor
GenerateMonitorDetailViewModel(Monitor m) Maps a Monitor → detail view model (incl. CSS class). MonitorDetailViewModel
GenerateMonitorListViewModel(IEnumerable, Status) Filters & maps list of monitors. MonitorListViewModel
MonitorToEditViewModel(Monitor m) Prepares an edit view model (incl. select lists). MonitorEditViewModel
EditViewModelToMonitor(MonitorEditViewModel vm) Maps edit vm → updated Monitor entity. Monitor
GenerateMonitorHistoryViewModel(AssetHistory history) Deserializes & maps history record. HistoryViewModel
GenerateMonitorHistoryListViewModel(IEnumerable) Builds a list view model from history records. HistoryListViewModel

6. Helper Methods & Utilities

  • Helpers.GenerateSelectListFor(...)
    Generates an IEnumerable<SelectListItem> for dropdowns based on provided entities (models, owners).

  • Status Color Mapping
    In GenerateMonitorDetailViewModel, a switch on AssetStatus assigns a CSS class:

    switch(monitor.Status) {
      case AssetStatus.Active:       colorClass = "irby-green";   break;
      case AssetStatus.Available:    colorClass = "irby-blue";    break;
      case AssetStatus.LostOrStolen: colorClass = "irby-red";     break;
      default:                       colorClass = String.Empty;   break;
    }
    

7. Error Handling & Return Types

❗ Error Handling

  • This service does not catch exceptions; errors bubble up to controllers.
  • Ensure non-null input: passing null for Monitor or AssetHistory will result in NullReferenceException.

✅ Return Types

  • Always returns a new view model or entity instance; no in‑place modifications occur.

8. Third-party Integrations

  • Newtonsoft.Json
    Used in GenerateMonitorHistoryViewModel to deserialize the JSON‑serialized properties of an asset:
    SomeAsset = JsonConvert.DeserializeObject<Monitor>(history.SerializedProperties);
    

9. Sample Code Blocks & Usage Examples

9.1. Dependency Injection Registration

public void ConfigureServices(IServiceCollection services) {
  // Register the asset manager implementation
  services.AddScoped<IAssetManager, AssetManager>();
  // Register the MonitorMapper service
  services.AddScoped<IMonitorMapper, MonitorMapper>();
}

9.2. Controller Example

public class MonitorController : Controller {
  private readonly IMonitorMapper _mapper;
  private readonly IMonitorRepository _repo;  // hypothetical data repo

  public MonitorController(IMonitorMapper mapper, IMonitorRepository repo) {
    _mapper = mapper;
    _repo   = repo;
  }

  // GET: /Monitor/Create
  public IActionResult Create() {
    var vm = _mapper.GenerateMonitorCreateViewModel();
    return View(vm);
  }

  // POST: /Monitor/Create
  [HttpPost]
  public IActionResult Create(MonitorCreateViewModel vm) {
    if (!ModelState.IsValid) {
      vm.ModelList = Helpers.GenerateSelectListFor(_assetManager.GetModelsFor(AssetCategory.Monitor));
      vm.OwnerList = Helpers.GenerateSelectListFor(_assetManager.GetOwners());
      return View(vm);
    }
    var monitor = _mapper.CreateViewModelToMonitor(vm);
    _repo.Add(monitor);
    return RedirectToAction("Details", new { id = monitor.Id });
  }

  // GET: /Monitor/Details/{id}
  public IActionResult Details(Guid id) {
    var monitor = _repo.GetById(id);
    var detailVm = _mapper.GenerateMonitorDetailViewModel(monitor);
    return View(detailVm);
  }
}

9.3. Displaying Monitor List in Razor

@model MonitorListViewModel

<h2>Monitors (@Model.Status)</h2>
<table>
  <thead><tr><th>Serial</th><th>Owner</th><th>Status</th></tr></thead>
  <tbody>
    @foreach(var m in Model.Monitors) {
      <tr class="@m.StatusColor">
        <td>@m.SerialNumber</td>
        <td>@m.OwnerFullName</td>
        <td>@m.Status</td>
      </tr>
    }
  </tbody>
</table>

10. UML Class Diagram

classDiagram
    direction LR
    IMonitorMapper <|.. MonitorMapper
    MonitorMapper o-- IAssetManager : uses
    MonitorMapper ..> MonitorCreateViewModel : maps
    MonitorMapper ..> MonitorDetailViewModel : maps
    MonitorMapper ..> MonitorListViewModel : maps
    MonitorMapper ..> MonitorEditViewModel   : maps
    MonitorMapper ..> HistoryViewModel       : maps
    MonitorMapper ..> HistoryListViewModel   : maps
    MonitorDetailViewModel --> Monitor : displays
    HistoryViewModel ..> Monitor : SomeAsset (deserialized)

11. Conclusion

🎯 MonitorMapper streamlines the translation between your domain and presentation layers. By leveraging this centralized mapping logic, your controllers remain lean, view models remain consistent, and future changes to the mapping rules occur in a single location.

Happy Coding! 🚀