Returns the conversations messages

 @return [Layer::RelationProxy] the conversation's messages
 @!macro various-apis
170296
def messages
      RelationProxy.new(self, Message, [Operations::Create, Operations::Paginate, Operations::Find, Operations::Delete, Operations::Destroy])
    end
878951
public function extendConversation()
    {
        Conversation::macro('sendDialog', function (Dialog $dialog, $next, $additionalParameters = []) {
            $response = $this->bot->replyDialog($dialog, $additionalParameters);

            $validation = function ($answer) use ($dialog, $next, $additionalParameters) {
                $errors = $dialog->errors(Collection::make($answer->getValue()));
                if (count($errors)) {
                    $this->bot->touchCurrentConversation();

                    return Response::create(json_encode(['errors' => $errors]), 200, ['ContentType' => 'application/json'])->send();
                } else {
                    if ($next instanceof \Closure) {
                        $next = $next->bindTo($this, $this);
                    }
                    $next($answer);
                }
            };
            $this->bot->storeConversation($this, $validation, $dialog, $additionalParameters);

            return $response;
        });
    }
284150
public function getMessages()
    {
        $messages = parent::getMessages();

        foreach ($this->children as $child) {
            $messages = array_merge($messages, $child->getMessages());
        }

        return $messages;
    }
1150053
def list_topics
      response = random_broker.fetch_metadata(topics: nil)
      response.topics.select do |topic|
        topic.topic_error_code == 0
      end.map(&:topic_name)
    end
1230948
def messages(self):
        
        if self._messages is None:
            self._messages = MessageList(
                self._version,
                service_sid=self._solution['service_sid'],
                channel_sid=self._solution['sid'],
            )
        return self._messages
1339005
public function getConversation(): Conversation
    {
        $body = $this->getJson();

        $resource = HalDeserializer::deserializeResource(
            Conversation::class,
            HalDeserializer::deserializeDocument($body)
        );

        return $resource->getEntity();
    }
625909
public static function get_conversation_messages_returns() {
        return new external_single_structure(
            array(
                'id' => new external_value(PARAM_INT, 'The conversation id'),
                'members' => new external_multiple_structure(
                    self::get_conversation_member_structure()
                ),
                'messages' => new external_multiple_structure(
                    self::get_conversation_message_structure()
                ),
            )
        );
    }
1351346
def conversations(self, max_id=None, min_id=None, since_id=None, limit=None):
        
        if max_id != None:
            max_id = self.__unpack_id(max_id)
        
        if min_id != None:
            min_id = self.__unpack_id(min_id)
            
        if since_id != None:
            since_id = self.__unpack_id(since_id)            
        
        params = self.__generate_params(locals())
        return self.__api_request('GET', "/api/v1/conversations/", params)
550526
protected function get_messages() {
        global $SESSION;

        $messages = array();
        if (!empty($SESSION->lesson_messages) && is_array($SESSION->lesson_messages) && array_key_exists($this->properties->id, $SESSION->lesson_messages)) {
            $messages = $SESSION->lesson_messages[$this->properties->id];
            unset($SESSION->lesson_messages[$this->properties->id]);
        }

        return $messages;
    }
476914
function Conversation (params) {
  var self = this
  if (!(self instanceof Conversation)) return new Conversation(params)

  var convoMessages = params['conversation_messages'] || { }
  var lastChatActions = params['last_chat_actions']
  var lastTransaction = params['last_cash_transaction']
  var pendingRecievedSnaps = params['pending_received_snaps'] || []
  var messages = convoMessages['messages'] || []
  var lastSnap = params['last_snap']
  var lastInteraction = +params['last_interaction_ts']

  self.messagingAuth = convoMessages['messaging_auth']

  self.state = params['conversation_state']
  self.identifier = params['id']
  self.pagination = params['iter_token']

  self.lastSnap = lastSnap ? new Snap(lastSnap) : null
  self.lastTransaction = lastTransaction ? new Transaction(lastTransaction) : null
  self.lastInteraction = lastInteraction > 0 ? new Date(lastInteraction) : null
  if (lastChatActions) {
    // self.lastChatType = SKChatTypeFromString(lastChatActions['last_write_type'])
    // self.lastChatRead = +NSDate dateWithTimeIntervalSince1970:[lastChatActions['last_read_timestamp']/1000]
    // self.lastChatWrite = +NSDate dateWithTimeIntervalSince1970:[lastChatActions['last_write_timestamp']/1000]
    self.lastChatReader = lastChatActions['last_reader']
    self.lastChatWriter = lastChatActions['last_writer']
  }

  self.participants = params['participants'] || self.identifier.split('~')
  self.usersWithPendingChats = params['pending_chats_for'] || []

  // Messages
  self.messages = messages.map(function (message) {
    if (message['snap']) {
      return new Snap(message['snap'])
    } else if (message['chat_message']) {
      return new Message(message['chat_message'])
    } else if (message['cash_transaction']) {
      return new CashTransaction(message['chat_transaction'])
    } else {
      debug('Unhandled conversation message type:%s', message)
      return null
    }
  })

  // Pending recieved snaps
  self.pendingRecievedSnaps = pendingRecievedSnaps.map(function (snap) {
    return new Snap(snap)
  })
}
608622
def connections
      response = Discordrb::API::User.connections(@token)
      JSON.parse(response).map { |e| Connection.new(e, self) }
    end
113928
def messages
      result = []
      seen = {}
      descriptors.each do |d|
        dm = d.messages
        dm.delete_if do |m|
          delete = seen[m.name]
          seen[m.name] = true
          delete
        end
        result.concat dm
      end
      result.sort!
    end
920229
def get_connection_info
      info = []
      @connections.each do |connection|
        info.push([connection.id, connection.target_uri, 'i', connection.protocol, @topic_name])
      end
      info
    end
200488
protected CmsMessages getMessages() {

        if (m_messages == null) {
            // initialize the localized messages
            m_messages = new CmsMessages(Messages.get().getBundleName(), getLocale().toString());
        }
        return m_messages;
    }
336974
def from_name(cls, relation_name, conversations=None):
        
        if relation_name is None:
            return None
        relation_class = cls._cache.get(relation_name)
        if relation_class:
            return relation_class(relation_name, conversations)
        role, interface = hookenv.relation_to_role_and_interface(relation_name)
        if role and interface:
            relation_class = cls._find_impl(role, interface)
            if relation_class:
                cls._cache[relation_name] = relation_class
                return relation_class(relation_name, conversations)
        return None
1069674
public function getMessages()
    {
        $messages = parent::getMessages();

        if ($this->model !== null) {
            foreach ($this->model as $row) {
                foreach ($this->columns as $column) {
                    $messages = array_merge(
                        $messages,
                        $column->getMessages($row)
                    );
                }

                foreach ($this->spanning_columns as $column) {
                    $messages = array_merge(
                        $messages,
                        $column->getMessages($row)
                    );
                }
            }

            foreach ($this->extra_rows as $row) {
                if ($row instanceof SwatTableViewWidgetRow) {
                    $messages = array_merge($messages, $row->getMessages());
                }
            }
        }

        return $messages;
    }
429888
public function getMessages()
    {
        $results  = $this->getResults();
        $messages = [];

        foreach ($results as $result) {
            /** @noinspection SlowArrayOperationsInLoopInspection */
            $messages = array_replace_recursive($messages, $result->getMessages());
        }

        return $messages;
    }