diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..61e9067
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+*.txt
+.env
\ No newline at end of file
diff --git a/backend/.gitignore b/backend/.gitignore
index 176da77..f03e819 100644
--- a/backend/.gitignore
+++ b/backend/.gitignore
@@ -5,6 +5,7 @@
 
 appsettings.Development.json
 appsettings.json
+*.txt
 efbundle
 
 # dotenv files
diff --git a/backend/Controllers/CityController.cs b/backend/Controllers/CityController.cs
new file mode 100644
index 0000000..164df51
--- /dev/null
+++ b/backend/Controllers/CityController.cs
@@ -0,0 +1,108 @@
+using Microsoft.AspNetCore.Mvc;
+using Mappa.Services;
+using Mappa.Dtos;
+using Mappa.Entities;
+using Microsoft.AspNetCore.Authorization;
+
+namespace Mappa.Controllers;
+
+[ApiController]
+[Route("[controller]")]
+public class CityController : ControllerBase
+{
+    private readonly IComplexEntityService<City, CityGeneralDto, CityDetailDto, 
+        CityCreateRequest, CityUpdateRequest>
+        _service;
+
+    public CityController(IComplexEntityService<City, CityGeneralDto,
+        CityDetailDto, CityCreateRequest, CityUpdateRequest> service)
+    {
+        _service = service;
+    }
+
+    [HttpGet]
+    public async Task<IActionResult> GetAll()
+    {
+        var items = await _service.GetAllAsync();
+        return Ok(items);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<IActionResult> GetById(int id)
+    {
+        try
+        {
+            var item = await _service.GetByIdAsync(id);
+            return Ok(item);
+        }
+        catch (ArgumentException ex) when (ex.Message.Contains($"Entity with ID {id} not found."))
+        {
+            return NotFound(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpPost]
+    public async Task<IActionResult> Create([FromBody] CityCreateRequest request)
+    {
+        try
+        {
+            var item = await _service.CreateAsync(request);
+            return CreatedAtAction(nameof(GetById), new { id = item.Id }, item);
+        }
+        catch (ArgumentException ex)
+        {
+            return Conflict(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpPut("{id}")]
+    public async Task<IActionResult> Update(int id, [FromBody] CityUpdateRequest request)
+    {
+        try
+        {
+            var item = await _service.UpdateAsync(id, request);
+            return Ok(item);
+        }
+        catch (ArgumentException ex)
+        {
+            return NotFound(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpDelete("{id}")]
+    public async Task<IActionResult> Delete(int id)
+    {
+        try
+        {
+            var result = await _service.DeleteAsync(id);
+            if (!result)
+                return NotFound(new {Message = $"Item with {id} not found"});
+
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/backend/Controllers/EntityController.cs b/backend/Controllers/EntityController.cs
index b9483c5..d7fda2f 100644
--- a/backend/Controllers/EntityController.cs
+++ b/backend/Controllers/EntityController.cs
@@ -88,13 +88,12 @@ public async Task<IActionResult> Delete(int id)
     {
         try
         {
-            await _service.DeleteAsync(id);
+            var result = await _service.DeleteAsync(id);
+            if (!result)
+                return NotFound(new {Message = $"Item with ${id} not found"});
+
             return NoContent();
         }
-        catch (ArgumentException ex) when (ex.Message.Contains($"Entity with ID {id} not found."))
-        {
-            return NotFound(new { Message = ex.Message });
-        }
         catch (Exception ex)
         {
             // Log the exception (optional)
diff --git a/backend/Controllers/OrdinaryPersonController.cs b/backend/Controllers/OrdinaryPersonController.cs
new file mode 100644
index 0000000..e0684d6
--- /dev/null
+++ b/backend/Controllers/OrdinaryPersonController.cs
@@ -0,0 +1,108 @@
+using Microsoft.AspNetCore.Mvc;
+using Mappa.Services;
+using Mappa.Dtos;
+using Mappa.Entities;
+using Microsoft.AspNetCore.Authorization;
+
+namespace Mappa.Controllers;
+
+[ApiController]
+[Route("[controller]")]
+public class OrdinaryPersonController : ControllerBase
+{
+    private readonly IComplexEntityService<OrdinaryPerson, OrdinaryPersonGeneralDto, 
+    OrdinaryPersonDetailDto, OrdinaryPersonCreateRequest, OrdinaryPersonUpdateRequest>
+        _service;
+
+    public OrdinaryPersonController(IComplexEntityService<OrdinaryPerson, OrdinaryPersonGeneralDto,
+        OrdinaryPersonDetailDto, OrdinaryPersonCreateRequest, OrdinaryPersonUpdateRequest> service)
+    {
+        _service = service;
+    }
+
+    [HttpGet]
+    public async Task<IActionResult> GetAll()
+    {
+        var items = await _service.GetAllAsync();
+        return Ok(items);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<IActionResult> GetById(int id)
+    {
+        try
+        {
+            var item = await _service.GetByIdAsync(id);
+            return Ok(item);
+        }
+        catch (ArgumentException ex) when (ex.Message.Contains($"Entity with ID {id} not found."))
+        {
+            return NotFound(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpPost]
+    public async Task<IActionResult> Create([FromBody] OrdinaryPersonCreateRequest request)
+    {
+        try
+        {
+            var item = await _service.CreateAsync(request);
+            return CreatedAtAction(nameof(GetById), new { id = item.Id }, item);
+        }
+        catch (ArgumentException ex)
+        {
+            return Conflict(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpPut("{id}")]
+    public async Task<IActionResult> Update(int id, [FromBody] OrdinaryPersonUpdateRequest request)
+    {
+        try
+        {
+            var item = await _service.UpdateAsync(id, request);
+            return Ok(item);
+        }
+        catch (ArgumentException ex)
+        {
+            return NotFound(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpDelete("{id}")]
+    public async Task<IActionResult> Delete(int id)
+    {
+        try
+        {
+            var result = await _service.DeleteAsync(id);
+            if (!result)
+                return NotFound(new {Message = $"Item with {id} not found"});
+
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/backend/Controllers/SecondarySourceController.cs b/backend/Controllers/SecondarySourceController.cs
new file mode 100644
index 0000000..7e0302c
--- /dev/null
+++ b/backend/Controllers/SecondarySourceController.cs
@@ -0,0 +1,107 @@
+using Microsoft.AspNetCore.Mvc;
+using Mappa.Services;
+using Mappa.Dtos;
+using Mappa.Entities;
+using Microsoft.AspNetCore.Authorization;
+
+namespace Mappa.Controllers;
+
+[ApiController]
+[Route("[controller]")]
+public class SecondarySourceController : ControllerBase
+{
+    private readonly IComplexEntityService<SecondarySource, SecondarySourceGeneralDto, SecondarySourceDetailDto, SecondarySourceCreateRequest, SecondarySourceUpdateRequest>
+        _service;
+
+    public SecondarySourceController(IComplexEntityService<SecondarySource, SecondarySourceGeneralDto,
+        SecondarySourceDetailDto, SecondarySourceCreateRequest, SecondarySourceUpdateRequest> service)
+    {
+        _service = service;
+    }
+
+    [HttpGet]
+    public async Task<IActionResult> GetAll()
+    {
+        var items = await _service.GetAllAsync();
+        return Ok(items);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<IActionResult> GetById(int id)
+    {
+        try
+        {
+            var item = await _service.GetByIdAsync(id);
+            return Ok(item);
+        }
+        catch (ArgumentException ex) when (ex.Message.Contains($"Entity with ID {id} not found."))
+        {
+            return NotFound(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpPost]
+    public async Task<IActionResult> Create([FromBody] SecondarySourceCreateRequest request)
+    {
+        try
+        {
+            var item = await _service.CreateAsync(request);
+            return CreatedAtAction(nameof(GetById), new { id = item.Id }, item);
+        }
+        catch (ArgumentException ex) 
+        {
+            return Conflict(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpPut("{id}")]
+    public async Task<IActionResult> Update(int id, [FromBody] SecondarySourceUpdateRequest request)
+    {
+        try
+        {
+            var item = await _service.UpdateAsync(id, request);
+            return Ok(item);
+        }
+        catch (ArgumentException ex)
+        {
+            return NotFound(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpDelete("{id}")]
+    public async Task<IActionResult> Delete(int id)
+    {
+        try
+        {
+            var result = await _service.DeleteAsync(id);
+            if (!result)
+                return NotFound(new {Message = $"Item with {id} not found"});
+
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/backend/Controllers/UnordinaryPersonController.cs b/backend/Controllers/UnordinaryPersonController.cs
new file mode 100644
index 0000000..2d93db8
--- /dev/null
+++ b/backend/Controllers/UnordinaryPersonController.cs
@@ -0,0 +1,107 @@
+using Microsoft.AspNetCore.Mvc;
+using Mappa.Services;
+using Mappa.Dtos;
+using Mappa.Entities;
+using Microsoft.AspNetCore.Authorization;
+
+namespace Mappa.Controllers;
+
+[ApiController]
+[Route("[controller]")]
+public class UnordinaryPersonController : ControllerBase
+{
+    private readonly IComplexEntityService<UnordinaryPerson, UnordinaryPersonGeneralDto, UnordinaryPersonDetailDto, UnordinaryPersonCreateRequest, UnordinaryPersonUpdateRequest>
+        _service;
+
+    public UnordinaryPersonController(IComplexEntityService<UnordinaryPerson, UnordinaryPersonGeneralDto,
+        UnordinaryPersonDetailDto, UnordinaryPersonCreateRequest, UnordinaryPersonUpdateRequest> service)
+    {
+        _service = service;
+    }
+
+    [HttpGet]
+    public async Task<IActionResult> GetAll()
+    {
+        var items = await _service.GetAllAsync();
+        return Ok(items);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<IActionResult> GetById(int id)
+    {
+        try
+        {
+            var item = await _service.GetByIdAsync(id);
+            return Ok(item);
+        }
+        catch (ArgumentException ex) when (ex.Message.Contains($"Entity with ID {id} not found."))
+        {
+            return NotFound(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpPost]
+    public async Task<IActionResult> Create([FromBody] UnordinaryPersonCreateRequest request)
+    {
+        try
+        {
+            var item = await _service.CreateAsync(request);
+            return CreatedAtAction(nameof(GetById), new { id = item.Id }, item);
+        }
+        catch (ArgumentException ex)
+        {
+            return Conflict(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpPut("{id}")]
+    public async Task<IActionResult> Update(int id, [FromBody] UnordinaryPersonUpdateRequest request)
+    {
+        try
+        {
+            var item = await _service.UpdateAsync(id, request);
+            return Ok(item);
+        }
+        catch (ArgumentException ex)
+        {
+            return NotFound(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpDelete("{id}")]
+    public async Task<IActionResult> Delete(int id)
+    {
+        try
+        {
+            var result = await _service.DeleteAsync(id);
+            if (!result)
+                return NotFound(new {Message = $"Item with {id} not found"});
+
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/backend/Controllers/WrittenSourceController.cs b/backend/Controllers/WrittenSourceController.cs
new file mode 100644
index 0000000..18b79ef
--- /dev/null
+++ b/backend/Controllers/WrittenSourceController.cs
@@ -0,0 +1,107 @@
+using Microsoft.AspNetCore.Mvc;
+using Mappa.Services;
+using Mappa.Dtos;
+using Mappa.Entities;
+using Microsoft.AspNetCore.Authorization;
+
+namespace Mappa.Controllers;
+
+[ApiController]
+[Route("[controller]")]
+public class WrittenSourceController : ControllerBase
+{
+    private readonly IComplexEntityService<WrittenSource, WrittenSourceGeneralDto, WrittenSourceDetailDto, WrittenSourceCreateRequest, WrittenSourceUpdateRequest>
+        _service;
+
+    public WrittenSourceController(IComplexEntityService<WrittenSource, WrittenSourceGeneralDto,
+        WrittenSourceDetailDto, WrittenSourceCreateRequest, WrittenSourceUpdateRequest> service)
+    {
+        _service = service;
+    }
+
+    [HttpGet]
+    public async Task<IActionResult> GetAll()
+    {
+        var items = await _service.GetAllAsync();
+        return Ok(items);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<IActionResult> GetById(int id)
+    {
+        try
+        {
+            var item = await _service.GetByIdAsync(id);
+            return Ok(item);
+        }
+        catch (ArgumentException ex) when (ex.Message.Contains($"Entity with ID {id} not found."))
+        {
+            return NotFound(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpPost]
+    public async Task<IActionResult> Create([FromBody] WrittenSourceCreateRequest request)
+    {
+        try
+        {
+            var item = await _service.CreateAsync(request);
+            return CreatedAtAction(nameof(GetById), new { id = item.Id }, item);
+        }
+        catch (ArgumentException ex)
+        {
+            return Conflict(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpPut("{id}")]
+    public async Task<IActionResult> Update(int id, [FromBody] WrittenSourceUpdateRequest request)
+    {
+        try
+        {
+            var item = await _service.UpdateAsync(id, request);
+            return Ok(item);
+        }
+        catch (ArgumentException ex)
+        {
+            return NotFound(new { Message = ex.Message });
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+    [Authorize]
+    [HttpDelete("{id}")]
+    public async Task<IActionResult> Delete(int id)
+    {
+        try
+        {
+            var result = await _service.DeleteAsync(id);
+            if (!result)
+                return NotFound(new {Message = $"Item with {id} not found"});
+
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            // Log the exception (optional)
+            return StatusCode(500, new { Message = "An unexpected error occurred.", Details = ex.Message });
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/backend/Db/AppDbContext.cs b/backend/Db/AppDbContext.cs
index 9ccd823..f6e281a 100644
--- a/backend/Db/AppDbContext.cs
+++ b/backend/Db/AppDbContext.cs
@@ -7,13 +7,14 @@ namespace Mappa.Db;
 
 public class AppDbContext : IdentityDbContext<User>
 {
+    public DbSet<City> Cities { get; set; }
     public DbSet<Ethnicity> Ethnicities { get; set; }
     public DbSet<Gender> Genders { get; set; }
     public DbSet<Genre> Genres { get; set; }
     public DbSet<Language> Languages { get; set; }
     public DbSet<OrdinaryPerson> OrdinaryPersons { get; set; }
     public DbSet<Profession> Professions { get; set; }
-    public DbSet<Relation> Relations { get; set; }
+    // public DbSet<Relation> Relations { get; set; }
     public DbSet<Religion> Religions { get; set; }
     public DbSet<SecondarySource> SecondarySources { get; set; }
     public DbSet<Entities.Type> Types { get; set; }
@@ -35,9 +36,7 @@ protected override void OnModelCreating(ModelBuilder builder)
                 e => e.HasOne<OrdinaryPerson>().WithMany().HasForeignKey(e => e.PersonIdA),
                 e => e.HasOne<OrdinaryPerson>().WithMany().HasForeignKey(e => e.PersonIdB)    
             );
-        builder.Entity<OrdinaryPerson>()
-            .HasMany(e => e.InteractionsWithUnordinary)
-            .WithMany(e => e.InteractionsWithOrdinary);
+            
         builder.Entity<UnordinaryPerson>()
             .HasMany(e => e.InteractionsWithUnordinaryA)
             .WithMany(e => e.InteractionsWithUnordinaryB)
diff --git a/backend/Dockerfile b/backend/Dockerfile
index 00b6a23..1a1eb81 100644
--- a/backend/Dockerfile
+++ b/backend/Dockerfile
@@ -1,14 +1,20 @@
 FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
 WORKDIR /source
 
+ARG DATABASE_CONNECTION_STRING
+# ENV DATABASE_CONNECTION_STRING=${DATABASE_CONNECTION_STRING}
+
 # copy csproj and restore as distinct layers
 COPY *.sln .
 COPY *.csproj ./
 RUN dotnet restore
+# install dotnet ef
+RUN dotnet tool install --version 8.0.11 --create-manifest-if-needed dotnet-ef
 
 # copy everything else and build app
 COPY . ./
 WORKDIR /source/
+RUN dotnet ef database update --connection "$DATABASE_CONNECTION_STRING"
 RUN dotnet publish -c release -o /app
 
 # final stage/image
diff --git a/backend/Dtos/CityDto.cs b/backend/Dtos/CityDto.cs
new file mode 100644
index 0000000..d01d8bc
--- /dev/null
+++ b/backend/Dtos/CityDto.cs
@@ -0,0 +1,37 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Mappa.Dtos;
+
+public class CityBaseDto
+{
+    public int Id { get; set; }
+    public string AsciiName { get; set; }
+}
+
+public class CityGeneralDto : CityBaseDto
+{
+}
+
+public class CityDetailDto : CityGeneralDto
+{
+    public string? GeoNamesId {get; set;}
+    public List<string>? AlternateNames {get; set;}
+    public string? CountryCode {get; set;}
+}
+
+public class CityCreateRequest
+{
+    [Required]
+    public string AsciiName { get; set; }
+    public string? GeoNamesId { get; set; }
+    public List<string>? AlternateNames { get; set; }
+    public string? CountryCode { get; set; }
+}
+
+public class CityUpdateRequest
+{
+    public string? AsciiName { get; set; }
+    public string? GeoNamesId { get; set; }
+    public List<string>? AlternateNames { get; set; }
+    public string? CountryCode { get; set; }
+}
diff --git a/backend/Dtos/OrdinaryPersonDto.cs b/backend/Dtos/OrdinaryPersonDto.cs
new file mode 100644
index 0000000..511fcd2
--- /dev/null
+++ b/backend/Dtos/OrdinaryPersonDto.cs
@@ -0,0 +1,103 @@
+using System.ComponentModel.DataAnnotations;
+using System.Threading.Tasks.Dataflow;
+using Mappa.Entities;
+using Microsoft.OpenApi.Expressions;
+
+namespace Mappa.Dtos;
+
+public class OrdinaryPersonBaseDto
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
+
+public class OrdinaryPersonGeneralDto : OrdinaryPersonBaseDto
+{
+    public ReligionDto? Religion {get; set;}
+    public EthnicityDto? Ethnicity {get; set;}
+    public ProfessionDto? Profession {get; set;}
+    public CityBaseDto? Location {get; set;}
+    public List<WrittenSourceBaseDto>? Sources {get; set;}
+    public GenderDto? Gender {get; set;}
+}
+
+public class OrdinaryPersonDetailDto : OrdinaryPersonGeneralDto
+{
+    public string? AlternateName {get; set;}
+    public List<int>? BirthYear {get; set;}
+    public List<int>? DeathYear {get; set;}
+    public int? ProbableBirthYear {get; set;}
+    public int? ProbableDeathYear {get; set;}
+    public string? Description {get; set;}
+    public List<ReligionDto>? FormerReligion {get; set;}
+    public string? ReligionExplanation{get; set;}
+    public string? ProfessionExplanation{get; set;}
+    public string? InterestingFeature{get; set;}
+    public string? InteractionWithOrdinaryExplanation{get; set;}
+    public string? InteractionWithUnordinaryExplanation{get; set;}
+    public string? Biography{get; set;}
+    public string? DepictionInTheSource{get; set;}
+    public string? ExplanationOfEthnicity{get; set;}
+    public List<OrdinaryPersonBaseDto>? InteractionsWithOrdinaryA{get; set;}
+    public List<UnordinaryPersonBaseDto>? InteractionsWithUnordinary{get; set;}
+    public CityBaseDto? BackgroundCity {get; set;}
+}
+
+public class OrdinaryPersonCreateRequest
+{
+    [Required]
+    public string Name { get; set; }
+    public string? Religion {get; set;}
+    public string? Ethnicity {get; set;}
+    public string? Profession {get; set;}
+    public string? Location {get; set;}
+    public List<int>? Sources {get; set;}
+    public string? Gender {get; set;}
+    public string? AlternateName {get; set;}
+    public List<int>? BirthYear {get; set;}
+    public List<int>? DeathYear {get; set;}
+    public int? ProbableBirthYear {get; set;}
+    public int? ProbableDeathYear {get; set;}
+    public string? Description {get; set;}
+    public List<string>? FormerReligion {get; set;}
+    public string? ReligionExplanation{get; set;}
+    public string? ProfessionExplanation{get; set;}
+    public string? InterestingFeature{get; set;}
+    public string? InteractionWithOrdinaryExplanation{get; set;}
+    public string? InteractionWithUnordinaryExplanation{get; set;}
+    public string? Biography{get; set;}
+    public string? DepictionInTheSource{get; set;}
+    public string? ExplanationOfEthnicity{get; set;}
+    public List<int>? InteractionsWithOrdinaryA{get; set;}
+    public List<int>? InteractionsWithUnordinary{get; set;}
+    public string? BackgroundCity {get; set;}  
+}
+
+public class OrdinaryPersonUpdateRequest
+{
+    public string? Name { get; set; }
+    public string? Religion {get; set;}
+    public string? Ethnicity {get; set;}
+    public string? Profession {get; set;}
+    public string? Location {get; set;}
+    public List<int>? Sources {get; set;}
+    public string? Gender {get; set;}
+    public string? AlternateName {get; set;}
+    public List<int>? BirthYear {get; set;}
+    public List<int>? DeathYear {get; set;}
+    public int? ProbableBirthYear {get; set;}
+    public int? ProbableDeathYear {get; set;}
+    public string? Description {get; set;}
+    public List<string>? FormerReligion {get; set;}
+    public string? ReligionExplanation{get; set;}
+    public string? ProfessionExplanation{get; set;}
+    public string? InterestingFeature{get; set;}
+    public string? InteractionWithOrdinaryExplanation{get; set;}
+    public string? InteractionWithUnordinaryExplanation{get; set;}
+    public string? Biography{get; set;}
+    public string? DepictionInTheSource{get; set;}
+    public string? ExplanationOfEthnicity{get; set;}
+    public List<int>? InteractionsWithOrdinaryA{get; set;}
+    public List<int>? InteractionsWithUnordinary{get; set;}
+    public string? BackgroundCity {get; set;}  
+}
diff --git a/backend/Dtos/SecondarySourceDto.cs b/backend/Dtos/SecondarySourceDto.cs
new file mode 100644
index 0000000..82394f0
--- /dev/null
+++ b/backend/Dtos/SecondarySourceDto.cs
@@ -0,0 +1,60 @@
+using System.ComponentModel.DataAnnotations;
+using System.Threading.Tasks.Dataflow;
+using Mappa.Entities;
+using Microsoft.OpenApi.Expressions;
+
+namespace Mappa.Dtos;
+
+public class SecondarySourceBaseDto
+{
+    public int Id {get; set;}
+    public List<string>? AlternateNames {get; set;}
+    
+}
+
+public class SecondarySourceGeneralDto : SecondarySourceBaseDto
+{
+    public string? Author {get; set;}
+    public int? YearWritten {get; set;}
+    public string? University {get; set;}
+    public TypeDto? Type {get; set;}
+}
+
+public class SecondarySourceDetailDto : SecondarySourceGeneralDto
+{
+    public string? Topic {get; set;}
+    public string? BibliographyInformation {get; set;}
+    public string? OtherInformation {get; set;}
+    public LanguageDto? Language {get; set;}
+    public List<LanguageDto>? TranslatedLanguages {get; set;}
+}
+
+// Field-classes are received as string, but they are stored in the db as classes
+public class SecondarySourceCreateRequest
+{
+    [Required]
+    public List<string>? AlternateNames {get; set;}
+    public string? Author {get; set;}
+    public int? YearWritten {get; set;}
+    public string? University {get; set;}
+    public string? Type {get; set;}
+    public string? Topic {get; set;}
+    public string? BibliographyInformation {get; set;}
+    public string? OtherInformation {get; set;}
+    public string? Language {get; set;}
+    public List<string>? TranslatedLanguages {get; set;}
+}
+
+public class SecondarySourceUpdateRequest
+{
+    public List<string>? AlternateNames {get; set;}
+    public string? Author {get; set;}
+    public int? YearWritten {get; set;}
+    public string? University {get; set;}
+    public string? Type {get; set;}
+    public string? Topic {get; set;}
+    public string? BibliographyInformation {get; set;}
+    public string? OtherInformation {get; set;}
+    public string? Language {get; set;}
+    public List<string>? TranslatedLanguages {get; set;}
+}
diff --git a/backend/Dtos/UnordinaryPersonDto.cs b/backend/Dtos/UnordinaryPersonDto.cs
new file mode 100644
index 0000000..f919b1e
--- /dev/null
+++ b/backend/Dtos/UnordinaryPersonDto.cs
@@ -0,0 +1,81 @@
+using System.ComponentModel.DataAnnotations;
+using Mappa.Entities;
+
+namespace Mappa.Dtos;
+
+public class UnordinaryPersonBaseDto
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
+
+public class UnordinaryPersonGeneralDto : UnordinaryPersonBaseDto
+{
+    public ReligionDto? Religion {get; set;}
+    public EthnicityDto? Ethnicity {get; set;}
+    public List<int>? DeathYear {get; set;}
+    public CityBaseDto? DeathPlace {get; set;}
+    public List<OrdinaryPersonBaseDto>? InteractionsWithOrdinary {get; set;}
+
+}
+
+public class UnordinaryPersonDetailDto : UnordinaryPersonGeneralDto
+{
+    public string? AlternateName {get; set;}
+    public List<int>? BirthYear {get; set;}
+    public int? ProbableBirthYear {get; set;}
+    public int? ProbableDeathYear {get; set;}
+    public string? Description {get; set;}
+    public List<ReligionDto>? FormerReligion {get; set;}
+    public ProfessionDto? Profession {get; set;}
+    public GenderDto? Gender {get; set;}
+    public CityBaseDto? BirthPlace {get; set;}
+    public List<UnordinaryPersonBaseDto>? InteractionsWithUnordinaryA {get; set;}
+    public List<UnordinaryPersonBaseDto>? InteractionsWithUnordinaryB {get; set;}
+    public List<WrittenSourceBaseDto>? Sources {get; set;}
+}
+
+// Simple entities will be denoted by their Names.
+// Complex entities with their ids
+public class UnordinaryPersonCreateRequest
+{
+    [Required]
+    public string Name { get; set; }
+    public string? Religion {get; set;}
+    public string? Ethnicity {get; set;}
+    public List<int>? DeathYear {get; set;}
+    public string? DeathPlace {get; set;}
+    public List<int>? InteractionsWithOrdinary {get; set;}
+    public string? AlternateName {get; set;}
+    public List<int>? BirthYear {get; set;}
+    public int? ProbableBirthYear {get; set;}
+    public int? ProbableDeathYear {get; set;}
+    public string? Description {get; set;}
+    public List<string>? FormerReligion {get; set;}
+    public string? Profession {get; set;}
+    public string? Gender {get; set;}
+    public string? BirthPlace {get; set;}
+    public List<int>? InteractionsWithUnordinaryA {get; set;}
+    public List<int>? Sources {get; set;}
+}
+
+public class UnordinaryPersonUpdateRequest
+{
+    public string? Name { get; set; }
+    public string? Religion {get; set;}
+    public string? Ethnicity {get; set;}
+    public List<int>? DeathYear {get; set;}
+    public string? DeathPlace {get; set;}
+    public List<int>? InteractionsWithOrdinary {get; set;}
+    public string? AlternateName {get; set;}
+    public List<int>? BirthYear {get; set;}
+    public int? ProbableBirthYear {get; set;}
+    public int? ProbableDeathYear {get; set;}
+    public string? Description {get; set;}
+    public List<string>? FormerReligion {get; set;}
+    public string? Profession {get; set;}
+    public string? Gender {get; set;}
+    public string? BirthPlace {get; set;}
+    public List<int>? InteractionsWithUnordinaryA {get; set;}
+    public List<int>? Sources {get; set;}
+}
diff --git a/backend/Dtos/WrittenSourceDto.cs b/backend/Dtos/WrittenSourceDto.cs
new file mode 100644
index 0000000..9551c9b
--- /dev/null
+++ b/backend/Dtos/WrittenSourceDto.cs
@@ -0,0 +1,72 @@
+using System.ComponentModel.DataAnnotations;
+using System.Threading.Tasks.Dataflow;
+using Mappa.Entities;
+using Microsoft.OpenApi.Expressions;
+
+namespace Mappa.Dtos;
+
+public class WrittenSourceBaseDto
+{
+    public int Id {get; set;}
+    public List<string>? AlternateNames {get; set;}
+    
+}
+
+public class WrittenSourceGeneralDto : WrittenSourceBaseDto
+{
+    public string? Author {get; set;}
+    public List<int>? YearWritten {get; set;}
+    public GenreDto? Genre {get; set;}
+    public LanguageDto? Language {get; set;}
+}
+
+public class WrittenSourceDetailDto : WrittenSourceGeneralDto
+{
+    public List<string>? KnownCopies {get; set;}
+    public List<string>? SurvivedCopies {get; set;}
+    public string? LibraryInformation {get; set;}
+    public string? OtherInformation {get; set;}
+    public string? RemarkableWorksOnTheBook {get; set;}
+    public string? Image {get; set;}
+    public List<LanguageDto>? TranslatedLanguages {get; set;}
+    public List<CityBaseDto>? CitiesMentioningTheSources {get; set;}
+    public List<CityBaseDto>? CitiesWhereSourcesAreWritten {get; set;}
+}
+
+public class WrittenSourceCreateRequest
+{
+    [Required]
+    public List<string>? AlternateNames {get; set;}
+    public string? Author {get; set;}
+    public List<int>? YearWritten {get; set;}
+    public string? Genre {get; set;}
+    public string? Language {get; set;}
+    public List<string>? KnownCopies {get; set;}
+    public List<string>? SurvivedCopies {get; set;}
+    public string? LibraryInformation {get; set;}
+    public string? OtherInformation {get; set;}
+    public string? RemarkableWorksOnTheBook {get; set;}
+    public string? Image {get; set;}
+    public List<string>? TranslatedLanguages {get; set;}
+    public List<string>? CitiesMentioningTheSources {get; set;}
+    public List<string>? CitiesWhereSourcesAreWritten {get; set;}
+    
+}
+
+public class WrittenSourceUpdateRequest
+{
+    public List<string>? AlternateNames {get; set;}
+    public string? Author {get; set;}
+    public List<int>? YearWritten {get; set;}
+    public string? Genre {get; set;}
+    public string? Language {get; set;}
+    public List<string>? KnownCopies {get; set;}
+    public List<string>? SurvivedCopies {get; set;}
+    public string? LibraryInformation {get; set;}
+    public string? OtherInformation {get; set;}
+    public string? RemarkableWorksOnTheBook {get; set;}
+    public string? Image {get; set;}
+    public List<string>? TranslatedLanguages {get; set;}
+    public List<string>? CitiesMentioningTheSources {get; set;}
+    public List<string>? CitiesWhereSourcesAreWritten {get; set;}
+}
diff --git a/backend/Entities/City.cs b/backend/Entities/City.cs
new file mode 100644
index 0000000..450311d
--- /dev/null
+++ b/backend/Entities/City.cs
@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.AspNetCore.Identity;
+
+namespace Mappa.Entities;
+
+public class City
+{
+    [Key]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    public int Id {get; set;}
+    [Required]
+    public string AsciiName {get; set;}
+    public string? GeoNamesId {get; set;}
+    public List<string>? AlternateNames {get; set;}
+    public string? CountryCode {get; set;}
+}
\ No newline at end of file
diff --git a/backend/Entities/OrdinaryPerson.cs b/backend/Entities/OrdinaryPerson.cs
index fdaf5f8..34183d0 100644
--- a/backend/Entities/OrdinaryPerson.cs
+++ b/backend/Entities/OrdinaryPerson.cs
@@ -12,13 +12,16 @@ public class OrdinaryPerson : Person
     public string? Biography{get; set;}
     public string? DepictionInTheSource{get; set;}
     public string? ExplanationOfEthnicity{get; set;}
-    public Relation? Relation{get; set;}
+    // public Relation? Relation{get; set;}
     [Required]
-    public List<OrdinaryPerson> InteractionsWithOrdinaryA{get; set;}
+    public List<OrdinaryPerson>? InteractionsWithOrdinaryA{get; set;}
     [Required]
-    public List<OrdinaryPerson> InteractionsWithOrdinaryB{get; set;}
+    public List<OrdinaryPerson>? InteractionsWithOrdinaryB{get; set;}
     [Required]
-    public List<UnordinaryPerson> InteractionsWithUnordinary{get; set;}
+    public List<UnordinaryPerson>? InteractionsWithUnordinary{get; set;}
+    public City? Location {get; set;}
+    public City? BackgroundCity {get; set;}
+    
 }
 
 public class IntraOrdinary
diff --git a/backend/Entities/Person.cs b/backend/Entities/Person.cs
index 5e394da..bacb68f 100644
--- a/backend/Entities/Person.cs
+++ b/backend/Entities/Person.cs
@@ -13,14 +13,15 @@ public abstract class Person
     [Required]
     public string Name {get; set;}
     public string? AlternateName {get; set;}
-    public string? Depiction {get; set;}
-    public DateOnly? BirthYear {get; set;}
-    public DateOnly? DeathYear {get; set;}
+    public List<int>? BirthYear {get; set;}
+    public List<int>? DeathYear {get; set;}
+    public int? ProbableBirthYear {get; set;}
+    public int? ProbableDeathYear {get; set;}
     public string? Description {get; set;}
     public Ethnicity? Ethnicity {get; set;}
     public Religion? Religion {get; set;}
-    public Religion? FormerReligion {get; set;}
+    public List<Religion>? FormerReligion {get; set;}
     public Profession? Profession {get; set;}
     public Gender? Gender {get; set;}
-
+    public List<WrittenSource>? Sources {get; set;}
 }
\ No newline at end of file
diff --git a/backend/Entities/SecondarySource.cs b/backend/Entities/SecondarySource.cs
index d7d982a..8b4b7c0 100644
--- a/backend/Entities/SecondarySource.cs
+++ b/backend/Entities/SecondarySource.cs
@@ -11,19 +11,14 @@ public class SecondarySource
     [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
     public int Id {get; set;}
     [Required]
-    public string[] AlternateNames {get; set;}
+    public List<string>? AlternateNames {get; set;}
     public string? Author {get; set;}
     public string? Topic {get; set;}
-    public DateOnly? YearWritten {get; set;}
+    public int? YearWritten {get; set;}
     public string? University {get; set;}
     public string? BibliographyInformation {get; set;}
     public string? OtherInformation {get; set;}
-    [Required]
-    public Type Type {get; set;}
-    [Required]
-    public Language Language {get; set;}
-    [Required]
-    public List<Language> TranslatedLanguages {get; set;}
-
-
+    public Type? Type {get; set;}
+    public Language? Language {get; set;}
+    public List<Language>? TranslatedLanguages {get; set;}
 }
\ No newline at end of file
diff --git a/backend/Entities/UnordinaryPerson.cs b/backend/Entities/UnordinaryPerson.cs
index ea8a319..a7383e1 100644
--- a/backend/Entities/UnordinaryPerson.cs
+++ b/backend/Entities/UnordinaryPerson.cs
@@ -7,11 +7,14 @@ namespace Mappa.Entities;
 public class UnordinaryPerson : Person
 {
     [Required]
-    public List<OrdinaryPerson> InteractionsWithOrdinary{get; set;}
+    public List<OrdinaryPerson>? InteractionsWithOrdinary{get; set;}
     [Required]
-    public List<UnordinaryPerson> InteractionsWithUnordinaryA{get; set;}
+    public List<UnordinaryPerson>? InteractionsWithUnordinaryA{get; set;}
     [Required]
-    public List<UnordinaryPerson> InteractionsWithUnordinaryB{get; set;}
+    public List<UnordinaryPerson>? InteractionsWithUnordinaryB{get; set;}
+    public City? BirthPlace {get; set;}
+    public City? DeathPlace {get; set;}
+
 }
 
 public class IntraUnordinary
diff --git a/backend/Entities/WrittenSource.cs b/backend/Entities/WrittenSource.cs
index 89f1b51..9e0f46f 100644
--- a/backend/Entities/WrittenSource.cs
+++ b/backend/Entities/WrittenSource.cs
@@ -11,24 +11,19 @@ public class WrittenSource
     [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
     public int Id {get; set;}
     [Required]
-    public string[] AlternateNames {get; set;}
+    public List<string>? AlternateNames {get; set;}
     public string? Author {get; set;}
-    public DateOnly? YearWritten {get; set;}
-    [Required]
-    public string[] KnownCopies {get; set;}
-    [Required]
-    public string[] SurvivedCopies {get; set;}
+    public List<int>? YearWritten {get; set;}
+    public List<string>? KnownCopies {get; set;}
+    public List<string>? SurvivedCopies {get; set;}
     public string? LibraryInformation {get; set;}
     public string? OtherInformation {get; set;}
     public string? RemarkableWorksOnTheBook {get; set;}
     public string? Image {get; set;}
-    public bool Patronage {get; set;}
-    [Required]
-    public Genre Genre {get; set;}
-    [Required]
-    public Language Language {get; set;}
-    [Required]
-    public List<Language> TranslatedLanguages {get; set;}
-
+    public Genre? Genre {get; set;}
+    public Language? Language {get; set;}
+    public List<Language>? TranslatedLanguages {get; set;}
+    public List<City>? CitiesMentioningTheSources {get; set;}
+    public List<City>? CitiesWhereSourcesAreWritten {get; set;}
 
 }
\ No newline at end of file
diff --git a/backend/Helpers/MappingProfile.cs b/backend/Helpers/MappingProfile.cs
new file mode 100644
index 0000000..87b6601
--- /dev/null
+++ b/backend/Helpers/MappingProfile.cs
@@ -0,0 +1,39 @@
+using AutoMapper;
+using Mappa.Entities;
+using Mappa.Dtos;
+using System.Threading.Tasks.Dataflow;
+
+namespace Mappa.Helpers;
+
+public class MappingProfile : Profile
+{
+    public MappingProfile()
+    {
+        CreateMap<City, CityBaseDto>();
+        CreateMap<Ethnicity, EthnicityDto>();
+        CreateMap<Gender, GenderDto>();
+        CreateMap<Genre, GenreDto>();
+        CreateMap<Language, LanguageDto>();
+        CreateMap<OrdinaryPerson, OrdinaryPersonBaseDto>();
+        CreateMap<Profession, ProfessionDto>();
+        CreateMap<Religion, ReligionDto>();
+        CreateMap<SecondarySource, SecondarySourceBaseDto>();
+        CreateMap<Entities.Type, TypeDto>();
+        CreateMap<UnordinaryPerson, UnordinaryPersonBaseDto>();
+        CreateMap<WrittenSource, WrittenSourceBaseDto>();
+        // CreateMap<WrittenSource, WrittenSourceGeneralDto>()
+        //     .ForMember(dest => dest.Genre, opt => opt.MapFrom(src => src.Genre != null ? new GenreDto { Id = src.Genre.Id, Name = src.Genre.Name } : null))
+        //     .ForMember(dest => dest.Language, opt => opt.MapFrom(src => src.Language != null ? new LanguageDto { Id = src.Language.Id, Name = src.Language.Name } : null));
+
+        // CreateMap<WrittenSource, WrittenSourceDetailDto>()
+        //     .ForMember(dest => dest.Genre, opt => opt.MapFrom(src => src.Genre != null ? new GenreDto { Id = src.Genre.Id, Name = src.Genre.Name } : null))
+        //     .ForMember(dest => dest.Language, opt => opt.MapFrom(src => src.Language != null ? new LanguageDto { Id = src.Language.Id, Name = src.Language.Name } : null))
+        //     .ForMember(dest => dest.TranslatedLanguages, opt => opt.MapFrom(src => src.TranslatedLanguages.Select(tl => new LanguageDto { Id = tl.Id, Name = tl.Name }).ToList()))
+        //     .ForMember(dest => dest.CitiesMentioningTheSources, opt => opt.MapFrom(src => src.CitiesMentioningTheSources.Select(cmts => new CityBaseDto { Id = cmts.Id, Name = cmts.Name }).ToList()))
+        //     .ForMember(dest => dest.CitiesWhereSourcesAreWritten, opt => opt.MapFrom(src => src.CitiesWhereSourcesAreWritten.Select(cwsaw => new CityBaseDto { Id = cwsaw.Id, Name = cwsaw.Name }).ToList()));
+
+        // CreateMap<WrittenSourceCreateRequest, WrittenSource>();
+        // CreateMap<WrittenSourceUpdateRequest, WrittenSource>();
+        
+    }
+}
diff --git a/backend/Migrations/20250131180400_SourcesPersonsCity.Designer.cs b/backend/Migrations/20250131180400_SourcesPersonsCity.Designer.cs
new file mode 100644
index 0000000..da59ed6
--- /dev/null
+++ b/backend/Migrations/20250131180400_SourcesPersonsCity.Designer.cs
@@ -0,0 +1,980 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using Mappa.Db;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace mappa.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250131180400_SourcesPersonsCity")]
+    partial class SourcesPersonsCity
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Mappa.Entities.City", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<List<string>>("AlternateNames")
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("AsciiName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("CountryCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GeoNamesId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("WrittenSourceId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("WrittenSourceId1")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WrittenSourceId");
+
+                    b.HasIndex("WrittenSourceId1");
+
+                    b.ToTable("Cities");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Ethnicity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Ethnicities");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Gender", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Genders");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Genre", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Genres");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.IntraOrdinary", b =>
+                {
+                    b.Property<int>("PersonIdA")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PersonIdB")
+                        .HasColumnType("integer");
+
+                    b.HasKey("PersonIdA", "PersonIdB");
+
+                    b.HasIndex("PersonIdB");
+
+                    b.ToTable("IntraOrdinary");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.IntraUnordinary", b =>
+                {
+                    b.Property<int>("PersonIdA")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PersonIdB")
+                        .HasColumnType("integer");
+
+                    b.HasKey("PersonIdA", "PersonIdB");
+
+                    b.HasIndex("PersonIdB");
+
+                    b.ToTable("IntraUnordinary");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Language", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("SecondarySourceId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("WrittenSourceId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SecondarySourceId");
+
+                    b.HasIndex("WrittenSourceId");
+
+                    b.ToTable("Languages");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.OrdinaryPerson", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternateName")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("BackgroundCityId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Biography")
+                        .HasColumnType("text");
+
+                    b.Property<List<int>>("BirthYear")
+                        .HasColumnType("integer[]");
+
+                    b.Property<List<int>>("DeathYear")
+                        .HasColumnType("integer[]");
+
+                    b.Property<string>("DepictionInTheSource")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EthnicityId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ExplanationOfEthnicity")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("GenderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("InteractionWithOrdinaryExplanation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InteractionWithUnordinaryExplanation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InterestingFeature")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProbableBirthYear")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ProbableDeathYear")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProfessionExplanation")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProfessionId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReligionExplanation")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ReligionId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BackgroundCityId");
+
+                    b.HasIndex("EthnicityId");
+
+                    b.HasIndex("GenderId");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("ProfessionId");
+
+                    b.HasIndex("ReligionId");
+
+                    b.ToTable("OrdinaryPersons");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Profession", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Professions");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Religion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("OrdinaryPersonId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("UnordinaryPersonId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrdinaryPersonId");
+
+                    b.HasIndex("UnordinaryPersonId");
+
+                    b.ToTable("Religions");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.SecondarySource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<List<string>>("AlternateNames")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("Author")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BibliographyInformation")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("LanguageId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Topic")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("TypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("University")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly?>("YearWritten")
+                        .HasColumnType("date");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LanguageId");
+
+                    b.HasIndex("TypeId");
+
+                    b.ToTable("SecondarySources");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Type", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Types");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.UnordinaryPerson", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternateName")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("BirthPlaceId")
+                        .HasColumnType("integer");
+
+                    b.Property<List<int>>("BirthYear")
+                        .HasColumnType("integer[]");
+
+                    b.Property<int?>("DeathPlaceId")
+                        .HasColumnType("integer");
+
+                    b.Property<List<int>>("DeathYear")
+                        .HasColumnType("integer[]");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EthnicityId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("GenderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProbableBirthYear")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ProbableDeathYear")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ProfessionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ReligionId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BirthPlaceId");
+
+                    b.HasIndex("DeathPlaceId");
+
+                    b.HasIndex("EthnicityId");
+
+                    b.HasIndex("GenderId");
+
+                    b.HasIndex("ProfessionId");
+
+                    b.HasIndex("ReligionId");
+
+                    b.ToTable("UnordinaryPersons");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.User", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Mappa.Entities.WrittenSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<List<string>>("AlternateNames")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("Author")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("GenreId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Image")
+                        .HasColumnType("text");
+
+                    b.Property<List<string>>("KnownCopies")
+                        .HasColumnType("text[]");
+
+                    b.Property<int?>("LanguageId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("LibraryInformation")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("OrdinaryPersonId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RemarkableWorksOnTheBook")
+                        .HasColumnType("text");
+
+                    b.Property<List<string>>("SurvivedCopies")
+                        .HasColumnType("text[]");
+
+                    b.Property<int?>("UnordinaryPersonId")
+                        .HasColumnType("integer");
+
+                    b.Property<List<int>>("YearWritten")
+                        .HasColumnType("integer[]");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GenreId");
+
+                    b.HasIndex("LanguageId");
+
+                    b.HasIndex("OrdinaryPersonId");
+
+                    b.HasIndex("UnordinaryPersonId");
+
+                    b.ToTable("WrittenSources");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("OrdinaryPersonUnordinaryPerson", b =>
+                {
+                    b.Property<int>("InteractionsWithOrdinaryId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("InteractionsWithUnordinaryId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("InteractionsWithOrdinaryId", "InteractionsWithUnordinaryId");
+
+                    b.HasIndex("InteractionsWithUnordinaryId");
+
+                    b.ToTable("OrdinaryPersonUnordinaryPerson");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.City", b =>
+                {
+                    b.HasOne("Mappa.Entities.WrittenSource", null)
+                        .WithMany("CitiesMentioningTheSources")
+                        .HasForeignKey("WrittenSourceId");
+
+                    b.HasOne("Mappa.Entities.WrittenSource", null)
+                        .WithMany("CitiesWhereSourcesAreWritten")
+                        .HasForeignKey("WrittenSourceId1");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.IntraOrdinary", b =>
+                {
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("PersonIdA")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("PersonIdB")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Mappa.Entities.IntraUnordinary", b =>
+                {
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("PersonIdA")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("PersonIdB")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Language", b =>
+                {
+                    b.HasOne("Mappa.Entities.SecondarySource", null)
+                        .WithMany("TranslatedLanguages")
+                        .HasForeignKey("SecondarySourceId");
+
+                    b.HasOne("Mappa.Entities.WrittenSource", null)
+                        .WithMany("TranslatedLanguages")
+                        .HasForeignKey("WrittenSourceId");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.OrdinaryPerson", b =>
+                {
+                    b.HasOne("Mappa.Entities.City", "BackgroundCity")
+                        .WithMany()
+                        .HasForeignKey("BackgroundCityId");
+
+                    b.HasOne("Mappa.Entities.Ethnicity", "Ethnicity")
+                        .WithMany()
+                        .HasForeignKey("EthnicityId");
+
+                    b.HasOne("Mappa.Entities.Gender", "Gender")
+                        .WithMany()
+                        .HasForeignKey("GenderId");
+
+                    b.HasOne("Mappa.Entities.City", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId");
+
+                    b.HasOne("Mappa.Entities.Profession", "Profession")
+                        .WithMany()
+                        .HasForeignKey("ProfessionId");
+
+                    b.HasOne("Mappa.Entities.Religion", "Religion")
+                        .WithMany()
+                        .HasForeignKey("ReligionId");
+
+                    b.Navigation("BackgroundCity");
+
+                    b.Navigation("Ethnicity");
+
+                    b.Navigation("Gender");
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Profession");
+
+                    b.Navigation("Religion");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Religion", b =>
+                {
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany("FormerReligion")
+                        .HasForeignKey("OrdinaryPersonId");
+
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany("FormerReligion")
+                        .HasForeignKey("UnordinaryPersonId");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.SecondarySource", b =>
+                {
+                    b.HasOne("Mappa.Entities.Language", "Language")
+                        .WithMany()
+                        .HasForeignKey("LanguageId");
+
+                    b.HasOne("Mappa.Entities.Type", "Type")
+                        .WithMany()
+                        .HasForeignKey("TypeId");
+
+                    b.Navigation("Language");
+
+                    b.Navigation("Type");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.UnordinaryPerson", b =>
+                {
+                    b.HasOne("Mappa.Entities.City", "BirthPlace")
+                        .WithMany()
+                        .HasForeignKey("BirthPlaceId");
+
+                    b.HasOne("Mappa.Entities.City", "DeathPlace")
+                        .WithMany()
+                        .HasForeignKey("DeathPlaceId");
+
+                    b.HasOne("Mappa.Entities.Ethnicity", "Ethnicity")
+                        .WithMany()
+                        .HasForeignKey("EthnicityId");
+
+                    b.HasOne("Mappa.Entities.Gender", "Gender")
+                        .WithMany()
+                        .HasForeignKey("GenderId");
+
+                    b.HasOne("Mappa.Entities.Profession", "Profession")
+                        .WithMany()
+                        .HasForeignKey("ProfessionId");
+
+                    b.HasOne("Mappa.Entities.Religion", "Religion")
+                        .WithMany()
+                        .HasForeignKey("ReligionId");
+
+                    b.Navigation("BirthPlace");
+
+                    b.Navigation("DeathPlace");
+
+                    b.Navigation("Ethnicity");
+
+                    b.Navigation("Gender");
+
+                    b.Navigation("Profession");
+
+                    b.Navigation("Religion");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.WrittenSource", b =>
+                {
+                    b.HasOne("Mappa.Entities.Genre", "Genre")
+                        .WithMany()
+                        .HasForeignKey("GenreId");
+
+                    b.HasOne("Mappa.Entities.Language", "Language")
+                        .WithMany()
+                        .HasForeignKey("LanguageId");
+
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany("Sources")
+                        .HasForeignKey("OrdinaryPersonId");
+
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany("Sources")
+                        .HasForeignKey("UnordinaryPersonId");
+
+                    b.Navigation("Genre");
+
+                    b.Navigation("Language");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Mappa.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Mappa.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Mappa.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Mappa.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("OrdinaryPersonUnordinaryPerson", b =>
+                {
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("InteractionsWithOrdinaryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("InteractionsWithUnordinaryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Mappa.Entities.OrdinaryPerson", b =>
+                {
+                    b.Navigation("FormerReligion");
+
+                    b.Navigation("Sources");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.SecondarySource", b =>
+                {
+                    b.Navigation("TranslatedLanguages");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.UnordinaryPerson", b =>
+                {
+                    b.Navigation("FormerReligion");
+
+                    b.Navigation("Sources");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.WrittenSource", b =>
+                {
+                    b.Navigation("CitiesMentioningTheSources");
+
+                    b.Navigation("CitiesWhereSourcesAreWritten");
+
+                    b.Navigation("TranslatedLanguages");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/backend/Migrations/20250131180400_SourcesPersonsCity.cs b/backend/Migrations/20250131180400_SourcesPersonsCity.cs
new file mode 100644
index 0000000..74dc44f
--- /dev/null
+++ b/backend/Migrations/20250131180400_SourcesPersonsCity.cs
@@ -0,0 +1,839 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace mappa.Migrations
+{
+    /// <inheritdoc />
+    public partial class SourcesPersonsCity : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_OrdinaryPersons_Relations_RelationId",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_OrdinaryPersons_Religions_FormerReligionId",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_SecondarySources_Languages_LanguageId",
+                table: "SecondarySources");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_SecondarySources_Types_TypeId",
+                table: "SecondarySources");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_UnordinaryPersons_Religions_FormerReligionId",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_WrittenSources_Genres_GenreId",
+                table: "WrittenSources");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_WrittenSources_Languages_LanguageId",
+                table: "WrittenSources");
+
+            migrationBuilder.DropTable(
+                name: "Relations");
+
+            migrationBuilder.DropIndex(
+                name: "IX_UnordinaryPersons_FormerReligionId",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropIndex(
+                name: "IX_OrdinaryPersons_FormerReligionId",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropIndex(
+                name: "IX_OrdinaryPersons_RelationId",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "Patronage",
+                table: "WrittenSources");
+
+            migrationBuilder.DropColumn(
+                name: "Depiction",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "Depiction",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "YearWritten",
+                table: "WrittenSources");
+
+            migrationBuilder.DropColumn(
+                name: "BirthYear",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "BirthYear",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "DeathYear",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "DeathYear",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.RenameColumn(
+                name: "FormerReligionId",
+                table: "UnordinaryPersons",
+                newName: "ProbableDeathYear");
+
+            migrationBuilder.RenameColumn(
+                name: "RelationId",
+                table: "OrdinaryPersons",
+                newName: "ProbableDeathYear");
+
+            migrationBuilder.RenameColumn(
+                name: "FormerReligionId",
+                table: "OrdinaryPersons",
+                newName: "ProbableBirthYear");
+
+            // migrationBuilder.AlterColumn<List<int>>(
+            //     name: "YearWritten",
+            //     table: "WrittenSources",
+            //     type: "integer[]",
+            //     nullable: true,
+            //     oldClrType: typeof(DateOnly),
+            //     oldType: "date",
+            //     oldNullable: true);
+
+            migrationBuilder.AlterColumn<List<string>>(
+                name: "SurvivedCopies",
+                table: "WrittenSources",
+                type: "text[]",
+                nullable: true,
+                oldClrType: typeof(string[]),
+                oldType: "text[]");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "LanguageId",
+                table: "WrittenSources",
+                type: "integer",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "integer");
+
+            migrationBuilder.AlterColumn<List<string>>(
+                name: "KnownCopies",
+                table: "WrittenSources",
+                type: "text[]",
+                nullable: true,
+                oldClrType: typeof(string[]),
+                oldType: "text[]");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "GenreId",
+                table: "WrittenSources",
+                type: "integer",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "integer");
+
+            migrationBuilder.AddColumn<List<int>>(
+                name: "YearWritten",
+                table: "WrittenSources",
+                type: "integer[]",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "OrdinaryPersonId",
+                table: "WrittenSources",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "UnordinaryPersonId",
+                table: "WrittenSources",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<List<int>>(
+                name: "BirthYear",
+                table: "UnordinaryPersons",
+                type: "integer[]",
+                nullable: true);
+
+            // migrationBuilder.AlterColumn<List<int>>(
+            //     name: "DeathYear",
+            //     table: "UnordinaryPersons",
+            //     type: "integer[]",
+            //     nullable: true,
+            //     oldClrType: typeof(DateOnly),
+            //     oldType: "date",
+            //     oldNullable: true);
+
+            // migrationBuilder.AlterColumn<List<int>>(
+            //     name: "BirthYear",
+            //     table: "UnordinaryPersons",
+            //     type: "integer[]",
+            //     nullable: true,
+            //     oldClrType: typeof(DateOnly),
+            //     oldType: "date",
+            //     oldNullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "BirthPlaceId",
+                table: "UnordinaryPersons",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "DeathPlaceId",
+                table: "UnordinaryPersons",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "ProbableBirthYear",
+                table: "UnordinaryPersons",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "TypeId",
+                table: "SecondarySources",
+                type: "integer",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "integer");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "LanguageId",
+                table: "SecondarySources",
+                type: "integer",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "integer");
+
+            migrationBuilder.AddColumn<int>(
+                name: "OrdinaryPersonId",
+                table: "Religions",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "UnordinaryPersonId",
+                table: "Religions",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<List<int>>(
+                name: "DeathYear",
+                table: "UnordinaryPersons",
+                type: "integer[]",
+                nullable: true);
+
+            migrationBuilder.AddColumn<List<int>>(
+                name: "DeathYear",
+                table: "OrdinaryPersons",
+                type: "integer[]",
+                nullable: true);
+
+            // migrationBuilder.AlterColumn<List<int>>(
+            //     name: "DeathYear",
+            //     table: "OrdinaryPersons",
+            //     type: "integer[]",
+            //     nullable: true,
+            //     oldClrType: typeof(DateOnly),
+            //     oldType: "date",
+            //     oldNullable: true);
+
+            // migrationBuilder.AlterColumn<List<int>>(
+            //     name: "BirthYear",
+            //     table: "OrdinaryPersons",
+            //     type: "integer[]",
+            //     nullable: true,
+            //     oldClrType: typeof(DateOnly),
+            //     oldType: "date",
+            //     oldNullable: true);
+
+            migrationBuilder.AddColumn<List<int>>(
+                name: "BirthYear",
+                table: "OrdinaryPersons",
+                type: "integer[]",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "BackgroundCityId",
+                table: "OrdinaryPersons",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "LocationId",
+                table: "OrdinaryPersons",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "Cities",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    AsciiName = table.Column<string>(type: "text", nullable: false),
+                    GeoNamesId = table.Column<string>(type: "text", nullable: true),
+                    AlternateNames = table.Column<List<string>>(type: "text[]", nullable: true),
+                    CountryCode = table.Column<string>(type: "text", nullable: true),
+                    WrittenSourceId = table.Column<int>(type: "integer", nullable: true),
+                    WrittenSourceId1 = table.Column<int>(type: "integer", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Cities", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Cities_WrittenSources_WrittenSourceId",
+                        column: x => x.WrittenSourceId,
+                        principalTable: "WrittenSources",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_Cities_WrittenSources_WrittenSourceId1",
+                        column: x => x.WrittenSourceId1,
+                        principalTable: "WrittenSources",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_WrittenSources_OrdinaryPersonId",
+                table: "WrittenSources",
+                column: "OrdinaryPersonId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_WrittenSources_UnordinaryPersonId",
+                table: "WrittenSources",
+                column: "UnordinaryPersonId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UnordinaryPersons_BirthPlaceId",
+                table: "UnordinaryPersons",
+                column: "BirthPlaceId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UnordinaryPersons_DeathPlaceId",
+                table: "UnordinaryPersons",
+                column: "DeathPlaceId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Religions_OrdinaryPersonId",
+                table: "Religions",
+                column: "OrdinaryPersonId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Religions_UnordinaryPersonId",
+                table: "Religions",
+                column: "UnordinaryPersonId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_OrdinaryPersons_BackgroundCityId",
+                table: "OrdinaryPersons",
+                column: "BackgroundCityId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_OrdinaryPersons_LocationId",
+                table: "OrdinaryPersons",
+                column: "LocationId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Cities_WrittenSourceId",
+                table: "Cities",
+                column: "WrittenSourceId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Cities_WrittenSourceId1",
+                table: "Cities",
+                column: "WrittenSourceId1");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_OrdinaryPersons_Cities_BackgroundCityId",
+                table: "OrdinaryPersons",
+                column: "BackgroundCityId",
+                principalTable: "Cities",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_OrdinaryPersons_Cities_LocationId",
+                table: "OrdinaryPersons",
+                column: "LocationId",
+                principalTable: "Cities",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Religions_OrdinaryPersons_OrdinaryPersonId",
+                table: "Religions",
+                column: "OrdinaryPersonId",
+                principalTable: "OrdinaryPersons",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Religions_UnordinaryPersons_UnordinaryPersonId",
+                table: "Religions",
+                column: "UnordinaryPersonId",
+                principalTable: "UnordinaryPersons",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_SecondarySources_Languages_LanguageId",
+                table: "SecondarySources",
+                column: "LanguageId",
+                principalTable: "Languages",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_SecondarySources_Types_TypeId",
+                table: "SecondarySources",
+                column: "TypeId",
+                principalTable: "Types",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_UnordinaryPersons_Cities_BirthPlaceId",
+                table: "UnordinaryPersons",
+                column: "BirthPlaceId",
+                principalTable: "Cities",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_UnordinaryPersons_Cities_DeathPlaceId",
+                table: "UnordinaryPersons",
+                column: "DeathPlaceId",
+                principalTable: "Cities",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_WrittenSources_Genres_GenreId",
+                table: "WrittenSources",
+                column: "GenreId",
+                principalTable: "Genres",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_WrittenSources_Languages_LanguageId",
+                table: "WrittenSources",
+                column: "LanguageId",
+                principalTable: "Languages",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_WrittenSources_OrdinaryPersons_OrdinaryPersonId",
+                table: "WrittenSources",
+                column: "OrdinaryPersonId",
+                principalTable: "OrdinaryPersons",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_WrittenSources_UnordinaryPersons_UnordinaryPersonId",
+                table: "WrittenSources",
+                column: "UnordinaryPersonId",
+                principalTable: "UnordinaryPersons",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_OrdinaryPersons_Cities_BackgroundCityId",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_OrdinaryPersons_Cities_LocationId",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Religions_OrdinaryPersons_OrdinaryPersonId",
+                table: "Religions");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Religions_UnordinaryPersons_UnordinaryPersonId",
+                table: "Religions");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_SecondarySources_Languages_LanguageId",
+                table: "SecondarySources");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_SecondarySources_Types_TypeId",
+                table: "SecondarySources");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_UnordinaryPersons_Cities_BirthPlaceId",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_UnordinaryPersons_Cities_DeathPlaceId",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_WrittenSources_Genres_GenreId",
+                table: "WrittenSources");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_WrittenSources_Languages_LanguageId",
+                table: "WrittenSources");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_WrittenSources_OrdinaryPersons_OrdinaryPersonId",
+                table: "WrittenSources");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_WrittenSources_UnordinaryPersons_UnordinaryPersonId",
+                table: "WrittenSources");
+
+            migrationBuilder.DropTable(
+                name: "Cities");
+
+            migrationBuilder.DropIndex(
+                name: "IX_WrittenSources_OrdinaryPersonId",
+                table: "WrittenSources");
+
+            migrationBuilder.DropIndex(
+                name: "IX_WrittenSources_UnordinaryPersonId",
+                table: "WrittenSources");
+
+            migrationBuilder.DropIndex(
+                name: "IX_UnordinaryPersons_BirthPlaceId",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropIndex(
+                name: "IX_UnordinaryPersons_DeathPlaceId",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Religions_OrdinaryPersonId",
+                table: "Religions");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Religions_UnordinaryPersonId",
+                table: "Religions");
+
+            migrationBuilder.DropIndex(
+                name: "IX_OrdinaryPersons_BackgroundCityId",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropIndex(
+                name: "IX_OrdinaryPersons_LocationId",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "OrdinaryPersonId",
+                table: "WrittenSources");
+
+            migrationBuilder.DropColumn(
+                name: "UnordinaryPersonId",
+                table: "WrittenSources");
+
+            migrationBuilder.DropColumn(
+                name: "BirthPlaceId",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "DeathPlaceId",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "ProbableBirthYear",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "OrdinaryPersonId",
+                table: "Religions");
+
+            migrationBuilder.DropColumn(
+                name: "UnordinaryPersonId",
+                table: "Religions");
+
+            migrationBuilder.DropColumn(
+                name: "BackgroundCityId",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "LocationId",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "YearWritten",
+                table: "WrittenSources");
+
+            migrationBuilder.DropColumn(
+                name: "BirthYear",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "BirthYear",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "DeathYear",
+                table: "UnordinaryPersons");
+
+            migrationBuilder.DropColumn(
+                name: "DeathYear",
+                table: "OrdinaryPersons");
+
+            migrationBuilder.RenameColumn(
+                name: "ProbableDeathYear",
+                table: "UnordinaryPersons",
+                newName: "FormerReligionId");
+
+            migrationBuilder.RenameColumn(
+                name: "ProbableDeathYear",
+                table: "OrdinaryPersons",
+                newName: "RelationId");
+
+            migrationBuilder.RenameColumn(
+                name: "ProbableBirthYear",
+                table: "OrdinaryPersons",
+                newName: "FormerReligionId");
+
+            // migrationBuilder.AlterColumn<DateOnly>(
+            //     name: "YearWritten",
+            //     table: "WrittenSources",
+            //     type: "date",
+            //     nullable: true,
+            //     oldClrType: typeof(List<int>),
+            //     oldType: "integer[]",
+            //     oldNullable: true);
+
+            migrationBuilder.AlterColumn<string[]>(
+                name: "SurvivedCopies",
+                table: "WrittenSources",
+                type: "text[]",
+                nullable: false,
+                defaultValue: new string[0],
+                oldClrType: typeof(List<string>),
+                oldType: "text[]",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "LanguageId",
+                table: "WrittenSources",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string[]>(
+                name: "KnownCopies",
+                table: "WrittenSources",
+                type: "text[]",
+                nullable: false,
+                defaultValue: new string[0],
+                oldClrType: typeof(List<string>),
+                oldType: "text[]",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "GenreId",
+                table: "WrittenSources",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            migrationBuilder.AddColumn<List<int>>(
+                name: "YearWritten",
+                table: "WrittenSources",
+                type: "date",
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "Patronage",
+                table: "WrittenSources",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+
+            // migrationBuilder.AlterColumn<DateOnly>(
+            //     name: "DeathYear",
+            //     table: "UnordinaryPersons",
+            //     type: "date",
+            //     nullable: true,
+            //     oldClrType: typeof(List<int>),
+            //     oldType: "integer[]",
+            //     oldNullable: true);
+
+            // migrationBuilder.AlterColumn<DateOnly>(
+            //     name: "BirthYear",
+            //     table: "UnordinaryPersons",
+            //     type: "date",
+            //     nullable: true,
+            //     oldClrType: typeof(List<int>),
+            //     oldType: "integer[]",
+            //     oldNullable: true);
+
+            migrationBuilder.AddColumn<DateOnly>(
+                name: "DeathYear",
+                table: "UnordinaryPersons",
+                type: "date",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateOnly>(
+                name: "DeathYear",
+                table: "OrdinaryPersons",
+                type: "date",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateOnly>(
+                name: "BirthYear",
+                table: "UnordinaryPersons",
+                type: "date",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Depiction",
+                table: "UnordinaryPersons",
+                type: "text",
+                nullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "TypeId",
+                table: "SecondarySources",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "LanguageId",
+                table: "SecondarySources",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            // migrationBuilder.AlterColumn<DateOnly>(
+            //     name: "DeathYear",
+            //     table: "OrdinaryPersons",
+            //     type: "date",
+            //     nullable: true,
+            //     oldClrType: typeof(List<int>),
+            //     oldType: "integer[]",
+            //     oldNullable: true);
+
+            // migrationBuilder.AlterColumn<DateOnly>(
+            //     name: "BirthYear",
+            //     table: "OrdinaryPersons",
+            //     type: "date",
+            //     nullable: true,
+            //     oldClrType: typeof(List<int>),
+            //     oldType: "integer[]",
+            //     oldNullable: true);
+
+            migrationBuilder.AddColumn<DateOnly>(
+                name: "BirthYear",
+                table: "OrdinaryPersons",
+                type: "date",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Depiction",
+                table: "OrdinaryPersons",
+                type: "text",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "Relations",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Name = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Relations", x => x.Id);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UnordinaryPersons_FormerReligionId",
+                table: "UnordinaryPersons",
+                column: "FormerReligionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_OrdinaryPersons_FormerReligionId",
+                table: "OrdinaryPersons",
+                column: "FormerReligionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_OrdinaryPersons_RelationId",
+                table: "OrdinaryPersons",
+                column: "RelationId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_OrdinaryPersons_Relations_RelationId",
+                table: "OrdinaryPersons",
+                column: "RelationId",
+                principalTable: "Relations",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_OrdinaryPersons_Religions_FormerReligionId",
+                table: "OrdinaryPersons",
+                column: "FormerReligionId",
+                principalTable: "Religions",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_SecondarySources_Languages_LanguageId",
+                table: "SecondarySources",
+                column: "LanguageId",
+                principalTable: "Languages",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_SecondarySources_Types_TypeId",
+                table: "SecondarySources",
+                column: "TypeId",
+                principalTable: "Types",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_UnordinaryPersons_Religions_FormerReligionId",
+                table: "UnordinaryPersons",
+                column: "FormerReligionId",
+                principalTable: "Religions",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_WrittenSources_Genres_GenreId",
+                table: "WrittenSources",
+                column: "GenreId",
+                principalTable: "Genres",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_WrittenSources_Languages_LanguageId",
+                table: "WrittenSources",
+                column: "LanguageId",
+                principalTable: "Languages",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}
diff --git a/backend/Migrations/20250207154128_DateToInt.Designer.cs b/backend/Migrations/20250207154128_DateToInt.Designer.cs
new file mode 100644
index 0000000..b42faf5
--- /dev/null
+++ b/backend/Migrations/20250207154128_DateToInt.Designer.cs
@@ -0,0 +1,980 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using Mappa.Db;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace mappa.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250207154128_DateToInt")]
+    partial class DateToInt
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Mappa.Entities.City", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<List<string>>("AlternateNames")
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("AsciiName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("CountryCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GeoNamesId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("WrittenSourceId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("WrittenSourceId1")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WrittenSourceId");
+
+                    b.HasIndex("WrittenSourceId1");
+
+                    b.ToTable("Cities");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Ethnicity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Ethnicities");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Gender", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Genders");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Genre", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Genres");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.IntraOrdinary", b =>
+                {
+                    b.Property<int>("PersonIdA")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PersonIdB")
+                        .HasColumnType("integer");
+
+                    b.HasKey("PersonIdA", "PersonIdB");
+
+                    b.HasIndex("PersonIdB");
+
+                    b.ToTable("IntraOrdinary");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.IntraUnordinary", b =>
+                {
+                    b.Property<int>("PersonIdA")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PersonIdB")
+                        .HasColumnType("integer");
+
+                    b.HasKey("PersonIdA", "PersonIdB");
+
+                    b.HasIndex("PersonIdB");
+
+                    b.ToTable("IntraUnordinary");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Language", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("SecondarySourceId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("WrittenSourceId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SecondarySourceId");
+
+                    b.HasIndex("WrittenSourceId");
+
+                    b.ToTable("Languages");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.OrdinaryPerson", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternateName")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("BackgroundCityId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Biography")
+                        .HasColumnType("text");
+
+                    b.Property<List<int>>("BirthYear")
+                        .HasColumnType("integer[]");
+
+                    b.Property<List<int>>("DeathYear")
+                        .HasColumnType("integer[]");
+
+                    b.Property<string>("DepictionInTheSource")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EthnicityId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ExplanationOfEthnicity")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("GenderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("InteractionWithOrdinaryExplanation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InteractionWithUnordinaryExplanation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InterestingFeature")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProbableBirthYear")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ProbableDeathYear")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProfessionExplanation")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProfessionId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReligionExplanation")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ReligionId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BackgroundCityId");
+
+                    b.HasIndex("EthnicityId");
+
+                    b.HasIndex("GenderId");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("ProfessionId");
+
+                    b.HasIndex("ReligionId");
+
+                    b.ToTable("OrdinaryPersons");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Profession", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Professions");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Religion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("OrdinaryPersonId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("UnordinaryPersonId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrdinaryPersonId");
+
+                    b.HasIndex("UnordinaryPersonId");
+
+                    b.ToTable("Religions");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.SecondarySource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<List<string>>("AlternateNames")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("Author")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BibliographyInformation")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("LanguageId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Topic")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("TypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("University")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("YearWritten")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LanguageId");
+
+                    b.HasIndex("TypeId");
+
+                    b.ToTable("SecondarySources");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Type", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Types");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.UnordinaryPerson", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternateName")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("BirthPlaceId")
+                        .HasColumnType("integer");
+
+                    b.Property<List<int>>("BirthYear")
+                        .HasColumnType("integer[]");
+
+                    b.Property<int?>("DeathPlaceId")
+                        .HasColumnType("integer");
+
+                    b.Property<List<int>>("DeathYear")
+                        .HasColumnType("integer[]");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EthnicityId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("GenderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProbableBirthYear")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ProbableDeathYear")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ProfessionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ReligionId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BirthPlaceId");
+
+                    b.HasIndex("DeathPlaceId");
+
+                    b.HasIndex("EthnicityId");
+
+                    b.HasIndex("GenderId");
+
+                    b.HasIndex("ProfessionId");
+
+                    b.HasIndex("ReligionId");
+
+                    b.ToTable("UnordinaryPersons");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.User", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Mappa.Entities.WrittenSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<List<string>>("AlternateNames")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("Author")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("GenreId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Image")
+                        .HasColumnType("text");
+
+                    b.Property<List<string>>("KnownCopies")
+                        .HasColumnType("text[]");
+
+                    b.Property<int?>("LanguageId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("LibraryInformation")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("OrdinaryPersonId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RemarkableWorksOnTheBook")
+                        .HasColumnType("text");
+
+                    b.Property<List<string>>("SurvivedCopies")
+                        .HasColumnType("text[]");
+
+                    b.Property<int?>("UnordinaryPersonId")
+                        .HasColumnType("integer");
+
+                    b.Property<List<int>>("YearWritten")
+                        .HasColumnType("integer[]");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GenreId");
+
+                    b.HasIndex("LanguageId");
+
+                    b.HasIndex("OrdinaryPersonId");
+
+                    b.HasIndex("UnordinaryPersonId");
+
+                    b.ToTable("WrittenSources");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("OrdinaryPersonUnordinaryPerson", b =>
+                {
+                    b.Property<int>("InteractionsWithOrdinaryId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("InteractionsWithUnordinaryId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("InteractionsWithOrdinaryId", "InteractionsWithUnordinaryId");
+
+                    b.HasIndex("InteractionsWithUnordinaryId");
+
+                    b.ToTable("OrdinaryPersonUnordinaryPerson");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.City", b =>
+                {
+                    b.HasOne("Mappa.Entities.WrittenSource", null)
+                        .WithMany("CitiesMentioningTheSources")
+                        .HasForeignKey("WrittenSourceId");
+
+                    b.HasOne("Mappa.Entities.WrittenSource", null)
+                        .WithMany("CitiesWhereSourcesAreWritten")
+                        .HasForeignKey("WrittenSourceId1");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.IntraOrdinary", b =>
+                {
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("PersonIdA")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("PersonIdB")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Mappa.Entities.IntraUnordinary", b =>
+                {
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("PersonIdA")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("PersonIdB")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Language", b =>
+                {
+                    b.HasOne("Mappa.Entities.SecondarySource", null)
+                        .WithMany("TranslatedLanguages")
+                        .HasForeignKey("SecondarySourceId");
+
+                    b.HasOne("Mappa.Entities.WrittenSource", null)
+                        .WithMany("TranslatedLanguages")
+                        .HasForeignKey("WrittenSourceId");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.OrdinaryPerson", b =>
+                {
+                    b.HasOne("Mappa.Entities.City", "BackgroundCity")
+                        .WithMany()
+                        .HasForeignKey("BackgroundCityId");
+
+                    b.HasOne("Mappa.Entities.Ethnicity", "Ethnicity")
+                        .WithMany()
+                        .HasForeignKey("EthnicityId");
+
+                    b.HasOne("Mappa.Entities.Gender", "Gender")
+                        .WithMany()
+                        .HasForeignKey("GenderId");
+
+                    b.HasOne("Mappa.Entities.City", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId");
+
+                    b.HasOne("Mappa.Entities.Profession", "Profession")
+                        .WithMany()
+                        .HasForeignKey("ProfessionId");
+
+                    b.HasOne("Mappa.Entities.Religion", "Religion")
+                        .WithMany()
+                        .HasForeignKey("ReligionId");
+
+                    b.Navigation("BackgroundCity");
+
+                    b.Navigation("Ethnicity");
+
+                    b.Navigation("Gender");
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Profession");
+
+                    b.Navigation("Religion");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.Religion", b =>
+                {
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany("FormerReligion")
+                        .HasForeignKey("OrdinaryPersonId");
+
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany("FormerReligion")
+                        .HasForeignKey("UnordinaryPersonId");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.SecondarySource", b =>
+                {
+                    b.HasOne("Mappa.Entities.Language", "Language")
+                        .WithMany()
+                        .HasForeignKey("LanguageId");
+
+                    b.HasOne("Mappa.Entities.Type", "Type")
+                        .WithMany()
+                        .HasForeignKey("TypeId");
+
+                    b.Navigation("Language");
+
+                    b.Navigation("Type");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.UnordinaryPerson", b =>
+                {
+                    b.HasOne("Mappa.Entities.City", "BirthPlace")
+                        .WithMany()
+                        .HasForeignKey("BirthPlaceId");
+
+                    b.HasOne("Mappa.Entities.City", "DeathPlace")
+                        .WithMany()
+                        .HasForeignKey("DeathPlaceId");
+
+                    b.HasOne("Mappa.Entities.Ethnicity", "Ethnicity")
+                        .WithMany()
+                        .HasForeignKey("EthnicityId");
+
+                    b.HasOne("Mappa.Entities.Gender", "Gender")
+                        .WithMany()
+                        .HasForeignKey("GenderId");
+
+                    b.HasOne("Mappa.Entities.Profession", "Profession")
+                        .WithMany()
+                        .HasForeignKey("ProfessionId");
+
+                    b.HasOne("Mappa.Entities.Religion", "Religion")
+                        .WithMany()
+                        .HasForeignKey("ReligionId");
+
+                    b.Navigation("BirthPlace");
+
+                    b.Navigation("DeathPlace");
+
+                    b.Navigation("Ethnicity");
+
+                    b.Navigation("Gender");
+
+                    b.Navigation("Profession");
+
+                    b.Navigation("Religion");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.WrittenSource", b =>
+                {
+                    b.HasOne("Mappa.Entities.Genre", "Genre")
+                        .WithMany()
+                        .HasForeignKey("GenreId");
+
+                    b.HasOne("Mappa.Entities.Language", "Language")
+                        .WithMany()
+                        .HasForeignKey("LanguageId");
+
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany("Sources")
+                        .HasForeignKey("OrdinaryPersonId");
+
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany("Sources")
+                        .HasForeignKey("UnordinaryPersonId");
+
+                    b.Navigation("Genre");
+
+                    b.Navigation("Language");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Mappa.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Mappa.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Mappa.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Mappa.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("OrdinaryPersonUnordinaryPerson", b =>
+                {
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("InteractionsWithOrdinaryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany()
+                        .HasForeignKey("InteractionsWithUnordinaryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Mappa.Entities.OrdinaryPerson", b =>
+                {
+                    b.Navigation("FormerReligion");
+
+                    b.Navigation("Sources");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.SecondarySource", b =>
+                {
+                    b.Navigation("TranslatedLanguages");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.UnordinaryPerson", b =>
+                {
+                    b.Navigation("FormerReligion");
+
+                    b.Navigation("Sources");
+                });
+
+            modelBuilder.Entity("Mappa.Entities.WrittenSource", b =>
+                {
+                    b.Navigation("CitiesMentioningTheSources");
+
+                    b.Navigation("CitiesWhereSourcesAreWritten");
+
+                    b.Navigation("TranslatedLanguages");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/backend/Migrations/20250207154128_DateToInt.cs b/backend/Migrations/20250207154128_DateToInt.cs
new file mode 100644
index 0000000..b9e431a
--- /dev/null
+++ b/backend/Migrations/20250207154128_DateToInt.cs
@@ -0,0 +1,39 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace mappa.Migrations
+{
+    /// <inheritdoc />
+    public partial class DateToInt : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "YearWritten",
+                table: "SecondarySources");
+
+            migrationBuilder.AddColumn<int>(
+                name: "YearWritten",
+                table: "SecondarySources",
+                type: "integer",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "YearWritten",
+                table: "SecondarySources");
+
+            migrationBuilder.AddColumn<DateOnly>(
+                name: "YearWritten",
+                table: "SecondarySources",
+                type: "date",
+                nullable: true);
+        }
+    }
+}
diff --git a/backend/Migrations/AppDbContextModelSnapshot.cs b/backend/Migrations/AppDbContextModelSnapshot.cs
index e98e5ef..8f96f2f 100644
--- a/backend/Migrations/AppDbContextModelSnapshot.cs
+++ b/backend/Migrations/AppDbContextModelSnapshot.cs
@@ -1,5 +1,6 @@
 // <auto-generated />
 using System;
+using System.Collections.Generic;
 using Mappa.Db;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
@@ -22,6 +23,42 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
 
+            modelBuilder.Entity("Mappa.Entities.City", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<List<string>>("AlternateNames")
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("AsciiName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("CountryCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GeoNamesId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("WrittenSourceId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("WrittenSourceId1")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WrittenSourceId");
+
+                    b.HasIndex("WrittenSourceId1");
+
+                    b.ToTable("Cities");
+                });
+
             modelBuilder.Entity("Mappa.Entities.Ethnicity", b =>
                 {
                     b.Property<int>("Id")
@@ -141,17 +178,17 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("AlternateName")
                         .HasColumnType("text");
 
+                    b.Property<int?>("BackgroundCityId")
+                        .HasColumnType("integer");
+
                     b.Property<string>("Biography")
                         .HasColumnType("text");
 
-                    b.Property<DateOnly?>("BirthYear")
-                        .HasColumnType("date");
+                    b.Property<List<int>>("BirthYear")
+                        .HasColumnType("integer[]");
 
-                    b.Property<DateOnly?>("DeathYear")
-                        .HasColumnType("date");
-
-                    b.Property<string>("Depiction")
-                        .HasColumnType("text");
+                    b.Property<List<int>>("DeathYear")
+                        .HasColumnType("integer[]");
 
                     b.Property<string>("DepictionInTheSource")
                         .HasColumnType("text");
@@ -165,9 +202,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("ExplanationOfEthnicity")
                         .HasColumnType("text");
 
-                    b.Property<int?>("FormerReligionId")
-                        .HasColumnType("integer");
-
                     b.Property<int?>("GenderId")
                         .HasColumnType("integer");
 
@@ -180,19 +214,25 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("InterestingFeature")
                         .HasColumnType("text");
 
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("integer");
+
                     b.Property<string>("Name")
                         .IsRequired()
                         .HasColumnType("text");
 
+                    b.Property<int?>("ProbableBirthYear")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ProbableDeathYear")
+                        .HasColumnType("integer");
+
                     b.Property<string>("ProfessionExplanation")
                         .HasColumnType("text");
 
                     b.Property<int?>("ProfessionId")
                         .HasColumnType("integer");
 
-                    b.Property<int?>("RelationId")
-                        .HasColumnType("integer");
-
                     b.Property<string>("ReligionExplanation")
                         .HasColumnType("text");
 
@@ -201,15 +241,15 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
-                    b.HasIndex("EthnicityId");
+                    b.HasIndex("BackgroundCityId");
 
-                    b.HasIndex("FormerReligionId");
+                    b.HasIndex("EthnicityId");
 
                     b.HasIndex("GenderId");
 
-                    b.HasIndex("ProfessionId");
+                    b.HasIndex("LocationId");
 
-                    b.HasIndex("RelationId");
+                    b.HasIndex("ProfessionId");
 
                     b.HasIndex("ReligionId");
 
@@ -233,7 +273,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Professions");
                 });
 
-            modelBuilder.Entity("Mappa.Entities.Relation", b =>
+            modelBuilder.Entity("Mappa.Entities.Religion", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
@@ -245,24 +285,17 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired()
                         .HasColumnType("text");
 
-                    b.HasKey("Id");
-
-                    b.ToTable("Relations");
-                });
+                    b.Property<int?>("OrdinaryPersonId")
+                        .HasColumnType("integer");
 
-            modelBuilder.Entity("Mappa.Entities.Religion", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
+                    b.Property<int?>("UnordinaryPersonId")
                         .HasColumnType("integer");
 
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+                    b.HasKey("Id");
 
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
+                    b.HasIndex("OrdinaryPersonId");
 
-                    b.HasKey("Id");
+                    b.HasIndex("UnordinaryPersonId");
 
                     b.ToTable("Religions");
                 });
@@ -275,7 +308,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
 
-                    b.Property<string[]>("AlternateNames")
+                    b.Property<List<string>>("AlternateNames")
                         .IsRequired()
                         .HasColumnType("text[]");
 
@@ -285,7 +318,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("BibliographyInformation")
                         .HasColumnType("text");
 
-                    b.Property<int>("LanguageId")
+                    b.Property<int?>("LanguageId")
                         .HasColumnType("integer");
 
                     b.Property<string>("OtherInformation")
@@ -294,14 +327,14 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("Topic")
                         .HasColumnType("text");
 
-                    b.Property<int>("TypeId")
+                    b.Property<int?>("TypeId")
                         .HasColumnType("integer");
 
                     b.Property<string>("University")
                         .HasColumnType("text");
 
-                    b.Property<DateOnly?>("YearWritten")
-                        .HasColumnType("date");
+                    b.Property<int?>("YearWritten")
+                        .HasColumnType("integer");
 
                     b.HasKey("Id");
 
@@ -340,14 +373,17 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("AlternateName")
                         .HasColumnType("text");
 
-                    b.Property<DateOnly?>("BirthYear")
-                        .HasColumnType("date");
+                    b.Property<int?>("BirthPlaceId")
+                        .HasColumnType("integer");
 
-                    b.Property<DateOnly?>("DeathYear")
-                        .HasColumnType("date");
+                    b.Property<List<int>>("BirthYear")
+                        .HasColumnType("integer[]");
 
-                    b.Property<string>("Depiction")
-                        .HasColumnType("text");
+                    b.Property<int?>("DeathPlaceId")
+                        .HasColumnType("integer");
+
+                    b.Property<List<int>>("DeathYear")
+                        .HasColumnType("integer[]");
 
                     b.Property<string>("Description")
                         .HasColumnType("text");
@@ -355,9 +391,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<int?>("EthnicityId")
                         .HasColumnType("integer");
 
-                    b.Property<int?>("FormerReligionId")
-                        .HasColumnType("integer");
-
                     b.Property<int?>("GenderId")
                         .HasColumnType("integer");
 
@@ -365,6 +398,12 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired()
                         .HasColumnType("text");
 
+                    b.Property<int?>("ProbableBirthYear")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ProbableDeathYear")
+                        .HasColumnType("integer");
+
                     b.Property<int?>("ProfessionId")
                         .HasColumnType("integer");
 
@@ -373,9 +412,11 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
-                    b.HasIndex("EthnicityId");
+                    b.HasIndex("BirthPlaceId");
+
+                    b.HasIndex("DeathPlaceId");
 
-                    b.HasIndex("FormerReligionId");
+                    b.HasIndex("EthnicityId");
 
                     b.HasIndex("GenderId");
 
@@ -458,44 +499,45 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
 
-                    b.Property<string[]>("AlternateNames")
+                    b.Property<List<string>>("AlternateNames")
                         .IsRequired()
                         .HasColumnType("text[]");
 
                     b.Property<string>("Author")
                         .HasColumnType("text");
 
-                    b.Property<int>("GenreId")
+                    b.Property<int?>("GenreId")
                         .HasColumnType("integer");
 
                     b.Property<string>("Image")
                         .HasColumnType("text");
 
-                    b.Property<string[]>("KnownCopies")
-                        .IsRequired()
+                    b.Property<List<string>>("KnownCopies")
                         .HasColumnType("text[]");
 
-                    b.Property<int>("LanguageId")
+                    b.Property<int?>("LanguageId")
                         .HasColumnType("integer");
 
                     b.Property<string>("LibraryInformation")
                         .HasColumnType("text");
 
+                    b.Property<int?>("OrdinaryPersonId")
+                        .HasColumnType("integer");
+
                     b.Property<string>("OtherInformation")
                         .HasColumnType("text");
 
-                    b.Property<bool>("Patronage")
-                        .HasColumnType("boolean");
-
                     b.Property<string>("RemarkableWorksOnTheBook")
                         .HasColumnType("text");
 
-                    b.Property<string[]>("SurvivedCopies")
-                        .IsRequired()
+                    b.Property<List<string>>("SurvivedCopies")
                         .HasColumnType("text[]");
 
-                    b.Property<DateOnly?>("YearWritten")
-                        .HasColumnType("date");
+                    b.Property<int?>("UnordinaryPersonId")
+                        .HasColumnType("integer");
+
+                    b.Property<List<int>>("YearWritten")
+                        .HasColumnType("integer[]");
 
                     b.HasKey("Id");
 
@@ -503,6 +545,10 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("LanguageId");
 
+                    b.HasIndex("OrdinaryPersonId");
+
+                    b.HasIndex("UnordinaryPersonId");
+
                     b.ToTable("WrittenSources");
                 });
 
@@ -653,6 +699,17 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("OrdinaryPersonUnordinaryPerson");
                 });
 
+            modelBuilder.Entity("Mappa.Entities.City", b =>
+                {
+                    b.HasOne("Mappa.Entities.WrittenSource", null)
+                        .WithMany("CitiesMentioningTheSources")
+                        .HasForeignKey("WrittenSourceId");
+
+                    b.HasOne("Mappa.Entities.WrittenSource", null)
+                        .WithMany("CitiesWhereSourcesAreWritten")
+                        .HasForeignKey("WrittenSourceId1");
+                });
+
             modelBuilder.Entity("Mappa.Entities.IntraOrdinary", b =>
                 {
                     b.HasOne("Mappa.Entities.OrdinaryPerson", null)
@@ -696,56 +753,63 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             modelBuilder.Entity("Mappa.Entities.OrdinaryPerson", b =>
                 {
-                    b.HasOne("Mappa.Entities.Ethnicity", "Ethnicity")
+                    b.HasOne("Mappa.Entities.City", "BackgroundCity")
                         .WithMany()
-                        .HasForeignKey("EthnicityId");
+                        .HasForeignKey("BackgroundCityId");
 
-                    b.HasOne("Mappa.Entities.Religion", "FormerReligion")
+                    b.HasOne("Mappa.Entities.Ethnicity", "Ethnicity")
                         .WithMany()
-                        .HasForeignKey("FormerReligionId");
+                        .HasForeignKey("EthnicityId");
 
                     b.HasOne("Mappa.Entities.Gender", "Gender")
                         .WithMany()
                         .HasForeignKey("GenderId");
 
-                    b.HasOne("Mappa.Entities.Profession", "Profession")
+                    b.HasOne("Mappa.Entities.City", "Location")
                         .WithMany()
-                        .HasForeignKey("ProfessionId");
+                        .HasForeignKey("LocationId");
 
-                    b.HasOne("Mappa.Entities.Relation", "Relation")
+                    b.HasOne("Mappa.Entities.Profession", "Profession")
                         .WithMany()
-                        .HasForeignKey("RelationId");
+                        .HasForeignKey("ProfessionId");
 
                     b.HasOne("Mappa.Entities.Religion", "Religion")
                         .WithMany()
                         .HasForeignKey("ReligionId");
 
-                    b.Navigation("Ethnicity");
+                    b.Navigation("BackgroundCity");
 
-                    b.Navigation("FormerReligion");
+                    b.Navigation("Ethnicity");
 
                     b.Navigation("Gender");
 
-                    b.Navigation("Profession");
+                    b.Navigation("Location");
 
-                    b.Navigation("Relation");
+                    b.Navigation("Profession");
 
                     b.Navigation("Religion");
                 });
 
+            modelBuilder.Entity("Mappa.Entities.Religion", b =>
+                {
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany("FormerReligion")
+                        .HasForeignKey("OrdinaryPersonId");
+
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany("FormerReligion")
+                        .HasForeignKey("UnordinaryPersonId");
+                });
+
             modelBuilder.Entity("Mappa.Entities.SecondarySource", b =>
                 {
                     b.HasOne("Mappa.Entities.Language", "Language")
                         .WithMany()
-                        .HasForeignKey("LanguageId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
+                        .HasForeignKey("LanguageId");
 
                     b.HasOne("Mappa.Entities.Type", "Type")
                         .WithMany()
-                        .HasForeignKey("TypeId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
+                        .HasForeignKey("TypeId");
 
                     b.Navigation("Language");
 
@@ -754,13 +818,17 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             modelBuilder.Entity("Mappa.Entities.UnordinaryPerson", b =>
                 {
-                    b.HasOne("Mappa.Entities.Ethnicity", "Ethnicity")
+                    b.HasOne("Mappa.Entities.City", "BirthPlace")
                         .WithMany()
-                        .HasForeignKey("EthnicityId");
+                        .HasForeignKey("BirthPlaceId");
 
-                    b.HasOne("Mappa.Entities.Religion", "FormerReligion")
+                    b.HasOne("Mappa.Entities.City", "DeathPlace")
                         .WithMany()
-                        .HasForeignKey("FormerReligionId");
+                        .HasForeignKey("DeathPlaceId");
+
+                    b.HasOne("Mappa.Entities.Ethnicity", "Ethnicity")
+                        .WithMany()
+                        .HasForeignKey("EthnicityId");
 
                     b.HasOne("Mappa.Entities.Gender", "Gender")
                         .WithMany()
@@ -774,9 +842,11 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .WithMany()
                         .HasForeignKey("ReligionId");
 
-                    b.Navigation("Ethnicity");
+                    b.Navigation("BirthPlace");
 
-                    b.Navigation("FormerReligion");
+                    b.Navigation("DeathPlace");
+
+                    b.Navigation("Ethnicity");
 
                     b.Navigation("Gender");
 
@@ -789,15 +859,19 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                 {
                     b.HasOne("Mappa.Entities.Genre", "Genre")
                         .WithMany()
-                        .HasForeignKey("GenreId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
+                        .HasForeignKey("GenreId");
 
                     b.HasOne("Mappa.Entities.Language", "Language")
                         .WithMany()
-                        .HasForeignKey("LanguageId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
+                        .HasForeignKey("LanguageId");
+
+                    b.HasOne("Mappa.Entities.OrdinaryPerson", null)
+                        .WithMany("Sources")
+                        .HasForeignKey("OrdinaryPersonId");
+
+                    b.HasOne("Mappa.Entities.UnordinaryPerson", null)
+                        .WithMany("Sources")
+                        .HasForeignKey("UnordinaryPersonId");
 
                     b.Navigation("Genre");
 
@@ -870,13 +944,31 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Mappa.Entities.OrdinaryPerson", b =>
+                {
+                    b.Navigation("FormerReligion");
+
+                    b.Navigation("Sources");
+                });
+
             modelBuilder.Entity("Mappa.Entities.SecondarySource", b =>
                 {
                     b.Navigation("TranslatedLanguages");
                 });
 
+            modelBuilder.Entity("Mappa.Entities.UnordinaryPerson", b =>
+                {
+                    b.Navigation("FormerReligion");
+
+                    b.Navigation("Sources");
+                });
+
             modelBuilder.Entity("Mappa.Entities.WrittenSource", b =>
                 {
+                    b.Navigation("CitiesMentioningTheSources");
+
+                    b.Navigation("CitiesWhereSourcesAreWritten");
+
                     b.Navigation("TranslatedLanguages");
                 });
 #pragma warning restore 612, 618
diff --git a/backend/Program.cs b/backend/Program.cs
index 4b57865..8785782 100644
--- a/backend/Program.cs
+++ b/backend/Program.cs
@@ -1,6 +1,7 @@
 using System.Text;
 using Mappa.Db;
 using Mappa.Entities;
+using Mappa.Helpers;
 using Microsoft.AspNetCore.Authentication.JwtBearer;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.EntityFrameworkCore;
@@ -8,6 +9,7 @@
 using Microsoft.OpenApi.Models;
 using Mappa.Services;
 using Mappa.Dtos;
+using Microsoft.IdentityModel.Logging;
 
 var builder = WebApplication.CreateBuilder(args);
 var configuration = builder.Configuration;
@@ -57,7 +59,7 @@
         {
             ValidateIssuer = true,
             ValidateAudience = true,
-            // ValidAudience = audience,
+            ValidAudience = audience,
             ValidIssuer = issuer,
             IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secret)),
             ValidateLifetime = true,
@@ -74,6 +76,11 @@
 builder.Services.AddScoped<IEntityService<Profession, ProfessionDto>, ProfessionService>();
 builder.Services.AddScoped<IEntityService<Religion, ReligionDto>, ReligionService>();
 builder.Services.AddScoped<IEntityService<Mappa.Entities.Type, TypeDto>, TypeService>();
+builder.Services.AddScoped<IComplexEntityService<City, CityGeneralDto, CityDetailDto, CityCreateRequest, CityUpdateRequest>, CityService>();
+builder.Services.AddScoped<IComplexEntityService<WrittenSource, WrittenSourceGeneralDto, WrittenSourceDetailDto, WrittenSourceCreateRequest, WrittenSourceUpdateRequest>, WrittenSourceService>();
+builder.Services.AddScoped<IComplexEntityService<SecondarySource, SecondarySourceGeneralDto, SecondarySourceDetailDto, SecondarySourceCreateRequest, SecondarySourceUpdateRequest>, SecondarySourceService>();
+builder.Services.AddScoped<IComplexEntityService<OrdinaryPerson, OrdinaryPersonGeneralDto, OrdinaryPersonDetailDto, OrdinaryPersonCreateRequest, OrdinaryPersonUpdateRequest>, OrdinaryPersonService>();
+builder.Services.AddScoped<IComplexEntityService<UnordinaryPerson, UnordinaryPersonGeneralDto, UnordinaryPersonDetailDto, UnordinaryPersonCreateRequest, UnordinaryPersonUpdateRequest>, UnordinaryPersonService>();
 
 builder.Services.AddControllers();
 // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
@@ -122,12 +129,15 @@
     });
 });
 
+builder.Services.AddAutoMapper(typeof(MappingProfile));
 
 var app = builder.Build();
 
 // Configure the HTTP request pipeline.
 if (app.Environment.IsDevelopment())
 {
+    IdentityModelEventSource.ShowPII = true;
+    IdentityModelEventSource.LogCompleteSecurityArtifact = true;
     app.UseSwagger();
     app.UseSwaggerUI(c =>
     {
@@ -140,6 +150,10 @@
 {
     var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
     dbContext.Database.EnsureCreated();
+    // if (dbContext.Database.GetPendingMigrations().Any())
+    // {
+    //     dbContext.Database.Migrate();
+    // }
 }
 
 app.UseHttpsRedirection();
diff --git a/backend/Services/AuthenticationService.cs b/backend/Services/AuthenticationService.cs
index f3288c0..0ffed7e 100644
--- a/backend/Services/AuthenticationService.cs
+++ b/backend/Services/AuthenticationService.cs
@@ -77,7 +77,7 @@ private JwtSecurityToken GetToken(IEnumerable<Claim> authClaims)
 
         var token = new JwtSecurityToken(
             issuer: _configuration["JWT:ValidIssuer"],
-            // audience: _configuration["JWT:ValidAudience"],
+            audience: _configuration["JWT:ValidAudience"],
             expires: DateTime.UtcNow.AddHours(Convert.ToDouble(_configuration["JWT:TokenExpirationInHours"])),
             claims: authClaims,
             signingCredentials: new SigningCredentials(authSigningKey, SecurityAlgorithms.HmacSha256));
diff --git a/backend/Services/CityService.cs b/backend/Services/CityService.cs
new file mode 100644
index 0000000..f5d8d12
--- /dev/null
+++ b/backend/Services/CityService.cs
@@ -0,0 +1,126 @@
+using Mappa.Db;
+using Mappa.Dtos;
+using Mappa.Entities;
+using Microsoft.EntityFrameworkCore;
+using AutoMapper;
+using Microsoft.IdentityModel.Tokens;
+using System.ComponentModel.DataAnnotations;
+
+namespace Mappa.Services;
+
+public class CityService : IComplexEntityService<City, 
+    CityGeneralDto, CityDetailDto, 
+    CityCreateRequest, CityUpdateRequest>
+{
+    private readonly AppDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public CityService(AppDbContext dbContext, IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<IEnumerable<CityGeneralDto>> GetAllAsync()
+    {
+        return await _dbContext.Set<City>()
+            .Select(e => new CityGeneralDto
+            {
+                Id = e.Id,
+                AsciiName = e.AsciiName,
+            })
+            .ToListAsync();
+    }
+
+    public async Task<CityDetailDto> GetByIdAsync(int id)
+    {
+        var entity = await _dbContext.Set<City>()
+            .FirstOrDefaultAsync(ws => ws.Id == id);
+        
+        if (entity == null)
+            throw new ArgumentException($"Entity with ID {id} not found.");
+
+        return new CityDetailDto
+        {
+            Id = entity.Id,
+            AsciiName = entity.AsciiName,
+            GeoNamesId = entity.GeoNamesId,
+            AlternateNames = entity.AlternateNames,
+            CountryCode = entity.CountryCode,
+        };
+    }
+
+    public async Task<CityDetailDto> CreateAsync(CityCreateRequest request)
+    {
+        bool exists = await _dbContext.Set<City>().AnyAsync(c => 
+            EF.Property<string>(c, "AsciiName") == request.AsciiName);
+
+        if (exists)
+        {
+            throw new ArgumentException($"An entity with the name '{request.AsciiName}' already exists.");
+        }
+
+        var city = new City
+        {
+            AsciiName = request.AsciiName,
+            GeoNamesId = request.GeoNamesId,
+            AlternateNames = request.AlternateNames,
+            CountryCode = request.CountryCode,
+        };
+        
+        _dbContext.Set<City>().Add(city);
+        await _dbContext.SaveChangesAsync();
+
+        return new CityDetailDto
+        {
+            Id = city.Id,
+            AsciiName = city.AsciiName,
+            GeoNamesId = city.GeoNamesId,
+            AlternateNames = city.AlternateNames,
+            CountryCode = city.CountryCode,
+        };
+    }
+
+    public async Task<CityDetailDto> UpdateAsync(int id, CityUpdateRequest request)
+    {
+        var city = await _dbContext.Set<City>()
+            .FirstOrDefaultAsync(ws => ws.Id == id);
+
+        if (city == null)
+            throw new ArgumentException($"Entity with ID {id} not found.");
+
+        if (request.AsciiName != null)
+            city.AsciiName = request.AsciiName;
+
+        if (request.GeoNamesId != null)
+            city.GeoNamesId = request.GeoNamesId;
+
+        if (request.AlternateNames != null)
+            city.AlternateNames = request.AlternateNames;
+
+        if (request.CountryCode != null)
+            city.CountryCode = request.CountryCode;
+
+        await _dbContext.SaveChangesAsync();
+
+        return new CityDetailDto
+        {
+            Id = city.Id,
+            AsciiName = city.AsciiName,
+            GeoNamesId = city.GeoNamesId,
+            AlternateNames = city.AlternateNames,
+            CountryCode = city.CountryCode,
+        };
+    }
+
+    public async Task<bool> DeleteAsync(int id)
+    {
+        var city = await _dbContext.Set<City>().FindAsync(id);
+        if (city == null)
+            return false;
+
+        _dbContext.Set<City>().Remove(city);
+        await _dbContext.SaveChangesAsync();
+        return true;
+    }
+}
diff --git a/backend/Services/EntityService.cs b/backend/Services/EntityService.cs
index 86cc0c0..e10226a 100644
--- a/backend/Services/EntityService.cs
+++ b/backend/Services/EntityService.cs
@@ -81,13 +81,14 @@ public async Task<TDto> UpdateAsync(int id, UpdateRequest request)
         };
     }
 
-    public async Task DeleteAsync(int id)
+    public async Task<bool> DeleteAsync(int id)
     {
         var entity = await _dbContext.Set<TEntity>().FindAsync(id);
         if (entity == null)
-            throw new ArgumentException($"Entity with ID {id} not found.");
+            return false;
 
         _dbContext.Set<TEntity>().Remove(entity);
         await _dbContext.SaveChangesAsync();
+        return true;
     }
 }
diff --git a/backend/Services/Interfaces/IComplexEntityService.cs b/backend/Services/Interfaces/IComplexEntityService.cs
new file mode 100644
index 0000000..2e9537c
--- /dev/null
+++ b/backend/Services/Interfaces/IComplexEntityService.cs
@@ -0,0 +1,12 @@
+using Mappa.Dtos;
+
+namespace Mappa.Services;
+
+public interface IComplexEntityService<TEntity, TGeneralDto, TDetailDto, TCreateRequest, TUpdateRequest>
+{
+    Task<IEnumerable<TGeneralDto>> GetAllAsync();
+    Task<TDetailDto> GetByIdAsync(int id);
+    Task<TDetailDto> CreateAsync(TCreateRequest request);
+    Task<TDetailDto> UpdateAsync(int id, TUpdateRequest request);
+    Task<bool> DeleteAsync(int id);
+}
diff --git a/backend/Services/Interfaces/IEntityService.cs b/backend/Services/Interfaces/IEntityService.cs
index d356498..4bbc8af 100644
--- a/backend/Services/Interfaces/IEntityService.cs
+++ b/backend/Services/Interfaces/IEntityService.cs
@@ -4,9 +4,9 @@ namespace Mappa.Services;
 
 public interface IEntityService<TEntity, TDto>
 {
-    Task<IEnumerable<TDto>> GetAllAsync();
+    Task<IEnumerable<TDto>>  GetAllAsync();
     Task<TDto> GetByIdAsync(int id);
     Task<TDto> CreateAsync(CreateRequest request);
     Task<TDto> UpdateAsync(int id, UpdateRequest request);
-    Task DeleteAsync(int id);
+    Task<bool> DeleteAsync(int id);
 }
diff --git a/backend/Services/OrdinaryPersonService.cs b/backend/Services/OrdinaryPersonService.cs
new file mode 100644
index 0000000..94c26a6
--- /dev/null
+++ b/backend/Services/OrdinaryPersonService.cs
@@ -0,0 +1,463 @@
+using Mappa.Db;
+using Mappa.Dtos;
+using Mappa.Entities;
+using Microsoft.EntityFrameworkCore;
+using AutoMapper;
+using Microsoft.IdentityModel.Tokens;
+using System.ComponentModel.DataAnnotations;
+
+namespace Mappa.Services;
+
+public class OrdinaryPersonService : IComplexEntityService<OrdinaryPerson, 
+    OrdinaryPersonGeneralDto, OrdinaryPersonDetailDto, 
+    OrdinaryPersonCreateRequest, OrdinaryPersonUpdateRequest>
+{
+    private readonly AppDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public OrdinaryPersonService(AppDbContext dbContext, IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<IEnumerable<OrdinaryPersonGeneralDto>> GetAllAsync()
+    {
+        return await _dbContext.Set<OrdinaryPerson>()
+            .Include(ws => ws.Religion)
+            .Include(ws => ws.Ethnicity)
+            .Include(ws => ws.Profession)
+            .Include(ws => ws.Location)
+            .Include(ws => ws.Sources)
+            .Include(ws => ws.Gender)
+            .Select(e => new OrdinaryPersonGeneralDto
+            {
+                Id = e.Id,
+                Name = e.Name,
+                Religion = _mapper.Map<ReligionDto>(e.Religion),
+                Ethnicity = _mapper.Map<EthnicityDto>(e.Ethnicity),
+                Profession = _mapper.Map<ProfessionDto>(e.Profession),
+                Location = _mapper.Map<CityBaseDto>(e.Location),
+                Sources = _mapper.Map<List<WrittenSourceBaseDto>>(e.Sources),
+                Gender = _mapper.Map<GenderDto>(e.Gender),
+            })
+            .ToListAsync();
+    }
+
+    public async Task<OrdinaryPersonDetailDto> GetByIdAsync(int id)
+    {
+        var entity = await _dbContext.Set<OrdinaryPerson>()
+            .Include(ws => ws.Religion)
+            .Include(ws => ws.Ethnicity)
+            .Include(ws => ws.Profession)
+            .Include(ws => ws.Location)
+            .Include(ws => ws.Sources)
+            .Include(ws => ws.Gender)
+            .Include(ws => ws.FormerReligion)
+            .Include(ws => ws.InteractionsWithOrdinaryA)
+            .Include(ws => ws.InteractionsWithUnordinary)
+            .Include(ws => ws.Sources)
+            .FirstOrDefaultAsync(ws => ws.Id == id);
+        
+        if (entity == null)
+            throw new ArgumentException($"Entity with ID {id} not found.");
+
+        return new OrdinaryPersonDetailDto
+        {
+            
+            Id = entity.Id,
+            Name = entity.Name,
+            Religion = _mapper.Map<ReligionDto>(entity.Religion),
+            Ethnicity = _mapper.Map<EthnicityDto>(entity.Ethnicity),
+            Profession = _mapper.Map<ProfessionDto>(entity.Profession),
+            Location = _mapper.Map<CityBaseDto>(entity.Location),
+            Sources = _mapper.Map<List<WrittenSourceBaseDto>>(entity.Sources),
+            Gender = _mapper.Map<GenderDto>(entity.Gender),
+            AlternateName = entity.AlternateName,
+            BirthYear = entity.BirthYear,
+            DeathYear = entity.DeathYear,
+            ProbableBirthYear = entity.ProbableBirthYear,
+            ProbableDeathYear = entity.ProbableDeathYear,
+            Description = entity.Description,
+            FormerReligion = _mapper.Map<List<ReligionDto>>(entity.FormerReligion),
+            ReligionExplanation = entity.ReligionExplanation,
+            ProfessionExplanation = entity.ProfessionExplanation,
+            InterestingFeature = entity.InterestingFeature,
+            InteractionWithOrdinaryExplanation = entity.InteractionWithOrdinaryExplanation,
+            InteractionWithUnordinaryExplanation = entity.InteractionWithUnordinaryExplanation,
+            Biography = entity.Biography,
+            DepictionInTheSource = entity.DepictionInTheSource,
+            ExplanationOfEthnicity = entity.ExplanationOfEthnicity,
+            InteractionsWithOrdinaryA = _mapper.Map<List<OrdinaryPersonBaseDto>>(entity.InteractionsWithOrdinaryA),
+            InteractionsWithUnordinary = _mapper.Map<List<UnordinaryPersonBaseDto>>(entity.InteractionsWithUnordinary),
+            BackgroundCity = _mapper.Map<CityBaseDto>(entity.BackgroundCity),
+        };
+    }
+
+    public async Task<OrdinaryPersonDetailDto> CreateAsync(OrdinaryPersonCreateRequest request)
+    {
+        var ordinaryPerson = new OrdinaryPerson
+        {
+            Name = request.Name,
+            AlternateName = request.AlternateName,
+            BirthYear = request.BirthYear,
+            DeathYear = request.DeathYear,
+            ProbableBirthYear = request.ProbableBirthYear,
+            ProbableDeathYear = request.ProbableDeathYear,
+            Description = request.Description,
+            ReligionExplanation = request.ReligionExplanation,
+            ProfessionExplanation = request.ProfessionExplanation,
+            InterestingFeature = request.InterestingFeature,
+            InteractionWithOrdinaryExplanation = request.InteractionWithOrdinaryExplanation,
+            InteractionWithUnordinaryExplanation = request.InteractionWithUnordinaryExplanation,
+            Biography = request.Biography,
+            DepictionInTheSource = request.DepictionInTheSource,
+            ExplanationOfEthnicity = request.ExplanationOfEthnicity,
+        };
+
+        // Check if Religion exists
+        if(request.Religion != null)
+        {
+            var religion = await _dbContext.Set<Religion>().FirstOrDefaultAsync(e => e.Name == request.Religion);
+            if (religion == null)
+                throw new ArgumentException($"Religion with name {request.Religion} not found.");
+            ordinaryPerson.Religion = religion;
+        }
+
+        // Check if Ethnicity exists
+        if(request.Ethnicity != null)
+        {
+            var ethnicity = await _dbContext.Set<Ethnicity>().FirstOrDefaultAsync(e => e.Name == request.Ethnicity);
+            if (ethnicity == null)
+                throw new ArgumentException($"Ethnicity with name {request.Ethnicity} not found.");
+            ordinaryPerson.Ethnicity = ethnicity;
+        }
+
+        // Check if Profession exists
+        if(request.Profession != null)
+        {
+            var profession = await _dbContext.Set<Profession>().FirstOrDefaultAsync(e => e.Name == request.Profession);
+            if (profession == null)
+                throw new ArgumentException($"Profession with name {request.Profession} not found.");
+            ordinaryPerson.Profession = profession;
+        }
+
+        // Check if Location exists
+        if(request.Location != null)
+        {
+            var location = await _dbContext.Set<City>().FirstOrDefaultAsync(e => e.AsciiName == request.Location);
+            if (location == null)
+                throw new ArgumentException($"Location with name {request.Location} not found.");
+            ordinaryPerson.Location = location;
+        }
+
+        // Check if Sources elements exists
+        if (request.Sources != null)
+        {
+            var sources = await _dbContext.Set<WrittenSource>()
+                .Where(c => request.Sources.Contains(c.Id))
+                .ToListAsync();
+
+            if (sources.Count != request.Sources.Count)
+                throw new ArgumentException("One or more provided Sources are invalid.");
+            ordinaryPerson.Sources = sources;
+        }
+
+        // Check if Gender exists
+        if(request.Gender != null)
+        {
+            var gender = await _dbContext.Set<Gender>().FirstOrDefaultAsync(e => e.Name == request.Gender);
+            if (gender == null)
+                throw new ArgumentException($"Gender with name {request.Gender} not found.");
+            ordinaryPerson.Gender = gender;
+        }
+
+        // Check if FormerReligion elements exists
+        if (request.FormerReligion != null)
+        {
+            var formerReligion = await _dbContext.Set<Religion>()
+                .Where(c => request.FormerReligion.Contains(c.Name))
+                .ToListAsync();
+
+            if (formerReligion.Count != request.FormerReligion.Count)
+                throw new ArgumentException("One or more provided Formerreligion are invalid.");
+            ordinaryPerson.FormerReligion = formerReligion;
+        }
+
+        // Check if InteractionsWithOrdinaryA elements exists
+        if (request.InteractionsWithOrdinaryA != null)
+        {
+            var interactionsWithOrdinaryA = await _dbContext.Set<OrdinaryPerson>()
+                .Where(c => request.InteractionsWithOrdinaryA.Contains(c.Id))
+                .ToListAsync();
+
+            if (interactionsWithOrdinaryA.Count != request.InteractionsWithOrdinaryA.Count)
+                throw new ArgumentException("One or more provided InteractionsWithOrdinaryA are invalid.");
+            ordinaryPerson.InteractionsWithOrdinaryA = interactionsWithOrdinaryA;
+        }
+
+        // Check if InteractionsWithUnordinary elements exists
+        if (request.InteractionsWithUnordinary != null)
+        {
+            var interactionsWithUnordinary = await _dbContext.Set<UnordinaryPerson>()
+                .Where(c => request.InteractionsWithUnordinary.Contains(c.Id))
+                .ToListAsync();
+
+            if (interactionsWithUnordinary.Count != request.InteractionsWithUnordinary.Count)
+                throw new ArgumentException("One or more provided InteractionsWithUnordinary are invalid.");
+            ordinaryPerson.InteractionsWithUnordinary = interactionsWithUnordinary;
+        }
+
+        // Check if BackgroundCity exists
+        if(request.BackgroundCity != null)
+        {
+            var backgroundCity = await _dbContext.Set<City>().FirstOrDefaultAsync(e => e.AsciiName == request.BackgroundCity);
+            if (backgroundCity == null)
+                throw new ArgumentException($"BackgroundCity with name {request.BackgroundCity} not found.");
+            ordinaryPerson.BackgroundCity = backgroundCity;
+        }
+        
+        _dbContext.Set<OrdinaryPerson>().Add(ordinaryPerson);
+        await _dbContext.SaveChangesAsync();
+
+        return new OrdinaryPersonDetailDto
+        {
+            Name = ordinaryPerson.Name,
+            Religion = _mapper.Map<ReligionDto>(ordinaryPerson.Religion),
+            Ethnicity = _mapper.Map<EthnicityDto>(ordinaryPerson.Ethnicity),
+            Profession = _mapper.Map<ProfessionDto>(ordinaryPerson.Profession),
+            Location = _mapper.Map<CityBaseDto>(ordinaryPerson.Location),
+            Sources = _mapper.Map<List<WrittenSourceBaseDto>>(ordinaryPerson.Sources),
+            Gender = _mapper.Map<GenderDto>(ordinaryPerson.Gender),
+            AlternateName = ordinaryPerson.AlternateName,
+            BirthYear = ordinaryPerson.BirthYear,
+            DeathYear = ordinaryPerson.DeathYear,
+            ProbableBirthYear = ordinaryPerson.ProbableBirthYear,
+            ProbableDeathYear = ordinaryPerson.ProbableDeathYear,
+            Description = ordinaryPerson.Description,
+            FormerReligion = _mapper.Map<List<ReligionDto>>(ordinaryPerson.FormerReligion),
+            ReligionExplanation = ordinaryPerson.ReligionExplanation,
+            ProfessionExplanation = ordinaryPerson.ProfessionExplanation,
+            InterestingFeature = ordinaryPerson.InterestingFeature,
+            InteractionWithOrdinaryExplanation = ordinaryPerson.InteractionWithOrdinaryExplanation,
+            InteractionWithUnordinaryExplanation = ordinaryPerson.InteractionWithUnordinaryExplanation,
+            Biography = ordinaryPerson.Biography,
+            DepictionInTheSource = ordinaryPerson.DepictionInTheSource,
+            ExplanationOfEthnicity = ordinaryPerson.ExplanationOfEthnicity,
+            InteractionsWithOrdinaryA = _mapper.Map<List<OrdinaryPersonBaseDto>>(ordinaryPerson.InteractionsWithOrdinaryA),
+            InteractionsWithUnordinary = _mapper.Map<List<UnordinaryPersonBaseDto>>(ordinaryPerson.InteractionsWithUnordinary),
+            BackgroundCity = _mapper.Map<CityBaseDto>(ordinaryPerson.BackgroundCity),
+        };
+    }
+
+    public async Task<OrdinaryPersonDetailDto> UpdateAsync(int id, OrdinaryPersonUpdateRequest request)
+    {
+        var ordinaryPerson = await _dbContext.Set<OrdinaryPerson>()
+            .Include(ws => ws.Religion)
+            .Include(ws => ws.Ethnicity)
+            .Include(ws => ws.Profession)
+            .Include(ws => ws.Location)
+            .Include(ws => ws.Sources)
+            .Include(ws => ws.Gender)
+            .Include(ws => ws.FormerReligion)
+            .Include(ws => ws.InteractionsWithOrdinaryA)
+            .Include(ws => ws.InteractionsWithUnordinary)
+            .Include(ws => ws.Sources)
+            .FirstOrDefaultAsync(ws => ws.Id == id);
+
+        if (ordinaryPerson == null)
+            throw new ArgumentException($"Entity with ID {id} not found.");
+
+        // Religion update only if a valid religion name is provided
+        if (request.Religion != null)
+        {
+            var religion = await _dbContext.Set<Religion>().FirstOrDefaultAsync(e => e.Name == request.Religion);
+            if (religion == null)
+                throw new ArgumentException($"Religion with name {request.Religion} not found.");
+            ordinaryPerson.Religion = religion;
+        }
+
+        // Ethnicity update only if a valid ethnicity name is provided
+        if (request.Ethnicity != null)
+        {
+            var ethnicity = await _dbContext.Set<Ethnicity>().FirstOrDefaultAsync(e => e.Name == request.Ethnicity);
+            if (ethnicity == null)
+                throw new ArgumentException($"Ethnicity with name {request.Ethnicity} not found.");
+            ordinaryPerson.Ethnicity = ethnicity;
+        }
+
+        // Profession update only if a valid profession name is provided
+        if (request.Profession != null)
+        {
+            var profession = await _dbContext.Set<Profession>().FirstOrDefaultAsync(e => e.Name == request.Profession);
+            if (profession == null)
+                throw new ArgumentException($"Profession with name {request.Profession} not found.");
+            ordinaryPerson.Profession = profession;
+        }
+
+        // Location update only if a valid city is provided
+        if (request.Location != null)
+        {
+            var location = await _dbContext.Set<City>().FirstOrDefaultAsync(e => e.AsciiName == request.Location);
+            if (location == null)
+                throw new ArgumentException($"Location with name {request.Location} not found.");
+            ordinaryPerson.Location = location;
+        }
+
+        // Update Sources 
+        if (request.Sources != null)
+        {
+            var sources = await _dbContext.Set<WrittenSource>()
+                .Where(l => request.Sources.Contains(l.Id))
+                .ToListAsync();
+
+            if (sources.Count != request.Sources.Count)
+                throw new ArgumentException("One or more provided Written Source are invalid.");
+
+            ordinaryPerson.Sources = sources;
+        }
+
+        // Gender update only if a valid gender name is provided
+        if (request.Gender != null)
+        {
+            var gender = await _dbContext.Set<Gender>().FirstOrDefaultAsync(e => e.Name == request.Gender);
+            if (gender == null)
+                throw new ArgumentException($"Gender with name {request.Gender} not found.");
+            ordinaryPerson.Gender = gender;
+        }
+
+        if (request.AlternateName != null)
+            ordinaryPerson.AlternateName = request.AlternateName;
+
+        if ((request.BirthYear!= null) && (request.BirthYear.Count > 0))
+            ordinaryPerson.BirthYear = request.BirthYear;
+
+        // Only update fields if they are not null
+        if ((request.DeathYear != null) && (request.DeathYear.Count > 0))
+            ordinaryPerson.DeathYear = request.DeathYear;
+
+        // Only update fields if they are provided in the request
+        if (request.ProbableBirthYear != null)
+            ordinaryPerson.ProbableBirthYear = request.ProbableBirthYear;
+
+        if (request.ProbableDeathYear != null)
+            ordinaryPerson.ProbableDeathYear = request.ProbableDeathYear;
+
+        if (request.Description != null)
+            ordinaryPerson.Description = request.Description;
+
+        // Update FormerReligion 
+        if (request.FormerReligion != null)
+        {
+            var formerReligion = await _dbContext.Set<Religion>()
+                .Where(l => request.FormerReligion.Contains(l.Name))
+                .ToListAsync();
+
+            if (formerReligion.Count != request.FormerReligion.Count)
+                throw new ArgumentException("One or more provided Former Religion are invalid.");
+
+            ordinaryPerson.FormerReligion = formerReligion;
+        }
+
+        if (request.ReligionExplanation != null)
+            ordinaryPerson.ReligionExplanation = request.ReligionExplanation;
+
+        if (request.ProfessionExplanation != null)
+            ordinaryPerson.ProfessionExplanation = request.ProfessionExplanation;
+
+        if (request.InterestingFeature != null)
+            ordinaryPerson.InterestingFeature = request.InterestingFeature;
+
+        if (request.InteractionWithOrdinaryExplanation != null)
+            ordinaryPerson.InteractionWithOrdinaryExplanation = request.InteractionWithOrdinaryExplanation;
+
+        if (request.InteractionWithUnordinaryExplanation != null)
+            ordinaryPerson.InteractionWithUnordinaryExplanation = request.InteractionWithUnordinaryExplanation;
+
+        if (request.Biography != null)
+            ordinaryPerson.Biography = request.Biography;
+
+        if (request.DepictionInTheSource != null)
+            ordinaryPerson.DepictionInTheSource = request.DepictionInTheSource;
+
+        if (request.ExplanationOfEthnicity != null)
+            ordinaryPerson.ExplanationOfEthnicity = request.ExplanationOfEthnicity;
+
+        // Update InteractionsWithOrdinaryA 
+        if (request.InteractionsWithOrdinaryA != null)
+        {
+            var InteractionsWithOrdinaryA = await _dbContext.Set<OrdinaryPerson>()
+                .Where(l => request.InteractionsWithOrdinaryA.Contains(l.Id))
+                .ToListAsync();
+
+            if (InteractionsWithOrdinaryA.Count != request.InteractionsWithOrdinaryA.Count)
+                throw new ArgumentException("One or more provided Ordinary Person are invalid.");
+
+            ordinaryPerson.InteractionsWithOrdinaryA = InteractionsWithOrdinaryA;
+        }
+
+        // Update InteractionsWithUnordinary 
+        if (request.InteractionsWithUnordinary != null)
+        {
+            var InteractionsWithUnordinary = await _dbContext.Set<UnordinaryPerson>()
+                .Where(l => request.InteractionsWithUnordinary.Contains(l.Id))
+                .ToListAsync();
+
+            if (InteractionsWithUnordinary.Count != request.InteractionsWithUnordinary.Count)
+                throw new ArgumentException("One or more provided Unordinary Person are invalid.");
+
+            ordinaryPerson.InteractionsWithUnordinary = InteractionsWithUnordinary;
+        }
+
+        // BackgroundCity update only if a valid ID is provided
+        if (request.BackgroundCity != null)
+        {
+            var backgroundCity = await _dbContext.Set<City>().FirstOrDefaultAsync(e => e.AsciiName == request.BackgroundCity);
+            if (backgroundCity == null)
+                throw new ArgumentException($"BackgroundCity with name {request.BackgroundCity} not found.");
+            ordinaryPerson.BackgroundCity = backgroundCity;
+        }
+
+        await _dbContext.SaveChangesAsync();
+
+        return new OrdinaryPersonDetailDto
+        {
+            Name = ordinaryPerson.Name,
+            Religion = _mapper.Map<ReligionDto>(ordinaryPerson.Religion),
+            Ethnicity = _mapper.Map<EthnicityDto>(ordinaryPerson.Ethnicity),
+            Profession = _mapper.Map<ProfessionDto>(ordinaryPerson.Profession),
+            Location = _mapper.Map<CityBaseDto>(ordinaryPerson.Location),
+            Sources = _mapper.Map<List<WrittenSourceBaseDto>>(ordinaryPerson.Sources),
+            Gender = _mapper.Map<GenderDto>(ordinaryPerson.Gender),
+            AlternateName = ordinaryPerson.AlternateName,
+            BirthYear = ordinaryPerson.BirthYear,
+            DeathYear = ordinaryPerson.DeathYear,
+            ProbableBirthYear = ordinaryPerson.ProbableBirthYear,
+            ProbableDeathYear = ordinaryPerson.ProbableDeathYear,
+            Description = ordinaryPerson.Description,
+            FormerReligion = _mapper.Map<List<ReligionDto>>(ordinaryPerson.FormerReligion),
+            ReligionExplanation = ordinaryPerson.ReligionExplanation,
+            ProfessionExplanation = ordinaryPerson.ProfessionExplanation,
+            InterestingFeature = ordinaryPerson.InterestingFeature,
+            InteractionWithOrdinaryExplanation = ordinaryPerson.InteractionWithOrdinaryExplanation,
+            InteractionWithUnordinaryExplanation = ordinaryPerson.InteractionWithUnordinaryExplanation,
+            Biography = ordinaryPerson.Biography,
+            DepictionInTheSource = ordinaryPerson.DepictionInTheSource,
+            ExplanationOfEthnicity = ordinaryPerson.ExplanationOfEthnicity,
+            InteractionsWithOrdinaryA = _mapper.Map<List<OrdinaryPersonBaseDto>>(ordinaryPerson.InteractionsWithOrdinaryA),
+            InteractionsWithUnordinary = _mapper.Map<List<UnordinaryPersonBaseDto>>(ordinaryPerson.InteractionsWithUnordinary),
+            BackgroundCity = _mapper.Map<CityBaseDto>(ordinaryPerson.BackgroundCity),
+        };
+    }
+
+    public async Task<bool> DeleteAsync(int id)
+    {
+        var ordinaryPerson = await _dbContext.Set<OrdinaryPerson>().FindAsync(id);
+        if (ordinaryPerson == null)
+            return false;
+
+        _dbContext.Set<OrdinaryPerson>().Remove(ordinaryPerson);
+        await _dbContext.SaveChangesAsync();
+        return true;
+    }
+}
diff --git a/backend/Services/SecondarySourceService.cs b/backend/Services/SecondarySourceService.cs
new file mode 100644
index 0000000..090179f
--- /dev/null
+++ b/backend/Services/SecondarySourceService.cs
@@ -0,0 +1,230 @@
+using Mappa.Db;
+using Mappa.Dtos;
+using Mappa.Entities;
+using Microsoft.EntityFrameworkCore;
+using AutoMapper;
+using Microsoft.IdentityModel.Tokens;
+
+namespace Mappa.Services;
+
+public class SecondarySourceService : IComplexEntityService<SecondarySource, SecondarySourceGeneralDto, SecondarySourceDetailDto, SecondarySourceCreateRequest, 
+    SecondarySourceUpdateRequest>
+{
+    private readonly AppDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public SecondarySourceService(AppDbContext dbContext, IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<IEnumerable<SecondarySourceGeneralDto>> GetAllAsync()
+    {
+        return await _dbContext.Set<SecondarySource>()
+            .Include(ss => ss.Type )
+            .Select(e => new SecondarySourceGeneralDto
+            {
+                Id = e.Id,
+                AlternateNames = e.AlternateNames,
+                Author = e.Author,
+                YearWritten = e.YearWritten,
+                University = e.University,
+                Type = _mapper.Map<TypeDto>(e.Type)
+            })
+            .ToListAsync();
+    }
+
+    public async Task<SecondarySourceDetailDto> GetByIdAsync(int id)
+    {
+        var entity = await _dbContext.Set<SecondarySource>()
+            .Include(ss => ss.Type)
+            .Include(ss => ss.Language)
+            .Include(ss => ss.TranslatedLanguages)
+            .FirstOrDefaultAsync(ss => ss.Id == id);
+        
+        if (entity == null)
+            throw new ArgumentException($"Entity with ID {id} not found.");
+
+        return new SecondarySourceDetailDto
+        {
+            Id = entity.Id,
+            AlternateNames = entity.AlternateNames,
+            Author = entity.Author,
+            YearWritten = entity.YearWritten,
+            University = entity.University,
+            Type = _mapper.Map<TypeDto>(entity.Type),
+            Topic = entity.Topic,
+            BibliographyInformation = entity.BibliographyInformation,
+            OtherInformation = entity.OtherInformation,
+            Language = _mapper.Map<LanguageDto>(entity.Language),
+            TranslatedLanguages = _mapper.Map<List<LanguageDto>>(entity.TranslatedLanguages),
+        };
+    }
+
+    public async Task<SecondarySourceDetailDto> CreateAsync(SecondarySourceCreateRequest request)
+    {
+        if ((request.AlternateNames != null) && (request.AlternateNames.Count == 0) )
+            throw new ArgumentException("Alternate names is not provided");
+
+        bool exists = await _dbContext.Set<SecondarySource>()
+            .AnyAsync(ws => ws.AlternateNames.Any(name => request.AlternateNames.Contains(name)));
+
+        if (exists)
+            throw new ArgumentException("A secondary source with one or more of the provided alternate names already exists.");
+
+        var entity = new SecondarySource
+        {
+            AlternateNames = request.AlternateNames,
+            Author = request.Author,
+            YearWritten = request.YearWritten,
+            University = request.University,
+            Topic = request.Topic,
+            BibliographyInformation = request.BibliographyInformation,
+            OtherInformation = request.OtherInformation
+        };
+
+        // Check if Type exists
+        if(request.Type != null)
+        {
+            Entities.Type? type = await _dbContext.Set<Entities.Type>().FirstOrDefaultAsync(e => e.Name == request.Type);
+            if (type == null)
+                throw new ArgumentException($"Type with name {request.Type} not found.");
+            entity.Type = type;
+        }
+
+        // Check if Language exists
+        if(request.Language != null)
+        {
+            Language? language = await _dbContext.Set<Language>().FirstOrDefaultAsync(e => e.Name == request.Language);
+            if (language == null)
+                throw new ArgumentException($"Language with name {request.Language} not found.");
+            entity.Language = language;
+        }
+
+        if (request.TranslatedLanguages != null)
+        {
+                List<Language>? translatedLanguages = await _dbContext.Set<Language>()
+                .Where(l => request.TranslatedLanguages.Contains(l.Name))
+                .ToListAsync();
+
+            if (translatedLanguages.Count != request.TranslatedLanguages.Count)
+                throw new ArgumentException("One or more provided Translated Languages are invalid.");
+            entity.TranslatedLanguages = translatedLanguages;
+        }
+
+        
+        _dbContext.Set<SecondarySource>().Add(entity);
+        await _dbContext.SaveChangesAsync();
+
+        return new SecondarySourceDetailDto
+        {
+            Id = entity.Id,
+            AlternateNames = entity.AlternateNames,
+            Author = entity.Author,
+            YearWritten = entity.YearWritten,
+            University = entity.University,
+            Type = _mapper.Map<TypeDto>(entity.Type),
+            Topic = entity.Topic,
+            BibliographyInformation = entity.BibliographyInformation,
+            OtherInformation = entity.OtherInformation,
+            Language = _mapper.Map<LanguageDto>(entity.Language),
+            TranslatedLanguages = _mapper.Map<List<LanguageDto>>(entity.TranslatedLanguages),    
+        };
+    }
+
+    public async Task<SecondarySourceDetailDto> UpdateAsync(int id, SecondarySourceUpdateRequest request)
+    {
+        var secondarySource = await _dbContext.Set<SecondarySource>()
+            .Include(ws => ws.Type)
+            .Include(ws => ws.Language)
+            .Include(ws => ws.TranslatedLanguages)
+            .FirstOrDefaultAsync(ws => ws.Id == id);
+
+        if (secondarySource == null)
+            throw new ArgumentException($"Entity with ID {id} not found.");
+
+        // Only update fields if they are not null
+        if (request.AlternateNames != null)
+            secondarySource.AlternateNames = request.AlternateNames;
+
+        if (request.Author != null)
+            secondarySource.Author = request.Author;
+
+        if (request.YearWritten != null)  // DateOnly
+            secondarySource.YearWritten = request.YearWritten;
+
+        if (request.University != null)
+            secondarySource.University = request.University;
+
+        // Type update only if a valid type is provided
+        if (request.Type != null)
+        {
+            var type = await _dbContext.Set<Entities.Type>().FirstOrDefaultAsync(
+                e => e.Name == request.Type);
+            if (type == null)
+                throw new ArgumentException($"Type with name {request.Type} not found.");
+            secondarySource.Type = type;
+        }
+
+        if (request.Topic != null)
+            secondarySource.Topic = request.Topic;
+
+        if (request.BibliographyInformation != null)
+            secondarySource.BibliographyInformation = request.BibliographyInformation;
+
+        if (request.OtherInformation != null)
+            secondarySource.OtherInformation = request.OtherInformation;
+
+        // Language update only if a valid language is provided
+        if (request.Language != null)
+        {
+            var language = await _dbContext.Set<Language>().FirstOrDefaultAsync(
+                e => e.Name == request.Language);
+            if (language == null)
+                throw new ArgumentException($"Language with name {request.Language} not found.");
+            secondarySource.Language = language;
+        }
+
+        // Update TranslatedLanguages (List of LanguageDto)
+        if (request.TranslatedLanguages != null)
+        {
+            var translatedLanguages = await _dbContext.Set<Language>()
+                .Where(l => request.TranslatedLanguages.Contains(l.Name))
+                .ToListAsync();
+
+            if (translatedLanguages.Count != request.TranslatedLanguages.Count)
+                throw new ArgumentException("One or more provided Translated Language IDs are invalid.");
+
+            secondarySource.TranslatedLanguages = translatedLanguages;
+        }
+
+        await _dbContext.SaveChangesAsync();
+
+        return new SecondarySourceDetailDto
+        {
+            Id = secondarySource.Id,
+            AlternateNames = secondarySource.AlternateNames,
+            Author = secondarySource.Author,
+            YearWritten = secondarySource.YearWritten,
+            University = secondarySource.University,
+            Type = _mapper.Map<TypeDto>(secondarySource.Type),
+            Topic = secondarySource.Topic,
+            BibliographyInformation = secondarySource.BibliographyInformation,
+            OtherInformation = secondarySource.OtherInformation,
+            Language = _mapper.Map<LanguageDto>(secondarySource.Language),
+            TranslatedLanguages = _mapper.Map<List<LanguageDto>>(secondarySource.TranslatedLanguages),    
+        };
+    }
+
+    public async Task<bool> DeleteAsync(int id)
+    {
+        var secondarySource = await _dbContext.Set<SecondarySource>().FindAsync(id);
+        if (secondarySource == null)
+            return false;
+
+        _dbContext.Set<SecondarySource>().Remove(secondarySource);
+        await _dbContext.SaveChangesAsync();
+        return true;
+    }
+}
diff --git a/backend/Services/UnordinaryPersonService.cs b/backend/Services/UnordinaryPersonService.cs
new file mode 100644
index 0000000..3e9199d
--- /dev/null
+++ b/backend/Services/UnordinaryPersonService.cs
@@ -0,0 +1,414 @@
+using Mappa.Db;
+using Mappa.Dtos;
+using Mappa.Entities;
+using Microsoft.EntityFrameworkCore;
+using AutoMapper;
+using Microsoft.IdentityModel.Tokens;
+using System.ComponentModel.DataAnnotations;
+
+namespace Mappa.Services;
+
+public class UnordinaryPersonService : IComplexEntityService<UnordinaryPerson, UnordinaryPersonGeneralDto, UnordinaryPersonDetailDto, UnordinaryPersonCreateRequest, UnordinaryPersonUpdateRequest>
+{
+    private readonly AppDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public UnordinaryPersonService(AppDbContext dbContext, IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<IEnumerable<UnordinaryPersonGeneralDto>> GetAllAsync()
+    {
+        return await _dbContext.Set<UnordinaryPerson>()
+            .Include(ws => ws.Religion)
+            .Include(ws => ws.Ethnicity)
+            .Include(ws => ws.DeathPlace)
+            .Include(ws => ws.InteractionsWithOrdinary)
+            .Select(e => new UnordinaryPersonGeneralDto
+            {
+                Id = e.Id,
+                Name = e.Name,
+                Religion = _mapper.Map<ReligionDto>(e.Religion),
+                Ethnicity = _mapper.Map<EthnicityDto>(e.Ethnicity),
+                DeathYear = e.DeathYear,
+                DeathPlace = _mapper.Map<CityBaseDto>(e.DeathPlace),
+                InteractionsWithOrdinary = _mapper.Map<List<OrdinaryPersonBaseDto>>(e.InteractionsWithOrdinary)
+            })
+            .ToListAsync();
+    }
+
+    public async Task<UnordinaryPersonDetailDto> GetByIdAsync(int id)
+    {
+        var entity = await _dbContext.Set<UnordinaryPerson>()
+            .Include(ws => ws.Religion)
+            .Include(ws => ws.Ethnicity)
+            .Include(ws => ws.DeathPlace)
+            .Include(ws => ws.InteractionsWithOrdinary)
+            .Include(ws => ws.FormerReligion)
+            .Include(ws => ws.Profession)
+            .Include(ws => ws.Gender)
+            .Include(ws => ws.InteractionsWithUnordinaryA)
+            .Include(ws => ws.Sources)
+            .FirstOrDefaultAsync(ws => ws.Id == id);
+        
+        if (entity == null)
+            throw new ArgumentException($"Entity with ID {id} not found.");
+
+        return new UnordinaryPersonDetailDto
+        {
+            Id = entity.Id,
+            Name = entity.Name,
+            Religion = _mapper.Map<ReligionDto>(entity.Religion),
+            Ethnicity = _mapper.Map<EthnicityDto>(entity.Ethnicity),
+            DeathYear = entity.DeathYear,
+            DeathPlace = _mapper.Map<CityBaseDto>(entity.DeathPlace),
+            InteractionsWithOrdinary = _mapper.Map<List<OrdinaryPersonBaseDto>>(entity.InteractionsWithOrdinary),
+            AlternateName = entity.AlternateName,
+            BirthYear = entity.BirthYear,
+            ProbableBirthYear = entity.ProbableBirthYear,
+            ProbableDeathYear = entity.ProbableDeathYear,
+            Description = entity.Description,
+            FormerReligion = _mapper.Map<List<ReligionDto>>(entity.FormerReligion),
+            Profession = _mapper.Map<ProfessionDto>(entity.Profession),
+            Gender = _mapper.Map<GenderDto>(entity.Gender),
+            BirthPlace = _mapper.Map<CityBaseDto>(entity.BirthPlace),
+            InteractionsWithUnordinaryA = _mapper.Map<List<UnordinaryPersonBaseDto>>(entity.InteractionsWithUnordinaryA),
+            InteractionsWithUnordinaryB = _mapper.Map<List<UnordinaryPersonBaseDto>>(entity.InteractionsWithUnordinaryB),
+            Sources = _mapper.Map<List<WrittenSourceBaseDto>>(entity.Sources),
+        };
+    }
+
+    public async Task<UnordinaryPersonDetailDto> CreateAsync(UnordinaryPersonCreateRequest request)
+    {
+        var unordinaryPerson = new UnordinaryPerson
+        {
+            Name = request.Name,
+            AlternateName = request.AlternateName,
+            BirthYear = request.BirthYear,
+            DeathYear = request.DeathYear,
+            ProbableBirthYear = request.ProbableBirthYear,
+            ProbableDeathYear = request.ProbableDeathYear,
+            Description = request.Description,
+            // Religion = _mapper.Map<Religion>(request.Religion),
+            // Ethnicity = _mapper.Map<Ethnicity>(request.Ethnicity),
+            // FormerReligion = _mapper.Map<List<Religion>>(request.FormerReligion),
+            // Profession = _mapper.Map<Profession>(request.Profession),
+            // Gender = _mapper.Map<Gender>(request.Gender),
+            // Sources = _mapper.Map<List<WrittenSource>>(request.Sources),
+            // InteractionsWithOrdinary = _mapper.Map<List<OrdinaryPerson>>(request.InteractionsWithOrdinary),
+            // InteractionsWithUnordinaryA = _mapper.Map<List<UnordinaryPerson>>(request.InteractionsWithUnordinaryA),
+            // BirthPlace = _mapper.Map<City>(request.BirthPlace),
+            // DeathPlace = _mapper.Map<City>(request.DeathPlace),
+        };
+
+        // Check if Religion exists
+        if(request.Religion != null)
+        {
+            var religion = await _dbContext.Set<Religion>().FirstOrDefaultAsync(e => e.Name == request.Religion);
+            if (religion == null)
+                throw new ArgumentException($"Religion with name {request.Religion} not found.");
+            unordinaryPerson.Religion = religion;
+        }
+
+        // Check if Ethnicity exists
+        if(request.Ethnicity != null)
+        {
+            var ethnicity = await _dbContext.Set<Ethnicity>().FirstOrDefaultAsync(e => e.Name == request.Ethnicity);
+            if (ethnicity == null)
+                throw new ArgumentException($"Ethnicity with name {request.Ethnicity} not found.");
+            unordinaryPerson.Ethnicity = ethnicity;
+        }
+
+        // Check if DeathPlace exists
+        if(request.DeathPlace != null)
+        {
+            var deathPlace = await _dbContext.Set<City>().FirstOrDefaultAsync(e => e.AsciiName == request.DeathPlace);
+            if (deathPlace == null)
+                throw new ArgumentException($"DeathPlace with name {request.DeathPlace} not found.");
+            unordinaryPerson.DeathPlace = deathPlace;
+        }
+
+        // Check if InteractionsWithOrdinary elements exists
+        if (request.InteractionsWithOrdinary != null)
+        {
+            var interactionsWithOrdinary = await _dbContext.Set<OrdinaryPerson>()
+                .Where(c => request.InteractionsWithOrdinary.Contains(c.Id))
+                .ToListAsync();
+
+            if (interactionsWithOrdinary.Count != request.InteractionsWithOrdinary.Count)
+                throw new ArgumentException("One or more provided InteractionsWithOrdinary are invalid.");
+            unordinaryPerson.InteractionsWithOrdinary = interactionsWithOrdinary;
+        }
+
+        // Check if FormerReligion elements exists
+        if (request.FormerReligion != null)
+        {
+            var formerReligion = await _dbContext.Set<Religion>()
+                .Where(c => request.FormerReligion.Contains(c.Name))
+                .ToListAsync();
+
+            if (formerReligion.Count != request.FormerReligion.Count)
+                throw new ArgumentException("One or more provided Formerreligion are invalid.");
+            unordinaryPerson.FormerReligion = formerReligion;
+        }
+
+        // Check if Profession exists
+        if(request.Profession != null)
+        {
+            var profession = await _dbContext.Set<Profession>().FirstOrDefaultAsync(e => e.Name == request.Profession);
+            if (profession == null)
+                throw new ArgumentException($"Profession with name {request.Profession} not found.");
+            unordinaryPerson.Profession = profession;
+        }
+
+        // Check if Gender exists
+        if(request.Gender != null)
+        {
+            var gender = await _dbContext.Set<Gender>().FirstOrDefaultAsync(e => e.Name == request.Gender);
+            if (gender == null)
+                throw new ArgumentException($"Gender with name {request.Gender} not found.");
+            unordinaryPerson.Gender = gender;
+        }
+
+        // Check if BirthPlace exists
+        if(request.BirthPlace != null)
+        {
+            var birthPlace = await _dbContext.Set<City>().FirstOrDefaultAsync(e => e.AsciiName == request.BirthPlace);
+            if (birthPlace == null)
+                throw new ArgumentException($"BirthPlace with name {request.BirthPlace} not found.");
+            unordinaryPerson.BirthPlace = birthPlace;
+        }
+
+        // Check if InteractionsWithUnordinaryA elements exists
+        if (request.InteractionsWithUnordinaryA != null)
+        {
+            var interactionsWithUnordinaryA = await _dbContext.Set<UnordinaryPerson>()
+                .Where(c => request.InteractionsWithUnordinaryA.Contains(c.Id))
+                .ToListAsync();
+
+            if (interactionsWithUnordinaryA.Count != request.InteractionsWithUnordinaryA.Count)
+                throw new ArgumentException("One or more provided InteractionsWithUnordinaryA are invalid.");
+            unordinaryPerson.InteractionsWithUnordinaryA = interactionsWithUnordinaryA;
+        }
+
+        // Check if Sources elements exists
+        if (request.Sources != null)
+        {
+            var sources = await _dbContext.Set<WrittenSource>()
+                .Where(c => request.Sources.Contains(c.Id))
+                .ToListAsync();
+
+            if (sources.Count != request.Sources.Count)
+                throw new ArgumentException("One or more provided Sources are invalid.");
+            unordinaryPerson.Sources = sources;
+        }
+        
+        _dbContext.Set<UnordinaryPerson>().Add(unordinaryPerson);
+        await _dbContext.SaveChangesAsync();
+
+        return new UnordinaryPersonDetailDto
+        {
+            Id = unordinaryPerson.Id,
+            Name = unordinaryPerson.Name,
+            AlternateName = unordinaryPerson.AlternateName,
+            BirthYear = unordinaryPerson.BirthYear,
+            DeathYear = unordinaryPerson.DeathYear,
+            ProbableBirthYear = unordinaryPerson.ProbableBirthYear,
+            ProbableDeathYear = unordinaryPerson.ProbableDeathYear,
+            Description = unordinaryPerson.Description,
+            Religion = _mapper.Map<ReligionDto>(unordinaryPerson.Religion),
+            Ethnicity = _mapper.Map<EthnicityDto>(unordinaryPerson.Ethnicity),
+            FormerReligion = _mapper.Map<List<ReligionDto>>(unordinaryPerson.FormerReligion),
+            Profession = _mapper.Map<ProfessionDto>(unordinaryPerson.Profession),
+            Gender = _mapper.Map<GenderDto>(unordinaryPerson.Gender),
+            Sources = _mapper.Map<List<WrittenSourceBaseDto>>(unordinaryPerson.Sources),
+            InteractionsWithOrdinary = _mapper.Map<List<OrdinaryPersonBaseDto>>(unordinaryPerson.InteractionsWithOrdinary),
+            InteractionsWithUnordinaryA = _mapper.Map<List<UnordinaryPersonBaseDto>>(unordinaryPerson.InteractionsWithUnordinaryA),
+            InteractionsWithUnordinaryB = _mapper.Map<List<UnordinaryPersonBaseDto>>(unordinaryPerson.InteractionsWithUnordinaryB),
+            BirthPlace = _mapper.Map<CityBaseDto>(unordinaryPerson.BirthPlace),
+            DeathPlace = _mapper.Map<CityBaseDto>(unordinaryPerson.DeathPlace),
+        };
+    }
+
+    public async Task<UnordinaryPersonDetailDto> UpdateAsync(int id, UnordinaryPersonUpdateRequest request)
+    {
+        var unordinaryPerson = await _dbContext.Set<UnordinaryPerson>()
+            .Include(ws => ws.Religion)
+            .Include(ws => ws.Ethnicity)
+            .Include(ws => ws.DeathPlace)
+            .Include(ws => ws.InteractionsWithOrdinary)
+            .Include(ws => ws.FormerReligion)
+            .Include(ws => ws.Profession)
+            .Include(ws => ws.Gender)
+            .Include(ws => ws.InteractionsWithUnordinaryA)
+            .Include(ws => ws.Sources)
+            .FirstOrDefaultAsync(ws => ws.Id == id);
+
+        if (unordinaryPerson == null)
+            throw new ArgumentException($"Entity with ID {id} not found.");
+
+        // Religion update only if a valid religion is provided
+        if (request.Religion != null)
+        {
+            var religion = await _dbContext.Set<Religion>().FirstOrDefaultAsync(e => e.Name == request.Religion);
+            if (religion == null)
+                throw new ArgumentException($"Religion with name {request.Religion} not found.");
+            unordinaryPerson.Religion = religion;
+        }
+
+        // Ethnicity update only if a valid ethnicity is provided
+        if (request.Ethnicity != null)
+        {
+            var ethnicity = await _dbContext.Set<Ethnicity>().FirstOrDefaultAsync(e => e.Name == request.Ethnicity);
+            if (ethnicity == null)
+                throw new ArgumentException($"Ethnicity with name {request.Ethnicity} not found.");
+            unordinaryPerson.Ethnicity = ethnicity;
+        }
+
+        // Only update fields if they are not null
+        if ((request.DeathYear != null) && (request.DeathYear.Count > 0))
+            unordinaryPerson.DeathYear = request.DeathYear;
+
+        // DeathPlace update only if a valid city name is provided
+        if (request.DeathPlace != null)
+        {
+            var deathPlace = await _dbContext.Set<City>().FirstOrDefaultAsync(e => e.AsciiName == request.DeathPlace);
+            if (deathPlace == null)
+                throw new ArgumentException($"DeathPlace with name {request.DeathPlace} not found.");
+            unordinaryPerson.DeathPlace = deathPlace;
+        }
+
+        // Update InteractionsWithOrdinary 
+        if (request.InteractionsWithOrdinary != null)
+        {
+            var interactionsWithOrdinary = await _dbContext.Set<OrdinaryPerson>()
+                .Where(l => request.InteractionsWithOrdinary.Contains(l.Id))
+                .ToListAsync();
+
+            if (interactionsWithOrdinary.Count != request.InteractionsWithOrdinary.Count)
+                throw new ArgumentException("One or more provided Ordinary Person are invalid.");
+
+            unordinaryPerson.InteractionsWithOrdinary = interactionsWithOrdinary;
+        }
+
+        if (request.AlternateName != null)
+            unordinaryPerson.AlternateName = request.AlternateName;
+
+        if (request.BirthYear != null && request.BirthYear.Count > 0)  
+            unordinaryPerson.BirthYear = request.BirthYear;
+
+        // Only update fields if they are provided in the request
+        if (request.ProbableBirthYear != null)
+            unordinaryPerson.ProbableBirthYear = request.ProbableBirthYear;
+
+        if (request.ProbableDeathYear != null)
+            unordinaryPerson.ProbableDeathYear = request.ProbableDeathYear;
+
+        if (request.Description != null)
+            unordinaryPerson.Description = request.Description;
+
+        // Update FormerReligion 
+        if (request.FormerReligion != null)
+        {
+            var formerReligion = await _dbContext.Set<Religion>()
+                .Where(l => request.FormerReligion.Contains(l.Name))
+                .ToListAsync();
+
+            if (formerReligion.Count != request.FormerReligion.Count)
+                throw new ArgumentException("One or more provided Former Religion are invalid.");
+
+            unordinaryPerson.FormerReligion = formerReligion;
+        }
+
+        // Profession update only if a valid profession is provided
+        if (request.Profession != null)
+        {
+            var profession = await _dbContext.Set<Profession>().FirstOrDefaultAsync(e => e.Name == request.Profession);
+            if (profession == null)
+                throw new ArgumentException($"Profession with name {request.Profession} not found.");
+            unordinaryPerson.Profession = profession;
+        }
+
+        // Gender update only if a valid gender is provided
+        if (request.Gender != null)
+        {
+            var gender = await _dbContext.Set<Gender>().FirstOrDefaultAsync(e => e.Name == request.Gender);
+            if (gender == null)
+                throw new ArgumentException($"Gender with name {request.Gender} not found.");
+            unordinaryPerson.Gender = gender;
+        }
+
+        // BirthPlace update only if a valid city is provided
+        if (request.BirthPlace != null)
+        {
+            var birthPlace = await _dbContext.Set<City>().FirstOrDefaultAsync(e => e.AsciiName == request.BirthPlace);
+            if (birthPlace == null)
+                throw new ArgumentException($"BirthPlace with name {request.BirthPlace} not found.");
+            unordinaryPerson.BirthPlace = birthPlace;
+        }
+
+        // Update InteractionsWithUnordinaryA 
+        if (request.InteractionsWithUnordinaryA != null)
+        {
+            var interactionsWithUnordinaryA = await _dbContext.Set<UnordinaryPerson>()
+                .Where(l => request.InteractionsWithUnordinaryA.Contains(l.Id))
+                .ToListAsync();
+
+            if (interactionsWithUnordinaryA.Count != request.InteractionsWithUnordinaryA.Count)
+                throw new ArgumentException("One or more provided Unordinary Person are invalid.");
+
+            unordinaryPerson.InteractionsWithUnordinaryA = interactionsWithUnordinaryA;
+        }
+
+        // Update Sources 
+        if (request.Sources != null)
+        {
+            var sources = await _dbContext.Set<WrittenSource>()
+                .Where(l => request.Sources.Contains(l.Id))
+                .ToListAsync();
+
+            if (sources.Count != request.Sources.Count)
+                throw new ArgumentException("One or more provided Written Source are invalid.");
+
+            unordinaryPerson.Sources = sources;
+        }
+
+        await _dbContext.SaveChangesAsync();
+
+        return new UnordinaryPersonDetailDto
+        {
+            Id = unordinaryPerson.Id,
+            Name = unordinaryPerson.Name,
+            AlternateName = unordinaryPerson.AlternateName,
+            BirthYear = unordinaryPerson.BirthYear,
+            DeathYear = unordinaryPerson.DeathYear,
+            ProbableBirthYear = unordinaryPerson.ProbableBirthYear,
+            ProbableDeathYear = unordinaryPerson.ProbableDeathYear,
+            Description = unordinaryPerson.Description,
+            Religion = _mapper.Map<ReligionDto>(unordinaryPerson.Religion),
+            Ethnicity = _mapper.Map<EthnicityDto>(unordinaryPerson.Ethnicity),
+            FormerReligion = _mapper.Map<List<ReligionDto>>(unordinaryPerson.FormerReligion),
+            Profession = _mapper.Map<ProfessionDto>(unordinaryPerson.Profession),
+            Gender = _mapper.Map<GenderDto>(unordinaryPerson.Gender),
+            Sources = _mapper.Map<List<WrittenSourceBaseDto>>(unordinaryPerson.Sources),
+            InteractionsWithOrdinary = _mapper.Map<List<OrdinaryPersonBaseDto>>(unordinaryPerson.InteractionsWithOrdinary),
+            InteractionsWithUnordinaryA = _mapper.Map<List<UnordinaryPersonBaseDto>>(unordinaryPerson.InteractionsWithUnordinaryA),
+            InteractionsWithUnordinaryB = _mapper.Map<List<UnordinaryPersonBaseDto>>(unordinaryPerson.InteractionsWithUnordinaryB),
+            BirthPlace = _mapper.Map<CityBaseDto>(unordinaryPerson.BirthPlace),
+            DeathPlace = _mapper.Map<CityBaseDto>(unordinaryPerson.DeathPlace),
+        };
+    }
+
+    public async Task<bool> DeleteAsync(int id)
+    {
+        var unordinaryPerson = await _dbContext.Set<UnordinaryPerson>().FindAsync(id);
+        if (unordinaryPerson == null)
+            return false;
+
+        _dbContext.Set<UnordinaryPerson>().Remove(unordinaryPerson);
+        await _dbContext.SaveChangesAsync();
+        return true;
+    }
+}
diff --git a/backend/Services/WrittenSourceService.cs b/backend/Services/WrittenSourceService.cs
new file mode 100644
index 0000000..7acd406
--- /dev/null
+++ b/backend/Services/WrittenSourceService.cs
@@ -0,0 +1,304 @@
+using Mappa.Db;
+using Mappa.Dtos;
+using Mappa.Entities;
+using Microsoft.EntityFrameworkCore;
+using AutoMapper;
+using Microsoft.IdentityModel.Tokens;
+using System.Threading.Tasks.Dataflow;
+
+namespace Mappa.Services;
+
+public class WrittenSourceService : IComplexEntityService<WrittenSource, WrittenSourceGeneralDto, WrittenSourceDetailDto, WrittenSourceCreateRequest, WrittenSourceUpdateRequest>
+{
+    private readonly AppDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public WrittenSourceService(AppDbContext dbContext, IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<IEnumerable<WrittenSourceGeneralDto>> GetAllAsync()
+    {
+        return await _dbContext.Set<WrittenSource>()
+            .Include(ws => ws.Genre)
+            .Include(ws => ws.Language)
+            .Select(e => new WrittenSourceGeneralDto
+            {
+                Id = e.Id,
+                AlternateNames = e.AlternateNames,
+                Author = e.Author,
+                YearWritten = e.YearWritten,
+                Genre = _mapper.Map<GenreDto>(e.Genre),
+                Language = _mapper.Map<LanguageDto>(e.Language)
+            })
+            .ToListAsync();
+    }
+
+    public async Task<WrittenSourceDetailDto> GetByIdAsync(int id)
+    {
+        var entity = await _dbContext.Set<WrittenSource>()
+            .Include(ws => ws.Genre)
+            .Include(ws => ws.Language)
+            .Include(ws => ws.TranslatedLanguages)
+            .Include(ws => ws.CitiesMentioningTheSources)
+            .Include(ws => ws.CitiesWhereSourcesAreWritten)
+            .FirstOrDefaultAsync(ws => ws.Id == id);
+        
+        if (entity == null)
+            throw new ArgumentException($"Entity with ID {id} not found.");
+
+        return new WrittenSourceDetailDto
+        {
+            Id = entity.Id,
+            AlternateNames = entity.AlternateNames,
+            Author = entity.Author,
+            YearWritten = entity.YearWritten,
+            Genre = _mapper.Map<GenreDto>(entity.Genre),
+            Language = _mapper.Map<LanguageDto>(entity.Language),
+            KnownCopies = entity.KnownCopies,
+            SurvivedCopies = entity.SurvivedCopies,
+            LibraryInformation = entity.LibraryInformation,
+            OtherInformation = entity.OtherInformation,
+            RemarkableWorksOnTheBook = entity.RemarkableWorksOnTheBook,
+            Image = entity.Image,
+            TranslatedLanguages = _mapper.Map<List<LanguageDto>>(entity.TranslatedLanguages),
+            CitiesMentioningTheSources = _mapper.Map<List<CityBaseDto>>(entity.CitiesMentioningTheSources),
+            CitiesWhereSourcesAreWritten = _mapper.Map<List<CityBaseDto>>(entity.CitiesWhereSourcesAreWritten),
+        };
+    }
+
+    public async Task<WrittenSourceDetailDto> CreateAsync(WrittenSourceCreateRequest request)
+    {
+        if ((request.AlternateNames != null) && (request.AlternateNames.Count != 0) )
+            throw new ArgumentException("Alternate names is not provided");
+
+        bool exists = await _dbContext.Set<WrittenSource>()
+            .AnyAsync(ws => ws.AlternateNames.Any(name => request.AlternateNames.Contains(name)));
+
+        if (exists)
+            throw new ArgumentException("A written source with one or more of the provided alternate names already exists.");
+
+        var writtenSource = new WrittenSource
+        {
+            AlternateNames = request.AlternateNames,
+            Author = request.Author,
+            YearWritten = request.YearWritten,
+            KnownCopies = request.KnownCopies,
+            SurvivedCopies = request.SurvivedCopies,
+            LibraryInformation = request.LibraryInformation,
+            OtherInformation = request.OtherInformation,
+            RemarkableWorksOnTheBook = request.RemarkableWorksOnTheBook,
+            Image = request.Image,
+        };
+
+        // Check if Genre exists
+        if(request.Genre != null)
+        {
+            var genre = await _dbContext.Set<Genre>().FirstOrDefaultAsync(e => e.Name == request.Genre );
+            if (genre == null)
+                throw new ArgumentException($"Genre with name {request.Genre} not found.");
+            writtenSource.Genre = genre;
+        }
+
+        // Check if Language exists
+        if(request.Language != null)
+        {
+            var language = await _dbContext.Set<Language>().FirstOrDefaultAsync(e => e.Name == request.Language );
+            if (language == null)
+                throw new ArgumentException($"Language with name {request.Language} not found.");
+            writtenSource.Language = language;
+        }
+
+        // Update TranslatedLanguages (List of LanguageDto)
+        if (request.TranslatedLanguages != null)
+        {
+            var translatedLanguages = await _dbContext.Set<Language>()
+                .Where(l => request.TranslatedLanguages.Contains(l.Name))
+                .ToListAsync();
+
+            if (translatedLanguages.Count != request.TranslatedLanguages.Count)
+                throw new ArgumentException("One or more provided Translated Language are invalid.");
+            writtenSource.TranslatedLanguages = translatedLanguages;
+        }
+
+        // Update CitiesMentioningTheSources (List of CityBaseDto)
+        if (request.CitiesMentioningTheSources != null)
+        {
+            var mentionedCities = await _dbContext.Set<City>()
+                .Where(c => request.CitiesMentioningTheSources.Contains(c.AsciiName))
+                .ToListAsync();
+
+            if (mentionedCities.Count != request.CitiesMentioningTheSources.Count)
+                throw new ArgumentException("One or more provided CitiesMentioningTheSources are invalid.");
+            writtenSource.CitiesMentioningTheSources = mentionedCities;
+        }
+
+        // Update CitiesWhereSourcesAreWritten (List of CityBaseDto)
+        if (request.CitiesWhereSourcesAreWritten != null)
+        {
+            var writtenCities = await _dbContext.Set<City>()
+                .Where(c => request.CitiesWhereSourcesAreWritten.Contains(c.AsciiName))
+                .ToListAsync();
+
+            if (writtenCities.Count != request.CitiesWhereSourcesAreWritten.Count)
+                throw new ArgumentException("One or more provided CitiesWhereSourcesAreWritten IDs are invalid.");
+            writtenSource.CitiesWhereSourcesAreWritten = writtenCities;
+        }
+        
+        _dbContext.Set<WrittenSource>().Add(writtenSource);
+        await _dbContext.SaveChangesAsync();
+
+        return new WrittenSourceDetailDto
+        {
+            Id = writtenSource.Id,
+            AlternateNames = writtenSource.AlternateNames,
+            Author = writtenSource.Author,
+            YearWritten = writtenSource.YearWritten,
+            Genre = _mapper.Map<GenreDto>(writtenSource.Genre),
+            Language = _mapper.Map<LanguageDto>(writtenSource.Language),
+            KnownCopies = writtenSource.KnownCopies,
+            SurvivedCopies = writtenSource.SurvivedCopies,
+            LibraryInformation = writtenSource.LibraryInformation,
+            OtherInformation = writtenSource.OtherInformation,
+            RemarkableWorksOnTheBook = writtenSource.RemarkableWorksOnTheBook,
+            Image = writtenSource.Image,
+            TranslatedLanguages = _mapper.Map<List<LanguageDto>>(writtenSource.TranslatedLanguages),
+            CitiesMentioningTheSources = _mapper.Map<List<CityBaseDto>>(writtenSource.CitiesMentioningTheSources),
+            CitiesWhereSourcesAreWritten = _mapper.Map<List<CityBaseDto>>(writtenSource.CitiesWhereSourcesAreWritten)
+        };
+    }
+
+    public async Task<WrittenSourceDetailDto> UpdateAsync(int id, WrittenSourceUpdateRequest request)
+    {
+        var writtenSource = await _dbContext.Set<WrittenSource>()
+            .Include(ws => ws.Genre)
+            .Include(ws => ws.Language)
+            .Include(ws => ws.TranslatedLanguages)
+            .Include(ws => ws.CitiesMentioningTheSources)
+            .Include(ws => ws.CitiesWhereSourcesAreWritten)
+            .FirstOrDefaultAsync(ws => ws.Id == id);
+
+        if (writtenSource == null)
+            throw new ArgumentException($"Entity with ID {id} not found.");
+
+        // Only update fields if they are not null
+        if (request.AlternateNames != null)
+            writtenSource.AlternateNames = request.AlternateNames;
+
+        if (request.Author != null)
+            writtenSource.Author = request.Author;
+
+        if ((request.YearWritten != null) && (request.YearWritten.Count != 0) )  
+            writtenSource.YearWritten = request.YearWritten;
+
+        // Genre update only if a valid genre is provided
+        if (request.Genre != null)
+        {
+            var genre = await _dbContext.Set<Genre>().FirstOrDefaultAsync(e => e.Name == request.Genre);
+            if (genre == null)
+                throw new ArgumentException($"Genre with name {request.Genre} not found.");
+            writtenSource.Genre = genre;
+        }
+
+        // Language update only if a valid language is provided
+        if (request.Language != null)
+        {
+            var language = await _dbContext.Set<Language>().FirstOrDefaultAsync(e => e.Name == request.Language);
+            if (language == null)
+                throw new ArgumentException($"Language with name {request.Language} not found.");
+            writtenSource.Language = language;
+        }
+
+        // Only update fields if they are provided in the request
+        if (request.KnownCopies != null)
+            writtenSource.KnownCopies = request.KnownCopies;
+
+        if (request.SurvivedCopies != null)
+            writtenSource.SurvivedCopies = request.SurvivedCopies;
+
+        if (request.LibraryInformation != null)
+            writtenSource.LibraryInformation = request.LibraryInformation;
+
+        if (request.OtherInformation != null)
+            writtenSource.OtherInformation = request.OtherInformation;
+
+        if (request.RemarkableWorksOnTheBook != null)
+            writtenSource.RemarkableWorksOnTheBook = request.RemarkableWorksOnTheBook;
+
+        if (request.Image != null)
+            writtenSource.Image = request.Image;
+
+        // Update TranslatedLanguages (List of LanguageDto)
+        if (request.TranslatedLanguages != null)
+        {
+            var translatedLanguages = await _dbContext.Set<Language>()
+                .Where(l => request.TranslatedLanguages.Contains(l.Name))
+                .ToListAsync();
+
+            if (translatedLanguages.Count != request.TranslatedLanguages.Count)
+                throw new ArgumentException("One or more provided Translated Languages are invalid.");
+
+            writtenSource.TranslatedLanguages = translatedLanguages;
+        }
+
+        // Update CitiesMentioningTheSources (List of CityBaseDto)
+        if (request.CitiesMentioningTheSources != null)
+        {
+            var mentionedCities = await _dbContext.Set<City>()
+                .Where(c => request.CitiesMentioningTheSources.Contains(c.AsciiName))
+                .ToListAsync();
+
+            if (mentionedCities.Count != request.CitiesMentioningTheSources.Count)
+                throw new ArgumentException("One or more provided CitiesMentioningTheSources are invalid.");
+
+            writtenSource.CitiesMentioningTheSources = mentionedCities;
+        }
+
+        // Update CitiesWhereSourcesAreWritten (List of CityBaseDto)
+        if (request.CitiesWhereSourcesAreWritten != null)
+        {
+            var writtenCities = await _dbContext.Set<City>()
+                .Where(c => request.CitiesWhereSourcesAreWritten.Contains(c.AsciiName))
+                .ToListAsync();
+
+            if (writtenCities.Count != request.CitiesWhereSourcesAreWritten.Count)
+                throw new ArgumentException("One or more provided CitiesWhereSourcesAreWritten are invalid.");
+
+            writtenSource.CitiesWhereSourcesAreWritten = writtenCities;
+        }
+
+        await _dbContext.SaveChangesAsync();
+
+        return new WrittenSourceDetailDto
+        {
+            Id = writtenSource.Id,
+            AlternateNames = writtenSource.AlternateNames,
+            Author = writtenSource.Author,
+            YearWritten = writtenSource.YearWritten,
+            Genre = _mapper.Map<GenreDto>(writtenSource.Genre),
+            Language = _mapper.Map<LanguageDto>(writtenSource.Language),
+            KnownCopies = writtenSource.KnownCopies,
+            SurvivedCopies = writtenSource.SurvivedCopies,
+            LibraryInformation = writtenSource.LibraryInformation,
+            OtherInformation = writtenSource.OtherInformation,
+            RemarkableWorksOnTheBook = writtenSource.RemarkableWorksOnTheBook,
+            Image = writtenSource.Image,
+            TranslatedLanguages = _mapper.Map<List<LanguageDto>>(writtenSource.TranslatedLanguages),
+            CitiesMentioningTheSources = _mapper.Map<List<CityBaseDto>>(writtenSource.CitiesMentioningTheSources),
+            CitiesWhereSourcesAreWritten = _mapper.Map<List<CityBaseDto>>(writtenSource.CitiesWhereSourcesAreWritten)
+        };
+    }
+
+    public async Task<bool> DeleteAsync(int id)
+    {
+        var writtenSource = await _dbContext.Set<WrittenSource>().FindAsync(id);
+        if (writtenSource == null)
+            return false;
+
+        _dbContext.Set<WrittenSource>().Remove(writtenSource);
+        await _dbContext.SaveChangesAsync();
+        return true;
+    }
+}
diff --git a/backend/example.appsettings.Development.json b/backend/example.appsettings.Development.json
new file mode 100644
index 0000000..b7ca0bb
--- /dev/null
+++ b/backend/example.appsettings.Development.json
@@ -0,0 +1,18 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Microsoft.AspNetCore.Authentication": "Debug",
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "ConnectionStrings": {
+    "db": "Host=<db_host_address>;Port=<port>;Database=<database_name>;Username=<db_user>;Password=<db_password>"
+  },
+  "JWT": {
+    "ValidAudience": "http://<valid_audience_host_address>:<port>",
+    "ValidIssuer": "http://<valid_issuer_host_address>:<port>",
+    "Secret": "<secret_string_to_create_jwt>",
+    "TokenExpirationInHours": 3
+  }
+}
\ No newline at end of file
diff --git a/backend/example.appsettings.json b/backend/example.appsettings.json
new file mode 100644
index 0000000..15bb8a3
--- /dev/null
+++ b/backend/example.appsettings.json
@@ -0,0 +1,18 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "ConnectionStrings": {
+    "db": "Host=<db_host_address>;Port=<port>;Database=<database_name>;Username=<db_user>;Password=<db_password>"
+  },
+  "AllowedHosts": "*",
+  "JWT": {
+    "ValidAudience": "http://<valid_audience_host_address>:<port>",
+    "ValidIssuer": "http://<valid_issuer_host_address>:<port>",
+    "Secret": "<secret_string_to_create_jwt>",
+    "TokenExpirationInHours": 3
+  }
+}
diff --git a/backend/mappa.csproj b/backend/mappa.csproj
index 803c0af..e9e035b 100644
--- a/backend/mappa.csproj
+++ b/backend/mappa.csproj
@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.0" />
     <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="8.0.0" />
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.11" />
@@ -20,6 +21,7 @@
     </PackageReference>
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.11" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="6.6.2" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="8.3.1" />
   </ItemGroup>
 
 </Project>
diff --git a/compose.yml b/compose.yml
index 2b49d5f..c4c4c71 100644
--- a/compose.yml
+++ b/compose.yml
@@ -1,22 +1,33 @@
 services:
   web_api:
     container_name: mappa_backend
-    build: ./backend
+    build: 
+      context: ./backend
+      args:
+        DATABASE_CONNECTION_STRING: ${DATABASE_CONNECTION_STRING}
     ports:
       - 8080:8080
     depends_on:
-      - "db"
+      db:
+        condition:  service_healthy
+    # environment:
+    #   DATABASE_CONNECTION_STRING: ${DATABASE_CONNECTION_STRING}
   db:
     image: postgres
     container_name: mappa_db
     ports:
       - 5433:5432
     environment:
-      - POSTGRES_DB=MappaDB
-      - POSTGRES_USER=postgres
-      - POSTGRES_PASSWORD=formatlatan123.
+      POSTGRES_DB: ${POSTGRES_DB}
+      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
     volumes:
       - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d MappaDB"]
+      interval: 5s
+      retries: 15
+      timeout: 3s
 
 volumes:
   postgres_data:
diff --git a/example.env b/example.env
new file mode 100644
index 0000000..6416f27
--- /dev/null
+++ b/example.env
@@ -0,0 +1,4 @@
+POSTGRES_PASSWORD=<your_postgres_db_password>
+POSTGRES_DB=<postgres_db_name>
+POSTGRES_USER=<postgres_db_user>
+DATABASE_CONNECTION_STRING="Host=<db_host_address>;Port=<port>;Database=<database_name>;Username=<db_user>;Password=<db_password>"
\ No newline at end of file