kintone 0.6.2

kintone REST API client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! # Kintone Space Models
//!
//! This module provides data structures for working with Kintone spaces.

use serde::{Deserialize, Serialize};

use crate::model::Entity;

/// Represents a comment to be posted to a thread in a Kintone space.
///
/// A thread comment can include text content and mentions of users, groups, or organizations.
///
/// # Examples
///
/// ```rust
/// use kintone::model::{Entity, EntityType};
/// use kintone::model::space::thread_comment;
///
/// // Using the builder pattern
/// let comment = thread_comment("This is a thread comment with a mention")
///     .mention(Entity {
///         entity_type: EntityType::USER,
///         code: "user1".to_string(),
///     })
///     .build();
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename = "camelCase")]
pub struct ThreadComment {
    /// The text content of the comment
    pub text: String,
    /// List of entities mentioned in the comment
    pub mentions: Vec<Entity>,
    /// List of attachment files
    pub files: Vec<ThreadCommentFile>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename = "camelCase")]
pub struct ThreadCommentFile {
    /// The fileKey of the attachment file.
    pub file_key: String,
    /// Width can be specified if the attachment file is an image.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub width: Option<u64>,
}

/// Creates a new thread comment builder with the specified text.
///
/// This function creates a builder that can be used to construct a [`ThreadComment`]
/// with optional mentions and file attachments using method chaining.
///
/// # Arguments
/// * `text` - The text content of the comment
///
/// # Examples
/// ```rust
/// use kintone::model::{Entity, EntityType};
/// use kintone::model::space::{thread_comment, ThreadCommentFile};
///
/// let comment = thread_comment("Hello, this is a comment!")
///     .mention(Entity {
///         entity_type: EntityType::USER,
///         code: "user1".to_string(),
///     })
///     .file(ThreadCommentFile {
///         file_key: "file123".to_string(),
///         width: Some(300),
///     })
///     .build();
/// ```
pub fn thread_comment(text: impl Into<String>) -> ThreadCommentBuilder {
    ThreadCommentBuilder {
        text: text.into(),
        mentions: Vec::new(),
        files: Vec::new(),
    }
}

/// Builder for creating a [`ThreadComment`] with optional mentions and files.
#[derive(Debug, Clone)]
pub struct ThreadCommentBuilder {
    text: String,
    mentions: Vec<Entity>,
    files: Vec<ThreadCommentFile>,
}

impl ThreadCommentBuilder {
    /// Adds a mention to the comment.
    ///
    /// # Arguments
    /// * `entity` - The entity to mention (user, group, or organization)
    pub fn mention(mut self, entity: Entity) -> Self {
        self.mentions.push(entity);
        self
    }

    /// Adds multiple mentions to the comment.
    ///
    /// # Arguments
    /// * `entities` - The entities to mention
    pub fn mentions(mut self, entities: impl IntoIterator<Item = Entity>) -> Self {
        self.mentions.extend(entities);
        self
    }

    /// Adds a file attachment to the comment.
    ///
    /// # Arguments
    /// * `file` - The file attachment information
    pub fn file(mut self, file: ThreadCommentFile) -> Self {
        self.files.push(file);
        self
    }

    /// Adds multiple file attachments to the comment.
    ///
    /// # Arguments
    /// * `files` - The file attachments to add
    pub fn files(mut self, files: impl IntoIterator<Item = ThreadCommentFile>) -> Self {
        self.files.extend(files);
        self
    }

    /// Builds and returns the final [`ThreadComment`].
    pub fn build(self) -> ThreadComment {
        ThreadComment {
            text: self.text,
            mentions: self.mentions,
            files: self.files,
        }
    }
}

impl From<ThreadCommentBuilder> for ThreadComment {
    fn from(builder: ThreadCommentBuilder) -> Self {
        builder.build()
    }
}