chore: nix friendly api

Author: orzklv

Cargo.toml

@@ -2,6 +2,9 @@
 name = "bot"
 version = "0.1.0"
 edition = "2021"
+license = "Apache-2.0"
+homepage = "https://github.com/rust-lang-uz/telegram"
+repository = "https://github.com/rust-lang-uz/telegram"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

default.nix

@@ -42,9 +42,9 @@ in
     RUST_SRC_PATH = "${pkgs.rust.packages.stable.rustPlatform.rustLibSrc}";
 
     meta = with lib; {
-      homepage = manifest.workspace.package.homepage;
+      homepage = manifest.homepage;
       description = "Telegram bot manager for Uzbek Rust community";
-      license = with lib.licenses; [gpl3Only];
+      license = with lib.licenses; [asl20];
 
       platforms = with platforms; linux ++ darwin;
 

result

@@ -0,0 +1 @@
+/nix/store/58np2nh1iiap7j5j5d9cj3qj15qm10r4-bot-0.1.0

src/bot.rs

@@ -0,0 +1,77 @@
+use crate::functions;
+use teloxide::{
+    dispatching::{UpdateFilterExt, UpdateHandler},
+    prelude::*,
+    utils::command::BotCommands,
+};
+
+#[derive(BotCommands, Clone, Debug)]
+#[command(rename_rule = "lowercase", parse_with = "split")]
+#[command(description = "These are the commands that I can understand:")]
+pub enum Command {
+    /// List existing commands
+    Help,
+
+    /// Starting point of the bot
+    Start,
+
+    /// Rules of our chat
+    Rules,
+
+    /// About the bot
+    About,
+
+    /// Available groups
+    Group,
+
+    /// Latest version
+    Latest,
+
+    /// Specific version
+    Version,
+
+    /// Report offtopic
+    Off,
+
+    /// Useful resources
+    Useful,
+
+    /// Roadmap for newbies,
+    Roadmap,
+
+    /// Check for chatid
+    Check,
+}
+
+pub fn handler() -> UpdateHandler<Box<dyn std::error::Error + Send + Sync + 'static>> {
+    dptree::entry()
+        // Inline Queries
+        .branch(Update::filter_inline_query().endpoint(functions::inline))
+        // Callbacks
+        .branch(Update::filter_callback_query().endpoint(functions::callback))
+        // Commands
+        .branch(
+            Update::filter_message()
+                .filter_command::<Command>()
+                .endpoint(functions::commands),
+        )
+        .branch(Update::filter_message().endpoint(functions::triggers))
+}
+
+pub fn dispatch(
+    bot: &Bot,
+    deps: DependencyMap,
+) -> Dispatcher<Bot, Box<dyn std::error::Error + Send + Sync>, teloxide::dispatching::DefaultKey> {
+    Dispatcher::builder(bot.clone(), handler())
+        .dependencies(deps) // dptree::deps![...]
+        // If no handler succeeded to handle an update, this closure will be called
+        .default_handler(|upd| async move {
+            log::warn!("Unhandled update: {:?}", upd);
+        })
+        // If the dispatcher fails for some reason, execute this handler
+        .error_handler(LoggingErrorHandler::with_custom_text(
+            "An error has occurred in the dispatcher",
+        ))
+        .enable_ctrlc_handler()
+        .build()
+}

src/config.rs

