private static DateTime GetAeltesterDigitalisierungsTerminDesBenutzers(DigitalisierungsKategorie kategorie, DigipoolEntry[] digipool,
DigipoolEntry digiItem)
{
return(digipool
.Where(d => d.UserId == digiItem.UserId && d.Digitalisierunskategorie == (int)kategorie)
.OrderBy(d => d.TerminDigitalisierung).FirstOrDefault()?.TerminDigitalisierung ?? DateTime.MinValue);
}
public async Task GetNextDigitalisierungsauftrag_Exception_in_method_with_digipoolEntry_not_null_should_return_413_return_code()
{
// Arrange
var digiPoolEntry = new DigipoolEntry {
VeId = 1, ApproveStatus = ApproveStatus.FreigegebenInSchutzfrist, OrderItemId = 999
};
var orderManagerMock = new Mock <IPublicOrder>();
orderManagerMock.Setup(x => x.GetDigipool(It.IsAny <int>())).ReturnsAsync(new[] { digiPoolEntry });
var mailHelperMock = new Mock <IMailHelper>();
var controller =
ArrangeControllerForGetNextDigitalisierungsauftragWithOrderMock(orderManagerMock.Object, mailHelperMock.Object,
null /*provokes error*/);
// Act
var auftrag = await controller.GetNextDigitalisierungsauftrag();
// Assert
auftrag.Should().BeOfType <NegotiatedContentResult <string> >();
((NegotiatedContentResult <string>)auftrag).StatusCode.Should().Be(HttpStatusCode.RequestEntityTooLarge);
// Verify that the order was marked a s faulted
orderManagerMock.Verify(x => x.MarkOrderAsFaulted(999), Times.Once);
mailHelperMock.Verify(
x => x.SendEmail(It.IsAny <IBus>(), It.IsAny <DigipoolAufbereitungFehlgeschlagen>(), It.IsAny <object>(), It.IsAny <bool>()), Times.Once);
}
private async Task <IHttpActionResult> ProcessFaultedItem(DigipoolEntry digipoolEntry, string exceptionInfo)
{
await orderManagerClient.MarkOrderAsFaulted(digipoolEntry.OrderItemId);
await SendDigipoolFailureMail(digipoolEntry.OrderItemId, exceptionInfo);
return(Content(HttpStatusCode.RequestEntityTooLarge, faultedItemExceptionMessage));
}
private async Task <IHttpActionResult> ProcessNormalError(DigipoolEntry digipoolEntry, Exception e)
{
// Any problem, mark the order as faulted.
if (digipoolEntry != null)
{
return(await ProcessFaultedItem(digipoolEntry, $"{e.Message}{Environment.NewLine + Environment.NewLine}{e.StackTrace}"));
}
// If there is an error, and we do not have a digipool entry, then return internal server error
// This should not happen
return(InternalServerError(e));
}
/// <summary>Erstellt einen DigitalisierungsAuftrag anhand der vom Benutzer gemachten Eingaben bei der Bestellung.</summary>
/// <param name="digipoolEntry">Der Auftrag aus dem DigiPool</param>
public async Task <DigitalisierungsAuftrag> GetManualDigitalisierungsAuftrag(DigipoolEntry digipoolEntry)
{
// Die Muss-Daten zunächst mit "keine Angabe" initialisieren
var auftrag = new DigitalisierungsAuftrag
{
Ablieferung = new AblieferungType
{
AblieferndeStelle = noDataAvailable, Ablieferungsnummer = noDataAvailable, AktenbildnerName = noDataAvailable
},
OrdnungsSystem = new OrdnungsSystemType {
Name = noDataAvailable, Signatur = noDataAvailable, Stufe = noDataAvailable
},
Dossier = new VerzEinheitType
{
Titel = noDataAvailable, Signatur = noDataAvailable, Entstehungszeitraum = noDataAvailable, Stufe = noDataAvailable
},
Auftragsdaten = new AuftragsdatenType {
Benutzungskopie = true, BestelleinheitId = "-1"
}
};
// Nun die Auftragsdaten mit den Benutzerangaben überschreiben, bzw. setzen
var orderItems = await orderManagerClient.FindOrderItems(new[] { digipoolEntry.OrderItemId });
var orderItem = orderItems.FirstOrDefault();
if (orderItem != null)
{
// Verschiedene Properties nun auf die angegebenen Benutzerangaben stellen.
auftrag.Ablieferung.Ablieferungsnummer = orderItem.Ablieferung;
auftrag.Dossier.Aktenzeichen = orderItem.Aktenzeichen;
auftrag.Dossier.Archivnummer = orderItem.ArchivNummer;
if (!string.IsNullOrEmpty(orderItem.BehaeltnisNummer))
{
auftrag.Dossier.Behaeltnisse = new List <BehaeltnisType>
{
new BehaeltnisType {
BehaeltnisCode = orderItem.BehaeltnisNummer, BehaeltnisTyp = noDataAvailable
}
};
}
auftrag.Dossier.Titel = orderItem.Dossiertitel;
auftrag.Dossier.Signatur = orderItem.Signatur;
auftrag.Dossier.Entstehungszeitraum = orderItem.ZeitraumDossier;
}
return(auftrag);
}
public async Task GetNextDigitalisierungsauftrag_if_ve_not_found_should_return_RequestEntityTooLarge()
{
// Arrange
var digiPoolEntry = new DigipoolEntry {
VeId = 1, ApproveStatus = ApproveStatus.FreigegebenInSchutzfrist
};
var controller = ArrangeControllerForGetNextDigitalisierungsauftrag(new[] { digiPoolEntry }, null);
// Act
var auftrag = await controller.GetNextDigitalisierungsauftrag();
// Assert
auftrag.Should().BeOfType <NegotiatedContentResult <string> >();
((NegotiatedContentResult <string>)auftrag).StatusCode.Should().Be(HttpStatusCode.RequestEntityTooLarge);
}
public void GetNextDigitalisierungsauftrag_returns_service_not_available_if_index_manager_is_not_running()
{
// Arrange
var digiPoolEntry = new DigipoolEntry {
VeId = 1, ApproveStatus = ApproveStatus.FreigegebenInSchutzfrist
};
var controller =
ArrangeControllerForGetNextDigitalisierungsauftragWithIndexManagerException(new[] { digiPoolEntry }, new RequestTimeoutException());
// Act
var auftrag = controller.GetNextDigitalisierungsauftrag().GetAwaiter().GetResult();
// Assert
auftrag.Should().BeOfType <NegotiatedContentResult <string> >();
((NegotiatedContentResult <string>)auftrag).StatusCode.Should().Be(HttpStatusCode.ServiceUnavailable);
}
private string GetBemerkungKunde(DigipoolEntry digipoolEntry)
{
var list = new List <string>();
if (!string.IsNullOrEmpty(digipoolEntry.OrderItemComment))
{
list.Add($"Aufrag: {digipoolEntry.OrderItemComment}");
}
if (!string.IsNullOrEmpty(digipoolEntry.OrderingComment))
{
list.Add($"Bestellung: {digipoolEntry.OrderingComment}");
}
return(string.Join(" ", list));
}
private void SetPriority(DigipoolEntry digipoolEntry)
{
var digitalisierunskategorie = (DigitalisierungsKategorie)digipoolEntry.Digitalisierunskategorie;
var terminBevorOrEqualToday = digipoolEntry.TerminDigitalisierung.Date <= DateTime.Now.Date;
if (digitalisierunskategorie == DigitalisierungsKategorie.Spezial)
{
digipoolEntry.Priority = 1;
}
else if ((digitalisierunskategorie == DigitalisierungsKategorie.Oeffentlichkeit ||
digitalisierunskategorie == DigitalisierungsKategorie.Forschungsgruppe) &&
terminBevorOrEqualToday)
{
digipoolEntry.Priority = 2;
}
else if (digitalisierunskategorie == DigitalisierungsKategorie.Gesuch && terminBevorOrEqualToday)
{
digipoolEntry.Priority = 3;
}
else if (digitalisierunskategorie == DigitalisierungsKategorie.Amt && terminBevorOrEqualToday)
{
digipoolEntry.Priority = 4;
}
else if (digitalisierunskategorie == DigitalisierungsKategorie.Intern && terminBevorOrEqualToday)
{
digipoolEntry.Priority = 5;
}
else if (digitalisierunskategorie == DigitalisierungsKategorie.Termin && terminBevorOrEqualToday)
{
digipoolEntry.Priority = 6;
}
else if (digitalisierunskategorie == DigitalisierungsKategorie.Amt)
{
digipoolEntry.Priority = 7;
}
else
{
digipoolEntry.Priority = 8;
}
// Die zuvor ermittelte Priorität wird übersteuert, wenn ein Aufbereitungsfehler vorliegt
if (digipoolEntry.HasAufbereitungsfehler)
{
digipoolEntry.Priority = 9;
}
}
public void GetNextDigitalisierungsauftrag_No_protection_end_date_returns_error()
{
// Arrange
var archiveRecord = new ElasticArchiveRecord {
ProtectionEndDate = null
};
var digiPoolEntry = new DigipoolEntry {
VeId = 1, ApproveStatus = ApproveStatus.FreigegebenInSchutzfrist, HasAufbereitungsfehler = false
};
var controller = ArrangeControllerForGetNextDigitalisierungsauftrag(new[] { digiPoolEntry }, archiveRecord);
// Act
var auftrag = controller.GetNextDigitalisierungsauftrag().GetAwaiter().GetResult();
// Assert
auftrag.Should().BeOfType <NegotiatedContentResult <string> >();
((NegotiatedContentResult <string>)auftrag).StatusCode.Should().Be(HttpStatusCode.RequestEntityTooLarge);
}
public async Task GetNextDigitalisierungsauftrag_if_ve_has_no_protectionEndDate_should_return_RequestEntityTooLarge()
{
// Arrange
var digiPoolEntry = new DigipoolEntry {
VeId = 1, ApproveStatus = ApproveStatus.FreigegebenInSchutzfrist
};
var archiveRecord = new ElasticArchiveRecord {
ArchiveRecordId = "1", ProtectionEndDate = null
};
var controller = ArrangeControllerForGetNextDigitalisierungsauftrag(new[] { digiPoolEntry }, archiveRecord);
// Act
var auftrag = await controller.GetNextDigitalisierungsauftrag();
// Assert
auftrag.Should().BeOfType <NegotiatedContentResult <string> >();
((NegotiatedContentResult <string>)auftrag).StatusCode.Should().Be(HttpStatusCode.RequestEntityTooLarge);
}
public async Task GetNextDigitalisierungsauftrag_VE_not_in_protection_with_approve_status_FreigegebenDurchSystem_returns_false()
{
// Arrange
var digiPoolEntry = new DigipoolEntry {
VeId = 1, ApproveStatus = ApproveStatus.FreigegebenDurchSystem
};
var archiveRecord = new ElasticArchiveRecord
{
ProtectionEndDate = new ElasticDateWithYear {
Date = new DateTime(1900, 12, 31), Year = 1900
}
};
var controller = ArrangeControllerForGetNextDigitalisierungsauftrag(new[] { digiPoolEntry }, archiveRecord);
// Act
var auftrag = (OkNegotiatedContentResult <DigitalisierungsAuftrag>) await controller.GetNextDigitalisierungsauftrag();
// Assert
auftrag.Content.Dossier.InSchutzfrist.Should().BeFalse();
}
public async Task GetNextDigitalisierungsauftrag_with_missing_must_fields_returns_internal_exception()
{
// Arrange
var digiPoolEntry = new DigipoolEntry {
VeId = 1, ApproveStatus = ApproveStatus.FreigegebenInSchutzfrist
};
var archiveRecord = new ElasticArchiveRecord
{
ProtectionEndDate = new ElasticDateWithYear {
Date = new DateTime(1900, 12, 31), Year = 1900
}
};
var controller = ArrangeControllerForInvalidGetNextDigitalisierungsauftrag(new[] { digiPoolEntry }, archiveRecord);
// Act
var auftrag = await controller.GetNextDigitalisierungsauftrag();
// Assert
auftrag.Should().BeOfType <NegotiatedContentResult <string> >();
((NegotiatedContentResult <string>)auftrag).StatusCode.Should().Be(HttpStatusCode.RequestEntityTooLarge);
}
public void GetNextDigitalisierungsauftrag_Digipool_returns_only_faulted_items_should_return_403_return_code()
{
// Arrange
var archiveRecord = new ElasticArchiveRecord
{
ProtectionEndDate = new ElasticDateWithYear {
Date = new DateTime(1900, 12, 31), Year = 1900
}
};
var digiPoolEntry = new DigipoolEntry {
VeId = 1, ApproveStatus = ApproveStatus.FreigegebenInSchutzfrist, HasAufbereitungsfehler = true
};
var controller = ArrangeControllerForGetNextDigitalisierungsauftrag(new[] { digiPoolEntry }, archiveRecord);
// Act
var auftrag = controller.GetNextDigitalisierungsauftrag().GetAwaiter().GetResult();
// Assert
auftrag.Should().BeOfType <NegotiatedContentResult <string> >();
((NegotiatedContentResult <string>)auftrag).StatusCode.Should().Be(HttpStatusCode.Forbidden);
}
public async Task GetNextDigitalisierungsauftrag_call_with_no_or_wrong_API_key_results_in_Unauthorized()
{
// Arrange
var digiPoolEntry = new DigipoolEntry {
VeId = null, ApproveStatus = ApproveStatus.FreigegebenInSchutzfrist
};
var archiveRecord = new ElasticArchiveRecord
{
ProtectionEndDate = new ElasticDateWithYear {
Date = new DateTime(1900, 12, 31), Year = 1900
}
};
var controller = ArrangeControllerForGetNextDigitalisierungsauftrag(new[] { digiPoolEntry }, archiveRecord);
// Now change api key
ApiKeyChecker.Key = "Change it";
// Act
var auftrag = await controller.GetNextDigitalisierungsauftrag();
// Assert
auftrag.Should().BeOfType <UnauthorizedResult>();
}
public async Task <IHttpActionResult> GetNextDigitalisierungsauftrag()
{
DigipoolEntry digipoolEntry = null;
if (!ApiKeyChecker.IsCorrect(Request))
{
return(Unauthorized());
}
try
{
Log.Verbose("Getting next order from digipool");
DigitalisierungsAuftrag auftrag;
var digipoolEntryArray = await orderManagerClient.GetDigipool(1);
if (digipoolEntryArray.Length == 0)
{
return(StatusCode(HttpStatusCode.NoContent));
}
digipoolEntry = digipoolEntryArray[0];
// Hat der zurückgelieferte Eintrag einen Aufbereitungsfehler, so bedeutet dies,
// dass nur noch Aufträge mit Aufbereitungsfehlern im Digipool liegen.
// Wir liefern einen spezifischen HTTP Code zurück um dies anzuzeigen
if (digipoolEntry.HasAufbereitungsfehler)
{
return(Content(HttpStatusCode.Forbidden, onlyFaultedItemsInDigipoolExceptionMessage));
}
if (digipoolEntry.VeId.HasValue)
{
// Hat die Bestellung eine VE-ID, so holen wir die Details zum Record aus Elastic und
// bereiten die Bestellung über den Dienst auf.
Log.Verbose($"Fetching ve {digipoolEntry.VeId} from elastic index");
var orderedItemRecord = await messageBusCallHelper.GetElasticArchiveRecord(digipoolEntry.VeId.ToString());
if (orderedItemRecord == null)
{
throw new Exception(veNotFoundMessage);
}
Log.Verbose($"Fetching full digitization order from AIS for {orderedItemRecord.GetAuszuhebendeArchiveRecordId()}");
auftrag = await digitizationHelper.GetDigitalisierungsAuftrag(orderedItemRecord.GetAuszuhebendeArchiveRecordId());
// Lade Dossier, falls bestellte Einheit nicht das Dossier ist
ElasticArchiveRecord dossierRecord;
dossierRecord = auftrag.Dossier.VerzEinheitId.ToString() != orderedItemRecord.ArchiveRecordId
? await messageBusCallHelper.GetElasticArchiveRecord(auftrag.Dossier.VerzEinheitId.ToString())
: orderedItemRecord;
if (dossierRecord.ProtectionEndDate?.Date == null)
{
throw new Exception(veHasNoProtectionEndDateMessage);
}
// Schutzfrist für Bestellungen hängen vom Schutzfrist-Enddatum des Dossiers und dem Freigabestatus ab.
// Der Freigabestatus ist immer derjenige der bestellten Einheit.
if (dossierRecord.ProtectionEndDate.Date > DateTime.Today)
{
auftrag.Dossier.InSchutzfrist = digipoolEntry.ApproveStatus != ApproveStatus.FreigegebenAusserhalbSchutzfrist;
}
else
{
auftrag.Dossier.InSchutzfrist = digipoolEntry.ApproveStatus == ApproveStatus.FreigegebenInSchutzfrist;
}
// Übertrage den Wert des Schutzfristproperties des Dossiers, auf alle enthaltenen VE (rekursiv)
UpdateInSchutzfrist(auftrag.Dossier.UntergeordneteVerzEinheiten, auftrag.Dossier.InSchutzfrist);
}
else
{
// Hat die Bestellung KEINE VE-ID, so handelt es sich um ein manuell hinzugefügtes Dossier.
// Wir erstellen manuell ein DigitalisierungsAuftrag mit den Angaben des Benutzers.
auftrag = await digitizationHelper.GetManualDigitalisierungsAuftrag(digipoolEntry);
// Schutzfrist für manuelle Bestellungen hängen nur vom Freigabestatus des Auftrags ab.
auftrag.Dossier.InSchutzfrist = digipoolEntry.ApproveStatus != ApproveStatus.FreigegebenAusserhalbSchutzfrist;
}
// Gemeinsame Daten
auftrag.Auftragsdaten.AuftragsId = digipoolEntry.OrderItemId.ToString();
auftrag.Auftragsdaten.BemerkungenBar = digipoolEntry.InternalComment + "";
auftrag.Auftragsdaten.BemerkungenKunde = GetBemerkungKunde(digipoolEntry) + "";
auftrag.Auftragsdaten.Bestelldatum = digipoolEntry.OrderDate;
Log.Verbose("Update Benutzungskopie flag for order");
await orderManagerClient.UpdateBenutzungskopie(digipoolEntry.OrderItemId, auftrag.Auftragsdaten.Benutzungskopie);
var errorList = ValidateAuftrag(auftrag);
if (errorList.Any())
{
throw new XmlSchemaValidationException("The data is not valid according to the Auftragsdaten.xsd schema. " +
$"{Environment.NewLine}The errors found are:{Environment.NewLine}" +
$"{string.Join(Environment.NewLine, errorList)}");
}
return(Ok(auftrag));
}
// Request timeout --> Manager, Index or External Content Service is not running
catch (RequestTimeoutException e)
{
Log.Error(e, "RequestTimeout Exception");
return(Content(HttpStatusCode.ServiceUnavailable, serviceNotAvailableExceptionMessage));
}
// Something in the remote call failed.
catch (RequestFaultException e)
{
Log.Error(e, "Remote call faulted");
// if we have a remote sql db problem, then return a service unavailable
if (e.Fault.Exceptions[0].ExceptionType == typeof(OrderDatabaseNotFoundOrNotRunningException).FullName)
{
return(Content(HttpStatusCode.ServiceUnavailable, $"{serviceNotAvailableExceptionMessage} (SQL Server not running.)"));
}
// if we have a remote ais db problem, then return a service unavailable
if (e.Fault.Exceptions[0].ExceptionType == typeof(AISDatabaseNotFoundOrNotRunningException).FullName)
{
return(Content(HttpStatusCode.ServiceUnavailable, $"{serviceNotAvailableExceptionMessage} (AIS database not running."));
}
// Any other problem, mark the order as faulted.
if (digipoolEntry != null)
{
return(await ProcessFaultedItem(digipoolEntry,
$"{e.Fault.Exceptions[0].Message}{Environment.NewLine + Environment.NewLine}{e.Fault.Exceptions[0].StackTrace}"));
}
// If there is an error, and we do not have a digipool entry, then return internal server error
// This should not happen
return(InternalServerError(e));
}
catch (XmlSchemaValidationException e)
{
Log.Error(e, "Schema validation failed");
return(await ProcessNormalError(digipoolEntry, e));
}
catch (Exception e)
{
Log.Error(e, "Unexpected error while getting next order from digipool.");
return(await ProcessNormalError(digipoolEntry, e));
}
}
