public async Task UpsertFilterExecutor_Transient_Existing_NoFilterUidProvided()
{
var custUid = Guid.NewGuid();
var userId = UIDs.JWT_USER_ID;
var projectUid = UIDs.MOCK_WEB_API_DIMENSIONS_PROJECT_UID;
var filterUid = Guid.NewGuid();
string name = string.Empty;
FilterType filterType = FilterType.Transient;
string filterJson = "{\"designUid\":\"c2e5940c-4370-4d23-a930-b5b74a9fc22b\",\"contributingMachines\":[{\"assetID\":\"123456789\",\"machineName\":\"TheMachineName\",\"isJohnDoe\":false,\"assetUid\":null}]}";
string filterJsonUpdated = "{\"designUid\":\"c2e5940c-4370-4d23-a930-b5b74a9fc22b\",\"onMachineDesignID\":null,\"elevationType\":3,\"vibeStateOn\":true}";
WriteEventToDb(new CreateFilterEvent
{
CustomerUID = custUid,
UserID = userId,
ProjectUID = projectUid,
FilterUID = filterUid,
Name = name,
FilterType = filterType,
FilterJson = filterJson,
ActionUTC = DateTime.UtcNow
});
var request = FilterRequestFull.Create(new HeaderDictionary(), custUid.ToString(), false, userId, new ProjectData {
ProjectUID = projectUid.ToString()
}, new FilterRequest {
Name = name, FilterJson = filterJsonUpdated, FilterType = filterType
});
var result = await executor.ProcessAsync(request) as FilterDescriptorSingleResult;
Assert.IsNotNull(result, "executor should always return a result");
Assert.AreNotEqual(filterUid, result.FilterDescriptor.FilterUid, "executor returned incorrect FilterUid");
Assert.AreEqual(name, result.FilterDescriptor.Name, "executor returned incorrect filter Name");
Assert.AreEqual("{\"designUid\":\"c2e5940c-4370-4d23-a930-b5b74a9fc22b\",\"elevationType\":3,\"vibeStateOn\":true}", result.FilterDescriptor.FilterJson, "executor returned incorrect FilterJson");
}
public async Task HydrateJsonWithBoundary_InvalidBoundary2(FilterType filterType)
{
var log = serviceProvider.GetRequiredService <ILoggerFactory>().CreateLogger <ValidationTests>();
var geofenceRepo = new Mock <IGeofenceRepository>();
var geofence = new Geofence
{
GeofenceType = GeofenceType.Filter,
GeometryWKT =
"POLYGON((-115.0200886019198 36.20745605916501,-115.02005976817289 36.20734622441246,-115.01992699882665 36.2073559634608,-115.0198176988093 36.207342978062755,-115.01973320922532 36.20734027277125,-115.01974729082266 36.20738950906242,-115.01975466689743 36.2074300884,-115.01996052643932 36.20746201079744))"
};
// var geofence = new Geofence { GeometryWKT = "POLYGON((-115.02022874734084 36.20751287018342,-115.02025556943099 36.207300775504265,-115.02001953503766 36.20729428280093,-115.01966816565673 36.20726506562927,-115.01945493004004 36.20714170411769,-115.0192846097676 36.20734189594616,-115.01962927362601 36.20748581732266,-115.02022874734084 36.20751287018342))" };
geofenceRepo.Setup(g => g.GetGeofence(It.IsAny <string>())).ReturnsAsync(geofence);
//var geofenceProxy = new Mock<IGeofenceProxy>();
//var geofenceData = new GeofenceData { GeofenceType = GeofenceType.Generic.ToString(), GeometryWKT = geofence.GeometryWKT };
//geofenceProxy.Setup(g => g.GetGeofenceForCustomer(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<HeaderDictionary>())).ReturnsAsync(geofenceData);
var request = FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
},
new FilterRequest
{
FilterUid = filterUid,
Name = "a filter",
FilterType = filterType,
FilterJson = "{\"designUID\": \"id\", \"vibeStateOn\": true, \"polygonUID\": \"" + boundaryUid + "\"}"
});
var ex = await Assert.ThrowsAsync <ServiceException>(async() => await ValidationUtil
.HydrateJsonWithBoundary(/*geofenceProxy.Object,*/ geofenceRepo.Object, log, serviceExceptionHandler, request).ConfigureAwait(false));
Assert.Contains("2045", ex.GetContent);
Assert.Contains("Invalid spatial filter boundary. One or more polygon components are missing.", ex.GetContent);
}
public async Task HydrateJsonWithBoundary_NoGeofence(FilterType filterType)
{
var log = serviceProvider.GetRequiredService <ILoggerFactory>().CreateLogger <ValidationTests>();
var geofenceRepo = new Mock <IGeofenceRepository>();
geofenceRepo.Setup(g => g.GetGeofence(It.IsAny <string>())).ReturnsAsync((Geofence)null);
//var geofenceProxy = new Mock<IGeofenceProxy>();
//geofenceProxy.Setup(g => g.GetGeofenceForCustomer(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<HeaderDictionary>())).ReturnsAsync(
// (GeofenceData)null);
var request = FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
},
new FilterRequest
{
FilterUid = filterUid,
Name = "a filter",
FilterType = filterType,
FilterJson = "{\"designUID\": \"id\", \"vibeStateOn\": true, \"polygonUID\": \"" + boundaryUid + "\"}"
});
var ex = await Assert.ThrowsAsync <ServiceException>(async() => await ValidationUtil
.HydrateJsonWithBoundary(/*geofenceProxy.Object,*/ geofenceRepo.Object, log, serviceExceptionHandler, request).ConfigureAwait(false));
Assert.Contains("2040", ex.GetContent);
Assert.Contains("Validation of Project/Boundary failed. Not allowed.", ex.GetContent);
}
public async Task HydrateJsonWithBoundary_InvalidBoundary(FilterType filterType)
{
var log = serviceProvider.GetRequiredService <ILoggerFactory>().CreateLogger <ValidationTests>();
var geofenceRepo = new Mock <IGeofenceRepository>();
var geofence = new Geofence {
GeometryWKT = "This is not a valid polygon WKT", GeofenceType = GeofenceType.Filter
};
geofenceRepo.Setup(g => g.GetGeofence(It.IsAny <string>())).ReturnsAsync(geofence);
//var geofenceProxy = new Mock<IGeofenceProxy>();
var geofenceData = new GeofenceData {
GeometryWKT = geofence.GeometryWKT, GeofenceType = GeofenceType.Generic.ToString()
};
//geofenceProxy.Setup(g => g.GetGeofenceForCustomer(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<HeaderDictionary>())).ReturnsAsync(geofenceData);
var request = FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
},
new FilterRequest
{
FilterUid = filterUid,
Name = "a filter",
FilterType = filterType,
FilterJson = "{\"designUID\": \"id\", \"vibeStateOn\": true, \"polygonUID\": \"" + boundaryUid + "\"}"
});
var ex = await Assert.ThrowsAsync <ServiceException>(async() => await ValidationUtil
.HydrateJsonWithBoundary(/*geofenceProxy.Object,*/ geofenceRepo.Object, log, serviceExceptionHandler, request).ConfigureAwait(false));
Assert.Contains("2045", ex.GetContent);
Assert.Contains("Invalid spatial filter boundary. One or more polygon components are missing.", ex.GetContent);
}
public async Task UpsertFilterExecutor_Transient_Existing_FilterUidNotSupported()
{
var custUid = Guid.NewGuid();
var userId = Guid.NewGuid();
var projectUid = Guid.NewGuid();
var filterUid = Guid.NewGuid();
string name = string.Empty;
FilterType filterType = FilterType.Transient;
string filterJson = "{\"designUID\":\"c2e5940c-4370-4d23-a930-b5b74a9fc22b\",\"contributingMachines\":[{\"assetID\":\"123456789\",\"machineName\":\"TheMachineName\",\"isJohnDoe\":false,\"assetUid\":null}]}";
string filterJsonUpdated = "{\"designUID\":\"c2e5940c-4370-4d23-a930-b5b74a9fc22b\",\"onMachineDesignID\":null,\"elevationType\":3,\"vibeStateOn\":true}";
WriteEventToDb(new CreateFilterEvent
{
CustomerUID = custUid,
UserID = userId.ToString(),
ProjectUID = projectUid,
FilterUID = filterUid,
Name = name,
FilterType = filterType,
FilterJson = filterJson,
ActionUTC = DateTime.UtcNow
});
var request = FilterRequestFull.Create(new HeaderDictionary(), custUid.ToString(), false, userId.ToString(), new ProjectData {
ProjectUID = projectUid.ToString()
}, new FilterRequest {
FilterUid = filterUid.ToString(), Name = name, FilterJson = filterJsonUpdated, FilterType = filterType
});
var ex = await Assert.ThrowsExceptionAsync <ServiceException>(async() => await executor.ProcessAsync(request)).ConfigureAwait(false);
Assert.AreNotEqual(-1, ex.GetContent.IndexOf("2016", StringComparison.Ordinal), "executor threw exception but incorrect code");
Assert.AreNotEqual(-1, ex.GetContent.IndexOf("UpsertFilter failed. Transient filter not updateable, should not have filterUid provided.", StringComparison.Ordinal), "executor threw exception but incorrect messaage");
}
/// <summary>
/// Store the filter in the database and notify Raptor of a filter change
/// </summary>
protected async Task <T> StoreFilterAndNotifyRaptor <T>(FilterRequestFull filterRequest, int[] errorCodes) where T : IFilterEvent
{
var filterEvent = default(T);
try
{
filterEvent = AutoMapperUtility.Automapper.Map <T>(filterRequest);
filterEvent.ActionUTC = DateTime.UtcNow;
var count = await((IFilterRepository)Repository).StoreEvent(filterEvent);
if (count == 0)
{
serviceExceptionHandler.ThrowServiceException(HttpStatusCode.InternalServerError, errorCodes[0]);
}
else
{
// It's not necessary to invalidate the Raptor services proxy filter cache when a filter is created, or if it's transient.
if (filterRequest.FilterType == FilterType.Transient || filterEvent is CreateFilterEvent)
{
return(filterEvent);
}
_ = Task.Run(() => NotifyProductivity3D(filterRequest));
}
}
catch (Exception e)
{
serviceExceptionHandler.ThrowServiceException(HttpStatusCode.InternalServerError, errorCodes[1], e.Message);
}
return(filterEvent);
}
public async Task HydrateJsonWithBoundary_HappyPath_Custom(FilterType filterType)
{
var log = serviceProvider.GetRequiredService <ILoggerFactory>().CreateLogger <ValidationTests>();
var geofenceRepo = new Mock <IGeofenceRepository>();
var geofence = new Geofence {
GeofenceUID = boundaryUid, Name = Name, GeometryWKT = GeometryWKT, GeofenceType = GeofenceType.Filter
};
geofenceRepo.Setup(g => g.GetGeofence(It.IsAny <string>())).ReturnsAsync(geofence);
//var geofenceProxy = new Mock<IGeofenceProxy>();
var request = FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
},
new FilterRequest
{
FilterUid = filterUid,
Name = "a filter",
FilterType = filterType,
FilterJson = "{\"designUid\": \"id\", \"vibeStateOn\": true, \"polygonUid\": \"" + geofence.GeofenceUID +
"\"}"
});
var result = await ValidationUtil
.HydrateJsonWithBoundary(/*geofenceProxy.Object,*/ geofenceRepo.Object, log, serviceExceptionHandler, request).ConfigureAwait(false);
var expectedResult =
"{\"designUid\":\"id\",\"vibeStateOn\":true,\"polygonUid\":\"" + geofence.GeofenceUID +
"\",\"polygonName\":\"" + geofence.Name +
"\",\"polygonLL\":[{\"Lat\":12.677856,\"Lon\":80.257874},{\"Lat\":13.039345,\"Lon\":79.856873},{\"Lat\":13.443052,\"Lon\":80.375977}]," +
"\"polygonType\":" + (int)geofence.GeofenceType + "}";
Assert.Equal(expectedResult, result);
}
public void MapFilterRequestToCreateFilterEvent_UserContext_NoFilterUID(FilterType filterType)
{
var filterRequest = FilterRequestFull.Create
(
null,
Guid.NewGuid().ToString(),
false,
Guid.NewGuid().ToString(),
new ProjectData {
ProjectUID = Guid.NewGuid().ToString()
},
new FilterRequest {
FilterUid = Guid.NewGuid().ToString(), Name = "the name", FilterJson = "the Json", FilterType = filterType
}
);
filterRequest.FilterUid = Guid.NewGuid().ToString();
var result = AutoMapperUtility.Automapper.Map <CreateFilterEvent>(filterRequest);
Assert.Equal(filterRequest.CustomerUid, result.CustomerUID.ToString());
Assert.Equal(filterRequest.UserId, result.UserID);
Assert.Equal(filterRequest.ProjectUid, result.ProjectUID.ToString());
Assert.Equal(filterRequest.FilterUid, result.FilterUID.ToString());
Assert.Equal(filterRequest.Name, result.Name);
Assert.Equal(filterRequest.FilterJson, result.FilterJson);
Assert.Equal(filterRequest.FilterType, result.FilterType);
}
public void FilterRequestValidation_InvalidAlignment(FilterType filterType)
{
var alignmentUid = Guid.NewGuid().ToString();
var startStation = 100.456;
var leftOffset = 4.5;
var rightOffset = 2.5;
var request = FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
},
new FilterRequest
{
FilterUid = filterUid,
Name = "a filter",
FilterType = filterType,
FilterJson = "{\"vibeStateOn\": true, \"alignmentUid\": \"" + alignmentUid + "\", \"startStation\":" +
startStation + ", \"endStation\": null, \"leftOffset\":" + leftOffset + ", \"rightOffset\":" +
rightOffset + "}"
});
var ex = Assert.Throws <ServiceException>(() => request.Validate(serviceExceptionHandler));
Assert.Contains("2065", ex.GetContent);
Assert.Contains("Invalid alignment filter. Start or end station are invalid.", ex.GetContent);
}
protected FilterRequestFull CreateAndValidateRequest(
ProjectData projectData,
bool isApplicationContext = false,
string userId = null,
string filterUid = null,
string name = null,
string filterJson = "",
string boundaryUid = null,
string customerUid = null,
FilterType filterType = FilterType.Transient,
bool onlyFilterUid = false)
{
var request = FilterRequestFull.Create(
new HeaderDictionary(),
customerUid ?? Guid.NewGuid().ToString(),
isApplicationContext,
userId ?? Guid.NewGuid().ToString(),
projectData ?? new ProjectData()
{
ProjectUID = Guid.NewGuid().ToString()
},
new FilterRequest
{
FilterUid = filterUid ?? Guid.NewGuid().ToString(),
Name = name,
FilterType = filterType,
FilterJson = filterJson
});
request.Validate(ServiceExceptionHandler, onlyFilterUid);
return(request);
}
/// <summary>
/// Notify 3dpm service that a filter has been added/updated/deleted.
/// </summary>
private async Task NotifyProductivity3D(FilterRequestFull filterRequest)
{
BaseMasterDataResult notificationResult = null;
try
{
notificationResult = await Productivity3dV2ProxyNotification.NotifyFilterChange(new Guid(filterRequest.FilterUid),
new Guid(filterRequest.ProjectUid), filterRequest.CustomHeaders);
}
catch (ServiceException se)
{
log.LogError(se, $"FilterExecutorBase: RaptorServices failed with service exception. FilterUid:{filterRequest.FilterUid}.");
//rethrow this to surface it
throw;
}
catch (Exception e)
{
log.LogError(e, $"FilterExecutorBase: RaptorServices failed with exception. FilterUid:{filterRequest.FilterUid}.");
serviceExceptionHandler.ThrowServiceException(HttpStatusCode.InternalServerError, 30, "Productivity3dV2ProxyNotification.NotifyFilterChange", e.Message);
}
log.LogDebug(
$"FilterExecutorBase: NotifyFilterChange in RaptorServices returned code: {notificationResult?.Code ?? -1} Message {notificationResult?.Message ?? "notificationResult == null"}.");
if (notificationResult != null && notificationResult.Code != 0)
{
serviceExceptionHandler.ThrowServiceException(HttpStatusCode.InternalServerError, 29, notificationResult.Code.ToString(), notificationResult.Message);
}
}
public async Task HydrateJsonWithBoundary_IncludeAlignment(FilterType filterType)
{
var log = serviceProvider.GetRequiredService <ILoggerFactory>().CreateLogger <ValidationTests>();
var geofenceRepo = new Mock <IGeofenceRepository>();
//var geofenceProxy = new Mock<IGeofenceProxy>();
var alignmentUid = Guid.NewGuid().ToString();
var startStation = 100.456;
var endStation = 200.5;
var leftOffset = 4.5;
var rightOffset = 2.5;
var request = FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
},
new FilterRequest
{
FilterUid = filterUid,
Name = "a filter",
FilterType = filterType,
FilterJson = "{\"designUID\": \"id\", \"vibeStateOn\": true, \"alignmentUid\": \"" + alignmentUid +
"\", \"startStation\":" + startStation + ", \"endStation\":" + endStation + ", \"leftOffset\":" +
leftOffset + ", \"rightOffset\":" + rightOffset + "}"
});
var result = await ValidationUtil
.HydrateJsonWithBoundary(/*geofenceProxy.Object,*/ geofenceRepo.Object, log, serviceExceptionHandler, request).ConfigureAwait(false);
Assert.Equal(request.FilterJson, result);
}
/// <summary>
/// Creates the requested filter
/// </summary>
private async Task <FilterDescriptorSingleResult> CreateFilter(FilterRequestFull filterRequest)
{
var isTransient = filterRequest.FilterType == FilterType.Transient;
filterRequest.FilterUid = Guid.NewGuid().ToString();
var createFilterEvent = await StoreFilterAndNotifyRaptor <CreateFilterEvent>(filterRequest, isTransient?new[] { 19, 20 } : new[] { 24, 25 });
return(RetrieveFilter(createFilterEvent));
}
private Task <string> CombineFilters(FilterRequestFull request)
{
if (request.HierarchicFilterUids == null || request.HierarchicFilterUids.Count == 0)
{
return(Task.FromResult(request.FilterJson));
}
return(FilterCombiner.Combine(request, (IFilterRepository)Repository, serviceExceptionHandler, log));
}
public async Task GetFiltersExecutor()
{
string custUid = Guid.NewGuid().ToString();
string userUid = Guid.NewGuid().ToString();
string projectUid = Guid.NewGuid().ToString();
string filterUid = Guid.NewGuid().ToString();
string name = "blah";
var configStore = serviceProvider.GetRequiredService <IConfigurationStore>();
var logger = serviceProvider.GetRequiredService <ILoggerFactory>();
var filterRepo = new Mock <FilterRepository>(configStore, logger);
var filters = new List <MasterData.Repositories.DBModels.Filter>
{
new MasterData.Repositories.DBModels.Filter
{
CustomerUid = custUid,
UserId = userUid,
ProjectUid = projectUid,
FilterUid = filterUid,
Name = name,
FilterJson = "{\"dateRangeType\":\"0\",\"elevationType\":null}",
FilterType = FilterType.Persistent,
LastActionedUtc = DateTime.UtcNow
}
};
filterRepo.As <IFilterRepository>().Setup(ps => ps.GetFiltersForProjectUser(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), false)).ReturnsAsync(filters);
var filterListToTest = new FilterDescriptorListResult
{
FilterDescriptors = filters
.Select(filter => AutoMapperUtility.Automapper.Map <FilterDescriptor>(filter))
.ToImmutableList()
};
var request = FilterRequestFull.Create
(
null,
custUid,
false,
userUid,
new ProjectData {
ProjectUID = projectUid
});
var executor =
RequestExecutorContainer.Build <GetFiltersExecutor>(configStore, logger, serviceExceptionHandler,
filterRepo.Object, null);
var filterListResult = await executor.ProcessAsync(request) as FilterDescriptorListResult;
Assert.NotNull(filterListResult);
Assert.Equal(filterListToTest.FilterDescriptors[0].FilterUid, filterListResult.FilterDescriptors[0].FilterUid);
Assert.Equal(filterListToTest.FilterDescriptors[0].Name, filterListResult.FilterDescriptors[0].Name);
Assert.Equal("{\"dateRangeType\":0,\"dateRangeName\":\"Today\"}", filterListResult.FilterDescriptors[0].FilterJson);
Assert.Equal(filterListToTest.FilterDescriptors[0].FilterType, filterListResult.FilterDescriptors[0].FilterType);
}
public void FilterRequestValidation_PartialFill()
{
var requestFull =
FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
});
requestFull.Validate(serviceExceptionHandler);
}
private Task <FilterDescriptorSingleResult> ProcessTransient(FilterRequestFull filterRequest)
{
// if filterUid supplied, then exception as cannot update a transient filter
// else create new one Note that can have duplicate transient name (i.e. "") per cust/prj/user
if (!string.IsNullOrEmpty(filterRequest.FilterUid))
{
serviceExceptionHandler.ThrowServiceException(HttpStatusCode.BadRequest, 16);
}
return(CreateFilter(filterRequest));
}
public void FilterRequestValidation_MissingProjectUid()
{
var requestFull =
FilterRequestFull.Create(null, custUid, false, userUid, null,
new FilterRequest {
FilterUid = filterUid, Name = Name, FilterJson = FilterJson, FilterType = filterType
});
var ex = Assert.Throws <ServiceException>(() => requestFull.Validate(serviceExceptionHandler));
Assert.Contains("2001", ex.GetContent);
Assert.Contains("Invalid projectUid.", ex.GetContent);
}
public void FilterRequestValidation_InvalidFilterJson()
{
var requestFull =
FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
},
new FilterRequest {
FilterUid = filterUid, Name = Name, FilterJson = null, FilterType = filterType
});
requestFull.Validate(serviceExceptionHandler);
}
public async Task GetFilterExecutor_ExistingFilter(FilterType filterType)
{
var custUid = Guid.NewGuid();
var userId = Guid.NewGuid();
var projectUid = Guid.NewGuid();
var filterUid = Guid.NewGuid();
string name = "blah";
string filterJson = "{\"dateRangeType\":1,\"elevationType\":null}";
WriteEventToDb(new CreateFilterEvent
{
CustomerUID = custUid,
UserID = userId.ToString(),
ProjectUID = projectUid,
FilterUID = filterUid,
Name = name,
FilterType = filterType,
FilterJson = filterJson,
ActionUTC = DateTime.UtcNow
});
var request = FilterRequestFull.Create(null, custUid.ToString(), false, userId.ToString(), new ProjectData()
{
ProjectUID = projectUid.ToString()
}, new FilterRequest {
FilterUid = filterUid.ToString(), FilterType = filterType
});
var executor =
RequestExecutorContainer.Build <GetFilterExecutor>(ConfigStore, Logger, ServiceExceptionHandler, FilterRepo, null);
var result = await executor.ProcessAsync(request).ConfigureAwait(false) as FilterDescriptorSingleResult;
var filterToTest = new FilterDescriptorSingleResult(
new FilterDescriptor
{
FilterUid = filterUid.ToString(),
Name = name,
FilterType = filterType,
FilterJson = filterJson
}
);
Assert.IsNotNull(result, Responses.ShouldReturnResult);
Assert.AreEqual(filterToTest.FilterDescriptor.FilterUid, result.FilterDescriptor.FilterUid,
Responses.IncorrectFilterDescriptorFilterUid);
Assert.AreEqual(filterToTest.FilterDescriptor.Name, result.FilterDescriptor.Name,
Responses.IncorrectFilterDescriptorName);
Assert.AreEqual("{\"dateRangeType\":1,\"dateRangeName\":\"Yesterday\"}", result.FilterDescriptor.FilterJson,
Responses.IncorrectFilterDescriptorFilterJson);
Assert.AreEqual(filterToTest.FilterDescriptor.FilterType, result.FilterDescriptor.FilterType,
Responses.IncorrectFilterDescriptorFilterType);
}
public async Task DeleteFilterExecutor(FilterType filterType)
{
string custUid = Guid.NewGuid().ToString();
string userUid = Guid.NewGuid().ToString();
string projectUid = Guid.NewGuid().ToString();
string filterUid = Guid.NewGuid().ToString();
string name = "not entry";
string filterJson = "theJsonString";
var configStore = serviceProvider.GetRequiredService <IConfigurationStore>();
var logger = serviceProvider.GetRequiredService <ILoggerFactory>();
var projectProxy = new Mock <IProjectProxy>();
var productivity3dV2ProxyNotification = new Mock <IProductivity3dV2ProxyNotification>();
productivity3dV2ProxyNotification.Setup(ps => ps.NotifyFilterChange(It.IsAny <Guid>(), It.IsAny <Guid>(), null)).ReturnsAsync(new BaseMasterDataResult());
var filterRepo = new Mock <FilterRepository>(configStore, logger);
var filters = new List <MasterData.Repositories.DBModels.Filter>
{
new MasterData.Repositories.DBModels.Filter
{
CustomerUid = custUid,
UserId = userUid,
ProjectUid = projectUid,
FilterUid = filterUid,
Name = name,
FilterJson = filterJson,
FilterType = filterType,
LastActionedUtc = DateTime.UtcNow
}
};
filterRepo.As <IFilterRepository>().Setup(ps => ps.GetFiltersForProjectUser(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), true)).ReturnsAsync(filters);
filterRepo.As <IFilterRepository>().Setup(ps => ps.StoreEvent(It.IsAny <DeleteFilterEvent>())).ReturnsAsync(1);
var request =
FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
}, new FilterRequest {
FilterUid = filterUid, Name = name, FilterJson = filterJson, FilterType = filterType
});
var executor = RequestExecutorContainer.Build <DeleteFilterExecutor>(configStore, logger, serviceExceptionHandler,
filterRepo.Object, null, projectProxy.Object,
productivity3dV2ProxyNotification: productivity3dV2ProxyNotification.Object);
var result = await executor.ProcessAsync(request);
Assert.NotNull(result);
Assert.Equal(0, result.Code);
}
public void FilterRequestValidation_Should_fail_When_supplied_string_is_invalid_json()
{
var requestFull = FilterRequestFull.Create(null, custUid, false, userUid,
new ProjectData {
ProjectUID = projectUid
},
new FilterRequest {
FilterUid = filterUid, Name = Name, FilterJson = "de blah", FilterType = filterType
});
var ex = Assert.Throws <ServiceException>(() => requestFull.Validate(serviceExceptionHandler));
Assert.Contains("2042", ex.GetContent);
Assert.Contains("Invalid filterJson. Exception: ", ex.GetContent);
}
/// <summary>
/// Validates and saves a single filter. Also creates the project-geofence association if the filter contains a polygon boundary.
/// </summary>
private async Task <FilterDescriptorSingleResult> UpsertFilter(UpsertFilterExecutor filterExecutor, ProjectData project, FilterRequest filterRequest)
{
var requestFull = FilterRequestFull.Create(
Request.Headers.GetCustomHeaders(),
CustomerUid,
IsApplication,
GetUserId,
project,
filterRequest);
requestFull.Validate(ServiceExceptionHandler);
return(await filterExecutor.ProcessAsync(requestFull) as FilterDescriptorSingleResult);
}
public async Task GetFilterExecutor_DoesntBelongToUser(FilterType filterType)
{
string custUid = Guid.NewGuid().ToString();
string requestingUserUid = Guid.NewGuid().ToString();
string filterUserUid = Guid.NewGuid().ToString();
string projectUid = Guid.NewGuid().ToString();
string filterUid = Guid.NewGuid().ToString();
string name = "blah";
string filterJson = "{{\"dateRangeType\":\"0\",\"elevationType\":null}}";
var configStore = serviceProvider.GetRequiredService <IConfigurationStore>();
var logger = serviceProvider.GetRequiredService <ILoggerFactory>();
var filterRepo = new Mock <FilterRepository>(configStore, logger);
var filter = new MasterData.Repositories.DBModels.Filter
{
CustomerUid = custUid,
UserId = filterUserUid,
ProjectUid = projectUid,
FilterUid = filterUid,
Name = name,
FilterJson = filterJson,
FilterType = filterType,
LastActionedUtc = DateTime.UtcNow
};
filterRepo.As <IFilterRepository>().Setup(ps => ps.GetFilter(It.IsAny <string>())).ReturnsAsync(filter);
var request = FilterRequestFull.Create
(
null,
custUid,
false,
requestingUserUid,
new ProjectData {
ProjectUID = projectUid
},
new FilterRequest {
FilterUid = filterUid
}
);
var executor =
RequestExecutorContainer.Build <GetFilterExecutor>(configStore, logger, serviceExceptionHandler,
filterRepo.Object, null);
var ex = await Assert.ThrowsAsync <ServiceException>(async() => await executor.ProcessAsync(request));
Assert.Contains("2036", ex.GetContent);
Assert.Contains("GetFilter By filterUid. The requested filter does not exist, or does not belong to the requesting customer; project or user.", ex.GetContent);
}
public void FilterRequestValidation_MissingName()
{
var requestFull =
FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
},
new FilterRequest
{
FilterUid = filterUid,
Name = string.Empty,
FilterJson = string.Empty,
FilterType = filterType
});
Assert.Throws <ServiceException>(() => requestFull.Validate(serviceExceptionHandler));
}
public void FilterRequestValidation_InvalidName()
{
var requestFull =
FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
},
new FilterRequest
{
FilterUid = filterUid,
Name = null,
FilterJson = string.Empty,
FilterType = FilterType.Transient
});
requestFull.Validate(serviceExceptionHandler);
}
public void FilterRequestValidation_Should_succeed_When_supplied_json_is_valid(string filterJson)
{
var requestFull =
FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
},
new FilterRequest
{
FilterUid = filterUid,
Name = string.Empty,
FilterJson = filterJson,
FilterType = FilterType.Transient
});
requestFull.Validate(serviceExceptionHandler);
}
public async Task UpsertFilterExecutor_Persistent_ExistingName_FilterUidProvided_ChangeJson()
{
//Note: this test only applies to persistent filters not report filters.
//Report filters are allowed duplicate names.
var custUid = Guid.NewGuid();
var userId = Guid.NewGuid();
var projectUid = Guid.NewGuid();
var filterUid1 = Guid.NewGuid();
var filterUid2 = Guid.NewGuid();
string name = "theName";
string filterJson = "{\"designUID\":\"c2e5940c-4370-4d23-a930-b5b74a9fc22b\",\"contributingMachines\":[{\"assetID\":\"123456789\",\"machineName\":\"TheMachineName\",\"isJohnDoe\":false,\"assetUid\":null}]}";
string filterJsonUpdated = "{\"designUID\":\"c2e5940c-4370-4d23-a930-b5b74a9fc22b\",\"onMachineDesignID\":null,\"elevationType\":3,\"vibeStateOn\":true}";
var filterType = FilterType.Persistent;
var filterEvent = new CreateFilterEvent
{
CustomerUID = custUid,
UserID = userId.ToString(),
ProjectUID = projectUid,
FilterUID = filterUid1,
Name = name,
FilterType = filterType,
FilterJson = filterJson,
ActionUTC = DateTime.UtcNow
};
WriteEventToDb(filterEvent);
filterEvent.FilterUID = filterUid2;
filterEvent.Name = "something else";
WriteEventToDb(filterEvent);
// now try to change the 2nd filter to the name of the first
var request = FilterRequestFull.Create(new HeaderDictionary(), custUid.ToString(), false, userId.ToString(), new ProjectData {
ProjectUID = projectUid.ToString()
}, new FilterRequest {
FilterUid = filterUid2.ToString(), Name = name, FilterJson = filterJsonUpdated, FilterType = filterType
});
var ex = await Assert.ThrowsExceptionAsync <ServiceException>(async() => await executor.ProcessAsync(request)).ConfigureAwait(false);
var content = ex.GetContent;
Assert.AreNotEqual(-1, content.IndexOf("2039", StringComparison.Ordinal), "executor threw exception but incorrect code");
Assert.AreNotEqual(-1, content.IndexOf("UpsertFilter failed. Unable to add persistent filter as Name already exists.", StringComparison.Ordinal), "executor threw exception but incorrect messaage");
}
/// <summary>
/// Takes a set of filters expressed as filter UIDs and combination roles and produces a JSON encoded filter
/// representing the combined filters
/// </summary>
/// <param name="request"></param>
/// <param name="repository"></param>
/// <param name="serviceExceptionHandler"></param>
/// <param name="log"></param>
/// <returns></returns>
public static async Task <string> Combine(FilterRequestFull request, IFilterRepository repository, IServiceExceptionHandler serviceExceptionHandler, ILogger log)
{
var filters =
(await repository.GetFiltersForProjectUser(request.CustomerUid, request.ProjectUid, request.UserId, true).ConfigureAwait(false))
.Where(x => request.HierarchicFilterUids.Any(f => string.Equals(f.FilterUid, x.FilterUid, StringComparison.OrdinalIgnoreCase)))
.ToList();
if (filters.Count != request.HierarchicFilterUids.Count)
{
serviceExceptionHandler.ThrowServiceException(HttpStatusCode.BadRequest, 11);
}
log.LogDebug($"CombineFilters retrieved {request.HierarchicFilterUids.Count} requested filters to combine");
// Perform the operations to combine the selected filters
return(JsonConvert.SerializeObject(CombineFilters(request, filters)));
}
public void FilterRequestValidation_ValidPassCountRange(FilterType filterType)
{
var minPassCount = 5;
var maxPassCount = 8;
var request = FilterRequestFull.Create(null, custUid, false, userUid, new ProjectData {
ProjectUID = projectUid
},
new FilterRequest
{
FilterUid = filterUid,
Name = "a filter",
FilterType = filterType,
FilterJson = "{\"vibeStateOn\": true, \"passCountRangeMin\": \"" + minPassCount + "\", \"passCountRangeMax\": \"" + maxPassCount + "\" }"
});
request.Validate(serviceExceptionHandler);
}
