ruwebframe 0.1.8

 
use crate::rubase::rutils::file_utils;
use crate::rubase::{BaseEntity, BaseEntitySingle, ruenc};
use crate::rudi::difactroy;
use crate::{rucfg, rulog};
use serde::{Deserialize, Serialize};
use crate::rubase::rudto::filedto::FileDto;

const HELP: &str = r#"rucmd - ruwebframe 命令行工具

用法:
  rucmd <command> [args]

可用命令:
  enc  <text>       加密文本
  dec  <text>       解密文本
  cfg               查看当前配置(JSON格式)
  rudi list         列出所有结构体
  rudi all          为所有结构体生成DI注入代码
  rudi <name>       为指定结构体生成DI注入代码
  rudi force <name> 为指定结构体生成DI注入代码(强制)
  rudi suite <name> 为指定结构体生成测试套
  rudi suites       为所有结构体生成测试套

  help              显示帮助信息
  version           显示版本信息
  i|inst            安装依赖
  i|inst cmd        安装命令
  i|inst data       安装数据
  i|inst config     安装配置
  i|inst web        安装web服务
  i|inst all        安装所有依赖
"#;

#[derive(Debug, Default, Serialize, Clone, Deserialize)]
pub struct RuCmd {}

impl BaseEntitySingle for RuCmd {}

impl RuCmd {
    pub fn new(&self) -> Self {
        Self {
            ..Default::default()
        }
    }

    pub fn help(&self) {
        println!("{}", HELP);
    }
    pub fn version(&self) {
        rulog::info("rucmd version 0.1.3");
    }
    pub fn dec(&self, args: &Vec<String>) {
        let result = ruenc::find_bean_ru_enc().unwrap().dec(&args[2]);
        println!("{}", result);
    }
    pub fn enc(&self, args: &Vec<String>) {
        let result = ruenc::find_bean_ru_enc().unwrap().enc(&args[2]);
        println!("{}", result);
        return;
    }
    pub fn rudi(&self, args: &Vec<String>) {
        rulog::info("rucmd rudi...");
        let difactry = difactroy::find_bean_di_factroy().unwrap();
        if args.len() == 2 || args[2] == "list" {
            difactry.lock().unwrap().list_di();
            return;
        } else if args.len() >= 3 {
            if args[2] == "all" {
                difactry.lock().unwrap().make_di();
                return;
            }
            if args[2] == "force" {
                difactry.lock().unwrap().make_di_force_one(&args[3]);
                return;
            }
            if args[2] == "suite" {
                difactry.lock().unwrap().make_suite(&args[3]);
                return;
            }
            if args[2] == "suites" {
                difactry.lock().unwrap().make_suites();
                return;
            }
            if true {
                difactry.lock().unwrap().make_di_one(&args[2]);
                return;
            }
        }
    }
    pub fn inst(&self, args: &Vec<String>) {
        println!("inst {}", args[1]);
    }

    pub fn list_config(&self, args: &Vec<String>) {
        let cfg = rucfg::find_bean_ru_config()
            .unwrap()
            .lock()
            .unwrap()
            .read_clone()
            .to_json();
        if args.len() == 3 && args[2] == "env" {
            println!(
                "{}",
                rucfg::find_bean_ru_config()
                    .unwrap()
                    .lock()
                    .unwrap()
                    .read_clone()
                    .software
                    .to_json()
                    .unwrap()
            );
            return;
        }
        if args.len() == 3 && args[2] == "db" {
            println!(
                "{}",
                rucfg::find_bean_ru_config()
                    .unwrap()
                    .lock()
                    .unwrap()
                    .read_clone()
                    .datasource
                    .to_json()
                    .unwrap()
            );
            return;
        }
        if args.len() == 3 && args[2] == "redis" {
            println!(
                "{}",
                rucfg::find_bean_ru_config()
                    .unwrap()
                    .lock()
                    .unwrap()
                    .read_clone()
                    .redis
                    .to_json()
                    .unwrap()
            );
            return;
        }
        if args.len() == 3 && args[2] == "web" {
            println!(
                "{}",
                rucfg::find_bean_ru_config()
                    .unwrap()
                    .lock()
                    .unwrap()
                    .read_clone()
                    .web
                    .to_json()
                    .unwrap()
            );
            return;
        } else {
            rulog::info2("cmd ruconfig:", cfg.unwrap().as_str());
        }
    }

    //register command

    pub fn execute(&self, args: &Vec<String>) {
        if args.len() >= 2 {
            match args[1].as_str() {
                "enc" => {
                    self.enc(&args);
                    return;
                }
                "dec" => {
                    self.dec(&args);
                    return;
                }
                "cfg" => {
                    self.list_config(&args);
                    return;
                }
                "rudi" => {
                    self.rudi(&args);
                    return;
                }
                "version" | "v" => {
                    self.version();
                    return;
                }
                "h" | "help" => {
                    self.help();
                    return;
                }
                "i" | "inst" => {
                    self.inst(&args);
                    return;
                }
                "list" => {
                    self.list_log(args);
                    return;
                }
                _ => {}
            }
        }

        self.help();
    }
    fn list_log(&self, args: &Vec<String>) {
        let mut dto = FileDto::new();
        if args.len() >= 2 {
            dto.set_dir(args[2].as_str().to_string());
        }
        let files = file_utils::list_files(&dto);
        for file in files {
            rulog::info2("log files:", file.as_str());
        }
    }
}