public PersonFluffyDateModelState(
ModelStateDictionary modelState,
FluffyDate selectedFluffyDate,
PersonFluffyDateTypeOptions selectedFluffyDateType,
IEnumerable <PersonFluffyDate> allFluffyDates,
int?personFluffyDateId)
{
ModelState = modelState;
_selectedFluffyDate = selectedFluffyDate;
_selectedFluffyDateType = selectedFluffyDateType;
_allFluffyDates = allFluffyDates;
_personFluffyDateId = personFluffyDateId;
switch (_selectedFluffyDateType)
{
case PersonFluffyDateTypeOptions.Birth:
_birthFluffyDate = _selectedFluffyDate;
var death =
_allFluffyDates
.FirstOrDefault(x =>
x.Type.Equals(PersonFluffyDateType.Death));
if (death != null)
{
_deathFluffyDate =
new FluffyDate(
death.Year,
death.Month,
death.Day);
}
break;
case PersonFluffyDateTypeOptions.Death:
_deathFluffyDate = _selectedFluffyDate;
var birth =
_allFluffyDates
.FirstOrDefault(x =>
x.Type.Equals(PersonFluffyDateType.Birth));
if (birth != null)
{
_birthFluffyDate =
new FluffyDate(
birth.Year,
birth.Month,
birth.Day);
}
break;
}
_birthVsDeathDate =
new BirthVsDeathDate(_birthFluffyDate, _deathFluffyDate);
}
//
// Add persons to view model
//
public void AddPersonsToViewModel(List <Person> persons)
{
foreach (var person in persons)
{
var personItem = new PersonItemInPersonListViewModel(person);
var birthFluffyDate =
person.FluffyDates.FirstOrDefault(x =>
x.Type == PersonFluffyDateType.Birth);
if (birthFluffyDate?.Year != null)
{
var fluffyDateStart =
new FluffyDate(
birthFluffyDate.Year,
birthFluffyDate.Month,
birthFluffyDate.Day);
var fluffyDateEnd =
new FluffyDate(
DateTime.Now.Year,
DateTime.Now.Month,
DateTime.Now.Day);
var deathFluffyDate =
person.FluffyDates.FirstOrDefault(x =>
x.Type == PersonFluffyDateType.Death);
if (deathFluffyDate?.Year != null)
{
fluffyDateEnd =
new FluffyDate(
deathFluffyDate.Year,
deathFluffyDate.Month,
deathFluffyDate.Day);
}
var age =
new Age(
fluffyDateStart,
fluffyDateEnd);
if (age.InYears != null)
{
personItem.Age = age.InYears.ToString();
}
}
PersonItems.Add(personItem);
}
}
public void AddOrUpdatePerson(Person person)
{
if (person.PersonGuid == Guid.Empty)
{
return;
}
IGraph g = new Graph();
// Namespaces
g.BaseUri =
new Uri($"https://resource.fylkesarkivet.no/person/{person.PersonGuid}#");
// Default:
// @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
// @prefix rdfs: < http://www.w3.org/2000/01/rdf-schema#>.
// @prefix xsd: < http://www.w3.org/2001/XMLSchema#>.
g.NamespaceMap.AddNamespace("foaf", UriFactory.Create("http://xmlns.com/foaf/0.1/"));
// http://dbpedia.org/ontology/Person
g.NamespaceMap.AddNamespace("dbo", UriFactory.Create("http://dbpedia.org/ontology/"));
g.NamespaceMap.AddNamespace("dbp", UriFactory.Create("http://dbpedia.org/property/"));
g.NamespaceMap.AddNamespace("xsd", UriFactory.Create("http://www.w3.org/2001/XMLSchema#"));
g.NamespaceMap.AddNamespace("fark", UriFactory.Create("https://ontology.fylkesarkivet.no/"));
// Agent
g.Assert(new Triple(
g.CreateUriNode(),
g.CreateUriNode("rdf:type"),
g.CreateUriNode("foaf:Agent")));
// Person
g.Assert(new Triple(
g.CreateUriNode(),
g.CreateUriNode("rdf:type"),
g.CreateUriNode("foaf:Person")));
// Gender
switch (person.Gender)
{
case PersonGender.Male:
g.Assert(new Triple(
g.CreateUriNode(),
g.CreateUriNode("foaf:Gender"),
g.CreateLiteralNode("male")));
break;
case PersonGender.Female:
g.Assert(new Triple(
g.CreateUriNode(),
g.CreateUriNode("foaf:Gender"),
g.CreateLiteralNode("female")));
break;
case PersonGender.GenderVariant:
g.Assert(new Triple(
g.CreateUriNode(),
g.CreateUriNode("foaf:Gender"),
g.CreateLiteralNode("gender variant")));
break;
}
// Name
if (person.Names != null && person.Names.Any())
{
foreach (var name in person.Names)
{
var triples = new List <Triple>();
var blankNode = g.CreateBlankNode();
triples.Add(
new Triple(
g.CreateUriNode(),
g.CreateUriNode("fark:Name"),
blankNode));
// foaf:name
var fullName =
string.Join(" ", new[]
{
name.Prefix,
name.First,
name.Middle,
name.Last,
name.Suffix
}.Where(x => !string.IsNullOrWhiteSpace(x)).ToArray());
if (!string.IsNullOrWhiteSpace(fullName))
{
triples.Add(
new Triple(
blankNode,
g.CreateUriNode("foaf:name"),
g.CreateLiteralNode(fullName)));
}
// foaf:firstName
var firstName =
string.Join(" ", new[]
{
name.Prefix,
name.First
}.Where(x => !string.IsNullOrWhiteSpace(x)).ToArray());
if (!string.IsNullOrWhiteSpace(firstName))
{
triples.Add(
new Triple(
blankNode,
g.CreateUriNode("foaf:firstName"),
g.CreateLiteralNode(firstName)));
}
// foaf:middleName
if (!string.IsNullOrWhiteSpace(name.Middle))
{
triples.Add(
new Triple(
blankNode,
g.CreateUriNode("foaf:middleName"),
g.CreateLiteralNode(name.Middle)));
}
// foaf:lastName
var lastName =
string.Join(" ", new[]
{
name.Last,
name.Suffix
}.Where(x => !string.IsNullOrWhiteSpace(x)).ToArray());
if (!string.IsNullOrWhiteSpace(lastName))
{
triples.Add(
new Triple(
blankNode,
g.CreateUriNode("foaf:lastName"),
g.CreateLiteralNode(lastName)));
}
// fark:nameWeight
if (!string.IsNullOrWhiteSpace(name.NameWeight.ToString()))
{
triples.Add(
new Triple(
blankNode,
g.CreateUriNode("fark:nameWeight"),
g.CreateLiteralNode(
name.NameWeight.ToString(),
g.CreateUriNode("xsd:integer").Uri)));
}
// Add triples to graph
if (triples.Count > 1)
{
g.Assert(triples);
}
}
}
// Description
if (person.Descriptions != null && person.Descriptions.Any())
{
foreach (var description in person.Descriptions)
{
var lang = "en";
if (description.Type == PersonDescriptionType.Norwegian)
{
lang = "no";
}
g.Assert(new Triple(
g.CreateUriNode(),
g.CreateUriNode("dbo:abstract"),
g.CreateLiteralNode(description.Description, lang)));
}
}
// Date
if (person.FluffyDates != null && person.FluffyDates.Any())
{
foreach (var fluffyDate in person.FluffyDates)
{
if (fluffyDate.Type == PersonFluffyDateType.Birth &&
fluffyDate.Type == PersonFluffyDateType.Death)
{
continue;
}
var date =
new FluffyDate(
fluffyDate.Year,
fluffyDate.Month,
fluffyDate.Day);
var monthWithZero = string.Format("{0:00}", date.Month);
var dayWithZero = string.Format("{0:00}", date.Day);
var dateType = "dbo:birthDate";
var yearType = "dbo:birthYear";
if (fluffyDate.Type == PersonFluffyDateType.Death)
{
dateType = "dbo:deathDate";
yearType = "dbo:deathYear";
// FluffyDate can be blank if person is dead
g.Assert(new Triple(
g.CreateUriNode(),
g.CreateUriNode("rdf:type"),
g.CreateUriNode("fark:Dead")));
}
if (date.IsValidDate)
{
g.Assert(new Triple(
g.CreateUriNode(),
g.CreateUriNode(dateType),
g.CreateLiteralNode(
$"{date.Year}-{monthWithZero}-{dayWithZero}",
g.CreateUriNode("xsd:date").Uri)));
}
if (date.HasValidYear)
{
g.Assert(new Triple(
g.CreateUriNode(),
g.CreateUriNode(yearType),
g.CreateLiteralNode(
$"{date.Year}",
g.CreateUriNode("xsd:gYear").Uri)));
}
}
}
// Timestamp
g.Assert(new Triple(
g.CreateUriNode(),
g.CreateUriNode("dbp:timestamp"),
g.CreateLiteralNode(
person.TimeLastUpdated.ToString("yyyyMMddHHmmss"),
g.CreateUriNode("xsd:double").Uri)));
var writer = new CompressingTurtleWriter();
writer.Save(g, $"{_serviceSettings.Value.RdfTurtleFilesForPersonPath}/{person.PersonGuid}.ttl");
}
public IActionResult Create(
Guid personGuid,
PersonFluffyDateCreateModel createModel)
{
// Must have GUID
if (personGuid == Guid.Empty)
{
return(NotFound());
}
// Must have a person
var person =
_personData.ReadPersonWithFluffyDates(personGuid);
// Do we have what we need so far?
if (person == null)
{
return(NotFound());
}
// Page navigation
ViewData["PersonGuid"] = person.PersonGuid;
//
// Validate
//
var form =
new PersonFluffyDateModelState(
ModelState,
new FluffyDate(
createModel.Year,
createModel.Month,
createModel.Day),
createModel.Type,
person.FluffyDates,
null);
form.HasValidValues();
if (!ModelState.IsValid)
{
return(View(createModel));
}
form.HasUniqueTypeToBeCreated();
if (!ModelState.IsValid)
{
return(View(createModel));
}
form.BirthVsDeathYear();
if (!ModelState.IsValid)
{
return(View(createModel));
}
form.BirthVsDeathMonth();
if (!ModelState.IsValid)
{
return(View(createModel));
}
form.BirthVsDeathDay();
if (!ModelState.IsValid)
{
return(View(createModel));
}
form.PersonHasNormalAge();
if (!ModelState.IsValid)
{
return(View(createModel));
}
form.DateIsNotInTheFuture(
DateTime.Now.Year,
DateTime.Now.Month,
DateTime.Now.Day);
if (!ModelState.IsValid)
{
return(View(createModel));
}
//
// Create
//
var newPersonFluffyDate = new PersonFluffyDate();
newPersonFluffyDate.PersonId = person.PersonId;
newPersonFluffyDate.Year = createModel.Year;
newPersonFluffyDate.Month = createModel.Month;
newPersonFluffyDate.Day = createModel.Day;
newPersonFluffyDate.Type =
(PersonFluffyDateType)createModel.Type;
try
{
_personData.AddPersonFluffyDate(newPersonFluffyDate);
}
catch (DbUpdateException /* ex */)
{
// Log the error (uncomment ex variable name and write a log.)
ModelState.AddModelError(
"",
"Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
return(View(createModel));
}
//
// Update RDF
//
var readPerson = _personData.ReadAllPersonData(personGuid);
if (readPerson != null)
{
_rdfData.AddOrUpdatePerson(readPerson);
}
//
// Update search index
//
// Update selected year type
switch (createModel.Type)
{
case PersonFluffyDateTypeOptions.Birth:
_personSearchIndex.MergeYearOfBirth(
person.PersonGuid.ToString(),
createModel.Year);
break;
case PersonFluffyDateTypeOptions.Death:
_personSearchIndex.MergeYearOfDeath(
person.PersonGuid.ToString(),
createModel.Year);
break;
}
// Update age
// Get updated dates
person = _personData.ReadPersonWithFluffyDates(personGuid);
var birthFluffyDate =
person.FluffyDates.FirstOrDefault(x =>
x.Type == PersonFluffyDateType.Birth);
if (birthFluffyDate?.Year != null)
{
var fluffyDateStart =
new FluffyDate(
birthFluffyDate.Year,
birthFluffyDate.Month,
birthFluffyDate.Day);
var fluffyDateEnd =
new FluffyDate(
DateTime.Now.Year,
DateTime.Now.Month,
DateTime.Now.Day);
var deathFluffyDate =
person.FluffyDates.FirstOrDefault(x =>
x.Type == PersonFluffyDateType.Death);
if (deathFluffyDate?.Year != null)
{
fluffyDateEnd =
new FluffyDate(
deathFluffyDate.Year,
deathFluffyDate.Month,
deathFluffyDate.Day);
}
var age =
new Age(
fluffyDateStart,
fluffyDateEnd);
if (age.InYears != null)
{
_personSearchIndex.MergeAge(
person.PersonGuid.ToString(),
age.InYears);
}
}
//
// Redirect
//
return(RedirectToAction(
"Details",
"Person",
new { personGuid = personGuid }));
}
public IActionResult DeleteByPost(
int personFluffyDateId)
{
var fluffyDate =
_personData
.GetPersonFluffyDateWithNavigation(
personFluffyDateId);
if (fluffyDate == null)
{
return(NotFound());
}
_personData.DeletePersonFluffyDate(fluffyDate);
//
// Update RDF
//
var readPerson =
_personData.ReadAllPersonData(fluffyDate.Person.PersonGuid);
if (readPerson != null)
{
_rdfData.AddOrUpdatePerson(readPerson);
}
//
// Update search index
//
// Update selected year type
switch (fluffyDate.Type)
{
case PersonFluffyDateType.Birth:
_personSearchIndex.MergeYearOfBirth(
fluffyDate.Person.PersonGuid.ToString(),
null);
break;
case PersonFluffyDateType.Death:
_personSearchIndex.MergeYearOfDeath(
fluffyDate.Person.PersonGuid.ToString(),
null);
break;
}
// Update age
// Get updated dates
var person = _personData.ReadPersonWithFluffyDates(fluffyDate.Person.PersonGuid);
var birthFluffyDate =
person.FluffyDates.FirstOrDefault(x =>
x.Type == PersonFluffyDateType.Birth);
if (birthFluffyDate?.Year != null)
{
var fluffyDateStart =
new FluffyDate(
birthFluffyDate.Year,
birthFluffyDate.Month,
birthFluffyDate.Day);
var fluffyDateEnd =
new FluffyDate(
DateTime.Now.Year,
DateTime.Now.Month,
DateTime.Now.Day);
var deathFluffyDate =
person.FluffyDates.FirstOrDefault(x =>
x.Type == PersonFluffyDateType.Death);
if (deathFluffyDate?.Year != null)
{
fluffyDateEnd =
new FluffyDate(
deathFluffyDate.Year,
deathFluffyDate.Month,
deathFluffyDate.Day);
}
var age =
new Age(
fluffyDateStart,
fluffyDateEnd);
if (age.InYears != null)
{
_personSearchIndex.MergeAge(
person.PersonGuid.ToString(),
age.InYears);
}
}
else
{
_personSearchIndex.MergeAge(
person.PersonGuid.ToString(),
null);
}
//
// Redirect
//
return(RedirectToAction(
"Details",
"Person",
new { personGuid = fluffyDate.Person.PersonGuid }));
}