@@ -0,0 +1,86 @@
+use std::fmt::{Display, Formatter};
+use std::path::PathBuf;
+use Field::{Domain, GitHub, Token};
+
+pub enum ConfigError {
+    NonExistent(String),
+    ReadError(std::io::Error),
+}
+
+impl Display for ConfigError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ConfigError::ReadError(e) => write!(f, "Error while reading config: {}", e),
+            ConfigError::NonExistent(e) => write!(f, "File is probably non existent: {}", e),
+        }
+    }
+}
+
+pub enum Field {
+    Token,
+    Domain,
+    GitHub,
+}
+
+#[derive(Default, Debug)]
+pub struct Config {
+    pub token: String,
+    pub domain: String,
+    pub github: String,
+}
+
+impl Config {
+    pub fn new(token: String, domain: String, github: String) -> Self {
+        Self {
+            token,
+            domain,
+            github,
+        }
+    }
+
+    pub fn set(&mut self, data: String, field: Field) -> Result<(), ConfigError> {
+        match field {
+            Token => self.token = data,
+            Domain => self.domain = data,
+            GitHub => self.github = data,
+        };
+
+        Ok(())
+    }
+
+    pub fn read(&mut self, path: PathBuf, field: Field) -> Result<(), ConfigError> {
+        let data = match self.parse_file(path) {
+            Ok(d) => d,
+            Err(e) => return Err(e),
+        };
+
+        match field {
+            Token => self.token = data,
+            Domain => self.domain = data,
+            GitHub => self.github = data,
+        };
+
+        Ok(())
+    }
+
+    fn parse_file(&self, path: PathBuf) -> Result<String, ConfigError> {
+        if !(path.is_absolute()) {
+            return Err(ConfigError::NonExistent(
+                "Given path is not absolute".to_string(),
+            ));
+        }
+
+        if !(path.is_file()) {
+            return Err(ConfigError::NonExistent(
+                "This file probably doesn't exist".to_string(),
+            ));
+        }
+
+        let result = match std::fs::read_to_string(path) {
+            Ok(d) => d,
+            Err(e) => return Err(ConfigError::ReadError(e)),
+        };
+
+        Ok(result)
+    }
+}

src/functions/groups.rs

@@ -24,7 +24,7 @@ pub async fn command(bot: &Bot, msg: &Message, groups: &Groups) -> ResponseResul
 pub async fn callback_list(
     bot: &Bot,
     q: &CallbackQuery,
-    args: &Vec<&str>,
+    args: &[&str],
     groups: &Groups,
 ) -> ResponseResult<()> {
     if !args.is_empty() {
@@ -43,7 +43,7 @@ pub async fn callback_list(
     Ok(())
 }
 
-pub async fn callback_detail(bot: &Bot, q: &CallbackQuery, args: &Vec<&str>) -> ResponseResult<()> {
+pub async fn callback_detail(bot: &Bot, q: &CallbackQuery, args: &[&str]) -> ResponseResult<()> {
     let groups: Groups = Groups::new();
     let find = groups.find_group(args[1..].join("_").to_string());
 

src/functions/help.rs

@@ -1,5 +1,5 @@
 use super::start::keyboard;
-use crate::{utils::message::Rustina, Command};
+use crate::{bot::Command, utils::message::Rustina};
 use teloxide::{payloads::SendMessageSetters, prelude::*, types::ParseMode};
 
 static TEXT: &[(&str, &str)] = &[

src/functions/mod.rs

@@ -14,8 +14,8 @@ pub mod version;
 
 pub use inline::inline;
 
+use crate::bot::Command;
 use crate::utils::{github::GitHub, groups::Groups, resources::Resources};
-use crate::Command;
 use std::error::Error;
 use teloxide::{prelude::*, types::*};
 

src/functions/useful.rs

@@ -73,7 +73,7 @@ pub async fn callback_category_list(
 pub async fn callback_material_detail(
     bot: &Bot,
     q: &CallbackQuery,
-    args: &Vec<&str>,
+    args: &[&str],
     resources: &Resources,
 ) -> ResponseResult<()> {
     let find = resources
@@ -96,7 +96,7 @@ pub async fn callback_material_detail(
 }
 
 pub fn view_category_list(category: &str) -> String {
-    format!("<b>Siz hozirda {}{} kategoriyasi ichida turibsiz.</b>\nIltimos, keltirilgan materiallardan birini tanlang...", 
+    format!("<b>Siz hozirda {}{} kategoriyasi ichida turibsiz.</b>\nIltimos, keltirilgan materiallardan birini tanlang...",
         &category[0..1].to_uppercase(), &category[1..].replace('_', " "))
 }
 

src/functions/version.rs

@@ -23,7 +23,7 @@ pub async fn command(bot: &Bot, github: GitHub, msg: &Message) -> ResponseResult
 pub async fn callback_list(
     bot: &Bot,
     q: &CallbackQuery,
-    args: &Vec<&str>,
+    args: &[&str],
     github: GitHub,
 ) -> ResponseResult<()> {
     let page = args[0].parse::<u32>().unwrap();
@@ -48,7 +48,7 @@ pub async fn callback_list(
 pub async fn callback_detail(
     bot: &Bot,
     q: &CallbackQuery,
-    args: &Vec<&str>,
+    args: &[&str],
     github: GitHub,
 ) -> ResponseResult<()> {
     let page = args[0].parse::<u32>().unwrap();