public async Task <ActionResult> Undelete(int instanceOwnerPartyId, Guid instanceGuid)
{
string instanceId = $"{instanceOwnerPartyId}/{instanceGuid}";
Instance instance;
try
{
instance = await _instanceRepository.GetOne(instanceId, instanceOwnerPartyId);
}
catch (DocumentClientException dce)
{
if (dce.Error.Code.Equals("NotFound"))
{
return(NotFound($"Didn't find the object that should be restored with instanceId={instanceId}"));
}
return(StatusCode(500, $"Unknown database exception in restore: {dce}"));
}
if (instance.Status.HardDeleted.HasValue)
{
return(BadRequest("Instance was permanently deleted and cannot be restored."));
}
else if (instance.Status.SoftDeleted.HasValue)
{
instance.LastChangedBy = User.GetUserOrOrgId();
instance.LastChanged = DateTime.UtcNow;
instance.Status.SoftDeleted = null;
InstanceEvent instanceEvent = new InstanceEvent
{
Created = DateTime.UtcNow,
EventType = InstanceEventType.Undeleted.ToString(),
InstanceId = instance.Id,
InstanceOwnerPartyId = instance.InstanceOwner.PartyId,
User = new PlatformUser
{
UserId = User.GetUserIdAsInt(),
AuthenticationLevel = User.GetAuthenticationLevel(),
OrgId = User.GetOrg(),
}
};
try
{
await _instanceRepository.Update(instance);
await _instanceEventRepository.InsertInstanceEvent(instanceEvent);
return(Ok(true));
}
catch (Exception e)
{
return(StatusCode(500, $"Unknown exception in restore: {e}"));
}
}
return(Ok(true));
}
/// <inheritdoc/>
public async Task <string> SaveInstanceEvent(object dataToSerialize, string org, string appName)
{
InstanceEvent instanceEvent = (InstanceEvent)dataToSerialize;
instanceEvent.CreatedDateTime = DateTime.UtcNow;
string apiUrl = $"instances/{instanceEvent.InstanceId}/events";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
try
{
HttpResponseMessage response = await _client.PostAsync(apiUrl, new StringContent(instanceEvent.ToString(), Encoding.UTF8, "application/json"));
string eventData = await response.Content.ReadAsStringAsync();
InstanceEvent result = JsonConvert.DeserializeObject <InstanceEvent>(eventData);
return(result.Id.ToString());
}
catch
{
_logger.LogError($"Unable to store instance event");
return(null);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="App"/> class.
/// </summary>
public App()
{
ParseArguments();
// IsCreatedNew is updated during static fields initialization.
if (!IsCreatedNew)
{
Logger.AddLog("Another instance is already running");
// Optionally tell the other instance to stop.
if (IsExitRequested)
{
InstanceEvent.Set();
}
UpdateLogger();
Shutdown();
return;
}
// This code is here mostly to make sure that the Taskbar static class is initialized ASAP.
// The taskbar rectangle is never empty. And if it is, we have no purpose.
Rectangle ScreenBounds = TaskbarLocation.ScreenBounds;
Debug.Assert(!ScreenBounds.IsEmpty);
Startup += OnStartup;
// Make sure we stop only on a call to Shutdown. This is for plugins that have a main window, we don't want to exit when it's closed.
ShutdownMode = ShutdownMode.OnExplicitShutdown;
}
public async void Post_UserHasToLowAuthLv_ReturnStatusForbidden()
{
// Arrange
string requestUri = $"storage/api/v1/instances/1337/3c42ee2a-9464-42a8-a976-16eb926bd20a/events/";
HttpClient client = GetTestClient();
string token = PrincipalUtil.GetToken(3, 1337, 0);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
InstanceEvent instance = new InstanceEvent();
// Act
HttpResponseMessage response = await client.PostAsync(requestUri, new StringContent(JsonConvert.SerializeObject(instance), Encoding.UTF8, "application/json"));
if (response.StatusCode.Equals(HttpStatusCode.InternalServerError))
{
string serverContent = await response.Content.ReadAsStringAsync();
Assert.Equal("Hei", serverContent);
}
// Assert
Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
}
public Task <InstanceEvent> InsertInstanceEvent(InstanceEvent instanceEvent)
{
lock (TestDataUtil.dataLock)
{
string instanceId = instanceEvent.InstanceId;
if (instanceId.Contains("/"))
{
instanceId = instanceEvent.InstanceId.Split("/")[1];
}
if (!Directory.Exists(GetInstanceEventsPath(instanceId, instanceEvent.InstanceOwnerPartyId)))
{
Directory.CreateDirectory(GetInstanceEventsPath(instanceId, instanceEvent.InstanceOwnerPartyId));
}
instanceEvent.Id = Guid.NewGuid();
string instancePath = GetInstanceEventPath(instanceId, instanceEvent.InstanceOwnerPartyId, instanceEvent.Id.Value);
File.WriteAllText(instancePath, instanceEvent.ToString());
return(Task.FromResult(instanceEvent));
}
}
public async void Undelete_ResponseIsDeny_ReturnsStatusForbidden()
{
// Arrange
MessageBoxTestData testData = new MessageBoxTestData();
Instance instance = testData.GetSoftDeletedInstance();
Mock <IApplicationRepository> applicationRepository = new Mock <IApplicationRepository>();
Mock <IInstanceRepository> instanceRepository = new Mock <IInstanceRepository>();
instanceRepository.Setup(s => s.GetOne(It.IsAny <string>(), It.IsAny <int>())).ReturnsAsync(instance);
instanceRepository.Setup(s => s.Update(It.IsAny <Instance>())).ReturnsAsync((Instance i) => i);
InstanceEvent instanceEvent = null;
Mock <IInstanceEventRepository> instanceEventRepository = new Mock <IInstanceEventRepository>();
instanceEventRepository.Setup(s => s.InsertInstanceEvent(It.IsAny <InstanceEvent>())).Callback <InstanceEvent>(p => instanceEvent = p)
.ReturnsAsync((InstanceEvent r) => r);
HttpClient client = GetTestClient(instanceRepository.Object, applicationRepository.Object, instanceEventRepository.Object);
string token = PrincipalUtil.GetToken(-1);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
// Act
HttpResponseMessage response = await client.PutAsync($"{BasePath}/sbl/instances/{testData.GetInstanceOwnerPartyId()}/{instance.Id.Split("/")[1]}/undelete", null);
// Assert
Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
string content = await response.Content.ReadAsStringAsync();
Assert.True(string.IsNullOrEmpty(content));
}
/// <inheritdoc/>
public async Task <string> SaveInstanceEvent(object dataToSerialize, string applicationOwnerId, string applicationId)
{
InstanceEvent instanceEvent = (InstanceEvent)dataToSerialize;
instanceEvent.CreatedDateTime = DateTime.UtcNow;
string apiUrl = $"{_platformSettings.GetApiStorageEndpoint}instances/{instanceEvent.InstanceId}/events";
using (HttpClient client = new HttpClient())
{
client.BaseAddress = new Uri(apiUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
try
{
HttpResponseMessage response = await client.PostAsync(apiUrl, new StringContent(instanceEvent.ToString(), Encoding.UTF8, "application/json"));
string eventData = await response.Content.ReadAsStringAsync();
InstanceEvent result = JsonConvert.DeserializeObject <InstanceEvent>(eventData);
return(result.Id.ToString());
}
catch
{
throw new Exception("Unable to store instance event");
}
}
}
public async Task <ActionResult> Undelete(int instanceOwnerId, Guid instanceGuid)
{
string instanceId = $"{instanceOwnerId}/{instanceGuid}";
Instance instance;
try
{
instance = await _instanceRepository.GetOne(instanceId, instanceOwnerId);
}
catch (DocumentClientException dce)
{
if (dce.Error.Code.Equals("NotFound"))
{
return(NotFound($"Didn't find the object that should be restored with instanceId={instanceId}"));
}
return(StatusCode(500, $"Unknown database exception in restore: {dce}"));
}
if (instance.InstanceState.IsMarkedForHardDelete)
{
return(BadRequest("Instance was permanently deleted and cannot be restored."));
}
else if (instance.InstanceState.IsDeleted)
{
instance.InstanceState.IsDeleted = false;
instance.LastChangedBy = User.Identity.Name;
instance.LastChangedDateTime = DateTime.UtcNow;
instance.InstanceState.DeletedDateTime = null;
InstanceEvent instanceEvent = new InstanceEvent
{
CreatedDateTime = DateTime.UtcNow,
AuthenticationLevel = 0, // update when authentication is turned on
EventType = InstanceEventType.Undeleted.ToString(),
InstanceId = instance.Id,
InstanceOwnerId = instance.InstanceOwnerId.ToString(),
UserId = 0, // update when authentication is turned on
};
try
{
await _instanceRepository.Update(instance);
await _instanceEventRepository.InsertInstanceEvent(instanceEvent);
return(Ok(true));
}
catch (Exception e)
{
return(StatusCode(500, $"Unknown exception in restore: {e}"));
}
// generate instance event 'Undeleted'
}
return(Ok(true));
}
/// <inheritdoc/>
public async Task <InstanceEvent> InsertInstanceEvent(InstanceEvent item)
{
item.Id ??= Guid.NewGuid();
ItemResponse <InstanceEvent> instanceEvent = await Container.CreateItemAsync(item, new PartitionKey(item.InstanceId));
return(instanceEvent);
}
public void MapInstanceEventsToProcessHistoryTest(InstanceEvent instanceEvent, string expectedPerformedBy, string expectedEventType)
{
ProcessHistoryItem actual = ProcessHelper.MapInstanceEventsToProcessHistory(new List <InstanceEvent> {
instanceEvent
}).First();
Assert.Equal(expectedPerformedBy, actual.PerformedBy);
Assert.Equal(expectedEventType, actual.EventType);
}
private void ClearDirty(SimulationModel.Key key, ISimulationAccess access)
{
HashSet <Subnet> nets = dirtyNets;
HashSet <Instance> instances = dirtyInstances;
if (nets != null && nets.Count > 0)
{
dirtyNets = new HashSet <Subnet>();
foreach (Subnet net in nets)
{
if (Debug)
{
Console.Write(" net {0} /", net);
}
Value v = null;
foreach (Port p in net.Drivers)
{
Value u = p.GetDrivenValue(key);
if (Debug)
{
Console.Write("{0}/", u);
}
v = v == null ? u : v.Resolve(u);
}
if (Debug)
{
Console.WriteLine("-> {0}", v);
}
if (v == null)
{
int w = net.Width;
v = Value.Create(Value.U, w == 0 ? 1 : w);
}
net.SetValue(key, v);
foreach (Port p in net.Readers)
{
instances.Add(p.Instance);
}
}
}
if (instances != null && instances.Count > 0)
{
InstanceEvent evnt = new InstanceEvent(InstanceEvent.Types.InstanceDirty);
InstanceState iState = new InstanceState(access, null);
dirtyInstances = new HashSet <Instance>();
foreach (Instance instance in instances)
{
if (Debug)
{
Console.WriteLine(" propagate instance {0}", instance);
}
iState.Instance = instance;
instance.HandleEvent(evnt, iState);
}
}
}
/// <summary>
/// Inserts new instance event into the instanceEvent collection.
/// </summary>
/// <param name="instanceEvent">Instance event to be stored. </param>
/// <returns>The stored instance event.</returns>
public async Task <string> PostInstanceEvent(InstanceEvent instanceEvent)
{
string requestUri = $"{versionPrefix}/instances/{instanceEvent.InstanceId}/events";
HttpResponseMessage response = await client.PostAsync(hostName + requestUri, new StringContent(instanceEvent.ToString(), Encoding.UTF8, "application/json"));
string newId = await response.Content.ReadAsStringAsync();
return(newId);
}
public Task<InstanceEvent> InsertInstanceEvent(InstanceEvent instanceEvent)
{
instanceEvent.Id = Guid.NewGuid();
string path = GetInstanceEventPath(instanceEvent.InstanceId, instanceEvent.Id.Value);
Directory.CreateDirectory(GetInstanceEventFolder());
File.WriteAllText(path, instanceEvent.ToString());
return Task.FromResult(instanceEvent);
}
/// <inheritdoc/>
public async Task <InstanceEvent> InsertInstanceEvent(InstanceEvent item)
{
ResourceResponse <Document> response = await Client.CreateDocumentAsync(CollectionUri, item);
Document document = response.Resource;
InstanceEvent instanceEvent = JsonConvert.DeserializeObject <InstanceEvent>(document.ToString());
return(instanceEvent);
}
/// <summary>
/// This method will remove duplicate events keeping the last of two or more events in a row.
/// Duplicates are defined as two events of the same event type, triggered by the same
/// user on the same resource.
/// </summary>
/// <param name="originalList">The original list of instance events.</param>
/// <returns>A sorted and filtered list of instance events.</returns>
public static List <InstanceEvent> RemoveDuplicateEvents(List <InstanceEvent> originalList)
{
foreach (InstanceEvent item in originalList.Where(ie => !string.IsNullOrEmpty(ie.DataId) && ie.EventType.Equals(InstanceEventType.Created.ToString())))
{
item.EventType = InstanceEventType.Saved.ToString();
}
List <InstanceEvent> orderedEnumerable =
originalList
.Where(ie =>
string.IsNullOrEmpty(ie.DataId) ||
ie.EventType.Equals(
InstanceEventType.Saved.ToString(),
StringComparison.InvariantCultureIgnoreCase))
.OrderBy(ie => ie.Created).ToList();
List <InstanceEvent> finalResult = new List <InstanceEvent>();
for (int i = 0; i < orderedEnumerable.Count; i++)
{
InstanceEvent currentInstanceEvent = orderedEnumerable[i];
InstanceEvent nextInstanceEvent =
i + 1 < orderedEnumerable.Count ? orderedEnumerable[i + 1] : null;
if (nextInstanceEvent == null)
{
// Last event should always be added.
finalResult.Add(currentInstanceEvent);
continue;
}
if (currentInstanceEvent.EventType != nextInstanceEvent.EventType)
{
finalResult.Add(currentInstanceEvent);
continue;
}
string currentSubject = currentInstanceEvent.User?.UserId != null
? currentInstanceEvent.User?.UserId.ToString()
: currentInstanceEvent.User?.OrgId;
string nextSubject = nextInstanceEvent.User?.UserId != null
? nextInstanceEvent.User?.UserId.ToString()
: nextInstanceEvent.User?.OrgId;
if (currentSubject != nextSubject)
{
// Events caused by different actors should be kept as separate events.
finalResult.Add(currentInstanceEvent);
}
}
return(finalResult);
}
/// <inheritdoc/>
public async Task <InstanceEvent> GetOneEvent(string instanceId, Guid eventGuid)
{
string cosmosId = eventGuid.ToString();
Uri uri = UriFactory.CreateDocumentUri(databaseId, collectionId, cosmosId);
InstanceEvent theEvent = await _client
.ReadDocumentAsync <InstanceEvent>(
uri,
new RequestOptions { PartitionKey = new PartitionKey(instanceId) });
return(theEvent);
}
public async Task <ActionResult> Delete(Guid instanceGuid, int instanceOwnerPartyId, bool hard)
{
string instanceId = $"{instanceOwnerPartyId}/{instanceGuid}";
Instance instance;
instance = await _instanceRepository.GetOne(instanceOwnerPartyId, instanceGuid);
if (instance == null)
{
return(NotFound($"Didn't find the object that should be deleted with instanceId={instanceId}"));
}
DateTime now = DateTime.UtcNow;
instance.Status ??= new InstanceStatus();
if (hard)
{
instance.Status.IsHardDeleted = true;
instance.Status.IsSoftDeleted = true;
instance.Status.HardDeleted = now;
instance.Status.SoftDeleted ??= now;
}
else
{
instance.Status.IsSoftDeleted = true;
instance.Status.SoftDeleted = now;
}
instance.LastChangedBy = User.GetUserOrOrgId();
instance.LastChanged = now;
InstanceEvent instanceEvent = new InstanceEvent
{
Created = DateTime.UtcNow,
EventType = InstanceEventType.Deleted.ToString(),
InstanceId = instance.Id,
InstanceOwnerPartyId = instance.InstanceOwner.PartyId,
User = new PlatformUser
{
UserId = User.GetUserIdAsInt(),
AuthenticationLevel = User.GetAuthenticationLevel(),
OrgId = User.GetOrg(),
},
};
await _instanceRepository.Update(instance);
await _instanceEventRepository.InsertInstanceEvent(instanceEvent);
return(Ok(true));
}
private static void CreatePluginList(Assembly pluginAssembly, List <Type> pluginClientTypeList, Guid embeddedPluginGuid, ITracer logger, out List <IPluginClient> pluginList)
{
pluginList = new List <IPluginClient>();
foreach (Type ClientType in pluginClientTypeList)
{
try
{
Contract.RequireNotNull(ClientType.FullName, out string FullName);
object?PluginHandle = pluginAssembly.CreateInstance(FullName);
if (PluginHandle != null)
{
string?PluginName = PluginProperty <string?>(PluginHandle, nameof(IPluginClient.Name));
Guid PluginGuid = PluginProperty <Guid>(PluginHandle, nameof(IPluginClient.Guid));
bool PluginRequireElevated = PluginProperty <bool>(PluginHandle, nameof(IPluginClient.RequireElevated));
bool PluginHasClickHandler = PluginProperty <bool>(PluginHandle, nameof(IPluginClient.HasClickHandler));
if (PluginName != null && PluginName.Length > 0 && PluginGuid != Guid.Empty)
{
bool createdNew;
EventWaitHandle?InstanceEvent;
if (PluginGuid != embeddedPluginGuid)
{
InstanceEvent = new EventWaitHandle(false, EventResetMode.ManualReset, GuidToString(PluginGuid), out createdNew);
}
else
{
createdNew = true;
InstanceEvent = null;
}
if (createdNew && PluginName != null)
{
IPluginClient NewPlugin = new PluginClient(PluginHandle, PluginName, PluginGuid, PluginRequireElevated, PluginHasClickHandler, InstanceEvent);
pluginList.Add(NewPlugin);
}
else
{
logger.Write(Category.Warning, "Another instance of a plugin is already running");
InstanceEvent?.Close();
InstanceEvent = null;
}
}
}
}
catch
{
}
}
}
public async Task <ActionResult> Delete(Guid instanceGuid, int instanceOwnerId, bool hard)
{
string instanceId = $"{instanceOwnerId}/{instanceGuid}";
Instance instance;
try
{
instance = await _instanceRepository.GetOne(instanceId, instanceOwnerId);
}
catch (DocumentClientException dce)
{
if (dce.Error.Code.Equals("NotFound"))
{
return(NotFound($"Didn't find the object that should be deleted with instanceId={instanceId}"));
}
return(StatusCode(500, $"Unknown database exception in delete: {dce}"));
}
catch (Exception e)
{
return(StatusCode(500, $"Unknown exception in delete: {e}"));
}
instance.InstanceState.IsDeleted = true;
instance.InstanceState.IsMarkedForHardDelete = hard;
instance.LastChangedBy = User.Identity.Name;
instance.LastChangedDateTime = instance.InstanceState.DeletedDateTime = DateTime.UtcNow;
InstanceEvent instanceEvent = new InstanceEvent
{
CreatedDateTime = DateTime.UtcNow,
AuthenticationLevel = 0, // update when authentication is turned on
EventType = InstanceEventType.Deleted.ToString(),
InstanceId = instance.Id,
InstanceOwnerId = instance.InstanceOwnerId.ToString(),
UserId = 0, // update when authentication is turned on
};
try
{
await _instanceRepository.Update(instance);
await _instanceEventRepository.InsertInstanceEvent(instanceEvent);
}
catch (Exception e)
{
return(StatusCode(500, $"Unknown exception in delete: {e}"));
}
return(Ok(true));
}
private async Task DispatchEvent(string eventType, Instance instance)
{
InstanceEvent instanceEvent = new InstanceEvent
{
AuthenticationLevel = 0, // update when authentication is turned on
EventType = eventType,
InstanceId = instance.Id,
InstanceOwnerId = instance.InstanceOwnerId,
UserId = 0, // update when authentication is turned on
ProcessInfo = instance.Process,
};
await _instanceEventRepository.InsertInstanceEvent(instanceEvent);
}
/// <summary>
/// Inserts new instance event into the instanceEvent collection.
/// </summary>
/// <param name="instanceEvent">Instance event to be stored. </param>
/// <returns>The stored instance event.</returns>
public async Task <string> PostInstanceEvent(InstanceEvent instanceEvent)
{
string requestUri = $"{versionPrefix}/instances/{instanceEvent.InstanceId}/events";
HttpResponseMessage response = await client.PostAsync(hostName + requestUri, new StringContent(instanceEvent.ToString(), Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
string newId = await response.Content.ReadAsStringAsync();
return(newId);
}
throw new StorageClientException($"POST error: {response.ReasonPhrase}");
}
private static void CreatePluginList(Assembly pluginAssembly, List <Type> PluginClientTypeList, Guid embeddedPluginGuid, IPluginLogger logger, out List <IPluginClient> PluginList)
{
PluginList = new List <IPluginClient>();
foreach (Type ClientType in PluginClientTypeList)
{
try
{
object PluginHandle = pluginAssembly.CreateInstance(ClientType.FullName);
if (PluginHandle != null)
{
string PluginName = PluginHandle.GetType().InvokeMember(nameof(IPluginClient.Name), BindingFlags.Default | BindingFlags.GetProperty, null, PluginHandle, null) as string;
Guid PluginGuid = (Guid)PluginHandle.GetType().InvokeMember(nameof(IPluginClient.Guid), BindingFlags.Default | BindingFlags.GetProperty, null, PluginHandle, null);
bool PluginRequireElevated = (bool)PluginHandle.GetType().InvokeMember(nameof(IPluginClient.RequireElevated), BindingFlags.Default | BindingFlags.GetProperty, null, PluginHandle, null);
bool PluginHasClickHandler = (bool)PluginHandle.GetType().InvokeMember(nameof(IPluginClient.HasClickHandler), BindingFlags.Default | BindingFlags.GetProperty, null, PluginHandle, null);
if (!string.IsNullOrEmpty(PluginName) && PluginGuid != Guid.Empty)
{
bool createdNew;
EventWaitHandle InstanceEvent;
if (PluginGuid != embeddedPluginGuid)
{
InstanceEvent = new EventWaitHandle(false, EventResetMode.ManualReset, GuidToString(PluginGuid), out createdNew);
}
else
{
createdNew = true;
InstanceEvent = null;
}
if (createdNew)
{
IPluginClient NewPlugin = new PluginClient(PluginHandle, PluginName, PluginGuid, PluginRequireElevated, PluginHasClickHandler, InstanceEvent);
PluginList.Add(NewPlugin);
}
else
{
logger.AddLog("Another instance of a plugin is already running");
InstanceEvent.Close();
InstanceEvent = null;
}
}
}
}
catch
{
}
}
}
public async Task <ActionResult <InstanceEvent> > GetOne(int instanceOwnerPartyId, Guid instanceGuid, Guid eventGuid)
{
string instanceId = $"{instanceOwnerPartyId}/{instanceGuid}";
InstanceEvent theEvent = await _repository.GetOneEvent(instanceId, eventGuid);
if (theEvent != null)
{
return(Ok(theEvent));
}
else
{
return(NotFound());
}
}
/// <inheritdoc/>
public async Task <InstanceEvent> InsertInstanceEvent(InstanceEvent item)
{
try
{
ResourceResponse <Document> response = await _client.CreateDocumentAsync(_collectionUri, item);
Document document = response.Resource;
InstanceEvent instanceEvent = JsonConvert.DeserializeObject <InstanceEvent>(document.ToString());
return(instanceEvent);
}
catch (Exception ex)
{
throw ex;
}
}
private InstanceEvent GenerateProcessChangeEvent(string eventType, Instance instance, DateTime now)
{
UserContext userContext = userHelper.GetUserContext(HttpContext).Result;
InstanceEvent instanceEvent = new InstanceEvent
{
InstanceId = instance.Id,
InstanceOwnerId = instance.InstanceOwnerId,
EventType = eventType,
CreatedDateTime = now,
UserId = userContext.UserId,
AuthenticationLevel = userContext.AuthenticationLevel,
ProcessInfo = instance.Process,
};
return(instanceEvent);
}
/// <inheritdoc/>
public Task <List <InstanceEvent> > GetInstanceEvents(string instanceId, string instanceOwnerId, string org, string app, string[] eventTypes, string from, string to)
{
string developer = AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext);
string testDataForParty = _settings.GetTestdataForPartyPath(org, app, developer);
string folderForEvents = $"{testDataForParty}{instanceOwnerId}/{instanceId}/events";
DateTime? fromDateTime = null, toDateTime = null;
List <InstanceEvent> events = new List <InstanceEvent>();
if (!(string.IsNullOrEmpty(from) || string.IsNullOrEmpty(to)))
{
try
{
fromDateTime = DateTime.ParseExact(from, "s", CultureInfo.InvariantCulture);
toDateTime = DateTime.ParseExact(to, "s", CultureInfo.InvariantCulture);
}
catch
{
_logger.LogError("Unable to perform query. Invalid format for time span. Use string format of UTC.");
}
}
if (Directory.Exists(folderForEvents))
{
foreach (string file in Directory.EnumerateFiles(folderForEvents, "*.json"))
{
string instanceData = File.ReadAllText(file, Encoding.UTF8);
InstanceEvent item = JsonConvert.DeserializeObject <InstanceEvent>(instanceData);
events.Add(item);
}
}
IQueryable <InstanceEvent> result = events.AsQueryable();
if (eventTypes != null && eventTypes.Length > 0 && events.Any())
{
result = result.Where(e => eventTypes.Contains(e.EventType));
}
if (fromDateTime.HasValue && toDateTime.HasValue && events.Any())
{
result = result.Where(e => fromDateTime <e.CreatedDateTime && toDateTime> e.CreatedDateTime);
}
return(Task.FromResult(result.ToList()));
}
public async void Delete_ArchivedHasRole_ReturnsOk()
{
// Arrange
int instanceOwnerId = 1000;
string instanceGuid = "1916cd18-3b8e-46f8-aeaf-4bc3397ddd12";
string json = File.ReadAllText($"data/instances/{org}/{app}/{instanceOwnerId}/{instanceGuid}.json");
Instance instance = JsonConvert.DeserializeObject <Instance>(json);
HttpStatusCode expectedStatusCode = HttpStatusCode.OK;
bool expectedResult = true;
Mock <IApplicationRepository> applicationRepository = new Mock <IApplicationRepository>();
Instance storedInstance = null;
Mock <IInstanceRepository> instanceRepository = new Mock <IInstanceRepository>();
instanceRepository.Setup(s => s.GetOne(It.IsAny <string>(), It.IsAny <int>())).ReturnsAsync(instance);
instanceRepository.Setup(s => s.Update(It.IsAny <Instance>())).Callback <Instance>(p => storedInstance = p).ReturnsAsync((Instance i) => i);
InstanceEvent instanceEvent = null;
Mock <IInstanceEventRepository> instanceEventRepository = new Mock <IInstanceEventRepository>();
instanceEventRepository.Setup(s => s.InsertInstanceEvent(It.IsAny <InstanceEvent>())).Callback <InstanceEvent>(p => instanceEvent = p)
.ReturnsAsync((InstanceEvent r) => r);
HttpClient client = GetTestClient(instanceRepository.Object, applicationRepository.Object, instanceEventRepository.Object);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _validTokenUsr3);
// Act
HttpResponseMessage response = await client.DeleteAsync($"{BasePath}/sbl/instances/{instanceOwnerId}/{instanceGuid}?hard=false");
HttpStatusCode actualStatusCode = response.StatusCode;
string content = await response.Content.ReadAsStringAsync();
bool actualResult = JsonConvert.DeserializeObject <bool>(content);
// Assert
Assert.Equal(expectedResult, actualResult);
Assert.Equal(expectedStatusCode, actualStatusCode);
Assert.False(storedInstance.Status.HardDeleted.HasValue);
Assert.True(storedInstance.Status.SoftDeleted.HasValue);
}
public async Task <ActionResult> Undelete(int instanceOwnerPartyId, Guid instanceGuid)
{
Instance instance;
instance = await _instanceRepository.GetOne(instanceOwnerPartyId, instanceGuid);
if (instance == null)
{
return(NotFound($"Didn't find the object that should be restored with instanceId={instanceOwnerPartyId}/{instanceGuid}"));
}
if (instance.Status.IsHardDeleted)
{
return(NotFound("Instance was permanently deleted and cannot be restored."));
}
else if (instance.Status.IsSoftDeleted)
{
instance.LastChangedBy = User.GetUserOrOrgId();
instance.LastChanged = DateTime.UtcNow;
instance.Status.IsSoftDeleted = false;
instance.Status.SoftDeleted = null;
InstanceEvent instanceEvent = new InstanceEvent
{
Created = DateTime.UtcNow,
EventType = InstanceEventType.Undeleted.ToString(),
InstanceId = instance.Id,
InstanceOwnerPartyId = instance.InstanceOwner.PartyId,
User = new PlatformUser
{
UserId = User.GetUserIdAsInt(),
AuthenticationLevel = User.GetAuthenticationLevel(),
OrgId = User.GetOrg(),
}
};
await _instanceRepository.Update(instance);
await _instanceEventRepository.InsertInstanceEvent(instanceEvent);
return(Ok(true));
}
return(Ok(true));
}
public async Task <ActionResult <string> > Post(int instanceOwnerPartyId, Guid instanceGuid, [FromBody] InstanceEvent instanceEvent)
{
if (instanceEvent?.InstanceId == null)
{
return(BadRequest("Missing parameter values: instance event must exist and instanceId must be set"));
}
instanceEvent.Created = instanceEvent.Created?.ToUniversalTime() ?? DateTime.UtcNow;
InstanceEvent result = await _repository.InsertInstanceEvent(instanceEvent);
if (result == null)
{
return(BadRequest("Unable to write new instance event to database"));
}
return(Created(result.Id.ToString(), result));
}
public async Task <ActionResult> Post([FromBody] InstanceEvent instanceEvent)
{
if (instanceEvent == null || instanceEvent.InstanceId == null)
{
return(BadRequest("Missing parameter values: instance event must exist and instanceId must be set"));
}
instanceEvent.Created = DateTime.UtcNow;
InstanceEvent result = await _repository.InsertInstanceEvent(instanceEvent);
if (result == null)
{
return(BadRequest("Unable to write new instance event to database"));
}
return(Created(result.Id.ToString(), result));
}
