First go to your specific server [Dashboard](https://ccbot.app) and click `Create > Slash Command`

Give it any name, in our example it will be `tic-tac-toe` and in the Command Description field put anything you want

Now move to the Hooks section and we need 2 views, first view is to allow someone to click a button to accept your challenge

```py
p1 = user.id
p2 = None

class StartView(View):
    def __init__(self):
        self.user_id = None

    @button(label="Accept", style="success")
    async def accept(self, i, b):
        if i.user.id == p1:
            await defer(i, action="create", ephemeral=True)
            return respond_interaction(i, content="You can't play with youself")
        
        self.user_id = i.user.id
        await defer(i, action="update")
        respond_interaction(i, empty=True)
        self.stop()
        
view = StartView()
respond_interaction(
    interaction, 
    content=f"{user.mention} is challenging you to play Tic-Tac-Toe", component=view
)

exit_code = await view.wait(scope=scope, timeout=60)
if exit_code == "timeout":
  set_error("No one accepted the challenge.")

p2 = view.user_id
```

Since this game need 2 player, we initialized `p1` to be the user who ran the command and for `p2` we initially made it None and then made a view where anyone can click `Accept` button to be the second player. And when someone accepts we assign `p2` to be the user id of that person

In the next part we make another view that controls the whole logic of the command. 

```py
async def check_winner(board):
    winning_combinations = [
        [0, 1, 2],
        [3, 4, 5],
        [6, 7, 8],
        [0, 3, 6],
        [1, 4, 7],
        [2, 5, 8],
        [0, 4, 8],
        [2, 4, 6] 
    ]
    
    is_game_over = False
    winner = None

    def check_combination(combination, index):
        nonlocal winner
        a, b, c = combination
        if board[a] is not None and board[a] == board[b] == board[c]:
            winner = board[a]
            break_loop() 
    
    loop(winning_combinations, check_combination)
    
    if (None not in board) or winner:
        is_game_over = True

    return [is_game_over, winner]

class GameView(View):
    def __init__(self):
        self.board = [
            None, None, None,
            None, None, None,
            None, None, None,
        ]

        self.players = [p1, p2]

        self.emojis = {
            p1: "⭕",
            p2: "❌"
        }
        
        self.current_player_index = random([0, 1]) # randomly select who goes first
        self.winner = None

    def get_current_player(self):
        return self.players[self.current_player_index]
    
    def change_player(self):
        self.current_player_index = 0 if self.current_player_index else 1
    
    async def validate_interaction(self, i):
        if i.user.id not in self.players:
            await defer(i, action="create", ephemeral=True)
            return respond_interaction(i, content="You are a member of this board") 

        if i.user.id != self.get_current_player():
            await defer(i, action="create", ephemeral=True)
            return respond_interaction(i, content="Its not your turn")

        return True
    
    async def update_board(self, i):
        await self.update_view()
        self.change_player()

        turn = get_member(self.get_current_player())
        respond_interaction(i, content=f"{turn.mention}'s turn")
    
    async def handle_turn(self, i, b):
        is_valid = await self.validate_interaction(i)
        if not is_valid:
            return

        await defer(i, action="update")
        self.board[b.metadata['index']] = i.user.id

        b.label = self.emojis[i.user.id]
        b.is_disabled = True

        is_game_over, winner = await check_winner(self.board)
        if winner:
            self.winner = winner
            self.stop()
            return

        if is_game_over:
            self.stop()
            return
        
        await self.update_board(i)

    @button(label="‎", row=1, index=0)
    async def one(self, i, b):
        await self.handle_turn(i, b)

    @button(label="‎", row=1, index=1)
    async def two(self, i, b):
        await self.handle_turn(i, b)

    @button(label="‎", row=1, index=2)
    async def three(self, i, b):
        await self.handle_turn(i, b)

    @button(label="‎", row=2, index=3)
    async def four(self, i, b):
        await self.handle_turn(i, b)

    @button(label="‎", row=2, index=4)
    async def five(self, i, b):
        await self.handle_turn(i, b)

    @button(label="‎", row=2, index=5)
    async def six(self, i, b):
        await self.handle_turn(i, b)

    @button(label="‎", row=3, index=6)
    async def seven(self, i, b):
        await self.handle_turn(i, b)

    @button(label="‎", row=3, index=7)
    async def eight(self, i, b):
        await self.handle_turn(i, b)

    @button(label="‎", row=3, index=8)
    async def nine(self, i, b):
        await self.handle_turn(i, b)
    
    async def start_game(self, i):
        player = get_member(self.get_current_player())
        respond_interaction(i, content=f"{player.mention}'s turn", component=self)

view = GameView()
await view.start_game(interaction)

exit_code = await view.wait(scope=scope, timeout=60)

if exit_code == "timeout":
    set_error("The board has been abandoned.")

winner = None
if view.winner:
    winner = get_member(view.winner)

message = f"The winner is {winner.mention} 🎉" if winner else "It's a draw"
```

And finally in the `Response` section of the command we can put `{message}` and create the command

### Example
![example](https://utfs.io/f/HxYNtp95mh2JLaeiQ8wyG4UHwbhEQxyRSkrB1N896mzDaJMn)

## This is how you can crate a multiplayer tic-tac-toe game using discord custom commands bot

Lets create a discord slash command that allows playing multiplayer tic-tac-toe

Create a tic-tac-toe game using custom commands bot

### Code
```py
pages = Paginator(
    interaction, 
    user_id=user.id,
    prev_text="Prev",
    next_text="Next",
    stop_text="Stop",
)

pages.add_page(
    Page(
        content="",
        embed=embed, # you can use load_embed()
        message=Message(), # see docs for custom message
        attachments=[], # list of attachments 
    )   
)
# add as many pages as you want

await pages.start()
```

Now running the command will show a paginator.

### Example
We will make a command named `pagination` and put the following code inside **Hooks (pre)**

```py
pages = Paginator(interaction, user_id=user.id)

pages.add_page(Page(content="This is page 1"))
pages.add_page(Page(content="This is page 2"))

await pages.start()
```
## Creating pagination is simple using Discord Custom Commands bot
If you followed the instructions above you will get the following output
![example](https://utfs.io/f/HxYNtp95mh2J7ySF1IR48deK3Y0VSMFmlZLoWGh1bvxHOsNX)

Lets learn how you can create paginator using slash commands bot

How to create pagination in Custom Commands bot

Here is a list of all possible permissions available in custom commands bot

- view_channel
- manage_channels
- manage_roles
- create_expressions
- manage_expressions
- view_audit_log
- view_guild_insights
- manage_webhooks
- manage_guild
- create_instant_invite
- change_nickname
- manage_nicknames
- kick_members
- ban_members
- moderate_members
- send_messages
- send_messages_in_threads
- create_public_threads
- create_private_threads
- embed_links
- attach_files
- add_reactions
- use_external_emoji
- use_external_stickers
- mention_roles
- manage_messages
- manage_threads
- read_messages
- send_tts_messages
- send_voice_messages
- create_polls
- connect
- speak
- stream
- use_soundboard
- use_external_sounds
- use_voice_activity
- priority_speaker
- mute_members
- deafen_members
- move_members
- use_application_commands
- use_activities
- use_external_apps
- request_to_speak
- create_events
- manage_events
- administrator

Here is a list of all possible permissions

All the possible permissions in custom commands bot

View is a collection of multiple components that work togather, lets learn how we can create a view in custom commands bot

### Create a view
```py
class AgreeView(View):
  def __init__(self):
    self.agree = False # initialize agree with false
  
  @button(label="Yes", style="success")
  async def yes(self, interaction, button):
    await defer(interaction, action="update")
    respond_interaction(interaction, empty=True)

    self.agree = True # sets agree = True because yes button clicked
    self.stop() # stops the view when this button is pressed
    

  @button(label="No", style="danger")
  async def stopper(self, interaction, button):
    await defer(interaction, action="update")
    respond_interaction(interaction, components=None, content="Cancelled")

    self.stop() # stops the view when this button is pressed

view = CustomView()
respond_interaction(interaction, content="Do you agree?", components=view) # send the view

exit_code = await view.wait(scope=scope)  # wait untill the view is stopped

if exit_code == "timeout": # if the view times out
  set_error("Timeout")
```

After that you can access `view.agree` anywhere and execute code based on conditions

How to create views in custom commands bot

In custom commands bot jobs run automatically after a given amount time, once a job is started it will keep running itself on the given interval until its cancelled

For example lets say you want to run a clock event every hour
```py
await start_job(
  custom_id="hourly_job",
  freq="hour",
  interval=1,
  minute=0,
  second=0
)
```
This codes run the clock event with hourly_job once every hour (because interval is 1), if you want to run every 2 hour, just make interval=2 so it run once in every 2 hour

### What about every day? Simple…
```py
await start_job(
  custom_id="daily_job",
  freq="day",
  interval=1,
  hour=12,
  minute=0,
  second=0
)
```

### Every week
```py
await start_job(
  custom_id="weekly_job",
  freq="week",
  day_name="sunday",
  interval=1,
  hour=12,
  minute=0,
  second=0
)
# every sunday 12:00:00
```

### Every month
```py
await start_job(
  custom_id="monthly_job",
  freq="month",
  interval=1,
  date=1,
  hour=12,
  minute=0,
  second=0
)
# every month's 1st day, 12:00:00
```

### Every year
```py
await start_job(
  custom_id="yearly_job",
  freq="year",
  interval=1,
  month=1,
  date=1,
  hour=12,
  minute=0,
  second=0
)
# every year 1st January, 12:00:00
```

If you want to create a repeating job that keeps running until cancelled

Create jobs that keeps running after interval in custom commands bot

There are multiple places we use variables, In `Content`, `Embed`, `Pre Code` and `Post Code`. But when should we use curly braces to make them work?

## When to use?

If you are using variables in `Content` or `Embed` then you have to use curly braces {} to make them work. Otherwise they will be treated as normal texts

> #### Example

```py
Hello {user.mention}!
```

## When not to use?

If you are using any variables in the `Pre Code` or `Post Code` you don't have to use any curly braces at all. In fact using them will cause errors.

> #### Example

```py
add_roles(user, 3904234823402349234)
```


If you are confused about when you should use curly braces for variables, read more...

When should I use curly braces and when not for variables?

## Custom Commands Setup

First of all we need to add an argument/option to our command, where we can mention the user we want to remove roles.
So go ahead and add an option, name it `target` and select `MEMBER` as the type then type anything relavent in the description.
Maybe _The target member_

## Code

Now we have to write code in the the Hooks (pre) to add roles to the mentioned user.

```py
# Example 1
add_roles(target, role_id)

# Example 2
add_roles(target, role_id, another_role_id)
```

In example 1 we just added 1 role to the target and in example 2 we have added 2 roles to the target, We can actually
add any amount of roles to the target, Just add another role id at the end followed by a comma (,).

Removing role works the same way, Just replace add_roles with remove_roles, others are same. You can use both of them at a same time in the same command.

**Note**: Make sure to properly manage permission of the command so that not everyone can use this command. You can see how we can manage permissions of a command
in this blog, [Manage permissions of custom slash commands](manage-permissions-of-custom-slash-commands)

Or you can just put the code below for basic permission management

```py
require_permission("administrator")
```

Just put this line of code above the add_roles/remove_roles code.

## Final code

```py
require_permission("administrator")
add_roles(target, role_id, another_role_id)
```


To remove role from mentioned user use the add_roles and remove_roles variable

Add or remove role from mentioned user using custom commands bot

### Custom Commands setup
First create a command and give it any name and description you want

Then disable `Auto Defer` so that the command does not get automatically deferred
![image](https://utfs.io/f/0b715f55-335e-4ec5-84d1-faed708c1048-chhe0d.png)

### Hooks (pre)
First create the modal

```py
modal = ModalBuilder(title="Test Modal", custom_id="test_modal")

modal.add_text_input(
    name="name",
    label="Country",
    placeholder="What country do you live in?"
)
modal.add_text_input(
    name="description",
    label="Description",
    placeholder="Write something about your country",
    style="long",
)
```

I have added 2 input fields `name` and `description` and also gave the modal a custom_id `test_modal` you can change the custom id and make your own fields

Then you have to send the modal

```py
await send_modal(modal)
```

After that you can handle the modal submission using an `Event` or you can handle it inside the command's hooks

### Handle using Event
if you want to handle the modal using events

```py
#! test_modal

name = values["name"]
description = values["description"]

# Do what you want to do with these variables

defer_response(ephemeral=True)
respond_interaction(interaction, content="Thank you for submitting the modal")
```

By the upper code you can access the values and do whatever you want

### Handle using pre hooks
if you want to handle using pre hook

```py
def check(event):
	return (
    	event.interaction.user.id == user.id and
        event.interaction.custom_id == "test_modal" # use your own custom id here
    )
   
event = await wait_for("modal_submit", check=check)

values = get_modal_values(event.interaction)
await defer(event.interaction, ephemeral=False)

respond_interaction(
    event.interaction, 
    content=f"Name: {values['name']}\nDescription: {values['description']}"
)
```

in this blog we will learn how we can create a command that sends a modal

Create a modal command using custom commands bot

### Step 1

Just create a normal custom command

### Setp 2

Add these codes to Hooks (post). This won't work in Hooks (pre) if you are not sending messages from pre hook

```py
add_reactions(response, "✅", "❌")

# Or Custom emojis with name
# For custom emojis you need to have them in your server emojis. Otherwise it won't work
add_reactions(response, "custom_name", "another_emoji")
```


Lets see how we can add reaction to response

Add reaction to response message using custom commands bot

## Construct Embed
Custom commands bot has its own way of defining Embeds, Follow the instructions below. 

```py
myEmbed = Message(
  content="Message outside embed",
  title="This is title",
  url="https://ccbot.app", # A link thats clickable on title
  description="This is just a description",
  color=0xffffff, # Any hex code here followed by `0x`
  fields=[
    ("Field Title", "Field Value", true), # last one is inline value can be true or false
    ("Another Field", "This is awesome", true),
  ],
  image="https://i.ibb.co/XpK0FLG/slash-commands.png", # Any image here
  thumbnail="https://i.ibb.co/XpK0FLG/slash-commands.png", # Any image here
  footer="This is footer text",
  footer_icon="https://i.ibb.co/XpK0FLG/slash-commands.png", # Icon shows beside footer
  timestamp=interaction.created_at, # For current time
  author=user.username,
  author_icon=user.avatar_url,
  author_url="https://ccbot.app"
)
```

## Send the embed

```py
send_message(channel_id, myEmbed)
```

Both code must be in pre or post hook.

To create a embed and send it to a channel programmitically using pre hook

Create and send custom embed to a channel programatically using custom commands bot

Lets know about different limits that are enforced by discord.

## Command

- Name: 32 Character
- Description: 100 Character

## Options

- Name: 32 Character
- Description: 100 Character

## Choices

- Max Choices: 25
- Value: 100 Character

## Hooks

- Pre: 1000 Character
- Post: 1000 Character

## Content

- Max: 2000 Character

## Embed

- Title: 256 Character
- Description: 4096 Character
- Author Name: 256 Character
- Fields
  - Max: 25 Fields
  - Name: 256 Character
  - Value: 1024 Character
- Footer: 2048 Character

Thumbnail and Image should have a appropriate image link otherwise it won't show up


Lets know about different limits that are enforced by discord

Limits for different fields on slash commands

By utilizing the new `has_permission` or `has_any_permission` we can have conditional cooldowns in a command.

Lets say we want a 10 seconds cooldown for administrators and 1 minute cooldown for other users. We can use the `has_permission` function.

## Code

```py
if has_permission(user, "administrator"):
    cooldown("10 seconds", user.id)
else:
    cooldown("1 minutes", user.id)
```

Using this code in pre-hook will allow admins to use the command every 10 seconds, but other users will have a 1 minute cooldown.

If you want no cooldown for admins you can also do that easily by using the code below.

```py
if not has_permission(user, "administrator"):
    cooldown("1 minutes", user.id)
```

This code will check if the user dont have the administrator permission, he will have 1 minute cooldown, Otherwise no cooldown.

Possibilities are endless. You just have to think. 🚀


Want to have different cooldown for different user groups?

Conditional cooldown for debugging custom commands

This blog is about how you can use the Custom Slash Commands bot.

## Invite

First you have to invite this bot into your server. Use this link to do so [Click Here](https://discord.com/oauth2/authorize?client_id=857903085665517588&permissions=274878097408&redirect_uri=https%3A%2F%2Fccbot.app%2Fapi%2Fauth%2Fcallback%2Fdiscord&response_type=code&scope=bot%20applications.commands%20identify).
Then you can select your server and start making commands.

## Creating command

To create a command, You need to click on `create` and then select `command`. You can find them on the sidebar.
![Custom Slash Command](https://cdn.discordapp.com/attachments/825069485110198333/1072454736709701712/Screenshot_2023-02-07_155124.png)

Then you have to fill out the command form. The name description and content is required to be filled.
You can keep other fields blank
![Custom Slash Command](https://cdn.discordapp.com/attachments/825069485110198333/1072455742176645120/image.png)

Then you can click on the green `Create Command` button. And your command will be created.

## Syncing

After you create a command you will be able to see a **Sync Now** button on the top of the page
![Sync Custom Slash Command](https://cdn.discordapp.com/attachments/825069485110198333/1072455464928952360/image.png)

Also in the commands page. You have to click on that button everytime you see it.
Otherwise your commands might not work as expected, or you might not be able to even see it in your server.

After the command has been synced, You will be able to see it in your server when you press / on your server and execute it.

## Video Tutorial

<YouTube videoId="zDRrkHEDkBQ" />


Basic usage of slash commands bot to start using this bot

How to use custom commands bot

Lets make a `/strike` command which we can use to strike a member
and if the member gets more than 3 strikes the bot will kick him.

### Command

- Name: strike
- Description: Give strike to a member

### Arguments

- Name: target
- Description: The target member to strike
- Type: MEMBER

### Hooks

Pre

```py
require_permission("administrator") # You can also use allowed_roles()

current_strikes = member_var("strikes", member=target.id, default=0)
new_strikes = number(current_strikes) + 1
remaining_strikes = 3 - new_strikes

update_member_var("strikes", new_strikes, member=target.id)

response = (
  f"{target.mention} has been striked. Total strikes **{new_strikes}**\n"
  f"If you get **{remaining_strikes}** more strikes you will get kicked from this server."
)

if new_strikes >= 3:
  kick_member(target, message=f"You got {new_strikes} strikes and kiked from {server.name}")
  response = f"{target} has been kicked from the server for getting 3 strikes"
```

### Response

Content

```py
{response}
```

Now you can run this command and give strike to member

> /strike @Shahriyar


We are going to make a command which gives a user strike and 3 strike = kick/ban

Lets make a strike command using custom commands bot

We can use MongoDB database with Commands Commands bot to store, find, update and delete data into a database.

## Code
```py
# initialization of database
db = SlashMongo("database_name")

# insert data
await db.insert_one(
    { "name": "Anything", "age": 21 } # you can insert any data
)

# insert multiple
await db.insert_many([
    { "name": "Anything 1", "age": 21 },
    { "name": "Anything 2", "age": 22 }.
    { "name": "Anything 3", "age": 23 },
])

# find data
data = await db.find({"age": 21}) # it returns a list of data
# [ { "name": "Anything 1", "age": 21 } ]
data = await db.find_one({"age": 21}) # single data in form of an object
# { "name": "Anything 1", "age": 21 }

# delete data
await db.delete_one({"age": 21}) # deletes one row
await db.delete_many({"age": 21}) # deletes multiple row 

# update data
await db.update_one(
    {"age": 21}, 
    { 
        "$set": { "age": 99 } # remember to use $set
    }
)

await db.update_many(
    {"age": 21}, 
    { 
        "$set": { "age": 99 } # remember to use $set
    }
)
```

## Cloud Mongodb
if you have your own mongodb server or you want to use an external mongodb databse you can do so by using the `MongoDB` function. Then you can use the following code

```py
db = MongoDB(
    "connection_url",
    "database_name",
    "collection_name"
)
```

Rest of the operations are same as SlashMongo

lets see how we can use mongodb database with slash commands

Use MongoDB with custom commands bot

If you want to control how often commands can be executed in Custom Commands bot. You need to use cooldowns.
To add cooldown to a command you need to **cooldowns** in it. To add cooldowns
to slash command you need to use the `cooldown` programmed variabe

## Code

Use these codes in Hooks (pre)

```py
cooldown("1 minutes", user.id)
```

Essentially what this code will do is, make the command cooldown for 1 minutes after last execution,
so the user can't use it for next 1 minutes.

in place of `user.id` if you put `server.id` it will put this cooldown globally. Which means the cooldown is now global.
And if anyone of the server use it. It will be unavailable for other users too for next 1 minute.


Add cooldown on custom commands

If you have created a slash command now you want to make it restricted to specific channel, role or permission.
You can do that using the built in permission management provided by custom slash commands bot

To manage permission of a command, first go to commands page and edit the command you want to manage permission.
Then in the command you will be able to see `Hooks`. Hooks are made for a lot of cool stuff, but we can manage permission from here

> All the codes specified below will be used in pre hook

## Specicic permission

You can require one or more permissions to be needed to run a command, For that you have to use the `require_permission` Programmed variable

```py
require_permission("administrator")
```

In the code above we have required the `administrator` permission to must have in order to run the command you are editing.
You can also require multiple permissions

```py
require_permission("kick_members", "ban_members")
```

And all the possible permissions that are available `create_instant_invite`, `kick_members`, `ban_members`, `administrator`, `manage_channels`, `manage_server`, `add_reactions`, `view_audit_log`, `priority_speaker`, `stream`, `read_messages`, `send_messages`, `send_tts_messages`, `manage_messages`, `embed_links`, `attach_files`, `read_message_history`, `mention_roles`, `use_external_emoji`, `use_external_stickers`, `view_server_insights`, `connect`, `speak`, `mute_members`, `deafen_members`, `move_members`, `use_voice_activity`, `manage_nicknames`, `manage_roles`, `manage_webhooks`, `manage_emojis`, `use_application_commands`, `request_to_speak`, `manage_events`, `manage_threads`, `create_public_threads`, `create_private_threads`, `send_messages_in_threads`, `moderate_members`

## Specific channel

To lock a command on a specific channel you can use the `allowed_channels` or `banned_channels`. Allowed channel will allow a command on a specific channel. And banned channel will ban a command on a specific channel and allow on other channels

Example:

```py
allowed_channels(channel_id, channel_id2)
banned_channels(channel_id, channel_id2)
```

Use whatever suits your command's use case. You can put as many channel id you want to allow or ban.

## Spefific Role

You can use the `allowed_roles` or `banned_roles` in the same way as channels, just put the role ids.

> you can find role id and channel id on the sidebar if you are using desktop and on the bottom if you are using phone


Learn how to manage permissions of a command

Manage permissions of custom commands

To send welcome message to a user using custom commands bot, we have to create and Event Handler.
Go to dashboard and click Events, Then click `Create` button 

Then give the event any name and select `MEMBER_JOIN` on Trigger

Then write this code in Pre
```py
send_dm(user, f"Welcome to {server.name}")
```

If you also want to give a role on memebr join, Additionally use this code

```py
send_dm(user, f"Welcome to {server.name}")
add_roles(user, role_id)
# Put the role id you want to give
```
Custom commsnds bot makes it super simple or non-coder users to be able to define their own logic into their commands

How to send welcome message to a user when he joins server

Blog