# Managing messages

## How to create a message?

## Using REST methods

Accessing from the Client the method is create a message is pretty simple and straightforward.

```javascript
client.rest.channels.createMessage(channelID, options);
client.createMessage(channelID, options);
// e.g:
client.rest.channels.createMessage("abcd-12345", { content: "hi!" });
client.createMessage("abcd-12345", { content: "hi!" });
```

## Using the Message itself

The main differences between creating a message with the message itself rather than using REST, are that it is faster, and behaves differently: it replies to it.

### createMessage – Reply to the trigger message.

By replying to the trigger message, which is the message that triggers your application, that is most likely sent by a user: it creates an original response to it and acknowledges your message.

```typescript
Message.createMessage(options); // acknowledges and reply to the Message
```

### createFollowup

Send a follow-up message that replies to the original response, the current Message has to be acknowledged to be used.

```typescript
Message.createFollowup(options);
```

## How do I detect when a message is created, edited or deleted?

We use **client.on to detect when an event is triggered.**

### Detect when a message is created

```javascript
client.on("messageCreate", async (message) => {
    // Whatever you want to do when a message is created
}
```

### Detect when a message is edited

```javascript
client.on("messageUpdate", async (message, oldMessage) => {
    // Whatever you want to do when a message is edited
}
```

### Detect when a message is deleted

```javascript
client.on("messageUpdate", async () => {
    // Whatever you want to do when a message is deleted
}
```

{% hint style="info" %}
We're shipping TouchGuild with a wide range of events, [you can check them out here.](https://docs.touchguild.com/dev/interfaces/Events.ClientEvents)
{% endhint %}

## Create a message when someone says 'hi'

<pre class="language-javascript"><code class="lang-javascript">client.on("messageCreate", async (message) => {
    // the member property is a getter that returns a Promise
    // that's why we await it before using it.
    const member = await message.member;
    // We can get the app property and return if it is true
<strong>    // That prevents the app to send message infinitely
</strong>    // (app sends a message, it's immediately detected, so it resends and so on).
    if (member.app) return;
    // We check if the content fo the message is hi
    if (message.content == "hi") {
       // We create a message!
       message.createMessage({ content: "hey there!" });
    }
});
</code></pre>

### Another way to do that without storing the message 'member'

```javascript
client.on("messageCreate", async (message)=> {
    if (await (message.member).app) return;
    if (message.content == "hi") {
       message.createMessage({ content: "hey there!" });
    }
});
```

### Common mistakes

{% hint style="danger" %}
Not adding the condition to return in case the user that sent the message is a app

Yes, it is a fairly common mistake among beginners, by not putting this condition and send a message whatever the message is, this can cause sooner or later a creation of a bunch of messages in a short period of time.

```javascript
client.on("messageCreate", async (message)=> {
    if (message.content == "hi") {
       message.createMessage({ content: "hey there!" });
    }
    // this will loop
    message.createMessage({ content: "a message has been sent!" });
    
    // this will loop as well, as the sent message
    // is the same as the message content detected
    if (message.content == "hello") {
       message.createMessage({ content: "hello" });
    }
});
```

In this case, we're detecting if the message content is 'hi', which makes it unable to loop, but it could happen by running messageCreate outside the condition.
{% endhint %}

{% hint style="danger" %}
Using message.member directly without awaiting it

message.member is a getter method that returns a Promise, you have to await it to be able to access to its properties, in that case message.member.app will be undefined instead of a boolean.

```javascript
client.on("messageCreate", async (message)=> {
    if (message.member.app) return;
    if (message.content == "hi") {
       message.createMessage({ content: "hey there!" });
    }
});

```

OUTPUT (console):

```javascript
TypeError: Cannot read properties of undefined (reading 'app')
```

{% endhint %}

and don't forget to make the function asynchronous (async) if you're using await inside it!

## Replying to a message

The difference with creating a message and replying, is that the reply mentions the user, and links the new message to a 'replied message'

Though replying is already built-in the Message component methods, you can still&#x20;

It is very similar to creating a message, you only add the property `replyMessageIds`

```javascript
client.on("messageCreate", async (message)=> {
    const member = await message.member;
    if (member.app) return;
    if (message.content == "hi"){
       message.createMessage({
          content: "hey there!",
          // replyMessageIds is a list of message IDs you're replying to.
          // (aditionally)
          replyMessageIDs: [message.id]
       });
    }
});
```

## Logging things to a specific channel

```javascript
client.on("messageUpdate", async (message)=> {
    client.createMessage("channel id", { content: `A message has been updated (channel id: ${message.channelID})` });
});
```

## Deleting messages containing swear words

```javascript
client.on("messageCreate", (message) => {
    if (message.content.includes("fuck")) message.delete();
});
```

## Editing messages

There's different ways to edit messages sent by the app.

### 1. Storing new messages.

```javascript
client.on("messageCreate", async (message)=> {
   const member = await message.member;
   if (member.app) return;
   if (message.content == "!ping"){
       // store inside a let the message
       let reply = await message.createMessage({ content: ".." });
       // edit the stored, recently created message.
       await reply.editMessage({ content: "pong!" });
   }
});
```

### 2. Using editLast

{% hint style="info" %}
&#x20;This method called editLast was previously editLastMessage in older TouchGuild versions
{% endhint %}

```javascript
client.on("messageCreate", async (message)=> {
   const member = await message.member;
   if (member.app) return;
   if (message.content == "!ping"){
       await message.createMessage({ content: ".." });
       await message.editLastMessage({ content: "pong!" });
   }
});
```

### 2. Using editOriginal

```typescript
client.on("messageCreate", async (message) => {
   const member = await message.member;
   if (member.app) return;
   if (message.content == "!ping"){
       const res = await message.createMessage({ content: ".." });
       res.editOriginal({ content: "res edited!" });
       // it is way more useful when you only have a children of an original
       // response message
   }
});
```

### 2. Using editFollowup

A derivative of editLast, that only works on followups.