corev1

type Article ¶

type Article struct {
	Id          int64              `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Type        Article_Type       `protobuf:"varint,2,opt,name=type,proto3,enum=stroeer.core.v1.Article_Type" json:"type,omitempty"`
	SubType     Article_SubType    `protobuf:"varint,3,opt,name=sub_type,json=subType,proto3,enum=stroeer.core.v1.Article_SubType" json:"sub_type,omitempty"`
	SectionTree *Reference         `protobuf:"bytes,4,opt,name=section_tree,json=sectionTree,proto3" json:"section_tree,omitempty"`
	Fields      map[string]string  `` /* 153-byte string literal not displayed */
	Bodies      []*Article_Body    `protobuf:"bytes,6,rep,name=bodies,proto3" json:"bodies,omitempty"`
	Metadata    *Article_Metadata  `protobuf:"bytes,7,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Elements    []*Article_Element `protobuf:"bytes,8,rep,name=elements,proto3" json:"elements,omitempty"`
	Keywords    []*Article_Keyword `protobuf:"bytes,9,rep,name=keywords,proto3" json:"keywords,omitempty"`
	Onwards     []int64            `protobuf:"varint,10,rep,packed,name=onwards,proto3" json:"onwards,omitempty"`
	// Deprecated: Marked as deprecated in stroeer/core/v1/article.proto.
	Entities []string `protobuf:"bytes,100,rep,name=entities,proto3" json:"entities,omitempty"`
	// contains filtered or unexported fields
}

func (*Article) Descriptor() ([]byte, []int)

func (x *Article) GetBodies() []*Article_Body

func (x *Article) GetElements() []*Article_Element

func (x *Article) GetEntities() []string

func (x *Article) GetFields() map[string]string

func (x *Article) GetId() int64

func (x *Article) GetKeywords() []*Article_Keyword

func (x *Article) GetMetadata() *Article_Metadata

func (x *Article) GetOnwards() []int64

func (x *Article) GetSectionTree() *Reference

func (x *Article) GetSubType() Article_SubType

func (x *Article) GetType() Article_Type

func (*Article) ProtoMessage()

func (x *Article) ProtoReflect() protoreflect.Message

func (x *Article) Reset()

func (x *Article) String() string

type Article_Body ¶

type Article_Body struct {
	Children []*Article_Body_BodyNode `protobuf:"bytes,1,rep,name=children,proto3" json:"children,omitempty"`
	Type     Article_Body_Type        `protobuf:"varint,2,opt,name=type,proto3,enum=stroeer.core.v1.Article_Body_Type" json:"type,omitempty"` //* @CodeBlockEnd
	// contains filtered or unexported fields
}

*

The `Body` represents a basic block. Each `Body` is self-contained and holds all the data required for rendering within its data structures.

Common use cases for this are `Type.BODY` where the textual article body can be found and the `TYPE.ARTICLE_SOURCE` where onward articles are referenced.

| Field name | Type | Description | |----------------|------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------| | `children` | `repeated` [`BodyNode`][bn] | Recursive/Nested structure that usually represents the textual body / Markup / HTML | | `type` | [`Type`][t] | Unique ID of the article defined by the content management system (required). |

[bn]: #bodynode [t]: #type

@CodeBlockStart protobuf

func (*Article_Body) Descriptor() ([]byte, []int)

func (x *Article_Body) GetChildren() []*Article_Body_BodyNode

func (x *Article_Body) GetType() Article_Body_Type

func (*Article_Body) ProtoMessage()

func (x *Article_Body) ProtoReflect() protoreflect.Message

func (x *Article_Body) Reset()

func (x *Article_Body) String() string

type Article_Body_BodyNode ¶

type Article_Body_BodyNode struct {
	Type     string                   `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Text     string                   `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
	Fields   map[string]string        `` /* 153-byte string literal not displayed */
	Children []*Article_Body_BodyNode `protobuf:"bytes,4,rep,name=children,proto3" json:"children,omitempty"`
	Elements []*Article_Element       `protobuf:"bytes,5,rep,name=elements,proto3" json:"elements,omitempty"`
	// contains filtered or unexported fields
}

* ## `BodyNode`

Recursive structure representing all types of possible nodes inside an article.

