zero4rs 2.0.0

zero4rs is a powerful, pragmatic, and extremely fast web framework for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

use crate::prelude2::*;

// use crate::commons::join_folder;
use crate::commons::upload_folder;

use crate::core::youtube::check_by_id;
use crate::core::youtube::download_async;
use crate::core::youtube::download_by_id;
use crate::core::youtube::video_info;

pub async fn check(
    query: web::Query<std::collections::HashMap<String, String>>,
    request: HttpRequest,
) -> impl Responder {
    let video_identifier = query
        .get("video_identifier")
        .ok_or_else(|| Error::invalid_request("Missing post parameter: `video_identifier`"))?;

    let output = check_by_id(video_identifier).await?;

    request.text(200, &output)
}

pub async fn content_length(
    query: web::Query<std::collections::HashMap<String, String>>,
    request: HttpRequest,
) -> impl Responder {
    let video_identifier = query
        .get("video_identifier")
        .ok_or_else(|| Error::invalid_request("Missing post parameter: `video_identifier`"))?;

    let (title, content_length, quality) =
        crate::core::youtube::content_length(video_identifier).await?;

    request.json(
        200,
        R::ok((
            title,
            quality,
            crate::commons::format_bytes_size(content_length as usize),
            content_length,
        )),
    )
}

pub async fn descrambler(
    query: web::Query<std::collections::HashMap<String, String>>,
    request: HttpRequest,
) -> impl Responder {
    let video_identifier = query
        .get("video_identifier")
        .ok_or_else(|| Error::invalid_request("Missing post parameter: `video_identifier`"))?;

    let video_info = video_info(video_identifier).await?;

    request.json(200, R::ok(video_info))
}

pub async fn best_quality(
    query: web::Query<std::collections::HashMap<String, String>>,
    request: HttpRequest,
) -> impl Responder {
    let video_identifier = query
        .get("video_identifier")
        .ok_or_else(|| Error::invalid_request("Missing post parameter: `video_identifier`"))?;

    let stream = crate::core::youtube::best_quality(video_identifier).await?;

    request.json(200, R::ok(stream))
}

pub async fn dl(
    query: web::Query<std::collections::HashMap<String, String>>,
    request: HttpRequest,
) -> impl Responder {
    let video_identifier = query
        .get("video_identifier")
        .ok_or_else(|| Error::invalid_request("Missing post parameter: `video_identifier`"))?;

    let saved_path = download_by_id(video_identifier, &upload_folder()).await?;

    request.json(200, R::ok(saved_path.as_os_str()))
}

// curl -v 'http://127.0.0.1:8000/youtube/dl_async?video_identifier=gnIogrE5nck' --header 'Content-Type: application/x-www-form-urlencoded' --data-urlencode 'download_foler=~/Desktop/android-developer/'
pub async fn dl_async(
    query: web::Query<std::collections::HashMap<String, String>>,
    form: web::Form<std::collections::HashMap<String, String>>,
    request: HttpRequest,
) -> impl Responder {
    let video_identifier = query
        .get("video_identifier")
        .ok_or_else(|| Error::invalid_request("Missing post parameter: `video_identifier`"))?;

    let _prefix = query.get("prefix");

    let _download_foler = form
        .get("download_foler")
        .ok_or_else(|| Error::invalid_request("Missing post parameter: `download_foler`"))?;

    let (title, content_length, quality) = download_async(
        video_identifier,
        // &join_folder(&upload_folder(), _download_foler),
        _download_foler,
        _prefix,
    )
    .await?;

    request.json(
        200,
        R::ok((
            title,
            quality,
            crate::commons::format_bytes_size(content_length as usize),
            content_length,
        )),
    )
}

// pub async fn video_frame(
//     _query: web::Query<std::collections::HashMap<String, String>>,
//     request: HttpRequest,
// ) -> impl Responder {
//     #[cfg(not(target_os = "linux"))]
//     {
//         request.json(200, R::ok("not_linux"))
//     }

//     #[cfg(target_os = "linux")]
//     {
//         // use ffmpeg_next as ffmpeg;

//         // // 初始化ffmpeg
//         // ffmpeg::init().unwrap();

//         // 输入视频文件路径
//         let input_file = "input.mp4";

//         // // 打开视频文件
//         // let mut ictx = ffmpeg::format::input(&Path::new(input_file)).unwrap().into_stream()?;

//         // // 获取视频流
//         // let input = ictx
//         //     .streams()
//         //     .best(ffmpeg::media::Type::Video)
//         //     .ok_or(ffmpeg::Error::StreamNotFound)?;

//         // // 创建视频解码器
//         // let mut decoder = input.codec().decoder().video()?;

//         // // 创建视频解码器上下文
//         // let mut dctx = decoder.context()?;

//         // // 打开解码器
//         // decoder.open_as(dctx)?;

//         // // 创建视频帧
//         // let mut video_frame = ffmpeg::util::frame::Video::empty();

//         // // 读取视频帧
//         // while ictx.read_packet()? {
//         //     // 解码视频帧
//         //     ictx.decode(&mut video_frame)?;

//         //     // 检查帧是否有效
//         //     if video_frame.is_valid() {
//         //         // 保存第一帧作为缩略图
//         //         video_frame
//         //             .as_image_frame()
//         //             .unwrap()
//         //             .image()
//         //             .write_to_png("thumbnail.png")?;
//         //         break;
//         //     }
//         // }

//         request.json(200, R::ok(input_file))
//     }
// }