Example #1
0
        private void GetMarkupComment(BCFv21.Schemas.Markup markup, BCFv2.BCFTopic sourceTopic)
        {
            if (!sourceTopic.Markup.ShouldSerializeComment())
            {
                return;
            }

            markup.Comment = sourceTopic.Markup.Comment
                             .Select(source => new BCFv21.Schemas.Comment
            {
                Author         = source.Author,
                Comment1       = source.Comment1,
                Date           = source.Date,
                Guid           = source.Guid,
                ModifiedAuthor = source.ModifiedAuthor,
                ModifiedDate   = source.ModifiedDate,
                Viewpoint      = source.Viewpoint == null
                                ? null
                                : new BCFv21.Schemas.CommentViewpoint
                {
                    Guid = source.Viewpoint.Guid
                }
            })
                             .ToList();
        }
Example #2
0
        private BCFv21.Schemas.Markup GetMarkup(BCFv2.BCFTopic sourceTopic)
        {
            if (sourceTopic.Markup == null)
            {
                return(null);
            }

            var markup = new BCFv21.Schemas.Markup();

            GetMarkupHeader(markup, sourceTopic);
            GetMarkupComment(markup, sourceTopic);
            GetMarkupTopic(markup, sourceTopic);
            GetMarkupViewpoints(markup, sourceTopic);

            return(markup);
        }
Example #3
0
        private void GetMarkupViewpoints(BCFv21.Schemas.Markup markup, BCFv2.BCFTopic sourceTopic)
        {
            if (!sourceTopic.Markup.ShouldSerializeViewpoints())
            {
                return;
            }

            markup.Viewpoints = sourceTopic.Markup.Viewpoints
                                .Select((source, index) => new BCFv21.Schemas.ViewPoint
            {
                Guid      = source.Guid,
                Index     = index,
                Snapshot  = source.Snapshot,
                Viewpoint = source.Viewpoint
            })
                                .ToList();
        }
Example #4
0
        private void GetMarkupHeader(BCFv21.Schemas.Markup markup, BCFv2.BCFTopic sourceTopic)
        {
            if (!sourceTopic.Markup.ShouldSerializeHeader())
            {
                return;
            }

            markup.Header = sourceTopic.Markup.Header
                            .Select(source => new BCFv21.Schemas.HeaderFile
            {
                Date       = source.Date,
                Filename   = source.Filename,
                IfcProject = source.IfcProject,
                IfcSpatialStructureElement = source.IfcSpatialStructureElement,
                isExternal = source.isExternal,
                Reference  = source.Reference
            })
                            .ToList();
        }
Example #5
0
        private void GetMarkupTopic(BCFv21.Schemas.Markup markup, BCFv2.BCFTopic sourceTopic)
        {
            if (!sourceTopic.Markup.ShouldSerializeTopic())
            {
                return;
            }

            var srcTopic = sourceTopic.Markup.Topic;

            markup.Topic = new BCFv21.Schemas.Topic();

            {
                if (srcTopic.ShouldSerializeAssignedTo())
                {
                    markup.Topic.AssignedTo = srcTopic.AssignedTo;
                }
                if (srcTopic.ShouldSerializeBimSnippet())
                {
                    markup.Topic.BimSnippet = srcTopic.BimSnippet == null
                        ? null
                        : new BCFv21.Schemas.BimSnippet
                    {
                        isExternal      = srcTopic.BimSnippet.isExternal,
                        Reference       = srcTopic.BimSnippet.Reference,
                        ReferenceSchema = srcTopic.BimSnippet.ReferenceSchema,
                        SnippetType     = srcTopic.BimSnippet.SnippetType
                    };
                }
                if (srcTopic.ShouldSerializeCreationAuthor())
                {
                    markup.Topic.CreationAuthor = srcTopic.CreationAuthor;
                }
                if (srcTopic.ShouldSerializeCreationDate())
                {
                    markup.Topic.CreationDate = srcTopic.CreationDate;
                }
                if (srcTopic.ShouldSerializeDescription())
                {
                    markup.Topic.Description = srcTopic.Description;
                }
                if (srcTopic.ShouldSerializeDocumentReferences())
                {
                    markup.Topic.DocumentReference = srcTopic.DocumentReferences?
                                                     .Select(src => new BCFv21.Schemas.TopicDocumentReference
                    {
                        Description        = src.Description,
                        Guid               = src.Guid,
                        isExternal         = src.isExternal,
                        ReferencedDocument = src.ReferencedDocument
                    })
                                                     .ToList();
                }
                if (srcTopic.ShouldSerializeGuid())
                {
                    markup.Topic.Guid = srcTopic.Guid;
                }
                if (srcTopic.ShouldSerializeLabels())
                {
                    markup.Topic.Labels = srcTopic.Labels?.ToList();
                }
                if (srcTopic.ShouldSerializeModifiedAuthor())
                {
                    markup.Topic.ModifiedAuthor = srcTopic.ModifiedAuthor;
                }
                if (srcTopic.ShouldSerializeModifiedDate())
                {
                    markup.Topic.ModifiedDate = srcTopic.ModifiedDate;
                }
                if (srcTopic.ShouldSerializePriority())
                {
                    markup.Topic.Priority = srcTopic.Priority;
                }
                if (srcTopic.ShouldSerializeReferenceLink())
                {
                    markup.Topic.ReferenceLink = srcTopic.ReferenceLink == null ? null : new List <string> {
                        srcTopic.ReferenceLink
                    };
                }
                if (srcTopic.ShouldSerializeTitle())
                {
                    markup.Topic.Title = srcTopic.Title;
                }
                if (srcTopic.ShouldSerializeRelatedTopics())
                {
                    markup.Topic.RelatedTopic = srcTopic.RelatedTopics?
                                                .Select(src => new BCFv21.Schemas.TopicRelatedTopic
                    {
                        Guid = src.Guid
                    })
                                                .ToList();
                }
                if (srcTopic.ShouldSerializeTopicStatus())
                {
                    markup.Topic.TopicStatus = srcTopic.TopicStatus;
                }
                if (srcTopic.ShouldSerializeTopicType())
                {
                    markup.Topic.TopicType = srcTopic.TopicType;
                }
            };
        }