One use-case is to represent [HTML-like](#html-like) markup in tapir, but it is also used to map [custom](#custom) elements that require a strict positional placement within the textual body. Things that are not part of the textual article body are represented as individual [`Body`][b] parts so they can be rendered independently if required.

Clients must be resilient to unknown or missing nodes.

@CodeBlockStart protobuf

func (*Article_Body_BodyNode) Descriptor() ([]byte, []int)

func (x *Article_Body_BodyNode) GetChildren() []*Article_Body_BodyNode

func (x *Article_Body_BodyNode) GetElements() []*Article_Element

func (x *Article_Body_BodyNode) GetFields() map[string]string

func (x *Article_Body_BodyNode) GetText() string

func (x *Article_Body_BodyNode) GetType() string

func (*Article_Body_BodyNode) ProtoMessage()

func (x *Article_Body_BodyNode) ProtoReflect() protoreflect.Message

func (x *Article_Body_BodyNode) Reset()

func (x *Article_Body_BodyNode) String() string

type Article_Body_Type ¶

type Article_Body_Type int32

* ## Type

Each `Body` has a `Body.Type` to help the consumer to correctly interpret the [`BodyNode's`][bn] content.

| Enum value | Description | |---------------------|---------------------------------------------------------------------------------------------------------------------------| | `TYPE_UNSPECIFIED` | unspecified | | `BODY` | The textual article body including all inline elements such as `IMAGE`, `VIDEO` and `EMBED` | | `ARTICLE_SOURCES` | A wrapper for all article sources ("Quellenaparat"). There can only be one of these per article. | | `DISCLAIMER` | A article disclaimer with important notes/legal stuff. E.g. "medizinischer Hinweis" on all medical articles | | `TRUST_BOX` | Includes information what the current article type is (e.g. opinion article). There can only be one of these per article. | | `TABLE_OF_CONTENTS` | Table of contents for this article, consists of anchors which refer to sub headlines within the `BODY` |

@CodeBlockStart protobuf

const (
	Article_Body_TYPE_UNSPECIFIED  Article_Body_Type = 0
	Article_Body_BODY              Article_Body_Type = 1
	Article_Body_ARTICLE_SOURCES   Article_Body_Type = 2
	Article_Body_DISCLAIMER        Article_Body_Type = 3
	Article_Body_TRUST_BOX         Article_Body_Type = 4
	Article_Body_TABLE_OF_CONTENTS Article_Body_Type = 5
)

func (Article_Body_Type) Descriptor() protoreflect.EnumDescriptor

func (x Article_Body_Type) Enum() *Article_Body_Type

func (Article_Body_Type) EnumDescriptor() ([]byte, []int)

func (x Article_Body_Type) Number() protoreflect.EnumNumber

func (x Article_Body_Type) String() string

func (Article_Body_Type) Type() protoreflect.EnumType

type Article_Element ¶

type Article_Element struct {
	Type      Article_Element_Type       `protobuf:"varint,1,opt,name=type,proto3,enum=stroeer.core.v1.Article_Element_Type" json:"type,omitempty"`
	Relations []Article_Element_Relation `protobuf:"varint,2,rep,packed,name=relations,proto3,enum=stroeer.core.v1.Article_Element_Relation" json:"relations,omitempty"`
	Assets    []*Article_Element_Asset   `protobuf:"bytes,3,rep,name=assets,proto3" json:"assets,omitempty"`
	Children  []*Article_Element         `protobuf:"bytes,4,rep,name=children,proto3" json:"children,omitempty"`
	// contains filtered or unexported fields
}

func (*Article_Element) Descriptor() ([]byte, []int)

func (x *Article_Element) GetAssets() []*Article_Element_Asset

func (x *Article_Element) GetChildren() []*Article_Element

func (x *Article_Element) GetRelations() []Article_Element_Relation

func (x *Article_Element) GetType() Article_Element_Type

func (*Article_Element) ProtoMessage()

func (x *Article_Element) ProtoReflect() protoreflect.Message

func (x *Article_Element) Reset()

func (x *Article_Element) String() string

type Article_Element_Asset ¶

type Article_Element_Asset struct {
	Type     Article_Element_Asset_Type `protobuf:"varint,1,opt,name=type,proto3,enum=stroeer.core.v1.Article_Element_Asset_Type" json:"type,omitempty"`
	Fields   map[string]string          ``                                                                      /* 153-byte string literal not displayed */
	Metadata *Article_Metadata          `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"` //* @CodeBlockEnd
	// contains filtered or unexported fields
}

* Asset of an [Element](article_>_element.html).

An asset configuration is dependant upon its use, it may alter depending on its [`type`](#enum-type) field.

| Field name | Type | Description | |------------|-----------------------|------------------------------------------------------------------------------------------------------------------------------------------------| | `type` | [`Type`][at] | Type of the asset. | | `fields` | `map<string, string>` | Generic map containing general content and configuration information of the asset. Clients must be resilient to unknown or missing entry sets. | | `metadata` | [`Metadata`][meta] | Only present for `assets` of `TYPE.METADATA`. Technical metadata for the parent `element` (state, validity, ...). See [`Metadata`][meta] |

[at]: #enum-type [meta]: article_%3E_metadata.html

@CodeBlockStart protobuf

func (*Article_Element_Asset) Descriptor() ([]byte, []int)

func (x *Article_Element_Asset) GetFields() map[string]string

func (x *Article_Element_Asset) GetMetadata() *Article_Metadata

func (x *Article_Element_Asset) GetType() Article_Element_Asset_Type

func (*Article_Element_Asset) ProtoMessage()

func (x *Article_Element_Asset) ProtoReflect() protoreflect.Message

func (x *Article_Element_Asset) Reset()

func (x *Article_Element_Asset) String() string

type Article_Element_Asset_Type ¶

type Article_Element_Asset_Type int32

const (
	Article_Element_Asset_TYPE_UNSPECIFIED Article_Element_Asset_Type = 0
	Article_Element_Asset_IMAGE            Article_Element_Asset_Type = 1
	Article_Element_Asset_VIDEO            Article_Element_Asset_Type = 2
	Article_Element_Asset_EXTERNAL_VIDEO   Article_Element_Asset_Type = 3
	Article_Element_Asset_METADATA         Article_Element_Asset_Type = 4
	Article_Element_Asset_LINK             Article_Element_Asset_Type = 5
)

func (Article_Element_Asset_Type) Descriptor() protoreflect.EnumDescriptor

func (x Article_Element_Asset_Type) Enum() *Article_Element_Asset_Type

func (Article_Element_Asset_Type) EnumDescriptor() ([]byte, []int)

func (x Article_Element_Asset_Type) Number() protoreflect.EnumNumber

func (x Article_Element_Asset_Type) String() string

func (Article_Element_Asset_Type) Type() protoreflect.EnumType

type Article_Element_Relation ¶

type Article_Element_Relation int32

* ## `Element.Relation`

| Enum value | Description | |------------------------|---------------------------------------------------------------------------------------------------| | `RELATION_UNSPECIFIED` | unspecified | | `OPENER` | As an opener element (within the content) | | `TEASER` | As an teaser element (when externally viewed) | @CodeBlockStart protobuf

const (
	Article_Element_RELATION_UNSPECIFIED Article_Element_Relation = 0
	Article_Element_OPENER               Article_Element_Relation = 1
	Article_Element_TEASER               Article_Element_Relation = 2
)

func (Article_Element_Relation) Descriptor() protoreflect.EnumDescriptor

func (x Article_Element_Relation) Enum() *Article_Element_Relation

func (Article_Element_Relation) EnumDescriptor() ([]byte, []int)

func (x Article_Element_Relation) Number() protoreflect.EnumNumber

func (x Article_Element_Relation) String() string

func (Article_Element_Relation) Type() protoreflect.EnumType

type Article_Element_Type ¶

type Article_Element_Type int32

const (
	Article_Element_TYPE_UNSPECIFIED  Article_Element_Type = 0
	Article_Element_ARTICLE           Article_Element_Type = 1
	Article_Element_IMAGE             Article_Element_Type = 2
	Article_Element_VIDEO             Article_Element_Type = 3
	Article_Element_GALLERY           Article_Element_Type = 4
	Article_Element_OEMBED            Article_Element_Type = 5
	Article_Element_AUTHOR            Article_Element_Type = 6
	Article_Element_AGENCY            Article_Element_Type = 7
	Article_Element_EDGE_SIDE_INCLUDE Article_Element_Type = 8
	Article_Element_CITATION          Article_Element_Type = 9
)

func (Article_Element_Type) Descriptor() protoreflect.EnumDescriptor

func (x Article_Element_Type) Enum() *Article_Element_Type

func (Article_Element_Type) EnumDescriptor() ([]byte, []int)

func (x Article_Element_Type) Number() protoreflect.EnumNumber

func (x Article_Element_Type) String() string

func (Article_Element_Type) Type() protoreflect.EnumType

type Article_Keyword ¶

type Article_Keyword struct {
	Value string  `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	Type  string  `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	Score float32 `protobuf:"fixed32,3,opt,name=score,proto3" json:"score,omitempty"`
	// contains filtered or unexported fields
}

* Extracted keywords from the article body like persons, locations, organizations etc.

| Field name | Type | Description | |-------------------------|-------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `value` | `string` | Unique value of this keyword. | | `type` | `string` | Type/Category of this keyword like `location`, `organization`, `person` | | `score` | `float` | Score for the relevance of this keyword set by the engine |

@CodeBlockStart protobuf

func (*Article_Keyword) Descriptor() ([]byte, []int)

func (x *Article_Keyword) GetScore() float32

func (x *Article_Keyword) GetType() string

func (x *Article_Keyword) GetValue() string

func (*Article_Keyword) ProtoMessage()

func (x *Article_Keyword) ProtoReflect() protoreflect.Message

func (x *Article_Keyword) Reset()

func (x *Article_Keyword) String() string

type Article_Metadata ¶

type Article_Metadata struct {
	State                Article_Metadata_State       `protobuf:"varint,1,opt,name=state,proto3,enum=stroeer.core.v1.Article_Metadata_State" json:"state,omitempty"`
	StartTime            *timestamppb.Timestamp       `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	EndTime              *timestamppb.Timestamp       `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	PublishTime          *timestamppb.Timestamp       `protobuf:"bytes,4,opt,name=publish_time,json=publishTime,proto3" json:"publish_time,omitempty"`
	UpdateTime           *timestamppb.Timestamp       `protobuf:"bytes,5,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"`
	TransformationTime   *timestamppb.Timestamp       `protobuf:"bytes,6,opt,name=transformation_time,json=transformationTime,proto3" json:"transformation_time,omitempty"`
	TransformationErrors int64                        `protobuf:"varint,7,opt,name=transformation_errors,json=transformationErrors,proto3" json:"transformation_errors,omitempty"`
	LastModificationTime *timestamppb.Timestamp       `protobuf:"bytes,8,opt,name=last_modification_time,json=lastModificationTime,proto3" json:"last_modification_time,omitempty"`
	EventSource          Article_Metadata_EventSource `` /* 145-byte string literal not displayed */
	SeoScore             float64                      `protobuf:"fixed64,10,opt,name=seo_score,json=seoScore,proto3" json:"seo_score,omitempty"`
	PublicationId        int64                        `protobuf:"varint,11,opt,name=publication_id,json=publicationId,proto3" json:"publication_id,omitempty"`
	// contains filtered or unexported fields
}

* Article metadata like publication state and technical timestamps.

| Field name | Type | Description | |--------------------------|---------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `state` | [`State`][state] | State of the article in the content management system. See [`enum State`](#enum-state) | | `start_time` | [`Timestamp`][ts] | Manually set editorial timestamp (_Gültig von_) at which the article is valid to deliver on digital platforms in seconds of UTC time since Unix epoch. | | `end_time` | [`Timestamp`][ts] | Manually set editorial timestamp (_Gültig bis_) till the article is valid to deliver on digital platforms in seconds of UTC time since Unix epoch. | | `publish_time` | [`Timestamp`][ts] | Editorial timestamp (_Publikationsdatum_) of the first publication of the article in seconds of UTC time since Unix epoch. This date will be set automatically by the content management system. | | `update_time` | [`Timestamp`][ts] | Editorial timestamp (_Aktualisierungsdatum_) at which the article was updated in seconds of UTC time since Unix epoch. On first publication this timestamp matches `publish_time`. Afterwards it's either updated manually in the content management system or automatically if the article content changed *significantly*. | | `transformation_time` | [`Timestamp`][ts] | Technical timestamp at which the article was transformed in the API layer in seconds of UTC time since Unix epoch. | | `transformation_errors` | `int64` | Number of errors occurred while fetching and/or transforming optional article components (e.g. `embeds` or nested `documents`) to an `article` message. | | `last_modification_time` | [`Timestamp`][ts] | Technical timestamp at which the article was published regardless of the amount and significance of the change. | | `event_source` | [`EventSource`][es] | Source of the event that caused this item to be transformed and to be written into the DB. | | `seo_score` | `double` | The `article score` (originates from team data's _Content Engine_, higher scores are better) | | `publication_id` | `int64` | The unique `publication_id` provided by the CMS, can be used to correlate the state of documents in tapir with the corresponding CMS publication event. |

[ts]: https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Timestamp [state]: #state [es]: #enum-eventsource

@CodeBlockStart protobuf

func (*Article_Metadata) Descriptor() ([]byte, []int)

func (x *Article_Metadata) GetEndTime() *timestamppb.Timestamp

func (x *Article_Metadata) GetEventSource() Article_Metadata_EventSource

func (x *Article_Metadata) GetLastModificationTime() *timestamppb.Timestamp

func (x *Article_Metadata) GetPublicationId() int64

func (x *Article_Metadata) GetPublishTime() *timestamppb.Timestamp

func (x *Article_Metadata) GetSeoScore() float64

func (x *Article_Metadata) GetStartTime() *timestamppb.Timestamp

func (x *Article_Metadata) GetState() Article_Metadata_State

func (x *Article_Metadata) GetTransformationErrors() int64

func (x *Article_Metadata) GetTransformationTime() *timestamppb.Timestamp

func (x *Article_Metadata) GetUpdateTime() *timestamppb.Timestamp

func (*Article_Metadata) ProtoMessage()

func (x *Article_Metadata) ProtoReflect() protoreflect.Message

func (x *Article_Metadata) Reset()

func (x *Article_Metadata) String() string

type Article_Metadata_EventSource ¶

type Article_Metadata_EventSource int32

* ## `enum EventSource`

Even more detail about the circumstances of transformation for this article.

The `EventSource` will be of type:

- `PRIMARY` in case this article was directly _updated_ and _published_ - `SECONDARY` in case this article was indirectly updated. This can be caused by updates of _nested elements_, such as _Videos_ that may expire at some point. Another source of change may be _Scheduled Events_ like this item becomes _valid_ or _invalid_ at some point in time in the future after the item's original publication time.

| Enum value | description | |--------------------------|---------------------------------------------------------------------------------| | EVENT_SOURCE_UNSPECIFIED | unspecified | | PRIMARY | this article's transformation was caused by a direct change in the CMS | | SECONDARY | this article's transformation was caused by a transitive update | | CONTENT_ENGINE | this article's transformation was caused by an external system (Content Engine) |

@CodeBlockStart protobuf

const (
	Article_Metadata_EVENT_SOURCE_UNSPECIFIED Article_Metadata_EventSource = 0
	Article_Metadata_PRIMARY                  Article_Metadata_EventSource = 1
	Article_Metadata_SECONDARY                Article_Metadata_EventSource = 2
	Article_Metadata_CONTENT_ENGINE           Article_Metadata_EventSource = 3
)

func (Article_Metadata_EventSource) Descriptor() protoreflect.EnumDescriptor

func (x Article_Metadata_EventSource) Enum() *Article_Metadata_EventSource

func (Article_Metadata_EventSource) EnumDescriptor() ([]byte, []int)

func (x Article_Metadata_EventSource) Number() protoreflect.EnumNumber

func (x Article_Metadata_EventSource) String() string

func (Article_Metadata_EventSource) Type() protoreflect.EnumType

type Article_Metadata_State ¶

type Article_Metadata_State int32

* ## `enum State`

State of the item ([`Article`](article.html), [`Element`](article.element.html)) in the content management system. The `state` in combination with `start_time` and `end_time` determines whether or not this item should be rendered; this must be respected by all consumers especially when content is duplicated or cached.

The terms `deleted` (articles) and `archived` (media lib) are interchangeable/synonyms. This enum combines those two into `State.DELETED`. An Article is in `State.DELETED` if it was deleted in the content management system, or if it's [end_time](#end_time) has been reached.

An Article is in `State.DRAFT` if it has never been published, or if the `start_time` lies in the future.

| Enum value | description | |---------------------|----------------------------------------------------------------| | `STATE_UNSPECIFIED` | unspecified | | `PUBLISHED` | published content which is currently within its validity dates | | `DELETED` | this content is deleted or expired in the CMS | | `DRAFT` | this content was never published in the CMS |

@CodeBlockStart protobuf

const (
	Article_Metadata_STATE_UNSPECIFIED Article_Metadata_State = 0
	Article_Metadata_PUBLISHED         Article_Metadata_State = 1
	Article_Metadata_DELETED           Article_Metadata_State = 2
	Article_Metadata_DRAFT             Article_Metadata_State = 3
)

func (Article_Metadata_State) Descriptor() protoreflect.EnumDescriptor

func (x Article_Metadata_State) Enum() *Article_Metadata_State

func (Article_Metadata_State) EnumDescriptor() ([]byte, []int)

func (x Article_Metadata_State) Number() protoreflect.EnumNumber

func (x Article_Metadata_State) String() string

func (Article_Metadata_State) Type() protoreflect.EnumType

type Article_SubType ¶

type Article_SubType int32

const (
	Article_SUB_TYPE_UNSPECIFIED Article_SubType = 0
	Article_NEWS                 Article_SubType = 1
	Article_COLUMN               Article_SubType = 2
	Article_COMMENTARY           Article_SubType = 3
	Article_INTERVIEW            Article_SubType = 4
	Article_CONTROVERSY          Article_SubType = 5
	Article_TAGESANBRUCH         Article_SubType = 6
	Article_EVERGREEN            Article_SubType = 7
	Article_AGENCY_IMPORT        Article_SubType = 8
	Article_ADVERTORIAL          Article_SubType = 9
	Article_QUIZ                 Article_SubType = 10
	Article_GAME                 Article_SubType = 11
	Article_COMPLIANCE           Article_SubType = 12
	Article_RECIPE               Article_SubType = 13
)

func (Article_SubType) Descriptor() protoreflect.EnumDescriptor

func (x Article_SubType) Enum() *Article_SubType

func (Article_SubType) EnumDescriptor() ([]byte, []int)

func (x Article_SubType) Number() protoreflect.EnumNumber

func (x Article_SubType) String() string

func (Article_SubType) Type() protoreflect.EnumType

type Article_Type ¶

type Article_Type int32

const (
	Article_TYPE_UNSPECIFIED Article_Type = 0
	Article_ARTICLE          Article_Type = 1
	// Deprecated: Marked as deprecated in stroeer/core/v1/article.proto.
	Article_IMAGE   Article_Type = 2
	Article_VIDEO   Article_Type = 3
	Article_GALLERY Article_Type = 4
	Article_EMBED   Article_Type = 5
	Article_AUTHOR  Article_Type = 6
	// Deprecated: Marked as deprecated in stroeer/core/v1/article.proto.
	Article_AGENCY   Article_Type = 7
	Article_EXTERNAL Article_Type = 8
	Article_INTERNAL Article_Type = 100
)

func (Article_Type) Descriptor() protoreflect.EnumDescriptor

func (x Article_Type) Enum() *Article_Type

func (Article_Type) EnumDescriptor() ([]byte, []int)

func (x Article_Type) Number() protoreflect.EnumNumber

func (x Article_Type) String() string

func (Article_Type) Type() protoreflect.EnumType

type BatchGetArticlesRequest ¶

type BatchGetArticlesRequest struct {
	Ids []int64 `protobuf:"varint,1,rep,packed,name=ids,proto3" json:"ids,omitempty"`
	// contains filtered or unexported fields
}

* # `⚙︎ BatchGetArticle`

returns multiple [`stroeer.core.v1.Article`](Article.html) for the given `ids`. The ordering of items will the same ordering as the `ids` requested. If an `id` does not exists, it is omitted in the result (no error will be raised).

There is a maximum of 100 items that can be queried in one batch.

| Field name | Type | Description | |------------------|---------------------|-------------------------------------------------------------| | `ids` | `repeated int64` | [required] A list of ids of the articles to be fetched |

@CodeBlockStart protobuf

func (*BatchGetArticlesRequest) Descriptor() ([]byte, []int)

func (x *BatchGetArticlesRequest) GetIds() []int64

func (*BatchGetArticlesRequest) ProtoMessage()

func (x *BatchGetArticlesRequest) ProtoReflect() protoreflect.Message

func (x *BatchGetArticlesRequest) Reset()

func (x *BatchGetArticlesRequest) String() string

type BatchGetArticlesResponse ¶

type BatchGetArticlesResponse struct {
	Articles []*Article `protobuf:"bytes,1,rep,name=articles,proto3" json:"articles,omitempty"`
	// contains filtered or unexported fields
}

func (*BatchGetArticlesResponse) Descriptor() ([]byte, []int)

func (x *BatchGetArticlesResponse) GetArticles() []*Article

func (*BatchGetArticlesResponse) ProtoMessage()

func (x *BatchGetArticlesResponse) ProtoReflect() protoreflect.Message

func (x *BatchGetArticlesResponse) Reset()

func (x *BatchGetArticlesResponse) String() string

type GetArticleRequest ¶

type GetArticleRequest struct {
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

* # `⚙︎ GetArticle` ```protobuf rpc GetArticle (GetArticleRequest) returns (stroeer.core.v1.Article) {} ```

returns a single [`stroeer.core.v1.Article`](Article.html) if the given `id` exists, an `Error`, otherwise. (todo: describe errors)

| Field name | Type | Description | |------------------|---------------------|-------------------------------------------------------------| | `id` | `int64` | [required] Unique id of the article to be fetched. |

@CodeBlockStart protobuf

func (*GetArticleRequest) Descriptor() ([]byte, []int)

func (x *GetArticleRequest) GetId() int64

func (*GetArticleRequest) ProtoMessage()

func (x *GetArticleRequest) ProtoReflect() protoreflect.Message

func (x *GetArticleRequest) Reset()

func (x *GetArticleRequest) String() string

type ListArticlesRequest ¶

type ListArticlesRequest struct {
	Query     *ListArticlesRequest_Query   `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
	Filters   *ListArticlesRequest_Filters `protobuf:"bytes,2,opt,name=filters,proto3" json:"filters,omitempty"`
	PageSize  int32                        `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	PageToken string                       `protobuf:"bytes,4,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

* returns a [`message-listarticlesresponse`](#ListArticlesResponse) with articles matching the query. If the results exceed 100 Articles or 1 MB the response can be paginated to obtain additional results.

## `ListArticlesRequest`

| Field name | Type | Description | |------------------|---------------------|-------------------------------------------------------------| | `query` | [`Query`][1] | [required] find items based on query values | | `filters` | [`Filters`][2] | [optional] A filter expression is applied after a Query finishes, but before the results are returned. | | `page_size` | `int32` | [optional] limit the results per page, default is `10`; max is `100` (or result exceeds `1 MB`). Values above 100 will be coerced to 100. If results get truncated, you can use pagination. | | `page_token` | `string` | [optional] A page token, received from a previous `ListArticles` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListArticles` must match the call that provided the page token.|

[1]: #query [2]: #filters

@CodeBlockStart protobuf

func (*ListArticlesRequest) Descriptor() ([]byte, []int)

func (x *ListArticlesRequest) GetFilters() *ListArticlesRequest_Filters

func (x *ListArticlesRequest) GetPageSize() int32

func (x *ListArticlesRequest) GetPageToken() string

func (x *ListArticlesRequest) GetQuery() *ListArticlesRequest_Query

func (*ListArticlesRequest) ProtoMessage()

func (x *ListArticlesRequest) ProtoReflect() protoreflect.Message

func (x *ListArticlesRequest) Reset()

func (x *ListArticlesRequest) String() string

type ListArticlesRequest_Filters ¶

type ListArticlesRequest_Filters struct {
	TypeIncludes    []Article_Type    `` /* 139-byte string literal not displayed */
	TypeExcludes    []Article_Type    `` /* 139-byte string literal not displayed */
	SubTypeIncludes []Article_SubType `` /* 153-byte string literal not displayed */
	SubTypeExcludes []Article_SubType `` /* 153-byte string literal not displayed */
	// contains filtered or unexported fields
}

* ## `Filters`

If you need to further refine the Query results, you can optionally provide a filter expression. A filter expression determines which items within the Query results should be returned to you. All of the other results are discarded.

A filter expression is applied after a Query finishes, but before the results
are returned. Therefore, a Query consumes the same amount of read capacity,
regardless of whether a filter expression is present.

| Field name | Type | Description | |----------------------|---------------------------------|---------------------------------------------| | `type_includes` | [`ContentType`][6] | `type` to include into the result set | | `type_includes` | [`ContentType`][6] | `type` to exclude from the result set | | `sub_type_includes` | [`ContentSubType`][7] | `sub_type` to include into the result set | | `sub_type_excludes` | [`ContentSubType`][7] | `sub_type` to exclude from the result set |

[6]: article.html#type [7]: article.html#sub_type

@CodeBlockStart protobuf

func (*ListArticlesRequest_Filters) Descriptor() ([]byte, []int)

func (x *ListArticlesRequest_Filters) GetSubTypeExcludes() []Article_SubType

func (x *ListArticlesRequest_Filters) GetSubTypeIncludes() []Article_SubType

func (x *ListArticlesRequest_Filters) GetTypeExcludes() []Article_Type

func (x *ListArticlesRequest_Filters) GetTypeIncludes() []Article_Type

func (*ListArticlesRequest_Filters) ProtoMessage()

func (x *ListArticlesRequest_Filters) ProtoReflect() protoreflect.Message

func (x *ListArticlesRequest_Filters) Reset()

func (x *ListArticlesRequest_Filters) String() string

type ListArticlesRequest_Query ¶

type ListArticlesRequest_Query struct {
	Path     string                           `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Type     ListArticlesRequest_Query_Type   `protobuf:"varint,2,opt,name=type,proto3,enum=stroeer.core.v1.ListArticlesRequest_Query_Type" json:"type,omitempty"`
	SortBy   ListArticlesRequest_Query_SortBy `` /* 134-byte string literal not displayed */
	Order    ListArticlesRequest_Query_Order  `protobuf:"varint,4,opt,name=order,proto3,enum=stroeer.core.v1.ListArticlesRequest_Query_Order" json:"order,omitempty"`
	FromTime *timestamppb.Timestamp           `protobuf:"bytes,5,opt,name=from_time,json=fromTime,proto3" json:"from_time,omitempty"`
	ToTime   *timestamppb.Timestamp           `protobuf:"bytes,6,opt,name=to_time,json=toTime,proto3" json:"to_time,omitempty"`
	// contains filtered or unexported fields
}

* ## `Query`

Specify the search criteria. The list-API is build around sections which come in two flavors:

1. `home_section`: find all articles that resides within that exact section. The `home_section` is equal to the settings found in the CMS, e.g. `/nachrichten/wissen/` 2. `root_section`: this property is derived from the `home_section` path by retaining only the _root_ folder, e.g. for `/nachrichten/wissen/` the `root_section` becomes `/nachrichten/`

In most cases using the `root_section` should yield better results since it will also find content in nested sections whereas `home_section` would only return content which was curated into the exact section that was queried.

| Field name | Type | Description | |------------------|---------------------|-------------------------------------------------------------| | `path` | `string` | [required] `path`, with leading and trailing slash (e.g. `/nachrichten/`) | | `type` | [`Type`][3] | [required] query type, either `Type.HOME_SECTION` or `Type.ROOT_SECTION` | | `sort_by` | [`SortBy`][4] | [required] sorting of the result set, either `SortBy.UPDATE_TIME` or `SortBy.PUBLISH_TIME` | | `order` | [`Order`][5] | [optional] sorting direction for the results regarding the `sort_by` field, default is `Order.ASCENDING` | | `from_time` | [`Timestamp`][ts] | [optional] time constraint that refers to the `sort_by` field. | | `to_time` | [`Timestamp`][ts] | [optional] time constraint that refers to the `sort_by` field. |

[3]: #type [4]: #sortby [5]: #order [ts]: https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Timestamp

@CodeBlockStart protobuf

func (*ListArticlesRequest_Query) Descriptor() ([]byte, []int)

func (x *ListArticlesRequest_Query) GetFromTime() *timestamppb.Timestamp

func (x *ListArticlesRequest_Query) GetOrder() ListArticlesRequest_Query_Order

func (x *ListArticlesRequest_Query) GetPath() string

func (x *ListArticlesRequest_Query) GetSortBy() ListArticlesRequest_Query_SortBy

func (x *ListArticlesRequest_Query) GetToTime() *timestamppb.Timestamp

func (x *ListArticlesRequest_Query) GetType() ListArticlesRequest_Query_Type

func (*ListArticlesRequest_Query) ProtoMessage()

func (x *ListArticlesRequest_Query) ProtoReflect() protoreflect.Message

func (x *ListArticlesRequest_Query) Reset()

func (x *ListArticlesRequest_Query) String() string

type ListArticlesRequest_Query_Order ¶

type ListArticlesRequest_Query_Order int32

* ## `Order`

order of index traversal, default: ascending.

| Enum value | Description | |---------------------|----------------------------------| | `ORDER_UNSPECIFIED` | unspecified | | `ASCENDING` | ascending order index traversal | | `DESCENDING` | descending order index traversal |

@CodeBlockStart protobuf

const (
	ListArticlesRequest_Query_ORDER_UNSPECIFIED ListArticlesRequest_Query_Order = 0
	ListArticlesRequest_Query_ASCENDING         ListArticlesRequest_Query_Order = 1
	ListArticlesRequest_Query_DESCENDING        ListArticlesRequest_Query_Order = 2
)

func (ListArticlesRequest_Query_Order) Descriptor() protoreflect.EnumDescriptor

func (x ListArticlesRequest_Query_Order) Enum() *ListArticlesRequest_Query_Order

func (ListArticlesRequest_Query_Order) EnumDescriptor() ([]byte, []int)

func (x ListArticlesRequest_Query_Order) Number() protoreflect.EnumNumber

func (x ListArticlesRequest_Query_Order) String() string

func (ListArticlesRequest_Query_Order) Type() protoreflect.EnumType

type ListArticlesRequest_Query_SortBy ¶

type ListArticlesRequest_Query_SortBy int32

* ## `SortBy`

| Enum value | Description | |-----------------------|------------------------------------------------------------| | `SORT_BY_UNSPECIFIED` | unspecified | | `UPDATE_TIME` | sort by the content's [`update_time`][8] | | `PUBLISH_TIME` | sort by the content's [`publish_time`][9] |

[8]: metadata.html#update_time [9]: metadata.html#publish_time

@CodeBlockStart protobuf

const (
	ListArticlesRequest_Query_SORT_BY_UNSPECIFIED ListArticlesRequest_Query_SortBy = 0
	ListArticlesRequest_Query_UPDATE_TIME         ListArticlesRequest_Query_SortBy = 1
	ListArticlesRequest_Query_PUBLISH_TIME        ListArticlesRequest_Query_SortBy = 2
)

func (ListArticlesRequest_Query_SortBy) Descriptor() protoreflect.EnumDescriptor

func (x ListArticlesRequest_Query_SortBy) Enum() *ListArticlesRequest_Query_SortBy

func (ListArticlesRequest_Query_SortBy) EnumDescriptor() ([]byte, []int)

func (x ListArticlesRequest_Query_SortBy) Number() protoreflect.EnumNumber

func (x ListArticlesRequest_Query_SortBy) String() string

func (ListArticlesRequest_Query_SortBy) Type() protoreflect.EnumType

type ListArticlesRequest_Query_Type ¶

type ListArticlesRequest_Query_Type int32

* ## `Type`

| Enum value | Description | |--------------------|-------------------------------------------------------------| | `TYPE_UNSPECIFIED` | unspecified | | `HOME_SECTION` | query by exact _home section_ which is configured in the CMS| | `ROOT_SECTION` | query by exact _root section_ which is derived from _home section_ when only retaining the first level of the `path` |

see the description [above](#query) why these query types exist, also see [`Reference`](article.html#section_tree) how section information are stored.

@CodeBlockStart protobuf

const (
	ListArticlesRequest_Query_TYPE_UNSPECIFIED ListArticlesRequest_Query_Type = 0
	ListArticlesRequest_Query_HOME_SECTION     ListArticlesRequest_Query_Type = 1
	ListArticlesRequest_Query_ROOT_SECTION     ListArticlesRequest_Query_Type = 2
)

func (ListArticlesRequest_Query_Type) Descriptor() protoreflect.EnumDescriptor

func (x ListArticlesRequest_Query_Type) Enum() *ListArticlesRequest_Query_Type

func (ListArticlesRequest_Query_Type) EnumDescriptor() ([]byte, []int)

func (x ListArticlesRequest_Query_Type) Number() protoreflect.EnumNumber

func (x ListArticlesRequest_Query_Type) String() string

func (ListArticlesRequest_Query_Type) Type() protoreflect.EnumType

type ListArticlesResponse ¶

type ListArticlesResponse struct {
	Articles      []*Article `protobuf:"bytes,1,rep,name=articles,proto3" json:"articles,omitempty"`
	NextPageToken string     `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

* ## `ListArticlesResponse`

| Field name | Type | Description | |------------------|---------------------|-------------------------------------------------------------| | `articles` | [`Article`][article]| list of articles that match the `query` and also the `filter`, otherwise `empty`. | | `next_page_token`| `string` | A token that can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages. |

[article]: article.html

@CodeBlockStart protobuf

func (*ListArticlesResponse) Descriptor() ([]byte, []int)

func (x *ListArticlesResponse) GetArticles() []*Article

func (x *ListArticlesResponse) GetNextPageToken() string

func (*ListArticlesResponse) ProtoMessage()

func (x *ListArticlesResponse) ProtoReflect() protoreflect.Message

func (x *ListArticlesResponse) Reset()

func (x *ListArticlesResponse) String() string

type ListSectionsResponse ¶

type ListSectionsResponse struct {
	Sections []string `protobuf:"bytes,1,rep,name=sections,proto3" json:"sections,omitempty"`
	// contains filtered or unexported fields
}

* # `⚙︎ ListSections`

list the available root sections

## `ListSectionsResponse`

list all available `root_sections` that can be used in the [`query`](#query) above.

@CodeBlockStart protobuf

func (*ListSectionsResponse) Descriptor() ([]byte, []int)

func (x *ListSectionsResponse) GetSections() []string

func (*ListSectionsResponse) ProtoMessage()

func (x *ListSectionsResponse) ProtoReflect() protoreflect.Message

func (x *ListSectionsResponse) Reset()

func (x *ListSectionsResponse) String() string

type Reference ¶

type Reference struct {
	Type     string            `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Label    string            `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"`
	Href     string            `protobuf:"bytes,3,opt,name=href,proto3" json:"href,omitempty"`
	Fields   map[string]string `` /* 153-byte string literal not displayed */
	Children []*Reference      `protobuf:"bytes,5,rep,name=children,proto3" json:"children,omitempty"`
	// contains filtered or unexported fields
}

func (*Reference) Descriptor() ([]byte, []int)

func (x *Reference) GetChildren() []*Reference

func (x *Reference) GetFields() map[string]string

func (x *Reference) GetHref() string

func (x *Reference) GetLabel() string

func (x *Reference) GetType() string

func (*Reference) ProtoMessage()

func (x *Reference) ProtoReflect() protoreflect.Message

func (x *Reference) Reset()

func (x *Reference) String() string