private void CopyPropertyData(ref FilterResult result, HierarchyProperty property)
{
if (result == null)
{
result = new FilterResult();
}
result.instanceID = property.instanceID;
result.name = property.name;
result.hasChildren = property.hasChildren;
result.colorCode = property.colorCode;
result.isMainRepresentation = property.isMainRepresentation;
result.hasFullPreviewImage = property.hasFullPreviewImage;
result.iconDrawStyle = property.iconDrawStyle;
result.isFolder = property.isFolder;
result.type = this.hierarchyType;
if (!property.isMainRepresentation)
{
result.icon = property.icon;
}
else if (property.isFolder && !property.hasChildren)
{
result.icon = EditorGUIUtility.FindTexture(EditorResourcesUtility.emptyFolderIconName);
}
else
{
result.icon = null;
}
}
public void SetEntities_Entities_Changed()
{
var target = new FilterResult<int>(new int[] { 1, 2, 3 }, 6);
((IFilterResult)target).SetEntities(new int[] { 1 });
((IFilterResult)target).TotalCount = 1;
Assert.AreEqual(1, ((IFilterResult)target).GetEntities().Cast<object>().Count());
Assert.AreEqual(1, ((IFilterResult)target).TotalCount);
}
public void ToAnonymous_Entities_Anonymous()
{
var target = new FilterResult<int>(new int[] { 1, 2, 3 }, 6);
var actual = target.ToAnonymous((i) =>
{
return (i * 10).ToString();
});
var entities = actual.Entities.ToList();
Assert.AreEqual(3, entities.Count);
Assert.AreEqual(6, actual.TotalCount);
Assert.AreEqual("10", entities[0]);
Assert.AreEqual("20", entities[1]);
Assert.AreEqual("30", entities[2]);
}
public CellDatumRequest(
long projectId,
Guid?projectUid,
DisplayMode displayMode,
WGSPoint llPoint,
Point gridPoint,
FilterResult filter,
LiftBuildSettings liftBuildSettings,
DesignDescriptor design)
{
ProjectId = projectId;
ProjectUid = projectUid;
DisplayMode = displayMode;
LLPoint = llPoint;
GridPoint = gridPoint;
Filter = filter;
FilterId = filter?.Id ?? -1;
LiftBuildSettings = liftBuildSettings;
Design = design;
}
public FilterResult Exec()
{
FilterResult res = FilterResult.N;
ICandle curr = _data["5"].Last();
ICandle last = _data["5"][_data["5"].Count - 2];
ICandle prev = _data["5"][_data["5"].Count - 3];
if (Func.Green(last) && Func.Big(last) && Func.Green(prev) && curr.close > last.close)
{
res = FilterResult.L;
}
if (Func.Red(last) && Func.Big(last) && Func.Red(prev) && curr.close < last.close)
{
res = FilterResult.S;
}
return res;
}
/// <summary>
/// Overload constructor with parameters.
/// </summary>
public PatchDataRequest(
Guid projectUid,
FilterResult filter1,
FilterResult filter2,
DisplayMode mode,
int patchNumber,
int patchSize,
OverridingTargets overrides,
LiftSettings liftSettings
)
{
ProjectUid = projectUid;
Filter = filter1;
Filter2 = filter2;
Mode = mode;
PatchNumber = patchNumber;
PatchSize = patchSize;
Overrides = overrides;
LiftSettings = liftSettings;
}
public void GriddedTRexRequest_Unsuccessful(
Guid projectUid, FilterResult filter,
bool reportElevation, bool reportCmv, bool reportMdp, bool reportPassCount, bool reportTemperature, bool reportCutFill,
Guid?cutFillDesignUid, double?cutfillDesignOffset,
double?gridInterval, GridReportOption gridReportOption,
double startNorthing, double startEasting, double endNorthing, double endEasting, double azimuth,
string errorMessage)
{
var request = new CompactionReportGridTRexRequest(
projectUid, filter,
reportElevation, reportCmv, reportMdp, reportPassCount, reportTemperature, reportCutFill,
cutFillDesignUid, cutfillDesignOffset,
gridInterval, gridReportOption, startNorthing, startEasting, endNorthing, endEasting, azimuth, null, null);
var ex = Assert.Throws <ServiceException>(() => request.Validate());
Assert.Equal(HttpStatusCode.BadRequest, ex.Code);
Assert.Equal(ContractExecutionStatesEnum.ValidationError, ex.GetResult.Code);
Assert.Equal(errorMessage, ex.GetResult.Message);
}
public void MapFilterResultHasLayerStateFilterToCombinedFilter()
{
FilterLayerMethod?layerType = FilterLayerMethod.Automatic;
var filter = new Filter();
var filterResult = new FilterResult(filter: filter, layerType: layerType, returnEarliest: true);
filterResult.Validate();
var combinedFilter = AutoMapperUtility.Automapper.Map <CombinedFilter>(filterResult);
combinedFilter.AttributeFilter.HasLayerStateFilter.Should().BeTrue();
combinedFilter.AttributeFilter.LayerState.Should().Be(LayerState.On);
filterResult = new FilterResult(filter: filter, returnEarliest: true);
filterResult.Validate();
combinedFilter = AutoMapperUtility.Automapper.Map <CombinedFilter>(filterResult);
combinedFilter.AttributeFilter.HasLayerStateFilter.Should().BeFalse();
combinedFilter.AttributeFilter.LayerState.Should().Be(LayerState.Off);
}
/// <summary>
/// Ensures there is not a misconfigured topFilter for certain operations that involve design surfaces for tile rendering operations
/// </summary>
public static FilterResult ReconcileTopFilterAndVolumeComputationMode(
FilterResult topFilter,
DisplayMode mode,
VolumesType computeVolType)
{
// Adjust filter to take into account volume type computations that effect Cut/Fill, Volume and Thickness requests.
// If these requests invovle a design through the appropriate volume computation modes, the topFilter has no effect
// and must be made safe so the underlying engines do not receive conflicting instructions between a specified design
// and a top filter indication one of the comparative surfaces used by these requests
if ((mode == DisplayMode.CutFill || mode == DisplayMode.VolumeCoverage || mode == DisplayMode.TargetThicknessSummary)
&&
(computeVolType == VolumesType.BetweenDesignAndFilter || computeVolType == VolumesType.BetweenFilterAndDesign))
{
// Force topfilter (which is filter2) to be a plain empty filter to remove any default
// setting such as the LayerType to percolate through into the request.
return(new FilterResult());
}
return(topFilter);
}
private FilterResult RunBlockHashFilter(string fileSha1, int phoneId, List <BlockHashFilter.UnfilterdBlockResult> storedBlocks)
{
FilterResult filterResult = null;
try
{
write("Starting block hash filtering");
DateTime dt = DateTime.Now;
BlockHashFilter bhf = new BlockHashFilter(this.filePath, HashLoader.HashLoader.DefaultBlockSize,
HashLoader.HashLoader.DefaultSlideAmount, fileSha1, true, storedBlocks);
#if _USESQLSERVER_
filterResult = bhf.Filter(phoneId);
#else
SQLiteConnection sql = DatabaseAccess.OpenSql(true);
try
{
filterResult = bhf.Filter(phoneId, sql, true);
}
finally
{
sql.Close();
sql.Dispose();
}
#endif
TimeSpan ts = DateTime.Now.Subtract(dt);
write("Time elapsed for block hash filtering: {0}", ts.ToString("c"));
long nBytes = filterResult.FilteredBytesCount + filterResult.UnfilteredBytesCount;
write("Filtered {0} out of {1} bytes: {2:0.00###}", filterResult.FilteredBytesCount,
nBytes, (nBytes - filterResult.UnfilteredBytesCount) / (double)nBytes);
}
catch (ThreadAbortException)
{
return(null);
}
catch (Exception ex)
{
DisplayExceptionMessages(ex, "Block Hash Filter");
return(null);
}
return(filterResult);
}
void SearchInFolders()
{
List <FilterResult> list = new List <FilterResult>();
List <string> baseFolders = new List <string>();
baseFolders.AddRange(ProjectWindowUtil.GetBaseFolders(m_SearchFilter.folders));
if (baseFolders.Remove(PackageManager.Folders.GetPackagesMountPoint()))
{
var packages = PackageManager.Packages.GetAll();
foreach (var package in packages)
{
if (package.source == PackageManager.PackageSource.BuiltIn)
{
continue;
}
if (!baseFolders.Contains(package.assetPath))
{
baseFolders.Add(package.assetPath);
}
}
}
foreach (string folderPath in baseFolders)
{
// Ensure we do not have a filter when finding folder
HierarchyProperty property = new HierarchyProperty(folderPath);
property.SetSearchFilter(m_SearchFilter);
// Set filter after we found the folder
int folderDepth = property.depth;
int[] expanded = null; // enter all children of folder
while (property.NextWithDepthCheck(expanded, folderDepth + 1))
{
FilterResult result = new FilterResult();
CopyPropertyData(ref result, property);
list.Add(result);
}
}
m_Results = list.ToArray();
}
public CompactionReportGridTRexRequest(
Guid projectUid,
FilterResult filter,
bool reportElevation,
bool reportCmv,
bool reportMdp,
bool reportPassCount,
bool reportTemperature,
bool reportCutFill,
Guid?cutFillDesignUid,
double?cutFillDesignOffset,
double?gridInterval,
GridReportOption gridReportOption,
double startNorthing,
double startEasting,
double endNorthing,
double endEasting,
double azimuth,
OverridingTargets overrides,
LiftSettings liftSettings)
{
ProjectUid = projectUid;
Filter = filter;
ReportElevation = reportElevation;
ReportCmv = reportCmv;
ReportMdp = reportMdp;
ReportPassCount = reportPassCount;
ReportTemperature = reportTemperature;
ReportCutFill = reportCutFill;
CutFillDesignUid = cutFillDesignUid;
CutFillDesignOffset = cutFillDesignOffset;
GridInterval = gridInterval ?? ValidationConstants3D.DEFAULT_SPACING_INTERVAL;
GridReportOption = gridReportOption;
StartNorthing = startNorthing;
StartEasting = startEasting;
EndNorthing = endNorthing;
EndEasting = endEasting;
Azimuth = azimuth;
Overrides = overrides;
LiftSettings = liftSettings;
}
/// <summary>
/// Overload constructor with parameters.
/// </summary>
public SummaryVolumesProfileDataRequest(
Guid projectUid,
FilterResult baseFilter,
FilterResult topFilter,
Guid?referenceDesignUid,
double?referenceDesignOffset,
VolumesType volumeCalcType,
bool positionsAreGrid,
double startX,
double startY,
double endX,
double endY,
OverridingTargets overrides,
LiftSettings liftSettings)
: base(projectUid, referenceDesignUid, referenceDesignOffset, positionsAreGrid,
startX, startY, endX, endY, overrides, liftSettings, baseFilter)
{
TopFilter = topFilter;
VolumeCalcType = volumeCalcType;
}
public void Should_set_DesignID_From_OnMachineDesignName_null()
{
string onMachineDesignName = null;
long? onMachineDesignId = null;
int expectedValue = 0;
var machineDesigns = new[]
{ new TDesignName {
FID = expectedValue, FMachineID = 4, FName = onMachineDesignName
} };
var mockRaptorClient = new Mock <IASNodeClient>();
mockRaptorClient.Setup(prj => prj.GetOnMachineDesignEvents(It.IsAny <long>())).Returns(machineDesigns);
var filterResult = new FilterResult(filter: CreateFilter(onMachineDesignId, onMachineDesignName: onMachineDesignName));
Assert.AreEqual(onMachineDesignId, filterResult.OnMachineDesignId);
var raptorFilter = RaptorConverters.ConvertFilter(filterResult, 1, mockRaptorClient.Object);
Assert.AreEqual(expectedValue, raptorFilter.DesignNameID);
}
/// <summary>
/// Overload constructor with parameters.
/// </summary>
public CellDatumTRexRequest(
Guid projectUid,
DisplayMode displayMode,
WGSPoint llPoint,
Point gridPoint,
FilterResult filter,
Guid?designUid,
double?offset,
OverridingTargets overrides,
LiftSettings liftSettings)
{
ProjectUid = projectUid;
DisplayMode = displayMode;
LLPoint = llPoint;
GridPoint = gridPoint;
Filter = filter;
DesignUid = designUid;
Offset = offset;
Overrides = overrides;
LiftSettings = liftSettings;
}
public FilterResult Exec()
{
FilterResult res = FilterResult.N;
//скользящая средняя для 60ти минуток
SimpleMovingAverage hours_ma = new SimpleMovingAverage(_data["60"], 30);
//определяем тренд
TRENDResult trend = new TREND(hours_ma, 3).GetResult();
if (trend == TRENDResult.Up)
{
res = FilterResult.L;
}
if (trend == TRENDResult.Down)
{
res = FilterResult.S;
}
return(res);
}
private JObject CreateResponse(FilterResult filter)
{
var result = new JObject();
var schemas = new JArray();
schemas.Add(Common.Constants.Messages.ListResponse);
result.Add(Common.Constants.ScimResourceNames.Schemas, schemas);
result[Common.Constants.SearchParameterResponseNames.Resources] = filter.Values;
if (filter.ItemsPerPage.HasValue)
{
result.Add(Common.Constants.SearchParameterResponseNames.ItemsPerPage, filter.ItemsPerPage);
}
if (filter.StartIndex.HasValue)
{
result.Add(Common.Constants.SearchParameterResponseNames.StartIndex, filter.StartIndex);
}
result.Add(Common.Constants.SearchParameterResponseNames.TotalResults, filter.TotalNumbers);
return(result);
}
private void FilterItems()
{
FilteredItems = Items;
if (FilteredItems != null && Filter != null)
{
FilteredItems = new List <ItemCraft>();
if (Items.Count >= Properties.Settings.Default.ProgressBarThreshold)
{
int i = 0;
ProgressDialog p = new ProgressDialog()
{
Title = "Filtering...", Steps = Items.Count, ReportStep = Math.Max(Items.Count / 100, 1)
};
p.Increment = () =>
{
FilterResult res = FilterEvaluator.Evaluate(Items[i], Filter);
Items[i].TempProps = res.Info;
if (res.Match)
{
FilteredItems.Add(Items[i]);
}
i++;
};
p.ShowDialog();
}
else
{
foreach (ItemCraft item in Items)
{
FilterResult res = FilterEvaluator.Evaluate(item, Filter);
item.TempProps = res.Info;
if (res.Match)
{
FilteredItems.Add(item);
}
}
}
}
//GraphWindows.Clear();
}
public static CompactionReportStationOffsetTRexRequest CreateRequest(
Guid projectUid,
FilterResult filter,
bool reportElevation,
bool reportCmv,
bool reportMdp,
bool reportPassCount,
bool reportTemperature,
bool reportCutFill,
Guid?cutFillDesignUid,
double?cutFillDesignOffset,
Guid alignmentDesignUid,
double crossSectionInterval,
double startStation,
double endStation,
double[] offsets,
OverridingTargets overrides,
LiftSettings liftSettings)
{
return(new CompactionReportStationOffsetTRexRequest
{
ProjectUid = projectUid,
Filter = filter,
ReportElevation = reportElevation,
ReportCmv = reportCmv,
ReportMdp = reportMdp,
ReportPassCount = reportPassCount,
ReportTemperature = reportTemperature,
ReportCutFill = reportCutFill,
CutFillDesignUid = cutFillDesignUid,
CutFillDesignOffset = cutFillDesignOffset,
AlignmentDesignUid = alignmentDesignUid,
CrossSectionInterval = crossSectionInterval,
StartStation = startStation,
EndStation = endStation,
Offsets = offsets,
Overrides = overrides,
LiftSettings = liftSettings
});
}
public CompactionCSVExportRequest(
Guid projectUid,
FilterResult filter,
string fileName,
CoordType coordType,
OutputTypes coordinateOutputType,
UserPreferences userPreferences,
string[] machineNames,
bool restrictOutputSize,
bool rawDataAsDBase
)
{
ProjectUid = projectUid;
Filter = filter;
FileName = fileName;
CoordType = coordType;
OutputType = coordinateOutputType;
MachineNames = machineNames;
UserPreferences = userPreferences;
RestrictOutputSize = restrictOutputSize;
RawDataAsDBase = rawDataAsDBase;
}
public void ValidateVolumesFilters(VolumesType computeVolType, FilterResult filter1, long filterId1, FilterResult filter2, long filterId2)
{
switch (computeVolType)
{
case VolumesType.Between2Filters:
if ((filter1 == null && filterId1 <= 0) || (filter2 == null && filterId2 <= 0))
{
throw new TwoFiltersRequiredException(HttpStatusCode.BadRequest,
new ContractExecutionResult(ContractExecutionStatesEnum.ValidationError,
string.Format("Two filters required for filter to filter volumes display")));
}
break;
case VolumesType.BetweenDesignAndFilter:
case VolumesType.BetweenFilterAndDesign:
if (filter1 == null && filterId1 <= 0 && filter2 == null && filterId2 <= 0)
{
throw new SingleFilterRequiredException(HttpStatusCode.BadRequest,
new ContractExecutionResult(ContractExecutionStatesEnum.ValidationError,
string.Format("One filter required for design to filter or filter to design volumes display")));
}
break;
default:
throw new ServiceException(HttpStatusCode.BadRequest,
new ContractExecutionResult(ContractExecutionStatesEnum.ValidationError,
string.Format("This type of volumes calculation is not supported")));
}
if (filter1 != null)
{
filter1.Validate();
}
if (filter2 != null)
{
filter2.Validate();
}
}
public void CSVExportHelper_MapCommonExportRequestToArgument(string decimalSeparator, string thousandsSeparator, UnitsTypeEnum units,
string dateSeparator, string timeSeparator, bool restrictOutputSize, bool rawDataAsDBase,
string expectedDateSeparator, string expectedTimeSeparator)
{
var projectUid = Guid.NewGuid();
FilterResult filter = null;
var fileName = "gotAFilename";
var coordType = CoordType.LatLon;
var outputType = OutputTypes.VedaAllPasses;
var theMachineName = "first machineName";
string[] machineNames = new string[] { theMachineName };
var userPreference = new UserPreferences()
{
DateSeparator = dateSeparator,
TimeSeparator = timeSeparator,
DecimalSeparator = decimalSeparator,
ThousandsSeparator = thousandsSeparator,
Units = (int)units
};
var request = new CompactionCSVExportRequest(
projectUid, filter, fileName,
coordType, outputType, userPreference, machineNames, restrictOutputSize, rawDataAsDBase);
request.Validate();
var csvExportRequestArgument = AutoMapperUtility.Automapper.Map <CSVExportRequestArgument>(request);
csvExportRequestArgument.CoordType.Should().Be(coordType);
csvExportRequestArgument.OutputType.Should().Be(outputType);
csvExportRequestArgument.UserPreferences.DecimalSeparator.Should().Be(decimalSeparator);
csvExportRequestArgument.UserPreferences.DateSeparator.Should().Be(expectedDateSeparator);
csvExportRequestArgument.UserPreferences.TimeSeparator.Should().Be(expectedTimeSeparator);
// these are mapped separately using CSVExportHelper.MapRequestedMachines()
csvExportRequestArgument.MappedMachines.Count.Should().Be(0);
csvExportRequestArgument.RawDataAsDBase.Should().Be(rawDataAsDBase);
}
void SearchAllAssets(SearchFilter.SearchArea area)
{
const int k_MaxAddCount = 3000;
if (m_HierarchyType == HierarchyType.Assets)
{
List <FilterResult> list = new List <FilterResult>();
list.AddRange(m_Results);
var maxAddCount = k_MaxAddCount;
m_SearchFilter.searchArea = area;
var enumerator = AssetDatabase.EnumerateAllAssets(m_SearchFilter);
while (enumerator.MoveNext() && --maxAddCount >= 0)
{
var result = new FilterResult();
CopyPropertyData(ref result, enumerator.Current);
list.Add(result);
}
m_Results = list.ToArray();
}
else
{
HierarchyProperty property = new HierarchyProperty(m_HierarchyType, false);
property.SetSearchFilter(m_SearchFilter);
int elements = property.CountRemaining(null);
elements = Mathf.Min(elements, k_MaxAddCount);
property.Reset();
int i = m_Results.Length;
System.Array.Resize(ref m_Results, m_Results.Length + elements);
while (property.Next(null) && i < m_Results.Length)
{
CopyPropertyData(ref m_Results[i], property);
i++;
}
}
}
/// <summary>
/// Overload constructor with parameters.
/// </summary>
public PassCounts(
long projectId,
Guid?projectUid,
PassCountSettings passCountSettings,
LiftBuildSettings liftBuildSettings,
FilterResult filter,
long filterID,
DateTime?overrideStartUTC,
DateTime?overrideEndUTC,
List <long> overrideAssetIds
)
{
ProjectId = projectId;
ProjectUid = projectUid;
this.passCountSettings = passCountSettings;
this.liftBuildSettings = liftBuildSettings;
Filter = filter;
FilterID = filterID;
OverrideStartUTC = overrideStartUTC;
OverrideEndUTC = overrideEndUTC;
OverrideAssetIds = overrideAssetIds;
}
public async Task CSVExportExecutor_GotSiteAndFilter()
{
var fileName = "gotAFilename";
var coordType = CoordType.Northeast;
var outputType = OutputTypes.VedaAllPasses;
string[] machineNames = new string[] { "first machineName" };
var userPreferences = new UserPreferences();
var filter = new Productivity3D.Filter.Abstractions.Models.Filter(
DateTime.SpecifyKind(new DateTime(2018, 1, 10), DateTimeKind.Utc),
DateTime.SpecifyKind(new DateTime(2019, 2, 11), DateTimeKind.Utc), "", "",
new List <MachineDetails>(), null, null, null, null, null, null
);
var filterResult = new FilterResult(null, filter, null, null, null, null, null, null, null);
var siteModel = DITAGFileAndSubGridRequestsWithIgniteFixture.NewEmptyModel();
var request = new CompactionVetaExportRequest(
siteModel.ID, filterResult, fileName,
coordType, outputType, userPreferences, machineNames, null, null);
request.Validate();
var compactionCSVExportRequest = AutoMapperUtility.Automapper.Map <CompactionCSVExportRequest>(request);
// Mock the CSV export request functionality to return a null CSV export reponse to stimulate tyhe desired internal processing error
var mockCompute = IgniteMock.Immutable.mockCompute;
mockCompute.Setup(x => x.ApplyAsync(It.IsAny <CSVExportRequestComputeFunc>(), It.IsAny <CSVExportRequestArgument>(), It.IsAny <CancellationToken>())).Returns((CSVExportRequestComputeFunc func, CSVExportRequestArgument argument, CancellationToken token) => Task.FromResult <CSVExportRequestResponse>(null));
var executor = RequestExecutorContainer
.Build <CSVExportExecutor>(DIContext.Obtain <IConfigurationStore>(),
DIContext.Obtain <ILoggerFactory>(),
DIContext.Obtain <IServiceExceptionHandler>());
var result = await Assert.ThrowsAsync <ServiceException>(() => executor.ProcessAsync(compactionCSVExportRequest));
result.Code.Should().Be(HttpStatusCode.InternalServerError);
result.GetResult.Code.Should().Be(ContractExecutionStatesEnum.InternalProcessingError);
result.GetResult.Message.Should().Be("Failed to complete TRex request: CSVExportExecutor with error: Failed to configure internal pipeline.");
}
public async Task GriddedReportExecutor_SiteModelNotFound()
{
var projectUid = Guid.NewGuid();
FilterResult filter = null;
bool reportElevation = true;
bool reportCmv = true;
bool reportMdp = true;
bool reportPassCount = true;
bool reportTemperature = true;
bool reportCutFill = false;
Guid? cutFillDesignUid = null;
double? cutFillDesignOffset = null;
double? gridInterval = null;
var gridReportOption = GridReportOption.Automatic;
double startNorthing = 800000;
double startEasting = 400000;
double endNorthing = 800010;
double endEasting = 400010;
double azimuth = 4;
var request = new CompactionReportGridTRexRequest(
projectUid, filter,
reportElevation, reportCmv, reportMdp, reportPassCount, reportTemperature, reportCutFill,
cutFillDesignUid, cutFillDesignOffset,
gridInterval, gridReportOption, startNorthing, startEasting, endNorthing, endEasting, azimuth, null, null);
request.Validate();
var executor = RequestExecutorContainer
.Build <GriddedReportExecutor>(DIContext.Obtain <IConfigurationStore>(),
DIContext.Obtain <ILoggerFactory>(),
DIContext.Obtain <IServiceExceptionHandler>());
var result = await Assert.ThrowsAsync <ServiceException>(() => executor.ProcessAsync(request));
Assert.Equal(HttpStatusCode.BadRequest, result.Code);
Assert.Equal(ContractExecutionStatesEnum.InternalProcessingError, result.GetResult.Code);
Assert.Equal($"Site model {projectUid} is unavailable", result.GetResult.Message);
}
/// <summary>
/// Creates an instance of the TileRequest class and populate it with data needed for a tile.
/// </summary>
/// <returns>An instance of the TileRequest class.</returns>
public TileRequest CreateTileRequest(DisplayMode mode, ushort width, ushort height,
BoundingBox2DLatLon bbox, ElevationStatisticsResult elevExtents, bool explicitFilters = false)
{
var liftSettings = SettingsManager.CompactionLiftBuildSettings(ProjectSettings);
Filter?.Validate();//Why is this here? Should be done where filter set up???
var palette = SettingsManager.CompactionPalette(mode, elevExtents, ProjectSettings, ProjectSettingsColors);
var computeVolType = (int)(volCalcType ?? VolumeCalcType.None);
DesignDescriptor design = DesignDescriptor;
FilterResult filter1 = Filter;
FilterResult filter2 = null;
if (mode == DisplayMode.CutFill)
{
switch (volCalcType)
{
case VolumeCalcType.DesignToGround:
case VolumeCalcType.GroundToDesign:
design = volumeDesign;
filter1 = baseFilter ?? topFilter;
break;
case VolumeCalcType.GroundToGround:
filter1 = baseFilter;
filter2 = topFilter;
break;
}
}
TileRequest tileRequest = new TileRequest(
ProjectId, ProjectUid, null, mode, palette, liftSettings, (VolumesType)computeVolType,
0, design, filter1, 0, filter2, 0,
Filter == null || !Filter.LayerType.HasValue ? FilterLayerMethod.None : Filter.LayerType.Value,
bbox, null, width, height, 0, CMV_DETAILS_NUMBER_OF_COLORS, CMV_PERCENT_CHANGE_NUMBER_OF_COLORS, false, explicitFilters);
return(tileRequest);
}
/// <summary>
/// Overload constructor with parameters.
/// </summary>
public PatchRequest(
long?projectId,
Guid?projectUid,
Guid?callId,
DisplayMode mode,
List <ColorPalette> palettes,
LiftBuildSettings liftBuildSettings,
bool renderColorValues,
VolumesType computeVolType,
double computeVolNoChangeTolerance,
DesignDescriptor designDescriptor,
FilterResult filter1,
FilterResult filter2,
FilterLayerMethod filterLayerMethod,
int patchNumber,
int patchSize,
bool includeTimeOffsets = false
)
{
ProjectId = projectId;
ProjectUid = projectUid;
CallId = callId;
Mode = mode;
Palettes = palettes;
LiftBuildSettings = liftBuildSettings;
RenderColorValues = renderColorValues;
ComputeVolType = computeVolType;
ComputeVolNoChangeTolerance = computeVolNoChangeTolerance;
DesignDescriptor = designDescriptor;
Filter1 = filter1;
FilterId1 = filter1?.Id ?? 0;
Filter2 = filter2;
FilterId2 = filter2?.Id ?? 0;
FilterLayerMethod = filterLayerMethod;
PatchNumber = patchNumber;
PatchSize = patchSize;
IncludeTimeOffsets = includeTimeOffsets;
}
public void BasicFilterWithPrecalculatedProb()
{
BasicFilter filter = new BasicFilter(40000, 1.0E-7);
foreach (string str in WordList)
{
filter.Insert(str);
}
foreach (string str in WordList)
{
Assert.True(filter.Check(str).Presence == BloomPresence.MightBeInserted);
}
// This was brute-forced not to be in the set
Assert.True(filter.Check("notInThere4").Presence == BloomPresence.NotInserted);
// This is inside the set
FilterResult res = filter.Check("radioimmunoelectrophoresis");
Assert.True(res.Presence == BloomPresence.MightBeInserted);
Assert.True(res.Probability <= 1.0E-7);
}
public void QueryTasks_ShouldReturnAllProjects()
{
//arrange
var testProjects = GetTestTasks();
var queryResult = new FilterResult <Task>()
{
Data = testProjects, Total = testProjects.Count()
};
var mockTaskRepository = new Mock <ITaskRepository>().Object;
Mock.Get <ITaskRepository>(mockTaskRepository).Setup(r => r.Query(It.IsAny <FilterState>())).Returns(queryResult);
var taskFacade = new TaskFacade(mockTaskRepository);
var taskController = new TaskController(taskFacade);
var filterState = new FilterState();
//act : no filters
var x = taskController.Query(filterState);
var result = x as OkNegotiatedContentResult <FilterResult <TaskDto> >;
//assert
Assert.AreEqual(testProjects.Count(), result.Content.Total);
}
public void QueryUsers_ShouldReturnAllUsers()
{
//arrange
var testUsers = GetTestUsers();
var queryResult = new FilterResult <User>()
{
Data = testUsers, Total = testUsers.Count()
};
var mockUserRepository = new Mock <IUserRepository>().Object;
Mock.Get <IUserRepository>(mockUserRepository).Setup(r => r.Query(It.IsAny <FilterState>())).Returns(queryResult);
var userFacade = new UserFacade(mockUserRepository);
var userControler = new UserController(userFacade);
var filterState = new FilterState();
//act : no filters
var x = userControler.Query(filterState);
var result = x as OkNegotiatedContentResult <FilterResult <UserDto> >;
//assert
Assert.AreEqual(testUsers.Count(), result.Content.Total);
}
public void MapFilterResultHasMachineFilterToCombinedFilter()
{
var contributingMachines = new List <MachineDetails>()
{
new MachineDetails(Consts.NULL_LEGACY_ASSETID, "Big yella 1", false, Guid.NewGuid()), new MachineDetails(Consts.NULL_LEGACY_ASSETID, "Big yella 2", true, Guid.NewGuid())
};
var filter = new Filter(contributingMachines: contributingMachines);
var filterResult = new FilterResult(filter: filter);
filterResult.Validate();
var combinedFilter = AutoMapperUtility.Automapper.Map <CombinedFilter>(filterResult);
combinedFilter.AttributeFilter.HasMachineFilter.Should().BeTrue();
combinedFilter.AttributeFilter.MachinesList.Length.Should().Be(2);
combinedFilter.AttributeFilter.MachinesList[0].Should().Be((Guid)(contributingMachines[0].AssetUid ?? null));
combinedFilter.AttributeFilter.MachinesList[1].Should().Be((Guid)(contributingMachines[1].AssetUid ?? null));
var internalMachineIdBitArray = combinedFilter.AttributeFilter.GetMachineIDsSet();
internalMachineIdBitArray.Should().NotBeNull();
internalMachineIdBitArray.Count.Should().Be(0);
}
public void Should_set_Machines_From_AssetIDs_list_When_ContributingMachines_is_not_empty(bool setAssetIds)
{
var assetIds = setAssetIds
? new List <long> {
1, 2, 3, 5, 8, 13
}
: null;
var contributingMachines = new List <MachineDetails>
{
new MachineDetails(21, "twentyone", false),
new MachineDetails(43, "thirtyfour", false)
};
var filterResult = FilterResult.CreateFilterForCCATileRequest(assetIDs: assetIds, contributingMachines: contributingMachines);
var result = RaptorConverters.ConvertFilter(filterResult);
var expectedArrayLength = (assetIds?.Count ?? 0) + contributingMachines.Count;
Assert.IsTrue(result.Machines.Length == expectedArrayLength);
Assert.IsTrue(result.Machines[expectedArrayLength - 2].Name == "twentyone");
Assert.IsTrue(result.Machines[expectedArrayLength - 1].Name == "thirtyfour");
}
public TreeViewNodeFilterResult(FilterResult? filterResult, bool isMatch)
{
this.FilterResult = filterResult;
this.IsMatch = isMatch;
}
private bool IsBetterDeletionMatch(FilterResult result1, FilterResult result2)
{
var item1 = result1.PresentationItem.Item;
var item2 = result2.PresentationItem.Item;
var prefixLength1 = item1.FilterText.GetCaseInsensitivePrefixLength(result1.FilterText);
var prefixLength2 = item2.FilterText.GetCaseInsensitivePrefixLength(result2.FilterText);
// Prefer the item that matches a longer prefix of the filter text.
if (prefixLength1 > prefixLength2)
{
return true;
}
// If the lengths are the same, prefer the one with the higher match priority.
// But only if it's an item that would have been hard selected. We don't want
// to aggressively select an item that was only going to be softly offered.
var item1Priority = item1.Rules.SelectionBehavior == CompletionItemSelectionBehavior.HardSelection
? item1.Rules.MatchPriority : MatchPriority.Default;
var item2Priority = item2.Rules.SelectionBehavior == CompletionItemSelectionBehavior.HardSelection
? item2.Rules.MatchPriority : MatchPriority.Default;
if (item1Priority > item2Priority)
{
return true;
}
return false;
}
public void GetEntities_NoArgs_Entities()
{
var target = new FilterResult<int>(new int[] { 1, 2, 3 }, 6);
Assert.AreEqual(3, ((IFilterResult)target).GetEntities().Cast<object>().Count());
}
public void Constructor_Args_PropertiesDefined()
{
var target = new FilterResult<int>(new int[] { 1, 2, 3 }, 6);
Assert.AreEqual(3, target.Entities.Count());
Assert.AreEqual(6, target.TotalCount);
}
private void FolderBrowsing(HierarchyProperty property)
{
List<FilterResult> list = new List<FilterResult>();
foreach (string str in this.m_SearchFilter.folders)
{
int mainAssetInstanceID = AssetDatabase.GetMainAssetInstanceID(str);
if (property.Find(mainAssetInstanceID, null))
{
int depth = property.depth;
int[] expanded = new int[] { mainAssetInstanceID };
while (property.Next(expanded))
{
if (property.depth <= depth)
{
break;
}
FilterResult result = new FilterResult();
this.CopyPropertyData(ref result, property);
list.Add(result);
if (property.hasChildren && !property.isFolder)
{
Array.Resize<int>(ref expanded, expanded.Length + 1);
expanded[expanded.Length - 1] = property.instanceID;
}
}
}
}
this.m_Results = list.ToArray();
}
