Esempio n. 1
0
        /// <summary>
        /// Builds the resource expression.
        /// </summary>
        /// <param name="resourceExpression">The resource expression.</param>
        /// <returns>ResourceExpression.</returns>
        /// <param name="context"></param>
        private static ResourceExpression BuildResourceExpression(Model.ResourceExpression resourceExpression, FromEntityContext context)
        {
            //resourceExpression entity node's followRelationship must not be null
            RelationshipReportNode relationshipReportNode =
                resourceExpression.SourceNode.As <RelationshipReportNode>();

            if (relationshipReportNode != null)
            {
                if (relationshipReportNode.FollowRelationship == null)
                {
                    EventLog.Application.WriteWarning(context.DebugInfo + "relationshipReportNode.FollowRelationship was null");
                    return(null);
                }
            }

            //resourceExpression sourceNode is null means that the source entity is removed
            if (resourceExpression.SourceNode == null)
            {
                EventLog.Application.WriteWarning(context.DebugInfo + "resourceExpression.SourceNode was null");
                return(null);
            }

            long          targetTypeId = 0;
            TypedArgument ta           = resourceExpression.ReportExpressionResultType.As <TypedArgument>();

            if (ta != null && ta.ConformsToType != null)
            {
                targetTypeId = ta.ConformsToType.Id;
            }

            DatabaseType castType = null;

            if (ta != null && ta.Name != null)
            {
                if (ta.Name == "ChoiceRelationship")
                {
                    castType = new ChoiceRelationshipType();
                }
                else
                {
                    castType = new InlineRelationshipType();
                }
            }


            return(new ResourceExpression {
                FieldId = new EntityRef("core:name"), SourceNodeEntityId = resourceExpression.SourceNode.Id, TargetTypeId = targetTypeId, CastType = castType
            });
        }
Esempio n. 2
0
        /// <summary>
        /// To check column is valid,
        /// if field or relationship is removed from object.
        /// </summary>
        /// <param name="expression">report column expression</param>
        /// <remarks>
        /// the report column expression must be exists, when field is removed from node object,
        /// the column expression will be deleted, on this case, it is not valid column
        /// the the column expression is resourceexpression, check the relationship exists or not
        /// if the relationship is removed, the followRelationship property will be null, current
        /// column is invalid column
        /// </remarks>
        /// <returns></returns>
        internal static bool IsValidExpression(ReportExpression expression)
        {
            if (expression == null)
            {
                return(false);
            }


            bool isValid = true;

            //resourceExpression reportnode's followRelationship must not be null
            Model.ResourceExpression resourceExpression = expression.As <Model.ResourceExpression>();
            if (resourceExpression != null)
            {
                RelationshipReportNode relationshipReportNode =
                    resourceExpression.SourceNode.As <RelationshipReportNode>();
                if (relationshipReportNode != null)
                {
                    if (relationshipReportNode.FollowRelationship == null)
                    {
                        isValid = false;
                    }
                }
            }

            //if aggregated grouped expression is resourceExpression reportnode's followRelationship must not be null
            Model.AggregateExpression aggregateExpression = expression.As <Model.AggregateExpression>();
            if (aggregateExpression != null)
            {
                if (!IsValidExpression(aggregateExpression.AggregatedExpression))
                {
                    isValid = false;
                }
            }

            return(isValid);
        }