protected bool IsEinsichtsbewilligungNotwendig(ElasticArchiveRecord record, UserAccess access, bool hasBewilligungsDatum)
{
return(record.HasCustomProperty("zugänglichkeitGemässBga") &&
record.CustomFields.zugänglichkeitGemässBga == "In Schutzfrist" &&
!access.HasAnyTokenFor(record.PrimaryDataDownloadAccessTokens) &&
!hasBewilligungsDatum);
}
private Auftrag GetAuftragForOrderItemWithVeId(Ordering ordering, OrderItem orderItem)
{
var bestellterRecord = GetElasticArchiveRecord(orderItem.VeId.ToString());
ElasticArchiveRecord auszuhebenderRecord = null;
var besteller = GetPerson(ordering.UserId);
if (ordering.Type == OrderType.Digitalisierungsauftrag)
{
var dossierId = bestellterRecord.GetAuszuhebendeArchiveRecordId();
if (dossierId != null)
{
auszuhebenderRecord = GetElasticArchiveRecord(dossierId);
}
}
else
{
auszuhebenderRecord = bestellterRecord;
}
var auftrag = new Auftrag(orderItem,
ordering,
InElasticIndexierteVe.FromElasticArchiveRecord(bestellterRecord),
InElasticIndexierteVe.FromElasticArchiveRecord(auszuhebenderRecord),
besteller);
return(auftrag);
}
public async Task Eine_Lesesaalausleihen_eines_BAR_Benutzers_wird_nicht_automatisch_freigegeben_wenn_die_DownloadTokens_nicht_BAR_enthalten()
{
var currentUser = new User {
Id = "current"
};
var besteller = new User
{
Id = "besteller", Access = new UserAccess("besteller", AccessRoles.RoleBAR, "ALLOW", new string[0], false, "de")
};
var item = new OrderItem {
OrderId = 1, Id = 1001, VeId = 200, Status = OrderStatesInternal.ImBestellkorb
};
var ordering = new Ordering {
Id = 1, UserId = "besteller", Type = OrderType.Lesesaalausleihen, OrderDate = DateTime.Now
};
var ear = new ElasticArchiveRecord
{
PrimaryDataDownloadAccessTokens = new List <string>(),
ArchiveRecordId = item.VeId.Value.ToString()
};
await PerformTest(currentUser, besteller, ordering, item, ear, p => p.Bestellen());
item.Status.Should().Be(OrderStatesInternal.FreigabePruefen);
item.ApproveStatus.Should().Be(ApproveStatus.NichtGeprueft);
}
/// <summary>
/// Diese Methode wurde nach den genauen schriftlichen Vorgaben des BARs implementiert.
/// Diese Vorgaben sind im Anwendungshandbuch enthalten und finden sich auch unter dem folgenden Link:
/// </summary>
public async Task <CacheRetentionCategory> GetRetentionCategory(ElasticArchiveRecord archiveRecord, string rolePublicClient,
IOrderDataAccess orderDataAccess)
{
var downloadAccessTokens = archiveRecord.PrimaryDataDownloadAccessTokens;
if (downloadAccessTokens.Contains(AccessRoles.RoleOe2) || downloadAccessTokens.Exists(t => t.StartsWith("FG_")))
{
return(CacheRetentionCategory.UsageCopyPublic);
}
if (downloadAccessTokens.Contains("DDS") && archiveRecord.ProtectionEndDate?.Date.Date < DateTime.Now.Date)
{
return(CacheRetentionCategory.UsageCopyPublic);
}
if (rolePublicClient == AccessRoles.RoleBAR)
{
return(CacheRetentionCategory.UsageCopyBarOrAS);
}
if (int.TryParse(archiveRecord.ArchiveRecordId, out var veId) && await orderDataAccess.HasEinsichtsbewilligung(veId))
{
return(CacheRetentionCategory.UsageCopyEB);
}
if (rolePublicClient == AccessRoles.RoleAS)
{
return(CacheRetentionCategory.UsageCopyBarOrAS);
}
return(CacheRetentionCategory.UsageCopyAB);
}
public async Task Ein_Digitalisierungsauftrag_eines_BAR_Benutzers_erhaelt_die_Digitalisierungskategorie_Intern()
{
var currentUser = new User {
Id = "current"
};
var besteller = new User
{
Id = "besteller", Access = new UserAccess("besteller", AccessRoles.RoleBAR, "ALLOW", new string [0], false, "de")
};
var item = new OrderItem {
OrderId = 1, Id = 1001, VeId = 200, Status = OrderStatesInternal.ImBestellkorb
};
var ordering = new Ordering {
Id = 1, UserId = "besteller", Type = OrderType.Digitalisierungsauftrag, OrderDate = DateTime.Now
};
var ear = new ElasticArchiveRecord
{
PrimaryDataDownloadAccessTokens = new List <string>(new[] { "BAR" }),
ArchiveRecordId = item.VeId.Value.ToString()
};
await PerformTest(currentUser, besteller, ordering, item, ear, p => p.Bestellen());
item.DigitalisierungsKategorie.Should().Be(DigitalisierungsKategorie.Intern);
}
/// <summary>
/// Falls die Methode true zurückgibt, muss der der Benutzer
/// A) wählen das keine Personendaten vorhanden sind oder
/// B) ein Grund auswählen
/// </summary>
internal static bool CouldNeedAReason(ElasticArchiveRecord record, UserAccess access)
{
return(record.HasCustomProperty("zugänglichkeitGemässBga") &&
access.RolePublicClient == AccessRoles.RoleAS &&
access.HasAsTokenFor(record.PrimaryDataDownloadAccessTokens) &&
(record.CustomFields.zugänglichkeitGemässBga == "In Schutzfrist" ||
record.CustomFields.zugänglichkeitGemässBga == "Prüfung nötig"));
}
private bool CheckUserHasDownloadTokensForVe(UserAccess access, ElasticArchiveRecord record)
{
if (record == null)
{
return(false);
}
return(access.HasAnyTokenFor(record.PrimaryDataDownloadAccessTokens));
}
public void Test_IndexManager_Should_Fill_CustomFields_Correctly()
{
// Arrange
var configFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "customFieldsConfig.json");
var mockSearchIndexAccess = new Mock <ISearchIndexDataAccess>();
mockSearchIndexAccess.Setup(s => s
.UpdateDocument(It.IsAny <ElasticArchiveRecord>()))
.Callback(() => Console.WriteLine("Update Document was called"));
mockSearchIndexAccess.Setup(s => s
.RemoveDocument(It.IsAny <string>()))
.Callback(() => Console.WriteLine("Remove Document was called"));
var config = new CustomFieldsConfiguration(configFile);
var indexmanager = new IndexManager(mockSearchIndexAccess.Object, config);
var archiveRecord = new ElasticArchiveRecord();
var dataElementFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "dataElements.json");
var json = File.ReadAllText(dataElementFile);
var dataElements = JsonConvert.DeserializeObject <List <DataElement> >(json);
// Act
indexmanager.TransferDataFromPropertyBag(archiveRecord, dataElements);
// Assert
Assert.IsNotNull(archiveRecord.CustomFields, "CustomField Property should be filled correctly");
Assert.Throws <RuntimeBinderException>(() =>
{
var test = archiveRecord.CustomFields.Title;
},
"Title is not a custom field, so it should not be in the dynamic property");
Assert.DoesNotThrow(() =>
{
var test = archiveRecord.CustomFields.ZugänglichkeitGemässBga;
},
"ZugänglichkeitGemässBga is a custom field (with special chars), and so it should not throw on access");
Assert.Throws <RuntimeBinderException>(() =>
{
var testYear = archiveRecord.CustomFields.DummyElasticdatewithyear;
},
"DummyElasticDateWithYear is not available, as there is no data for it.");
Assert.IsNotNull(archiveRecord.CustomFields.Form);
Assert.AreEqual("Fotografie", archiveRecord.CustomFields.Form);
Assert.IsAssignableFrom <List <ElasticHyperlink> >(archiveRecord.CustomFields.DigitaleVersion);
Assert.AreEqual("https://commons.wikimedia.org/wiki/File:Flugzeug_Grandjean_vor_dem_Aufstieg_-_CH-BAR_-_3236769.tif",
archiveRecord.CustomFields.DigitaleVersion[0].Url);
Assert.AreEqual("E27#1000/721#14093#5489* (Wikimedia Commons)",
archiveRecord.CustomFields.DigitaleVersion[0].Text);
}
public void Test_CustomFields_Serialization_Working_Correct()
{
// Arrange
var configFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "customFieldsConfig.json");
var mockSearchIndexAccess = new Mock <ISearchIndexDataAccess>();
mockSearchIndexAccess.Setup(s => s
.UpdateDocument(It.IsAny <ElasticArchiveRecord>()))
.Callback(() => Console.WriteLine("Update Document was called"));
mockSearchIndexAccess.Setup(s => s
.RemoveDocument(It.IsAny <string>()))
.Callback(() => Console.WriteLine("Remove Document was called"));
var config = new CustomFieldsConfiguration(configFile);
var indexmanager = new IndexManager(mockSearchIndexAccess.Object, config);
var archiveRecord = new ElasticArchiveRecord();
var dataElementFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "dataElements.json");
var json = File.ReadAllText(dataElementFile);
var dataElements = JsonConvert.DeserializeObject <List <DataElement> >(json);
// Act
indexmanager.TransferDataFromPropertyBag(archiveRecord, dataElements);
var jsonString = JsonConvert.SerializeObject(archiveRecord);
var record = JsonConvert.DeserializeObject <ElasticArchiveRecord>(jsonString);
// Assert
Assert.IsNotNull(record);
// Beim deserialisieren via Elastic hat das dynamic Property ein ExpandoObject
Assert.IsAssignableFrom <ExpandoObject>(record.CustomFields);
// - nicht weiter schlimm, wir können es weiterhin als dynamic ansprechen
Assert.DoesNotThrow(() =>
{
var test = record.CustomFields.Form;
Console.WriteLine(test);
});
// - und die properties auslesen
var form = record.CustomFields.Form;
Assert.IsNotNull(form);
Assert.AreEqual("Fotografie", form);
Assert.IsAssignableFrom <List <dynamic> >(record.CustomFields.DigitaleVersion);
var hyperlink = record.CustomFields.DigitaleVersion[0];
Assert.AreEqual("https://commons.wikimedia.org/wiki/File:Flugzeug_Grandjean_vor_dem_Aufstieg_-_CH-BAR_-_3236769.tif",
hyperlink.Url);
Assert.AreEqual("E27#1000/721#14093#5489* (Wikimedia Commons)",
hyperlink.Text);
}
public VeFuerKontrollstelle(ElasticArchiveRecord elasticArchiveRecord, int?begruendung) : base(elasticArchiveRecord)
{
var idList = new List <int>();
var hasBegruendung = begruendung != null && begruendung != 0;
if (hasBegruendung)
{
idList.Add(begruendung.Value);
}
Begründung = new Stammdaten(idList, "Reason");
HatPersonendaten = hasBegruendung;
}
private ElasticArchiveRecord GetSampleArchiveRecord()
{
var record = new ElasticArchiveRecord
{
CreationPeriod = new ElasticTimePeriod {
StartDate = DateTime.Today
},
CustomFields = new ExpandoObject()
};
record.CustomFields.aktenzeichen = "Ein Beispiel";
return(record);
}
/// <summary>Arranges the Vecteur controller</summary>
/// <param name="digipoolResult">The result that should be returned from the call to GetDigipool</param>
/// <param name="archiveRecordResult">The result that should be returned from the Elastic DB. It is the archive record</param>
private VecteurController ArrangeControllerForGetNextDigitalisierungsauftrag(DigipoolEntry[] digipoolResult,
ElasticArchiveRecord archiveRecordResult)
{
var actionClientMock = Mock.Of <IVecteurActions>();
var orderManagerMock = Mock.Of <IPublicOrder>(x => x.GetDigipool(It.IsAny <int>()) == Task.FromResult(digipoolResult));
var digitizationHelperMock = Mock.Of <IDigitizationHelper>(x =>
x.GetDigitalisierungsAuftrag(It.IsAny <string>()) == GetEmptyDigitalisierungsauftrag() &&
x.GetManualDigitalisierungsAuftrag(It.IsAny <DigipoolEntry>()) == GetEmptyDigitalisierungsauftrag());
var busHelper =
Mock.Of <IMessageBusCallHelper>(x => x.GetElasticArchiveRecord(It.IsAny <string>()) == Task.FromResult(archiveRecordResult));
return(SetupVecteurController(actionClientMock, orderManagerMock, digitizationHelperMock, busHelper, Mock.Of <IMailHelper>()));
}
private IHttpActionResult CheckStatusAsync(string packageId, ElasticArchiveRecord record, UserAccess access)
{
if (string.IsNullOrEmpty(packageId))
{
return(BadRequest("VE does not contain any primarydata and/or a valid packageid"));
}
if (!CheckUserHasDownloadTokensForVe(access, record))
{
return(StatusCode(HttpStatusCode.Forbidden));
}
return(StatusCode(HttpStatusCode.OK));
}
private bool VeLiegtDigitalVor(int?veId)
{
// Für die Ermittlung von VeLiegtDigitalVor kann nicht OrderItem.IdentifikationDigitalesMagazin verwendet werden.
// Darum werden Daten vom Elastic geholt.
ElasticArchiveRecord archiveRecord = null;
if (veId.HasValue)
{
archiveRecord = Context.IndexAccess.FindDocument(veId.Value.ToString(), false);
}
return(!string.IsNullOrEmpty(archiveRecord?.PrimaryDataLink));
}
private static ElasticArchiveRecord CreateElasticArchiveRecord(List <int> list)
{
// Arrange
var elasticArchiveRecord = new ElasticArchiveRecord()
{
ArchiveRecordId = "Start1",
PrimaryDataLink = "DifferentAip@DossierId",
AggregationFields = new ElasticAggregationFields(),
CreationPeriod = new ElasticTimePeriod()
};
elasticArchiveRecord.CreationPeriod.Years = list;
return(elasticArchiveRecord);
}
/// <summary>
/// Calculate the Period how create the Record
/// </summary>
/// <param name="elasticArchiveRecord"></param>
public static void CalculateCreationPeriodBuckets(ElasticArchiveRecord elasticArchiveRecord)
{
if (elasticArchiveRecord.CreationPeriod != null && elasticArchiveRecord.CreationPeriod.Years.Any())
{
elasticArchiveRecord.AggregationFields.CreationPeriodYears001 =
elasticArchiveRecord.CreationPeriod.Years;
elasticArchiveRecord.AggregationFields.CreationPeriodYears005 =
elasticArchiveRecord.CreationPeriod.Years.Select(year => (int)Math.Floor(year / 5m) * 5).Distinct().ToList();
elasticArchiveRecord.AggregationFields.CreationPeriodYears010 =
elasticArchiveRecord.CreationPeriod.Years.Select(year => (int)Math.Floor(year / 10m) * 10).Distinct().ToList();
elasticArchiveRecord.AggregationFields.CreationPeriodYears025 =
elasticArchiveRecord.CreationPeriod.Years.Select(year => (int)Math.Floor(year / 25m) * 25).Distinct().ToList();
elasticArchiveRecord.AggregationFields.CreationPeriodYears100 =
elasticArchiveRecord.CreationPeriod.Years.Select(year => (int)Math.Floor(year / 100m) * 100).Distinct().ToList();
}
}
public async Task <IHttpActionResult> AddUnknowToBasket(string signatur)
{
if (string.IsNullOrEmpty(signatur))
{
return(BadRequest($"{nameof(signatur)}"));
}
var searchResult =
entityProvider.SearchByReferenceCodeWithoutSecurity <ElasticArchiveRecord>(signatur);
var searchRecordResult = searchResult as SearchResult <ElasticArchiveRecord>;
ElasticArchiveRecord entity = null;
if (searchRecordResult?.Entities != null)
{
entity = searchRecordResult.Entities.Items[0].Data;
}
if (entity == null)
{
return(Content(HttpStatusCode.NotFound, $"No VE found by signatur {signatur}"));
}
if (!entity.CanBeOrdered ||
!(entity.Level == "Dossier" || entity.Level == "Subdossier" || entity.Level == "Dokument"))
{
return(Content(HttpStatusCode.Conflict, "Ve can not be ordered according to index"));
}
var userId = ControllerHelper.GetCurrentUserId();
// Check VE is exists already in basket
if (int.TryParse(entity.ArchiveRecordId, out var veId) && !await client.IsUniqueVeInBasket(veId, userId))
{
return(Content(HttpStatusCode.OK, new OrderItemDto {
VeId = veId
}));
}
var settings = FrontendSettingsViaduc.Instance;
var unknowText = settings.GetTranslation(WebHelper.GetClientLanguage(Request), "order.unknowtext",
"[Nicht sichtbar]");
var indexSnapShot = OrderHelper.GetOrderingIndexSnapshot(entity, unknowText);
var orderItemDb = await client.AddToBasket(indexSnapShot, ControllerHelper.GetCurrentUserId());
return(Content(HttpStatusCode.Created, ConvertDbItemToDto(orderItemDb, OrderType.Bestellkorb, true)));
}
public async Task Statuswechsel_zu_Reponieren_bereit_löst_für_eine_Gebrauchskopie_download_aus()
{
var currentUser = Users.Vecteur;
var besteller = new User {
Id = "besteller"
};
var item = new OrderItem
{
OrderId = 1, Id = 1001, VeId = 200, Benutzungskopie = false, Status = OrderStatesInternal.DigitalisierungExtern
};
var ordering = new Ordering {
Id = 1, UserId = "besteller", Type = OrderType.Digitalisierungsauftrag, OrderDate = DateTime.Now
};
var ear = new ElasticArchiveRecord
{
PrimaryDataDownloadAccessTokens = new List <string>(),
ArchiveRecordId = item.VeId?.ToString()
};
var auftragErledigtMock = new Mock <IConsumer <IDigitalisierungsAuftragErledigt> >();
auftragErledigtMock.Setup(e => e.Consume(It.IsAny <ConsumeContext <IDigitalisierungsAuftragErledigt> >())).Returns(Task.CompletedTask);
var benutzungskopieErledigtMock = new Mock <IConsumer <IBenutzungskopieAuftragErledigt> >();
benutzungskopieErledigtMock.Setup(e => e.Consume(It.IsAny <ConsumeContext <IBenutzungskopieAuftragErledigt> >()))
.Returns(Task.CompletedTask);
var harness = new InMemoryTestHarness();
var auftragConsumer = harness.Consumer(() => auftragErledigtMock.Object, BusConstants.DigitalisierungsAuftragErledigtEvent);
var benutzungConsumer = harness.Consumer(() => benutzungskopieErledigtMock.Object, BusConstants.BenutzungskopieAuftragErledigtEvent);
await harness.Start();
await PerformTest(currentUser, besteller, ordering, item, ear, p => p.SetStatusZumReponierenBereit(), harness.Bus);
item.Status.Should().Be(OrderStatesInternal.ZumReponierenBereit);
auftragConsumer.Consumed.Select <IDigitalisierungsAuftragErledigt>().Any().Should().BeTrue();
auftragErledigtMock.Verify(e => e.Consume(It.IsAny <ConsumeContext <IDigitalisierungsAuftragErledigt> >()), Times.Once);
benutzungConsumer.Consumed.Select <IBenutzungskopieAuftragErledigt>().Any().Should().BeFalse();
benutzungskopieErledigtMock.Verify(e => e.Consume(It.IsAny <ConsumeContext <IBenutzungskopieAuftragErledigt> >()), Times.Never);
await harness.Stop();
}
public void GetNextDigitalisierungsauftrag_returns_service_not_available_if_order_manager_is_not_running()
{
// Arrange
var archiveRecord = new ElasticArchiveRecord
{
ProtectionEndDate = new ElasticDateWithYear {
Date = new DateTime(1900, 12, 31), Year = 1900
}
};
var controller = ArrangeControllerForGetNextDigitalisierungsauftragWithDigipoolException(new RequestTimeoutException(), archiveRecord);
// Act
var auftrag = controller.GetNextDigitalisierungsauftrag().GetAwaiter().GetResult();
// Assert
auftrag.Should().BeOfType <NegotiatedContentResult <string> >();
((NegotiatedContentResult <string>)auftrag).StatusCode.Should().Be(HttpStatusCode.ServiceUnavailable);
}
public async Task GetNextDigitalisierungsauftrag_if_digipool_is_empty_NoContent_is_returned()
{
// Arrange
var archiveRecord = new ElasticArchiveRecord
{
ProtectionEndDate = new ElasticDateWithYear {
Date = new DateTime(1900, 12, 31), Year = 1900
}
};
var controller = ArrangeControllerForGetNextDigitalisierungsauftrag(Array.Empty <DigipoolEntry>(), archiveRecord);
// Act
var auftrag = await controller.GetNextDigitalisierungsauftrag();
// Assert
auftrag.Should().BeOfType <StatusCodeResult>();
((StatusCodeResult)auftrag).StatusCode.Should().Be(HttpStatusCode.NoContent);
}
public void TransferDataFromPropertyBag(ElasticArchiveRecord elasticArchiveRecord, List <DataElement> detailData)
{
var customFields = new ExpandoObject() as IDictionary <string, object>;
var defaultProperties = elasticArchiveRecord.GetType().GetProperties();
foreach (var fieldConfiguration in fieldsConfiguration.Fields)
{
try
{
var value = GetValue(detailData, fieldConfiguration);
if ((fieldConfiguration.TargetField == "ReferenceCode" || fieldConfiguration.TargetField == "Title") &&
string.IsNullOrWhiteSpace(value as string))
{
value = "Keine Angabe";
}
if (value != null)
{
if (fieldConfiguration.IsDefaultField)
{
var prop = defaultProperties.FirstOrDefault(d =>
d.Name.ToLowerInvariant() == fieldConfiguration.TargetField.ToLowerInvariant());
if (prop != null)
{
prop.SetValue(elasticArchiveRecord, value);
}
}
else
{
customFields.Add(fieldConfiguration.TargetField, value);
}
}
}
catch (Exception ex)
{
Log.Error(ex.Message);
}
}
// Add the customer fields to the "main" record
elasticArchiveRecord.CustomFields = customFields;
}
public static ElasticArchiveRecord Generate(long id)
{
var record = new ElasticArchiveRecord
{
ArchiveRecordId = id.ToString()
};
record.ArchiveRecordId = "ID" + 71 * id;
record.MetadataAccessTokens = GenerateAccessTokens(id);
record.Title = GenerateTitel(id);
record.ReferenceCode = "RC" + 3 * id;
record.Level = PickFromArray(new[] { "Abteilung", "Bestand", "Serie", "Dossier", "Dokument" },
id);
record.CreationPeriod = GetTimePeriod(id);
record.WithinInfo =
PickFromArray(
new[] { "Diverse", "Gut erhaltene", "Teilweise historisch interessante", "Von Säure zerfressene" }, id) +
" " +
PickFromArray(
new[]
{
"Fotos", "Briefe", "Siegel", "Urkunden aus Pergament", "diplomatische Depeschen",
"verschlüsselte Nachrichten"
}, id);
record.HasImage = false;
record.HasAudioVideo = false;
record.FormerReferenceCode = string.Empty;
record.PlayingLengthInS = id % 31 == 0 ? (int)(91 * id) % 3600 : 0;
record.Extent = PickFromArray(
new[] { "1", "2", "5", "21" }, id) +
" " +
PickFromArray(
new[]
{
"Laufmeter", "Archivschachteln", "Dossiermappen", "Mikrofilme"
}, id);
record.CanBeOrdered = id % 19 < 18;
return(record);
}
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 void OneTimeSetup()
{
var uri = "(change here, but do not commit)";
var node = new Uri(uri);
helper = new ElasticIndexHelper(node, "test2");
if (helper.IndexExists("test2"))
{
helper.DeleteIndex("test2");
}
helper.CreateIndex("test2");
var ear = new ElasticArchiveRecord();
ear.ArchiveRecordId = "1";
ear.PrimaryData = new List <ElasticArchiveRecordPackage>();
ear.PrimaryData.Add(new ElasticArchiveRecordPackage());
ear.PrimaryData[0].Items.Add(new ElasticRepositoryObject());
ear.PrimaryData[0].Items[0].Content = "PrimaryDataContent";
ear.Title = "Title";
ear.WithinInfo = "WithinInfo";
ear.CustomFields = new
{
zugänglichkeitGemässBga = "In Schutzfrist",
publikationsrechte = "ABC"
};
helper.Index(ear);
// Wait till index is ready
ISearchResponse <ElasticArchiveRecord> searchResponse;
do
{
Thread.Sleep(500);
searchResponse = Search("Title", "title");
} while (searchResponse.Hits.Count == 0);
}
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 void When_Providing_Unknown_Test_It_Should_Fill_Every_Secret_Property_With_UnknownText()
{
// arrange
var record = new ElasticArchiveRecord();
SetAllStringPropertiesWithThisText(record, "SECRET");
record.Containers = new List <ElasticContainer>
{
new ElasticContainer
{
ContainerCode = "SECRET",
ContainerCarrierMaterial = "SECRET",
ContainerLocation = "SECRET",
ContainerType = "SECRET",
IdName = "SECRET"
}
};
// these fields are allowed to contain the secret texts
var exceptions = new[]
{
nameof(OrderingIndexSnapshot.VeId),
nameof(OrderingIndexSnapshot.Signatur),
nameof(OrderingIndexSnapshot.ZugaenglichkeitGemaessBga)
};
// act
var snapshot = OrderHelper.GetOrderingIndexSnapshot(record, "HIDDEN");
// assert
foreach (var prop in typeof(OrderingIndexSnapshot)
.GetProperties()
.Where(p => p.PropertyType == typeof(string) && !exceptions.Contains(p.Name)))
{
var value = prop.GetValue(snapshot);
value.Should().Be("HIDDEN", $"Field {prop.Name} must not leak secret details");
}
}
public void GetNextDigitalisierungsauftrag_SQL_Server_not_available_returns_service_not_available()
{
// Arrange
var archiveRecord = new ElasticArchiveRecord
{
ProtectionEndDate = new ElasticDateWithYear {
Date = new DateTime(1900, 12, 31), Year = 1900
}
};
// Setup specific exception that signals that database is down
var fe = new FaultEvent <OrderDatabaseNotFoundOrNotRunningException>(new OrderDatabaseNotFoundOrNotRunningException(), new Guid(), null,
new OrderDatabaseNotFoundOrNotRunningException(), null);
var ex = new RequestFaultException("", fe);
var controller = ArrangeControllerForGetNextDigitalisierungsauftragWithDigipoolException(ex, archiveRecord);
// Act
var auftrag = controller.GetNextDigitalisierungsauftrag().GetAwaiter().GetResult();
// Assert
auftrag.Should().BeOfType <NegotiatedContentResult <string> >();
((NegotiatedContentResult <string>)auftrag).StatusCode.Should().Be(HttpStatusCode.ServiceUnavailable);
}
