internal bool Validate(ObjectType objectType, string name, ErrorContext errorContext)
{
bool result = true;
if (string.IsNullOrEmpty(name) || name.Length > 256)
{
errorContext.Register(m_errorCodeNameLength, Severity.Error, objectType, name, "Name", "256");
result = false;
}
if (!NameValidator.IsCLSCompliant(name))
{
errorContext.Register(m_errorCodeNotCLS, Severity.Error, objectType, name, "Name");
result = false;
}
if (!IsUnique(name))
{
errorContext.Register(m_errorCodeNotUnique, Severity.Error, objectType, name, "Name");
result = false;
}
if (IsCaseInsensitiveDuplicate(name))
{
errorContext.Register(m_errorCodeCaseInsensitiveDuplicate, Severity.Warning, objectType, name, "Name");
}
return(result);
}
public static bool ValidateSize(string size, bool allowNegative, double minValue, double maxValue, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext, out double validSizeInMM, out string newSize)
{
validSizeInMM = minValue;
newSize = minValue + "mm";
RVUnit rVUnit = default(RVUnit);
if (!Validator.ValidateSizeString(size, out rVUnit))
{
errorContext.Register(ProcessingErrorCode.rsInvalidSize, Severity.Error, objectType, objectName, propertyName, size);
return(false);
}
if (!Validator.ValidateSizeUnitType(rVUnit))
{
errorContext.Register(ProcessingErrorCode.rsInvalidMeasurementUnit, Severity.Error, objectType, objectName, propertyName, rVUnit.Type.ToString());
return(false);
}
if (!allowNegative && !Validator.ValidateSizeIsPositive(rVUnit))
{
errorContext.Register(ProcessingErrorCode.rsNegativeSize, Severity.Error, objectType, objectName, propertyName);
return(false);
}
double num = Converter.ConvertToMM(rVUnit);
if (!Validator.ValidateSizeValue(num, minValue, maxValue))
{
errorContext.Register(ProcessingErrorCode.rsOutOfRangeSize, Severity.Error, objectType, objectName, propertyName, size, Converter.ConvertSizeFromMM(allowNegative ? minValue : Math.Max(0.0, minValue), rVUnit.Type), Converter.ConvertSizeFromMM(maxValue, rVUnit.Type));
return(false);
}
validSizeInMM = num;
newSize = rVUnit.ToString(CultureInfo.InvariantCulture);
return(true);
}
private void BindToParentDataSet(ScopeTree scopeTree, IRIFReportDataScope scope, ErrorContext errorContext, ParentDataSetContainer parentDataSets)
{
if (parentDataSets == null)
{
if (scopeTree.GetParentDataRegion(scope) == null)
{
if (scopeTree.Report.MappingDataSetIndexToDataSet.Count == 0)
{
errorContext.Register(ProcessingErrorCode.rsDataRegionWithoutDataSet, Severity.Error, scope.DataScopeObjectType, scope.Name, null);
}
else
{
errorContext.Register(ProcessingErrorCode.rsMissingDataSetName, Severity.Error, scope.DataScopeObjectType, scope.Name, "DataSetName");
}
}
}
else if (parentDataSets.Count > 1 && !parentDataSets.AreAllSameDataSet())
{
DataRegion parentDataRegion = scopeTree.GetParentDataRegion(scope);
IRIFDataScope parentRowScopeForIntersection = scopeTree.GetParentRowScopeForIntersection(scope);
IRIFDataScope parentColumnScopeForIntersection = scopeTree.GetParentColumnScopeForIntersection(scope);
errorContext.Register(ProcessingErrorCode.rsMissingIntersectionDataSetName, Severity.Error, scope.DataScopeObjectType, parentDataRegion.Name, "DataSetName", parentDataRegion.ObjectType.ToString(), parentRowScopeForIntersection.Name, parentColumnScopeForIntersection.Name);
}
else
{
UpdateDataSet(parentDataSets.ParentDataSet, scope);
}
}
internal override bool ValidateRelationships(ScopeTree scopeTree, ErrorContext errorContext, DataSet ourDataSet, ParentDataSetContainer parentDataSets, IRIFReportDataScope currentScope)
{
Global.Tracer.Assert(parentDataSets != null, "IntersectJoinInfo can only be used with one or two parent data sets");
if (parentDataSets.Count == 1)
{
DataRegion parentDataRegion = scopeTree.GetParentDataRegion(currentScope);
errorContext.Register(ProcessingErrorCode.rsUnexpectedCellDataSetName, Severity.Error, currentScope.DataScopeObjectType, parentDataRegion.Name, "DataSetName", parentDataRegion.ObjectType.ToString());
return(false);
}
if (parentDataSets.AreAllSameDataSet() && DataSet.AreEqualById(parentDataSets.RowParentDataSet, ourDataSet))
{
return(false);
}
m_rowParentDataSet = parentDataSets.RowParentDataSet;
m_columnParentDataSet = parentDataSets.ColumnParentDataSet;
if (m_rowParentDataSet == null || m_columnParentDataSet == null)
{
return(false);
}
bool dataSetAlreadyHasRelationship = false;
bool dataSetAlreadyHasRelationship2 = false;
if (m_relationships != null)
{
foreach (IdcRelationship relationship in m_relationships)
{
if (relationship.ValidateIntersectRelationship(errorContext, currentScope, scopeTree))
{
CheckRelationshipDataSetBinding(scopeTree, errorContext, currentScope, relationship, m_rowParentDataSet, ref dataSetAlreadyHasRelationship);
CheckRelationshipDataSetBinding(scopeTree, errorContext, currentScope, relationship, m_columnParentDataSet, ref dataSetAlreadyHasRelationship2);
continue;
}
return(false);
}
}
dataSetAlreadyHasRelationship = HasRelationshipOrDefaultForDataSet(scopeTree, errorContext, currentScope, ourDataSet, m_rowParentDataSet, dataSetAlreadyHasRelationship);
dataSetAlreadyHasRelationship2 = HasRelationshipOrDefaultForDataSet(scopeTree, errorContext, currentScope, ourDataSet, m_columnParentDataSet, dataSetAlreadyHasRelationship2);
if (!dataSetAlreadyHasRelationship || !dataSetAlreadyHasRelationship2)
{
return(false);
}
DataRegion parentDataRegion2 = scopeTree.GetParentDataRegion(currentScope);
if (ValidateCellBoundTotheSameDataSetAsParentScpoe(m_columnParentDataSet, m_rowParentDataSet, ourDataSet, parentDataRegion2.IsColumnGroupingSwitched))
{
IRIFDataScope parentDataRegion3 = scopeTree.GetParentDataRegion(currentScope);
IRIFDataScope parentRowScopeForIntersection = scopeTree.GetParentRowScopeForIntersection(currentScope);
IRIFDataScope parentColumnScopeForIntersection = scopeTree.GetParentColumnScopeForIntersection(currentScope);
if (parentDataRegion2.IsColumnGroupingSwitched)
{
errorContext.Register(ProcessingErrorCode.rsInvalidIntersectionNaturalJoin, Severity.Error, currentScope.DataScopeObjectType, parentDataRegion3.Name, "ParentScope", parentDataRegion3.DataScopeObjectType.ToString(), parentColumnScopeForIntersection.Name, parentRowScopeForIntersection.Name);
return(false);
}
errorContext.Register(ProcessingErrorCode.rsInvalidIntersectionNaturalJoin, Severity.Error, currentScope.DataScopeObjectType, parentDataRegion3.Name, "ParentScope", parentDataRegion3.DataScopeObjectType.ToString(), parentRowScopeForIntersection.Name, parentColumnScopeForIntersection.Name);
return(false);
}
return(true);
}
public override bool Validate(Severity severity, string propertyName, ObjectType objectType, string objectName, string propertyNameValue, ErrorContext errorContext)
{
bool result = true;
if (propertyNameValue == null || !base.IsUnique(propertyNameValue))
{
errorContext.Register(ProcessingErrorCode.rsInvalidObjectNameNotUnique, severity, objectType, objectName, propertyName, propertyNameValue);
result = false;
}
if (propertyNameValue != null && !NameValidator.IsCLSCompliant(propertyNameValue))
{
errorContext.Register(ProcessingErrorCode.rsInvalidObjectNameNotCLSCompliant, severity, objectType, objectName, propertyName, propertyNameValue);
result = false;
}
return(result);
}
internal static void ValidateTextRunMarkupType(string value, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
if (!Validator.ValidateTextRunMarkupType(value))
{
errorContext.Register(ProcessingErrorCode.rsInvalidMarkupType, Severity.Error, objectType, objectName, propertyName, value);
}
}
internal static void ValidateBorderColorNotTransparent(ObjectType objectType, string objectName, Microsoft.ReportingServices.ReportIntermediateFormat.Style styleClass, string styleName, ErrorContext errorContext)
{
if (styleClass.GetAttributeInfo(styleName, out Microsoft.ReportingServices.ReportIntermediateFormat.AttributeInfo styleAttribute) && !styleAttribute.IsExpression && ReportColor.TryParse(styleAttribute.Value, allowTransparency: true, out ReportColor reportColor) && reportColor.ToColor().A != byte.MaxValue)
{
errorContext.Register(ProcessingErrorCode.rsInvalidColor, Severity.Error, objectType, objectName, styleName, styleAttribute.Value);
}
}
internal bool Validate(string parameterName, ObjectType objectType, string objectName, ErrorContext errorContext)
{
bool result = true;
if (string.IsNullOrEmpty(parameterName) || parameterName.Length > 256)
{
errorContext.Register(ProcessingErrorCode.rsInvalidParameterNameLength, Severity.Error, objectType, objectName, "Name", parameterName, "256");
result = false;
}
if (!NameValidator.IsCLSCompliant(parameterName))
{
errorContext.Register(ProcessingErrorCode.rsInvalidParameterNameNotCLSCompliant, Severity.Error, objectType, objectName, "Name", parameterName);
result = false;
}
return(result);
}
private void BindToNamedDataSet(ScopeTree scopeTree, IRIFReportDataScope scope, ErrorContext errorContext, ParentDataSetContainer parentDataSets)
{
DataSet dataSet = scopeTree.GetDataSet(this.m_dataSetName);
if (dataSet == null)
{
DataRegion parentDataRegion = scopeTree.GetParentDataRegion(scope);
if (parentDataSets != null && parentDataSets.Count == 1 && scope is DataRegion && parentDataRegion != null)
{
this.UpdateDataSet(parentDataSets.ParentDataSet, scope);
this.m_dataSetName = parentDataSets.ParentDataSet.Name;
}
else
{
errorContext.Register(ProcessingErrorCode.rsInvalidDataSetName, Severity.Error, scope.DataScopeObjectType, scope.Name, "DataSetName", this.m_dataSetName.MarkAsPrivate());
if (parentDataSets != null)
{
this.UpdateDataSet(parentDataSets.ParentDataSet, scope);
}
}
}
else
{
this.UpdateDataSet(dataSet, scope);
}
}
internal override bool ValidateRelationships(ScopeTree scopeTree, ErrorContext errorContext, DataSet ourDataSet, ParentDataSetContainer parentDataSets, IRIFReportDataScope currentScope)
{
Global.Tracer.Assert(parentDataSets != null && parentDataSets.Count == 1, "LinearJoinInfo can only be used with exactly one parent data set");
m_parentDataSet = parentDataSets.ParentDataSet;
if (DataSet.AreEqualById(ourDataSet, m_parentDataSet))
{
return(false);
}
bool flag = false;
if (m_relationships != null)
{
foreach (IdcRelationship relationship in m_relationships)
{
flag |= relationship.ValidateLinearRelationship(errorContext, m_parentDataSet);
}
}
if (flag || ourDataSet.HasDefaultRelationship(m_parentDataSet))
{
Relationship activeRelationship = GetActiveRelationship(ourDataSet);
if (activeRelationship == null)
{
RegisterInvalidInnerDataSetNameError(errorContext, ourDataSet, currentScope);
return(false);
}
if (activeRelationship.IsCrossJoin && (!activeRelationship.NaturalJoin || ScopeHasParentGroups(currentScope, scopeTree)))
{
errorContext.Register(ProcessingErrorCode.rsInvalidNaturalCrossJoin, Severity.Error, currentScope.DataScopeObjectType, currentScope.Name, "JoinConditions");
return(false);
}
return(true);
}
RegisterInvalidInnerDataSetNameError(errorContext, ourDataSet, currentScope);
return(false);
}
protected void CheckContainerRelationshipForNaturalJoin(IRIFDataScope startScope, ErrorContext errorContext, IRIFDataScope scope, Relationship outerRelationship)
{
if (outerRelationship != null && !outerRelationship.NaturalJoin)
{
errorContext.Register(ProcessingErrorCode.rsInvalidRelationshipContainerNotNaturalJoin, Severity.Error, startScope.DataScopeObjectType, startScope.Name, "Relationship", scope.DataScopeObjectType.ToString(), scope.Name);
}
}
public bool Validate(string name, string dataField, string dataSetName, ErrorContext errorContext)
{
bool result = true;
if (!NameValidator.IsCLSCompliant(name))
{
errorContext.Register(this.m_errorCodeNotCLS, Severity.Error, ObjectType.Field, dataField, "Name", name, dataSetName);
result = false;
}
if (!base.IsUnique(name))
{
errorContext.Register(this.m_errorCodeNotUnique, Severity.Error, ObjectType.Field, dataField, "Name", name, dataSetName);
result = false;
}
return(result);
}
internal void MergeCollationSettings(ErrorContext errorContext, string dataSourceType, string cultureName, bool caseSensitive, bool accentSensitive, bool kanatypeSensitive, bool widthSensitive)
{
if (!NeedAutoDetectCollation())
{
return;
}
uint lcid = DataSetValidator.LOCALE_SYSTEM_DEFAULT;
if (cultureName != null)
{
try
{
lcid = (uint)CultureInfo.GetCultureInfo(cultureName).LCID;
}
catch (Exception)
{
errorContext?.Register(ProcessingErrorCode.rsInvalidCollationCultureName, Severity.Warning, Microsoft.ReportingServices.ReportProcessing.ObjectType.DataSet, m_name, dataSourceType, cultureName);
}
}
if (DataSetValidator.LOCALE_SYSTEM_DEFAULT == m_lcid)
{
m_lcid = lcid;
}
m_accentSensitivity = MergeSensitivity(m_accentSensitivity, accentSensitive);
m_caseSensitivity = MergeSensitivity(m_caseSensitivity, caseSensitive);
m_kanatypeSensitivity = MergeSensitivity(m_kanatypeSensitivity, kanatypeSensitive);
m_widthSensitivity = MergeSensitivity(m_widthSensitivity, widthSensitive);
}
public void MergeCollationSettings(ErrorContext errorContext, string dataSourceType, string cultureName, bool caseSensitive, bool accentSensitive, bool kanatypeSensitive, bool widthSensitive)
{
if (this.NeedAutoDetectCollation())
{
uint lcid = DataSetValidator.LOCALE_SYSTEM_DEFAULT;
if (cultureName != null)
{
try
{
CultureInfo cultureInfo = CultureInfo.GetCultureInfo(cultureName);
lcid = (uint)cultureInfo.LCID;
}
catch (Exception)
{
if (errorContext != null)
{
errorContext.Register(ProcessingErrorCode.rsInvalidCollationCultureName, Severity.Warning, AspNetCore.ReportingServices.ReportProcessing.ObjectType.DataSet, this.m_name, dataSourceType, cultureName);
}
}
}
if (DataSetValidator.LOCALE_SYSTEM_DEFAULT == this.m_lcid)
{
this.m_lcid = lcid;
}
this.m_accentSensitivity = this.MergeSensitivity(this.m_accentSensitivity, accentSensitive);
this.m_caseSensitivity = this.MergeSensitivity(this.m_caseSensitivity, caseSensitive);
this.m_kanatypeSensitivity = this.MergeSensitivity(this.m_kanatypeSensitivity, kanatypeSensitive);
this.m_widthSensitivity = this.MergeSensitivity(this.m_widthSensitivity, widthSensitive);
}
}
public static void ValidateParagraphListStyle(string value, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
if (!Validator.ValidateParagraphListStyle(value))
{
errorContext.Register(ProcessingErrorCode.rsInvalidListStyle, Severity.Error, objectType, objectName, propertyName, value);
}
}
private bool HasRelationshipOrDefaultForDataSet(ScopeTree scopeTree, ErrorContext errorContext, IRIFReportDataScope currentScope, DataSet ourDataSet, DataSet parentDataSet, bool hasValidRelationship)
{
if (DataSet.AreEqualById(parentDataSet, ourDataSet))
{
return(true);
}
if (hasValidRelationship || ourDataSet.HasDefaultRelationship(parentDataSet))
{
Relationship activeRelationship = GetActiveRelationship(ourDataSet, parentDataSet);
if (activeRelationship == null)
{
RegisterInvalidCellDataSetNameError(scopeTree, errorContext, currentScope, ourDataSet, parentDataSet);
return(false);
}
if (activeRelationship.IsCrossJoin)
{
DataRegion parentDataRegion = scopeTree.GetParentDataRegion(currentScope);
errorContext.Register(ProcessingErrorCode.rsInvalidIntersectionNaturalCrossJoin, Severity.Error, currentScope.DataScopeObjectType, parentDataRegion.Name, "JoinConditions", parentDataRegion.ObjectType.ToString());
return(false);
}
return(true);
}
RegisterInvalidCellDataSetNameError(scopeTree, errorContext, currentScope, ourDataSet, parentDataSet);
return(false);
}
public static void ValidateCalendar(CultureInfo language, string calendar, ObjectType objectType, string ObjectName, string propertyName, ErrorContext errorContext)
{
if (!Validator.ValidateCalendar(language, calendar))
{
errorContext.Register(ProcessingErrorCode.rsInvalidCalendarForLanguage, Severity.Error, objectType, ObjectName, propertyName, calendar, language.Name);
}
}
public static void ValidateNumeralVariant(CultureInfo language, int numVariant, ObjectType objectType, string ObjectName, string propertyName, ErrorContext errorContext)
{
if (!Validator.ValidateNumeralVariant(language, numVariant))
{
errorContext.Register(ProcessingErrorCode.rsInvalidNumeralVariantForLanguage, Severity.Error, objectType, ObjectName, propertyName, numVariant.ToString(CultureInfo.InvariantCulture), language.Name);
}
}
private static void ValidateBackgroundImage(AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo backgroundImageSource, AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo backgroundImageValue, AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo backgroundImageMIMEType, AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo backgroundEmbeddingMode, AspNetCore.ReportingServices.ReportIntermediateFormat.Style style, ObjectType objectType, string objectName, ErrorContext errorContext)
{
if (backgroundImageSource != null)
{
bool flag = true;
Global.Tracer.Assert(AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == backgroundImageSource.Type);
AspNetCore.ReportingServices.OnDemandReportRendering.Image.SourceType intValue = (AspNetCore.ReportingServices.OnDemandReportRendering.Image.SourceType)backgroundImageSource.IntValue;
Global.Tracer.Assert(null != backgroundImageValue);
if (AspNetCore.ReportingServices.OnDemandReportRendering.Image.SourceType.Database == intValue && AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == backgroundImageValue.Type)
{
errorContext.Register(ProcessingErrorCode.rsBinaryConstant, Severity.Error, objectType, objectName, "BackgroundImageValue");
flag = false;
}
if (AspNetCore.ReportingServices.OnDemandReportRendering.Image.SourceType.Database == intValue && !PublishingValidator.ValidateMimeType(backgroundImageMIMEType, objectType, objectName, "BackgroundImageMIMEType", errorContext))
{
flag = false;
}
if (flag)
{
style.AddAttribute("BackgroundImageSource", backgroundImageSource);
style.AddAttribute("BackgroundImageValue", backgroundImageValue);
if (backgroundEmbeddingMode != null)
{
style.AddAttribute("EmbeddingMode", backgroundEmbeddingMode);
}
if (AspNetCore.ReportingServices.OnDemandReportRendering.Image.SourceType.Database == intValue)
{
style.AddAttribute("BackgroundImageMIMEType", backgroundImageMIMEType);
}
}
}
}
internal bool Validate(string name, ObjectType objectType, string objectName, ErrorContext errorContext)
{
bool result = true;
if (!NameValidator.IsCLSCompliant(name))
{
errorContext.Register(m_errorCodeNotCLS, Severity.Error, objectType, objectName, "Name", name);
result = false;
}
if (!IsUnique(name))
{
errorContext.Register(m_errorCodeNotUnique, Severity.Error, objectType, objectName, "Name", name);
result = false;
}
return(result);
}
internal byte[] Compile(IExpressionHostAssemblyHolder expressionHostAssemblyHolder, AppDomain compilationTempAppDomain, bool refusePermissions, PublishingVersioning versioning)
{
byte[] result = null;
if (m_builder.HasExpressions && versioning.IsRdlFeatureRestricted(RdlFeatures.ComplexExpression))
{
m_errorContext.Register(ProcessingErrorCode.rsInvalidComplexExpressionInReport, Severity.Error, Microsoft.ReportingServices.ReportProcessing.ObjectType.Report, "Report", "Body");
}
else
{
m_expressionHostAssemblyHolder = expressionHostAssemblyHolder;
RevertImpersonationContext.Run(delegate
{
result = InternalCompile(compilationTempAppDomain, refusePermissions);
});
}
return(result);
}
internal static string ValidateMimeType(string mimeType, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
if (Validator.ValidateMimeType(mimeType))
{
return(mimeType);
}
errorContext.Register(ProcessingErrorCode.rsInvalidMIMEType, Severity.Warning, objectType, objectName, propertyName, mimeType);
return(null);
}
private static bool ValidateEmbeddedImageName(string embeddedImageName, Dictionary <string, AspNetCore.ReportingServices.ReportIntermediateFormat.ImageInfo> embeddedImages, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
if (!Validator.ValidateEmbeddedImageName(embeddedImageName, embeddedImages))
{
errorContext.Register(ProcessingErrorCode.rsInvalidEmbeddedImageProperty, Severity.Error, objectType, objectName, propertyName, embeddedImageName);
return(false);
}
return(true);
}
public static bool ValidateMimeType(string mimeType, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
if (!Validator.ValidateMimeType(mimeType))
{
errorContext.Register(ProcessingErrorCode.rsInvalidMIMEType, Severity.Error, objectType, objectName, propertyName, mimeType);
return(false);
}
return(true);
}
public static bool ValidateColumns(int columns, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext, int sectionNumber)
{
if (!Validator.ValidateColumns(columns))
{
errorContext.Register(ProcessingErrorCode.rsInvalidColumnsInReportSection, Severity.Error, objectType, objectName, propertyName, sectionNumber.ToString(CultureInfo.InvariantCulture));
return(false);
}
return(true);
}
private static bool ValidateNumeralVariant(AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo numeralVariant, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
Global.Tracer.Assert(null != numeralVariant);
if (AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == numeralVariant.Type && !Validator.ValidateNumeralVariant(numeralVariant.IntValue))
{
errorContext.Register(ProcessingErrorCode.rsInvalidNumeralVariant, Severity.Error, objectType, objectName, propertyName, numeralVariant.IntValue.ToString(CultureInfo.InvariantCulture));
return(false);
}
return(true);
}
private static bool ValidateUnicodeBiDi(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo unicodeBiDi, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
Global.Tracer.Assert(unicodeBiDi != null);
if (Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == unicodeBiDi.Type && !Validator.ValidateUnicodeBiDi(unicodeBiDi.StringValue))
{
errorContext.Register(ProcessingErrorCode.rsInvalidUnicodeBiDi, Severity.Error, objectType, objectName, propertyName, unicodeBiDi.StringValue);
return(false);
}
return(true);
}
public static void ValidateBorderColorNotTransparent(ObjectType objectType, string objectName, AspNetCore.ReportingServices.ReportIntermediateFormat.Style styleClass, string styleName, ErrorContext errorContext)
{
ReportColor reportColor = default(ReportColor);
AspNetCore.ReportingServices.ReportIntermediateFormat.AttributeInfo attributeInfo = default(AspNetCore.ReportingServices.ReportIntermediateFormat.AttributeInfo);
if (styleClass.GetAttributeInfo(styleName, out attributeInfo) && !attributeInfo.IsExpression && ReportColor.TryParse(attributeInfo.Value, true, out reportColor) && reportColor.ToColor().A != 255)
{
errorContext.Register(ProcessingErrorCode.rsInvalidColor, Severity.Error, objectType, objectName, styleName, attributeInfo.Value);
}
}
private static bool ValidateCalendar(AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo calendar, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
Global.Tracer.Assert(null != calendar);
if (AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == calendar.Type && !Validator.ValidateCalendar(calendar.StringValue))
{
errorContext.Register(ProcessingErrorCode.rsInvalidCalendar, Severity.Error, objectType, objectName, propertyName, calendar.StringValue);
return(false);
}
return(true);
}
private static bool ValidateBackgroundRepeat(AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo repeat, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
Global.Tracer.Assert(null != repeat);
if (AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == repeat.Type && !Validator.ValidateBackgroundRepeat(repeat.StringValue, objectType))
{
errorContext.Register(ProcessingErrorCode.rsInvalidBackgroundRepeat, Severity.Error, objectType, objectName, propertyName, repeat.StringValue);
return(false);
}
return(true);
}
