feat(discord): Added /avatar command

- Added formattable error strings
feat!: Added limit field to quests
2025-12-31 23:31:41 +03:00 · 2025-12-30 15:44:23 +03:00 · 2025-12-24 17:46:22 +03:00 · 2025-12-24 14:35:15 +03:00 · 2025-12-21 11:08:08 +03:00
20 changed files with 480 additions and 88 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -2140,7 +2140,7 @@ checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"

 [[package]]
 name = "squad-quest"
-version = "0.11.0"
+version = "0.12.0"
 dependencies = [
 "serde",
 "toml 0.9.10+spec-1.1.0",
@ -2148,7 +2148,7 @@ dependencies = [

 [[package]]
 name = "squad-quest-cli"
-version = "0.11.0"
+version = "0.12.0"
 dependencies = [
 "chrono",
 "clap",
@ -2159,7 +2159,7 @@ dependencies = [

 [[package]]
 name = "squad-quest-discord"
-version = "0.11.0"
+version = "0.12.0"
 dependencies = [
 "chrono",
 "clap",
--- a/Cargo.toml
+++ b/Cargo.toml
@ -2,7 +2,7 @@
 members = ["cli", "discord"]

 [workspace.package]
-version = "0.11.0"
+version = "0.12.0"
 edition = "2024"
 repository = "https://2ndbeam.ru/git/2ndbeam/squad-quest"
 homepage = "https://2ndbeam.ru/git/2ndbeam/squad-quest"
--- a/cli/Cargo.toml
+++ b/cli/Cargo.toml
@ -9,5 +9,5 @@ license.workspace = true
 chrono = "0.4.42"
 clap = { version = "4.5.53", features = ["derive"] }
 serde = { version = "1.0.228", features = ["derive"] }
-squad-quest = { version = "0.11.0", path = ".." }
+squad-quest = { version = "0.12.0", path = ".." }
 toml = "0.9.8"
--- a/cli/src/cli/quest.rs
+++ b/cli/src/cli/quest.rs
@ -83,6 +83,9 @@ pub struct QuestCreateArgs {
    /// Quest expiration date (format = YYYY-MM-DD, ex. 2025-12-24)
    #[arg(short,long,value_parser = parse_date)]
    pub deadline: Option<Date>,
+    /// Limit on how many users can solve the quest (0 = no limit)
+    #[arg(short,long)]
+    pub limit: Option<u8>,
 }

 #[derive(Args)]
@ -113,6 +116,9 @@ pub struct QuestUpdateArgs {
    /// Quest expiration date (format = YYYY-MM-DD, ex. 2025-12-24)
    #[arg(long,value_parser = parse_date)]
    pub deadline: Option<Date>,
+    /// Limit on how many users can solve the quest (0 = no limit)
+    #[arg(long)]
+    pub limit: Option<u8>,
 }

 #[derive(Args)]
--- a/cli/src/main.rs
+++ b/cli/src/main.rs
@ -148,6 +148,7 @@ fn main() {
                        public: args.public,
                        available_on: args.available.clone(),
                        deadline: args.deadline.clone(),
+                        limit: args.limit.unwrap_or_default(),
                        ..Default::default()
                    };

@ -171,6 +172,7 @@ fn main() {
                        public: args.public.unwrap_or(quest.public),
                        available_on: args.available.clone().or(quest.available_on.clone()),
                        deadline: args.deadline.clone().or(quest.deadline.clone()),
+                        limit: args.limit.unwrap_or_default(),
                        ..Default::default()
                    };
                    
@ -284,10 +286,6 @@ fn main() {
                    do_and_log(account.save(path), !cli.quiet, format!("Updated balance of account \"{}\".", account.id));
                },
                AccountCommands::Complete(args) => {
-                    let Some(account) = accounts.iter_mut().find(|a| a.id == args.account) else {
-                        if !cli.quiet { eprintln!("Error: account \"{}\" not found.", args.account); }
-                        return;
-                    };

                    let quests = config.load_quests();
                    
@ -299,9 +297,17 @@ fn main() {
                        },
                    };

-                    match quest.complete_for_account(account) {
+                    let result = quest.complete_for_account(&args.account, &mut accounts);
+
+                    match result {
                        Err(error) if !cli.quiet => println!("Error: {error}"),
-                        Ok(_) => do_and_log(account.save(path), !cli.quiet, format!("Completed quest #{} on account \"{}\".", args.quest, account.id)),
+                        Ok(_) => {
+                                let Some(account) = accounts.iter_mut().find(|a| a.id == args.account) else {
+                                if !cli.quiet { eprintln!("Error: account \"{}\" not found.", args.account); }
+                                return;
+                            };
+                            do_and_log(account.save(path), !cli.quiet, format!("Completed quest #{} on account \"{}\".", args.quest, account.id));
+                        },
                        _ => {},
                    }
                },
--- a/discord/Cargo.toml
+++ b/discord/Cargo.toml
@ -13,6 +13,6 @@ poise = "0.6.1"
 rocket = { version = "0.5.1", features = ["json"] }
 serde = "1.0.228"
 serde_json = "1.0.146"
-squad-quest = { version = "0.11.0", path = ".." }
+squad-quest = { version = "0.12.0", path = ".." }
 tokio = { version = "1.48.0", features = ["rt-multi-thread"] }
 toml = "0.9.8"
--- a/discord/src/account.rs
+++ b/discord/src/account.rs
@ -3,8 +3,14 @@ use std::collections::HashMap;
 use poise::serenity_prelude::{User, UserId};
 use squad_quest::{account::Account, config::Config, map::Map};

-pub fn fetch_or_init_account(conf: &Config, id: String, user: Option<&User>) -> Account {
+/// Returns Ok(account) if account was found or Err(new_account) if not
+pub fn fetch_or_init_account(conf: &Config, id: &str, user: Option<&User>) -> Result<Account, Account> {
    let accounts = conf.load_accounts();
+    
+    if let Some(account) = accounts.iter().find(|a| a.id == id) {
+        return Ok(account.clone());
+    }
+
    let mut data: HashMap<String, String> = HashMap::new();

    if let Some(user) = user {
@ -14,14 +20,13 @@ pub fn fetch_or_init_account(conf: &Config, id: String, user: Option<&User>) ->
        data.insert("name".to_string(), name);
    }

-    match accounts.iter().find(|a| a.id == id) {
-        Some(a) => a.clone(),
-        None => Account {
-            id,
-            data: Some(data),
-            ..Default::default()
-        },
-    }
+    let new_account = Account {
+        id: id.to_string(),
+        data: Some(data),
+        ..Default::default()
+    };
+
+    Err(new_account)
 }

 pub fn account_rooms_value(account: &Account, map: &Map) -> u32 {
--- a/discord/src/commands/account.rs
+++ b/discord/src/commands/account.rs
@ -1,7 +1,7 @@
 use poise::serenity_prelude::User;
 use squad_quest::{SquadObject, account::Account, map::Map};

-use crate::{Context, Error, account::{account_full_balance, account_user_id, fetch_or_init_account}, strings::StringFormatter};
+use crate::{Context, Error, account::{account_full_balance, account_user_id}, strings::StringFormatter, commands::guild};

 async fn account_balance_string(
    ctx: &Context<'_>,
@ -26,6 +26,7 @@ async fn account_balance_string(
    prefix_command,
    slash_command,
    guild_only,
+    check = "guild",
    required_permissions = "ADMINISTRATOR",
    name_localized("ru", "сбросить"),
    description_localized("ru", "Сбросить аккаунт пользователя, вкл. баланс, открытые комнаты и пройденные квесты"),
@ -63,6 +64,7 @@ pub async fn reset(
    prefix_command,
    slash_command,
    guild_only,
+    check = "guild",
    name_localized("ru", "счет"),
    description_localized("ru", "Отобразить таблицу лидеров"),
 )]
@ -106,6 +108,7 @@ pub async fn scoreboard(
    prefix_command,
    slash_command,
    guild_only,
+    check = "guild",
    subcommands("give", "set"),
    name_localized("ru", "баланс"),
 )]
@ -120,6 +123,7 @@ pub async fn balance(
    prefix_command,
    slash_command,
    guild_only,
+    check = "guild",
    name_localized("ru", "передать"),
    description_localized("ru", "Передать очки другому пользователю"),
 )]
@ -142,31 +146,41 @@ pub async fn give(
    let mut accounts = config.load_accounts();

    let user_id = format!("{}", ctx.author().id.get());
-
-    let mut user_account = fetch_or_init_account(config, user_id, Some(ctx.author()));
-
+    let strings = &ctx.data().strings;
+    let formatter: StringFormatter;
+    let accounts_path = config.full_accounts_path();
+ 
    let who_id = format!("{}", who.id.get());
-    let Some(other_account) = accounts.iter_mut().find(|a| a.id == who_id ) else {
-        return Err(Error::AccountNotFound);
-    };
    
-    if user_account.balance < amount {
-        return Err(Error::InsufficientFunds(amount));
+    if let None = accounts.iter().find(|a| a.id == who_id ) {
+        return Err(Error::AccountNotFound);
    }

-    user_account.balance -= amount;
+    {
+        let Some(user_account) = accounts.iter_mut().find(|a| a.id == user_id) else {
+            return Err(Error::AccountNotFound);
+        };
+
+        if user_account.balance < amount {
+            return Err(Error::InsufficientFunds(amount));
+        }
+
+        user_account.balance -= amount;
+        user_account.save(accounts_path.clone())?;
+        
+        formatter = strings.formatter()
+            .value(amount)
+            .user(&who)
+            .current_balance(&user_account);
+    }
+    
+    let other_account = accounts.iter_mut().find(|a| a.id == who_id ).expect("We already checked its existence earlier");
+
    other_account.balance += amount;

-    let accounts_path = config.full_accounts_path();
-    user_account.save(accounts_path.clone())?;
    other_account.save(accounts_path)?;

-    let strings = &ctx.data().strings;
-    let formatter = strings.formatter()
-        .user(&who)
-        .value(amount)
-        .current_balance(&user_account);
-
+    
    let reply_string = formatter.fmt(&strings.account.give_pt);
    ctx.reply(reply_string).await?;

@ -178,6 +192,7 @@ pub async fn give(
    prefix_command,
    slash_command,
    guild_only,
+    check = "guild",
    required_permissions = "ADMINISTRATOR",
    name_localized("ru", "установить"),
    description_localized("ru", "Устанавливает текущий баланс пользователя"),
--- a/discord/src/commands/answer.rs
+++ b/discord/src/commands/answer.rs
@ -1,13 +1,14 @@
 use poise::serenity_prelude::{Attachment, ComponentInteractionCollector, CreateActionRow, CreateAttachment, CreateButton, CreateMessage, EditMessage};
 use squad_quest::SquadObject;

-use crate::{Context, Error, account::fetch_or_init_account};
+use crate::{account::fetch_or_init_account, commands::{guild, quest::update_quest_message}, Context, Error};

 /// Send an answer to the quest for review
 #[poise::command(
    prefix_command,
    slash_command,
    guild_only,
+    check = "guild",
    name_localized("ru", "ответить"),
    description_localized("ru", "Отправить ответ на квест на проверку"),
 )]
@ -34,19 +35,34 @@ pub async fn answer(
    #[description_localized("ru", "Вложение к ответу на квест")]
    file3: Option<Attachment>,
 ) -> Result<(), Error> {
-    let mut account = fetch_or_init_account(&ctx.data().config, ctx.author().id.to_string(), Some(ctx.author()));
-
-    if let Some(_) = account.quests_completed.iter().find(|qid| **qid == quest_id) {
-        return Err(Error::QuestIsCompleted(quest_id));
-    }
-
    let quests = ctx.data().config.load_quests();
    let Some(quest) = quests.iter()
        .filter(|q| q.public)
        .find(|q| q.id == quest_id) else {
        return Err(Error::QuestNotFound(quest_id));
    };
+    {
+        let accounts = ctx.data().config.load_accounts();
+        let completed_times = accounts.iter().filter(|a| a.has_completed_quest(&quest)).count() as u8;
+        if quest.limit > 0 && completed_times >= quest.limit {
+            return Err(Error::QuestLimitExceeded(quest.id));
+        }
+    }
 
+    let user_id = ctx.author().id.to_string();
+    match fetch_or_init_account(&ctx.data().config, &user_id, Some(ctx.author())) {
+        Ok(account) => {
+            if let Some(_) = account.quests_completed.iter().find(|qid| **qid == quest_id) {
+                return Err(Error::QuestIsCompleted(quest_id));
+            }
+        },
+        Err(new_account) => {
+            let path = ctx.data().config.full_accounts_path();
+            new_account.save(path)?
+        }
+    }
+
+
    let mut files: Vec<Attachment> = Vec::new();
    for file in [file1, file2, file3] {
        if let Some(f) = file {
@ -134,16 +150,20 @@ pub async fn answer(
        let content: String;
        if is_approved {
            let mut no_errors = true;
-            if let Err(error) = quest.complete_for_account(&mut account) {
+            let mut accounts = ctx.data().config.load_accounts();
+            if let Err(error) = quest.complete_for_account(&ctx.author().id.to_string(), &mut accounts) {
                eprintln!("{error}");
                no_errors = false;
            };
+            let account = accounts.iter_mut().find(|a| a.id == user_id).expect("we done fetch_or_init earlier");
            let path = ctx.data().config.full_accounts_path();
            if let Err(error) = account.save(path) {
                eprintln!("{error}");
                no_errors = false;
            };

+            update_quest_message(ctx, &quest).await?;
+
            formatter = formatter.current_balance(&account);

            if no_errors {
--- a/discord/src/commands/init.rs
+++ b/discord/src/commands/init.rs
@ -4,7 +4,7 @@ use poise::{CreateReply, serenity_prelude::ChannelId};
 use squad_quest::SquadObject;
 use toml::value::Time;

-use crate::{Context, Error, timer::DailyTimer};
+use crate::{Context, Error, timer::DailyTimer, commands::guild};

 /// Set channels to post quests and answers to
 #[poise::command(
@ -12,6 +12,7 @@ use crate::{Context, Error, timer::DailyTimer};
    slash_command,
    required_permissions = "ADMINISTRATOR",
    guild_only,
+    check = "guild",
    name_localized("ru", "инит"),
    description_localized("ru", "Установить каналы для публикации квестов и ответов"),
 )]
@ -75,6 +76,7 @@ fn seconds(time: Time) -> u64 {
    slash_command,
    required_permissions = "ADMINISTRATOR",
    guild_only,
+    check = "guild",
    name_localized("ru", "таймер"),
    description_localized("ru", "Включить таймер публикации по заданной временной метке UTC (МСК -3)"),
 )]
--- a/discord/src/commands/map.rs
+++ b/discord/src/commands/map.rs
@ -1,12 +1,14 @@
+use poise::{serenity_prelude::{Attachment, CreateAttachment, CreateMessage}, CreateReply};
 use squad_quest::{SquadObject, map::Map};

-use crate::{Context, account::fetch_or_init_account, error::Error};
+use crate::{Context, account::fetch_or_init_account, error::Error, commands::guild};

 /// Unlock specified room if it is reachable and you have required amount of points
 #[poise::command(
    prefix_command,
    slash_command,
    guild_only,
+    check = "guild",
    name_localized("ru", "открыть"),
    description_localized("ru", "Открывает указанную комнату, если хватает очков и до нее можно добраться"),
 )]
@ -27,7 +29,10 @@ pub async fn unlock(
    };

    let acc_id = format!("{}", ctx.author().id.get());
-    let mut account = fetch_or_init_account(conf, acc_id, Some(ctx.author()));
+    let mut account = match fetch_or_init_account(conf, &acc_id, Some(ctx.author())) {
+        Ok(account) => account,
+        Err(account) => account,
+    };

    if account.balance < room.value {
        return Err(Error::InsufficientFunds(room.value));
@ -55,6 +60,7 @@ pub async fn unlock(
    prefix_command,
    slash_command,
    guild_only,
+    check = "guild",
    name_localized("ru", "пойти"),
    description_localized("ru", "Переместиться в другую разблокированную комнату"),
 )]
@ -68,7 +74,10 @@ pub async fn r#move(
    let conf = &ctx.data().config;

    let acc_id = format!("{}", ctx.author().id.get());
-    let mut account = fetch_or_init_account(conf, acc_id, Some(ctx.author()));
+    let mut account = match fetch_or_init_account(conf, &acc_id, Some(ctx.author())) {
+        Ok(account) => account,
+        Err(account) => account,
+    };

    if let None = account.rooms_unlocked.iter().find(|rid| **rid == id) {
        return Err(Error::CannotReach(id));
@ -88,3 +97,99 @@ pub async fn r#move(

    Ok(())
 }
+
+/// Change avatar on web map
+#[poise::command(
+    slash_command,
+    prefix_command,
+    guild_only,
+    check = "guild",
+    name_localized("ru", "аватар"),
+    description_localized("ru", "Сменить аватар на веб карте"),
+)]
+pub async fn avatar(
+    ctx: Context<'_>,
+    #[description = "URL to the avatar"]
+    #[name_localized("ru", "ссылка")]
+    #[description_localized("ru", "Ссылка на аватар")]
+    url: Option<String>,
+    #[description = "Attachment to use as avatar"]
+    #[name_localized("ru", "вложение")]
+    #[description_localized("ru", "Вложение, используемое как аватар")]
+    attachment: Option<Attachment>,
+) -> Result<(), Error> {
+    let user_id = ctx.author().id.to_string();
+    let mut accounts = ctx.data().config.load_accounts();
+    let Some(account) = accounts.iter_mut().find(|a| a.id == user_id) else {
+        return Err(Error::AccountNotFound);
+    };
+
+    if url.is_none() && attachment.is_none() {
+        return Err(Error::NoUrlOrAttachment);
+    }
+
+    if url.is_some() && attachment.is_some() {
+        return Err(Error::BothUrlAndAttachment);
+    }
+
+    let strings = &ctx.data().strings;
+    let formatter = strings.formatter();
+
+    if let Some(url) = url {
+        let attachment = CreateAttachment::url(ctx, &url).await?;
+        let reply_string = formatter.fmt(&strings.map.processing_url);
+        let builder = CreateMessage::new()
+            .content(reply_string)
+            .add_file(attachment.clone());
+        let message = ctx.channel_id().send_message(ctx, builder).await?;
+
+        let attachment_check = message.attachments.first().expect("we just sent it");
+        if attachment_check.width.is_none()
+            || !attachment_check.content_type
+                .as_ref()
+                .is_some_and(|t| t.starts_with("image/")) {
+            message.delete(ctx).await?;
+            return Err(Error::NonImageAttachment);
+        }
+        let data = account.data.as_mut().expect("automatically created");
+        data.insert("avatar".to_string(), url);
+        
+        message.delete(ctx).await?;
+
+        let reply_string = formatter.fmt(&strings.map.updated_avatar);
+        let builder = CreateReply::default()
+            .content(reply_string)
+            .attachment(attachment)
+            .reply(true);
+        ctx.send(builder).await?;
+
+    } else if let Some(attachment) = attachment {
+        if attachment.width.is_none()
+            || !attachment.content_type
+                .as_ref()
+                .is_some_and(|t| t.starts_with("image/")) {
+            return Err(Error::NonImageAttachment);
+        }
+
+        let reply_string = formatter.fmt(&strings.map.updated_avatar);
+        let copied_attachment = CreateAttachment::url(ctx, &attachment.url).await?;
+
+        let data = account.data.as_mut().expect("automatically created");
+        data.insert("avatar".to_string(), attachment.url);
+
+        let path = ctx.data().config.full_accounts_path();
+        account.save(path)?;
+
+        let builder = CreateReply::default()
+            .content(reply_string)
+            .attachment(copied_attachment)
+            .reply(true);
+
+        ctx.send(builder).await?;
+    }
+    
+    let path = ctx.data().config.full_accounts_path();
+    account.save(path)?;
+
+    Ok(())
+}
--- a/discord/src/commands/mod.rs
+++ b/discord/src/commands/mod.rs
@ -1,7 +1,8 @@
 use std::error::Error as StdError;
-use poise::CreateReply;
+use poise::{CreateReply, serenity_prelude::GuildId};
+use squad_quest::quest::Quest;

-use crate::{Context, Data, Error};
+use crate::{error, Context, Data, Error};

 pub mod quest;
 pub mod init;
@ -10,6 +11,18 @@ pub mod social;
 pub mod account;
 pub mod map;

+pub async fn guild(ctx: Context<'_>) -> Result<bool, Error> {
+    let id = ctx.guild_id().expect("guild-only command");
+    let guard = ctx.data().discord.lock().expect("shouldn't be locked");
+    let expected_id = guard.guild;
+    
+    if expected_id != GuildId::default() && id != expected_id {
+        return Err(Error::NotThisGuild);
+    }
+
+    Ok(true)
+}
+
 #[poise::command(prefix_command)]
 pub async fn register(ctx: Context<'_>) -> Result<(), Error> {
    poise::builtins::register_application_commands_buttons(ctx).await?;
@ -36,10 +49,45 @@ pub async fn error_handler(error: poise::FrameworkError<'_, Data, Error>) {
    eprintln!("ERROR:");
    print_error_recursively(&error);
    if let Some(ctx) = error.ctx() {
-        let response = match error {
-            poise::FrameworkError::Command { error, .. } => format!("Internal server error: {error}"),
-            _ => format!("Internal server error: {error}"),
+        let user = ctx.author().display_name();
+        
+        eprintln!("User: {user} ({id})", id = ctx.author().id);
+        eprintln!("Invokation string: {}", ctx.invocation_string());
+        
+        let strings = &ctx.data().strings;
+
+        let response = if let poise::FrameworkError::Command { error, .. } = error {
+            let formatter = match error {
+                error::Error::QuestNotFound(id) |
+                error::Error::QuestIsPublic(id) |
+                error::Error::QuestIsCompleted(id) |
+                error::Error::QuestLimitExceeded(id) => 
+                    strings.formatter().quest(&Quest { id, ..Default::default() }),
+                
+                error::Error::InsufficientFunds(amount) =>
+                    strings.formatter().value(amount),
+
+                error::Error::RoomNotFound(value) |
+                error::Error::RoomAlreadyUnlocked(value) |
+                error::Error::CannotReach(value) =>
+                    strings.formatter().value(value),
+
+                error::Error::SerenityError(ref error) =>
+                    strings.formatter().text(error),
+
+                error::Error::SquadQuestError(ref error) =>
+                    strings.formatter().text(error),
+
+                _ => strings.formatter(),
+            };
+
+            let error_string = error.formattable_string(&strings.error);
+            formatter.fmt(error_string)
+        } else {
+            let formatter = strings.formatter().text(&error);
+            formatter.fmt(&strings.error.non_command_error)
        };
+        
        if let Err(error) = ctx.send(CreateReply::default().content(response).ephemeral(true)).await {
            eprintln!("Couldn't send error message: {error}");
        }
--- a/discord/src/commands/quest.rs
+++ b/discord/src/commands/quest.rs
@ -1,9 +1,10 @@
 use std::{future, str::FromStr};

-use poise::serenity_prelude::{CreateMessage, EditMessage, Message, futures::StreamExt};
-use squad_quest::{SquadObject, quest::{Quest, QuestDifficulty}};
+use poise::serenity_prelude as serenity;
+use serenity::{CreateMessage, EditMessage, Message, futures::StreamExt};
+use squad_quest::{account::Account, quest::{Quest, QuestDifficulty}, SquadObject};
 use toml::value::Date;
-use crate::{Context, Error};
+use crate::{Context, Error,commands::guild};

 async fn find_quest_message(ctx: Context<'_>, id: u16) -> Result<Option<Message>, Error>{
    ctx.defer().await?;
@ -24,16 +25,42 @@ async fn find_quest_message(ctx: Context<'_>, id: u16) -> Result<Option<Message>
    Ok(messages.first().cloned())
 }

-fn make_quest_message_content(ctx: Context<'_>, quest: &Quest) -> String {
+fn make_quest_message_content(ctx: Context<'_>, quest: &Quest, accounts: &Option<Vec<Account>>) -> String {
    let strings = &ctx.data().strings;
-    let formatter = strings.formatter().quest(quest);
+    let formatter = match accounts {
+        Some(accounts) => strings.formatter().quest_full(quest, accounts),
+        None => strings.formatter().quest(quest),
+    };
    formatter.fmt(&strings.quest.message_format)
 }

+pub async fn update_quest_message(ctx: Context<'_>, quest: &Quest) -> Result<(), Error> {
+    let strings = &ctx.data().strings;
+    let formatter = strings.formatter().quest(&quest);
+    let accounts = ctx.data().config.load_accounts();
+    let content = make_quest_message_content(ctx, &quest, &Some(accounts));
+    let builder = EditMessage::new().content(content);
+        
+    let message = find_quest_message(ctx, quest.id).await?;
+    if let Some(mut message) = message {
+        return match message.edit(ctx, builder).await {
+            Ok(_) => Ok(()),
+            Err(error) => Err(error.into()),
+        }
+    } else {
+        let reply_string = formatter.fmt(&strings.quest.message_not_found);
+        match ctx.reply(reply_string).await {
+            Ok(_) => Ok(()),
+            Err(error) => Err(error.into()),
+        }
+    }
+}
+
 #[poise::command(
    prefix_command,
    slash_command,
    guild_only,
+    check = "guild",
    subcommands("list", "create", "update", "publish", "delete"),
    required_permissions = "ADMINISTRATOR",
    name_localized("ru", "квест"),
@ -49,6 +76,7 @@ pub async fn quest(
    prefix_command,
    slash_command,
    guild_only,
+    check = "guild",
    required_permissions = "ADMINISTRATOR",
    name_localized("ru", "список"),
    description_localized("ru", "Вывести все квесты")
@ -114,6 +142,7 @@ impl From<DateWrapper> for Date {
    slash_command,
    required_permissions = "ADMINISTRATOR",
    guild_only,
+    check = "guild",
    name_localized("ru", "создать"),
    description_localized("ru", "Создать квест и получить его идентификатор"),
 )]
@ -143,6 +172,10 @@ pub async fn create(
    #[name_localized("ru", "доступен")]
    #[description_localized("ru", "Дата публикации (в формате ГГГГ-ММ-ДД, напр. 2025-12-24)")]
    available: Option<DateWrapper>,
+    #[description = "Limit how many users are allowed to complete the quest"]
+    #[name_localized("ru", "лимит")]
+    #[description_localized("ru", "Ограничение количества участников, которые могут выполнить квест")]
+    limit: Option<u8>,
    /*
    #[description = "Deadline (in format of YYYY-MM-DD, e.g. 2025-12-24)"]
    #[name_localized("ru", "дедлайн")]
@ -179,6 +212,7 @@ pub async fn create(
        answer,
        public: false,
        available_on,
+        limit: limit.unwrap_or_default(),
        //deadline,
        ..Default::default()
    };
@ -202,6 +236,7 @@ pub async fn create(
    slash_command,
    required_permissions = "ADMINISTRATOR",
    guild_only,
+    check = "guild",
    name_localized("ru", "обновить"),
    description_localized("ru", "Обновить выбранные значения указанного квеста"),
 )]
@ -235,6 +270,10 @@ pub async fn update(
    #[name_localized("ru", "доступен")]
    #[description_localized("ru", "Дата публикации (в формате ГГГГ-ММ-ДД, напр. 2025-12-24")]
    available: Option<DateWrapper>,
+    #[description = "Limit how many users are allowed to complete the quest"]
+    #[name_localized("ru", "лимит")]
+    #[description_localized("ru", "Ограничение количества участников, которые могут выполнить квест")]
+    limit: Option<u8>,
    /*
    #[description = "Quest deadline (in format of YYYY-MM-DD, e.g. 2025-12-24)"]
    #[name_localized("ru", "дедлайн")]
@ -260,15 +299,18 @@ pub async fn update(
    };

    let available_on: Option<Date>;
+    let new_limit: u8;
    //let dead_line: Option<Date>;

    match reset.unwrap_or(false) {
        true => {
            available_on = None;
+            new_limit = limit.unwrap_or_default();
            //dead_line = None;
        },
        false => {
            available_on = available.map_or_else(|| quest.available_on.clone(), |v| Some(v.into()));
+            new_limit = limit.unwrap_or(quest.limit);
            //dead_line = deadline.map_or_else(|| quest.deadline.clone(), |v| Some(v.into()));
        },
    }
@ -282,6 +324,7 @@ pub async fn update(
        answer: answer.unwrap_or(quest.answer.clone()),
        public: quest.public,
        available_on,
+        limit: new_limit,
        //deadline: dead_line,
        ..Default::default()
    };
@ -290,16 +333,7 @@ pub async fn update(
    let formatter = strings.formatter().quest(&new_quest);

    if new_quest.public {
-        let content = make_quest_message_content(ctx, &new_quest);
-        let builder = EditMessage::new().content(content);
-        
-        let message = find_quest_message(ctx, id).await?;
-        if let Some(mut message) = message {
-            message.edit(ctx, builder).await?;
-        } else {
-            let reply_string = formatter.fmt(&strings.quest.message_not_found);
-            ctx.reply(reply_string).await?;
-        }
+        update_quest_message(ctx, &new_quest).await?;
    }
    
    let path = conf.full_quests_path();
@ -310,13 +344,14 @@ pub async fn update(
    Ok(())
 }

-pub async fn publish_inner(ctx: Context<'_>, quest: &mut Quest) -> Result<(), Error> {
+pub async fn publish_inner(ctx: Context<'_>, quest: &mut Quest) -> Result<Message, Error> {
    quest.public = true;

    let quests_path = ctx.data().config.full_quests_path();
    quest.save(quests_path)?;
-
-    let content = make_quest_message_content(ctx, &quest);
+    
+    let accounts = ctx.data().config.load_accounts();
+    let content = make_quest_message_content(ctx, &quest, &Some(accounts));

    let builder = CreateMessage::new()
        .content(content);
@ -327,8 +362,10 @@ pub async fn publish_inner(ctx: Context<'_>, quest: &mut Quest) -> Result<(), Er
        guard.quests_channel
    };

-    channel.send_message(ctx, builder).await?;
-    Ok(())
+    match channel.send_message(ctx, builder).await {
+        Ok(m) => Ok(m),
+        Err(error) => Err(Error::SerenityError(error)),
+    }
 }

 /// Mark quest as public and send its message in quests channel
@ -337,6 +374,7 @@ pub async fn publish_inner(ctx: Context<'_>, quest: &mut Quest) -> Result<(), Er
    slash_command,
    required_permissions = "ADMINISTRATOR",
    guild_only,
+    check = "guild",
    name_localized("ru", "опубликовать"),
    description_localized("ru", "Отметить квест как публичный и отправить его сообщение в канал квестов"),
 )]
@ -357,10 +395,12 @@ pub async fn publish(
        return Err(Error::QuestIsPublic(id));
    }

-    publish_inner(ctx, quest).await?;
+    let message = publish_inner(ctx, quest).await?;

    let strings = &ctx.data().strings;
-    let formatter = strings.formatter().quest(&quest);
+    let formatter = strings.formatter()
+        .quest(&quest)
+        .message(&message);

    let reply_string = formatter.fmt(&strings.quest.publish);
    ctx.reply(reply_string).await?;
@ -374,6 +414,7 @@ pub async fn publish(
    slash_command,
    required_permissions = "ADMINISTRATOR",
    guild_only,
+    check = "guild",
    name_localized("ru", "удалить"),
    description_localized("ru", "Удалить квест (и его сообщение, если он был опубликован)"),
 )]
--- a/discord/src/commands/social.rs
+++ b/discord/src/commands/social.rs
@ -1,12 +1,13 @@
 use poise::serenity_prelude::{Attachment, ChannelId, CreateAttachment, CreateMessage, EditMessage, MessageId, UserId};

-use crate::{Context, Error};
+use crate::{Context, Error, commands::guild};

 #[poise::command(
    prefix_command,
    slash_command,
    required_permissions = "ADMINISTRATOR",
    guild_only,
+    check = "guild",
    subcommands("msg", "edit", "undo"),
    name_localized("ru", "сообщение"),
 )]
@ -20,6 +21,7 @@ pub async fn social( _ctx: Context<'_> ) -> Result<(), Error> {
    slash_command,
    required_permissions = "ADMINISTRATOR",
    guild_only,
+    check = "guild",
    name_localized("ru", "написать"),
    description_localized("ru", "Отправить сообщение пользователю или в канал"),
 )]
@ -98,6 +100,7 @@ pub async fn msg (
    slash_command,
    required_permissions = "ADMINISTRATOR",
    guild_only,
+    check = "guild",
    name_localized("ru", "редактировать"),
    description_localized("ru", "Редактировать сообщение в канале или в ЛС"),
 )]
@ -177,6 +180,7 @@ pub async fn edit (
    slash_command,
    required_permissions = "ADMINISTRATOR",
    guild_only,
+    check = "guild",
    name_localized("ru", "удалить"),
    description_localized("ru", "Удалить сообщение в канале или в ЛС"),
 )]
--- a/discord/src/error.rs
+++ b/discord/src/error.rs
@ -3,6 +3,8 @@ use std::fmt::Display;
 use poise::serenity_prelude as serenity;
 use squad_quest::error::MapError;

+use crate::strings::ErrorStrings;
+
 #[non_exhaustive]
 #[derive(Debug)]
 pub enum Error {
@ -21,6 +23,11 @@ pub enum Error {
    RoomAlreadyUnlocked(u16),
    CannotReach(u16),
    TimerSet,
+    NotThisGuild,
+    QuestLimitExceeded(u16),
+    BothUrlAndAttachment,
+    NoUrlOrAttachment,
+    NonImageAttachment,
 }

 impl From<serenity::Error> for Error {
@ -53,9 +60,9 @@ impl Display for Error {
            Self::QuestNotFound(u16) => write!(f, "quest #{u16} not found"),
            Self::QuestIsPublic(u16) => write!(f, "quest #{u16} is already public"),
            Self::QuestIsCompleted(u16) => write!(f, "quest #{u16} is already completed for this user"),
-            Self::NoContent => write!(f, "no text or attachment was specified"),
-            Self::NoChannelOrUser => write!(f, "no channel or user was specified"),
-            Self::BothChannelAndUser => write!(f, "both channel and user was specified"),
+            Self::NoContent => write!(f, "no text or attachment were specified"),
+            Self::NoChannelOrUser => write!(f, "no channel or user were specified"),
+            Self::BothChannelAndUser => write!(f, "both channel and user were specified"),
            Self::SerenityError(_) => write!(f, "discord interaction error"),
            Self::SquadQuestError(_) => write!(f, "internal logic error"),
            Self::AccountNotFound => write!(f, "account not found"),
@ -65,6 +72,11 @@ impl Display for Error {
            Self::RoomAlreadyUnlocked(id) => write!(f, "room #{id} is already unlocked for this user"),
            Self::CannotReach(id) => write!(f, "user cannot reach room #{id}"),
            Self::TimerSet => write!(f, "timer is already set"),
+            Self::NotThisGuild => write!(f, "cannot be used in this guild"),
+            Self::QuestLimitExceeded(id) => write!(f, "exceeded limit for quest #{id}"),
+            Self::BothUrlAndAttachment => write!(f, "both url and attachment were specified"),
+            Self::NoUrlOrAttachment => write!(f, "no url or attachment were specified"),
+            Self::NonImageAttachment => write!(f, "attachment is not an image"),
        }
    }
 }
@ -84,11 +96,41 @@ impl std::error::Error for Error {
            Self::RoomNotFound(_) |
            Self::RoomAlreadyUnlocked(_) |
            Self::CannotReach(_) |
-            Self::TimerSet => None,
+            Self::TimerSet |
+            Self::NotThisGuild |
+            Self::QuestLimitExceeded(_) |
+            Self::BothUrlAndAttachment |
+            Self::NoUrlOrAttachment |
+            Self::NonImageAttachment => None,
            Self::SerenityError(error) => Some(error),
            Self::SquadQuestError(error) => Some(error),
        }
    }
 }

-
+impl<'a> Error {
+    pub fn formattable_string(&self, errors: &'a ErrorStrings) -> &'a str {
+        match self {
+            Self::QuestNotFound(_) => &errors.quest_not_found,
+            Self::QuestIsPublic(_) => &errors.quest_is_public,
+            Self::QuestIsCompleted(_) => &errors.quest_is_completed,
+            Self::NoContent => &errors.no_content,
+            Self::NoChannelOrUser => &errors.no_channel_or_user,
+            Self::BothChannelAndUser => &errors.both_channel_and_user,
+            Self::SerenityError(_) => &errors.discord_error,
+            Self::SquadQuestError(_) => &errors.library_error,
+            Self::AccountNotFound => &errors.account_not_found,
+            Self::AccountIsSelf => &errors.account_is_self,
+            Self::InsufficientFunds(_) => &errors.insufficient_funds,
+            Self::RoomNotFound(_) => &errors.room_not_found,
+            Self::RoomAlreadyUnlocked(_) => &errors.room_already_unlocked,
+            Self::CannotReach(_) => &errors.cannot_reach,
+            Self::TimerSet => &errors.timer_set,
+            Self::NotThisGuild => &errors.not_this_guild,
+            Self::QuestLimitExceeded(_) => &errors.quest_limit_exceeded,
+            Self::BothUrlAndAttachment => &errors.both_url_and_attachment,
+            Self::NoUrlOrAttachment => &errors.no_url_or_attachment,
+            Self::NonImageAttachment => &errors.non_image_attachment,
+        }
+    }
+}
--- a/discord/src/main.rs
+++ b/discord/src/main.rs
@ -92,6 +92,7 @@ async fn main() {
                commands::account::reset(),
                commands::map::unlock(),
                commands::map::r#move(),
+                commands::map::avatar(),
            ],
            ..Default::default()
        })
--- a/discord/src/strings.rs
+++ b/discord/src/strings.rs
@ -45,11 +45,20 @@ impl StringFormatter {
        let name = ("{q.name}".to_string(), quest.name.clone());
        let description = ("{q.description}".to_string(), quest.description.clone());
        let answer = ("{q.answer}".to_string(), quest.answer.clone());
-        let new_tags = vec![ id, difficulty, reward, name, description, answer ];
+        let limit = ("{q.limit}".to_string(), quest.limit.to_string());
+        let new_tags = vec![ id, difficulty, reward, name, description, answer, limit ];
        
        self.with_tags(new_tags)
    }

+    pub fn quest_full(mut self, quest: &Quest, accounts: &Vec<Account>) -> Self {
+        self = self.quest(&quest);
+        let completed_times = accounts.iter().filter(|a| a.has_completed_quest(&quest)).count();
+        let completions = ("{q.completions}".to_string(), completed_times.to_string());
+
+        self.with_tags(vec![completions])
+    }
+
    pub fn user(self, user: &User) -> Self {
        let mention = ("{u.mention}".to_string(), user.mention().to_string());
        let name = ("{u.name}".to_string(), user.display_name().to_string());
@ -133,6 +142,7 @@ pub struct Strings {
    pub scoreboard: Scoreboard,
    pub social: Social,
    pub quest: QuestStrings,
+    pub error: ErrorStrings,
 }

 impl Default for Strings {
@ -151,6 +161,7 @@ impl Default for Strings {
            social: Social::default(),
            account: AccountReplies::default(),
            map: MapReplies::default(),
+            error: ErrorStrings::default(),
        }
    }
 }
@ -328,7 +339,7 @@ impl Default for QuestStrings {
            list_item: "{n}{q.id}: {q.name}{n}    Description: {q.description}".to_string(),
            create: "Created quest {q.id}".to_string(),
            update: "Updated quest {q.id}".to_string(),
-            publish: "Published quest {q.id}: {text}".to_string(),
+            publish: "Published quest {q.id}: {m.link}".to_string(),
            delete: "Deleted quest {q.id}".to_string(),
            message_format: "### `{q.id}` {q.name} (+{q.reward}){n}\
            Difficulty: *{q.difficulty}*{n}\
@ -382,6 +393,8 @@ impl Default for AccountReplies {
 pub struct MapReplies {
    pub room_unlocked: String,
    pub moved_to_room: String,
+    pub updated_avatar: String,
+    pub processing_url: String,
 }

 impl Default for MapReplies {
@ -389,6 +402,62 @@ impl Default for MapReplies {
        Self {
            room_unlocked: "Unlocked room #{value}. Your balance: {b.current}".to_string(),
            moved_to_room: "Moved to room #{value}".to_string(),
+            updated_avatar: "Successfully changed avatar".to_string(),
+            processing_url: "Processing URL...".to_string(),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(default)]
+pub struct ErrorStrings {
+    pub non_command_error: String,
+    pub quest_not_found: String,
+    pub quest_is_public: String,
+    pub quest_is_completed: String,
+    pub no_content: String,
+    pub no_channel_or_user: String,
+    pub both_channel_and_user: String,
+    pub discord_error: String,
+    pub library_error: String,
+    pub account_not_found: String,
+    pub account_is_self: String,
+    pub insufficient_funds: String,
+    pub room_not_found: String,
+    pub room_already_unlocked: String,
+    pub cannot_reach: String,
+    pub timer_set: String,
+    pub not_this_guild: String,
+    pub quest_limit_exceeded: String,
+    pub both_url_and_attachment: String,
+    pub no_url_or_attachment: String,
+    pub non_image_attachment: String,
+}
+
+impl Default for ErrorStrings {
+    fn default() -> Self {
+        Self {
+            non_command_error: "Internal server error: {text}".to_string(),
+            quest_not_found: "Quest {q.id} not found".to_string(),
+            quest_is_public: "Quest {q.id} is already public".to_string(),
+            quest_is_completed: "Quest {q.id} is already completed for this user".to_string(),
+            no_content: "No text or attachment were specified".to_string(),
+            no_channel_or_user: "No channel or user were specified".to_string(),
+            both_channel_and_user: "Both channel and user were specified".to_string(),
+            discord_error: "Discord interaction error: {text}".to_string(),
+            library_error: "Some internal logic error: {text}".to_string(),
+            account_not_found: "Given account was not found".to_string(),
+            account_is_self: "Given account is the same as command invoker".to_string(),
+            insufficient_funds: "You don't have {value} points".to_string(),
+            room_not_found: "Room #{value} not found".to_string(),
+            room_already_unlocked: "Room #{value} is already unlocked for this account".to_string(),
+            cannot_reach: "You cannot reach room #{value}".to_string(),
+            timer_set: "Timer is already set".to_string(),
+            not_this_guild: "Bot cannot be used in this guild".to_string(),
+            quest_limit_exceeded: "Exceeded limit for quest {q.id}".to_string(),
+            both_url_and_attachment: "Both URL and attachment were specified".to_string(),
+            no_url_or_attachment: "No URL or attachment were specified".to_string(),
+            non_image_attachment: "Given attachment is not an image".to_string(),
        }
    }
 }
--- a/src/account/mod.rs
+++ b/src/account/mod.rs
@ -4,7 +4,7 @@ use std::{collections::HashMap, fs, io::Write, path::PathBuf};

 use serde::{ Serialize, Deserialize };

-use crate::{SquadObject, error::Error};
+use crate::{error::Error, quest::Quest, SquadObject};

 fn default_id() -> String {
    "none".to_string()
@ -99,3 +99,10 @@ impl SquadObject for Account {
        Ok(())
    }
 }
+
+impl Account {
+    /// Returns true if given quest is completed on this account
+    pub fn has_completed_quest(&self, quest: &Quest) -> bool {
+        self.quests_completed.contains(&quest.id)
+    }
+}
--- a/src/error.rs
+++ b/src/error.rs
@ -49,12 +49,18 @@ impl std::error::Error for Error {
 pub enum QuestError {
    /// Quest (self.0) is already completed for given account (self.1)
    AlreadyCompleted(u16, String),
+    /// Account (self.0) not found
+    AccountNotFound(String),
+    /// Limit for quest (self.0) exceeded
+    LimitExceeded(u16),
 }

 impl fmt::Display for QuestError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::AlreadyCompleted(quest_id, account_id) => write!(f, "quest #{quest_id} is already completed for account \"{account_id}\""),
+            Self::AccountNotFound(account_id) => write!(f, "account \"{account_id}\""),
+            Self::LimitExceeded(quest_id) => write!(f, "exceeded limit for quest #{quest_id}"),
        }
    }
 }
--- a/src/quest/mod.rs
+++ b/src/quest/mod.rs
@ -70,6 +70,10 @@ pub struct Quest {

    /// Additional implementation-defined data
    pub data: Option<HashMap<String, String>>,
+
+    /// Limit how many users can complete the quest.
+    /// If set to 0, quest is not limited.
+    pub limit: u8,
 }

 impl Default for Quest {
@ -85,6 +89,7 @@ impl Default for Quest {
            available_on: None,
            deadline: None,
            data: None,
+            limit: 0,
        }
    }
 }
@ -159,7 +164,17 @@ impl Quest {
    ///     // handle error
    /// }
    /// ```
-    pub fn complete_for_account(&self, account: &mut Account) -> Result<(),QuestError> {
+    pub fn complete_for_account(&self, id: &str, accounts: &mut Vec<Account>) -> Result<(),QuestError> {
+        let completed_times = accounts.iter().filter(|a| a.has_completed_quest(self)).count();
+
+        if self.limit > 0 && completed_times as u8 >= self.limit {
+            return Err(QuestError::LimitExceeded(self.id));
+        }
+
+        let Some(account) = accounts.iter_mut().find(|a| a.id == id) else {
+            return Err(QuestError::AccountNotFound(id.to_string()));
+        };
+
        match account.quests_completed.iter().find(|qid| **qid == self.id) {
            Some(_) => Err(QuestError::AlreadyCompleted(self.id, account.id.clone())),
            None => {
Author	SHA1	Message	Date
2ndbeam	1db7ce877e	feat(discord): Added /avatar command - Added formattable error strings	2025-12-31 23:31:41 +03:00
2ndbeam	2640821a05	feat!: Added limit field to quests - Bump version to 0.12.0 - lib: Changed Quest::complete_for_account behavior - cli: Added limit field for quest create and quest update - discord: Quests are checked for limit on /answer - discord: Added limit field for /quest create and /quest update - discord: Changed behavior of fetch_or_init_account	2025-12-30 15:44:23 +03:00
2ndbeam	d188bba16e	feat: Implemented guild check - Also added more error logging	2025-12-24 17:46:22 +03:00
2ndbeam	d584340f01	merge: Merged message context and rocket api	2025-12-24 14:35:15 +03:00
2ndbeam	81a9ec0c50	feat: Added message context to strings.quest.publish	2025-12-21 11:08:08 +03:00