pub mod models;
pub mod parser;
pub mod reviews;
pub mod schemas;
mod sql;
use self::models::*;
use self::schemas::{problems::dsl::*, tags::dsl::*};
use self::sql::*;
use crate::helper::test_cases_path;
use crate::{config::Config, err::Error, plugins::LeetCode};
use anyhow::anyhow;
use diesel::prelude::*;
use serde::de::DeserializeOwned;
use serde_json::Value;
use std::collections::HashMap;
use std::time::{Duration, Instant};
use wreq::Response;
const VERIFY_POLL_INTERVAL: Duration = Duration::from_millis(500);
const VERIFY_POLL_TIMEOUT: Duration = Duration::from_secs(120);
#[derive(Clone, Copy, Debug, PartialEq)]
enum Block {
RateLimit,
Challenge,
}
impl From<Block> for Error {
fn from(block: Block) -> Self {
match block {
Block::RateLimit => Error::Throttled,
Block::Challenge => Error::CloudflareChallenge,
}
}
}
fn detect_block(http_status: wreq::StatusCode, body: &str) -> Option<Block> {
if http_status == wreq::StatusCode::TOO_MANY_REQUESTS {
return Some(Block::RateLimit);
}
if body.contains("cf_chl_opt") || body.contains("<title>Just a moment...</title>") {
return Some(Block::Challenge);
}
None
}
pub fn conn(p: String) -> Result<SqliteConnection, Error> {
SqliteConnection::establish(&p).map_err(|source| Error::CacheOpen { path: p, source })
}
#[derive(Clone, Debug, Default)]
pub enum Run {
Test,
#[default]
Submit,
}
#[derive(Clone)]
pub struct Cache(pub LeetCode);
impl Cache {
fn conn(&self) -> Result<SqliteConnection, Error> {
conn(self.0.conf.storage.cache()?)
}
pub fn clean(&self) -> Result<(), Error> {
Ok(std::fs::remove_file(self.0.conf.storage.cache()?)?)
}
pub async fn update(self) -> Result<(), Error> {
self.download_problems().await?;
Ok(())
}
pub fn update_after_ac(self, rid: i32) -> Result<(), Error> {
let mut c = conn(self.0.conf.storage.cache()?)?;
let target = problems.filter(id.eq(rid));
diesel::update(target)
.set(status.eq("ac"))
.execute(&mut c)?;
Ok(())
}
async fn get_user_info(&self) -> Result<(String, bool), Error> {
let user = parser::user(self.clone().0.get_user_info().await?.json().await?);
match user {
None => Err(Error::NoneError),
Some(None) => Err(Error::CookieError),
Some(Some((s, b))) => Ok((s, b)),
}
}
async fn is_session_bad(&self) -> bool {
matches!(self.get_user_info().await, Err(Error::CookieError))
}
async fn resp_to_json<T: DeserializeOwned>(&self, resp: Response) -> Result<T, Error> {
let http_status = resp.status();
let text = resp.text().await?;
if let Some(block) = detect_block(http_status, &text) {
return Err(block.into());
}
match serde_json::from_str(&text) {
Ok(json) => Ok(json),
Err(e) => {
if self.is_session_bad().await {
Err(Error::CookieError)
} else {
Err(e.into())
}
}
}
}
pub async fn download_problems(self) -> Result<Vec<Problem>, Error> {
info!("Fetching leetcode problems...");
let mut ps: Vec<Problem> = vec![];
for i in &self.0.conf.sys.categories.to_owned() {
let json = self
.0
.clone()
.get_category_problems(i)
.await?
.json() .await?;
parser::problem(&mut ps, json).ok_or(Error::NoneError)?;
}
diesel::replace_into(problems)
.values(&ps)
.execute(&mut self.conn()?)?;
Ok(ps)
}
pub fn get_problem(&self, rfid: i32) -> Result<Problem, Error> {
let p: Problem = problems.filter(fid.eq(rfid)).first(&mut self.conn()?)?;
if p.category != "algorithms" {
return Err(anyhow!("No support for database and shell questions yet").into());
}
Ok(p)
}
pub fn get_problem_id_from_name(&self, problem_name: &String) -> Result<i32, Error> {
let p: Problem = problems
.filter(name.eq(problem_name))
.first(&mut self.conn()?)?;
if p.category != "algorithms" {
return Err(anyhow!("No support for database and shell questions yet").into());
}
Ok(p.fid)
}
pub async fn get_daily_problem_id(&self) -> Result<i32, Error> {
parser::daily(
self.clone()
.0
.get_question_daily()
.await?
.json() .await?,
)
.ok_or(Error::NoneError)
}
fn problem_fid(&self, internal_id: i32) -> Result<i32, Error> {
Ok(problems
.filter(id.eq(internal_id))
.select(fid)
.first(&mut self.conn()?)?)
}
fn record_submission(&self, res: &VerifyResult) -> Result<(), Error> {
let Some(internal_id) = res.submitted_problem_id()? else {
return Ok(());
};
let rfid = self.problem_fid(internal_id)?;
let today = crate::srs::today();
if res.is_accepted() {
self.grade_review(rfid, crate::srs::Grade::Good, today)?;
} else {
self.grade_enrolled_review(rfid, crate::srs::Grade::Again, today)?;
}
Ok(())
}
pub fn get_problems(&self) -> Result<Vec<Problem>, Error> {
Ok(problems.load::<Problem>(&mut self.conn()?)?)
}
#[allow(clippy::useless_let_if_seq)]
pub async fn get_question(&self, rfid: i32) -> Result<Question, Error> {
let target: Problem = problems.filter(fid.eq(rfid)).first(&mut self.conn()?)?;
if target.category != "algorithms" {
return Err(anyhow!("No support for database and shell questions yet").into());
}
let mut rdesc = Question::default();
if !target.desc.is_empty() {
rdesc = serde_json::from_str(&target.desc)?;
} else {
let json: Value = self
.0
.clone()
.get_question_detail(&target.slug)
.await?
.json()
.await?;
debug!("{:#?}", json);
match parser::desc(&mut rdesc, json) {
None => return Err(Error::NoneError),
Some(false) => {
return if self.is_session_bad().await {
Err(Error::CookieError)
} else {
Err(Error::PremiumError)
};
}
Some(true) => (),
}
let sdesc = serde_json::to_string(&rdesc)?;
diesel::update(&target)
.set(desc.eq(sdesc))
.execute(&mut self.conn()?)?;
}
Ok(rdesc)
}
pub async fn get_tagged_questions(self, rslug: &str) -> Result<Vec<String>, Error> {
trace!("Geting {} questions...", rslug);
let ids: Vec<String>;
let rtag = tags
.filter(tag.eq(rslug.to_string()))
.first::<Tag>(&mut self.conn()?);
if let Ok(t) = rtag {
trace!("Got {} questions from local cache...", rslug);
ids = serde_json::from_str(&t.refs)?;
} else {
ids = parser::tags(
self.clone()
.0
.get_question_ids_by_tag(rslug)
.await?
.json()
.await?,
)
.ok_or(Error::NoneError)?;
let t = Tag {
r#tag: rslug.to_string(),
r#refs: serde_json::to_string(&ids)?,
};
diesel::insert_into(tags)
.values(&t)
.execute(&mut self.conn()?)?;
}
Ok(ids)
}
pub fn get_tags(&self) -> Result<Vec<Tag>, Error> {
Ok(tags.load::<Tag>(&mut self.conn()?)?)
}
async fn pre_run_code(
&self,
run: Run,
rfid: i32,
test_case: Option<String>,
) -> Result<(HashMap<&'static str, String>, [String; 2]), Error> {
trace!("pre-run code...");
use crate::helper::code_path;
use std::fs::File;
use std::io::Read;
let mut p = self.get_problem(rfid)?;
if p.desc.is_empty() {
trace!("Problem description does not exist, pull desc and exec again...");
self.get_question(rfid).await?;
p = self.get_problem(rfid)?;
}
let d: Question = serde_json::from_str(&p.desc)?;
let conf = &self.0.conf;
let mut json: HashMap<&'static str, String> = HashMap::new();
let mut code: String = "".to_string();
let maybe_file_testcases: Option<String> = test_cases_path(&p)
.map(|file_name| {
let mut tests = "".to_string();
File::open(file_name)
.and_then(|mut file_descriptor| file_descriptor.read_to_string(&mut tests))
.map(|_| Some(tests))
.unwrap_or(None)
})
.unwrap_or(None);
let maybe_all_testcases: Option<String> = if d.all_cases.is_empty() {
None
} else {
Some(d.all_cases.to_string())
};
let test_case = test_case
.or(maybe_file_testcases)
.or(maybe_all_testcases)
.unwrap_or(d.case);
File::open(code_path(&p, None)?)?.read_to_string(&mut code)?;
let code = if conf.code.edit_code_marker {
let begin = code.find(&conf.code.start_marker);
let end = code.find(&conf.code.end_marker);
if let (Some(l), Some(r)) = (begin, end) {
code.get((l + conf.code.start_marker.len())..r)
.map(|s| s.to_string())
.unwrap_or_else(|| code)
} else {
code
}
} else {
code
};
json.insert("lang", conf.code.lang.to_string());
json.insert("question_id", p.id.to_string());
json.insert("typed_code", code);
json.insert("name", p.name.to_string());
json.insert("data_input", test_case);
let url = match run {
Run::Test => conf.sys.urls.test(&p.slug),
Run::Submit => {
json.insert("judge_type", "large".to_string());
conf.sys.urls.submit(&p.slug)
}
};
Ok((json, [url, conf.sys.urls.problem(&p.slug)]))
}
async fn poll_verify(&self, rid: String) -> Result<VerifyResult, Error> {
trace!("Polling judge for {rid}...");
let deadline = Instant::now() + VERIFY_POLL_TIMEOUT;
loop {
tokio::time::sleep(VERIFY_POLL_INTERVAL).await;
let res: VerifyResult = self
.resp_to_json(self.clone().0.verify_result(rid.clone()).await?)
.await?;
if res.state == "SUCCESS" {
return Ok(res);
}
if Instant::now() >= deadline {
return Err(Error::VerifyTimeout { rid });
}
}
}
pub async fn exec_problem(
&self,
rfid: i32,
run: Run,
test_case: Option<String>,
) -> Result<VerifyResult, Error> {
trace!("Exec problem filter —— Test or Submit");
let (json, [url, refer]) = self.pre_run_code(run.clone(), rfid, test_case).await?;
trace!("Pre-run code result {:#?}, {}, {}", json, url, refer);
let resp = self
.0
.clone()
.run_code(json.clone(), url.clone(), refer.clone())
.await?;
let http_status = resp.status();
let text = resp.text().await?;
if let Some(block) = detect_block(http_status, &text) {
return Err(block.into());
}
let run_res: RunCode = serde_json::from_str(&text).map_err(|e| {
anyhow!(
"Failed to decode run code result, could be caused by cookie expiration, \
csrf token mismatch, or network issue:\n {e}, raw response:\n {text}\n, \
please report this issue at https://github.com/siansiansu/leetctl/issues/new"
)
})?;
trace!("Run code result {:#?}", run_res);
if match run {
Run::Test => run_res.interpret_id.is_empty(),
Run::Submit => run_res.submission_id == 0,
} {
return Err(Error::CookieError);
}
let mut res = match run {
Run::Test => self.poll_verify(run_res.interpret_id.clone()).await?,
Run::Submit => self.poll_verify(run_res.submission_id.to_string()).await?,
};
trace!("Recur verify result {:#?}", res);
res.name = json.get("name").ok_or(Error::NoneError)?.to_string();
res.data_input = json.get("data_input").ok_or(Error::NoneError)?.to_string();
res.result_type = run;
if let Some(pid) = res.accepted_problem_id()? {
self.clone().update_after_ac(pid)?;
}
self.record_submission(&res)?;
Ok(res)
}
pub fn new() -> Result<Self, Error> {
let conf = Config::locate()?;
let mut c = conn(conf.storage.cache()?)?;
diesel::sql_query(CREATE_PROBLEMS_IF_NOT_EXISTS).execute(&mut c)?;
diesel::sql_query(CREATE_TAGS_IF_NOT_EXISTS).execute(&mut c)?;
diesel::sql_query(CREATE_REVIEWS_IF_NOT_EXISTS).execute(&mut c)?;
Ok(Cache(LeetCode::new()?))
}
}
#[cfg(test)]
mod tests {
use super::{Block, detect_block};
use wreq::StatusCode;
const CHALLENGE_PAGE: &str = "<!DOCTYPE html><html lang=\"en-US\"><head>\
<title>Just a moment...</title></head><body><script>\
(function(){window._cf_chl_opt = {cRay: 'a2d10820ce8588ff'};}());</script></body></html>";
#[test]
fn detect_block_reads_a_cloudflare_challenge_page_as_a_challenge() {
assert_eq!(
detect_block(StatusCode::OK, CHALLENGE_PAGE),
Some(Block::Challenge)
);
}
#[test]
fn detect_block_reads_429_as_a_rate_limit() {
assert_eq!(
detect_block(StatusCode::TOO_MANY_REQUESTS, "<html>slow down</html>"),
Some(Block::RateLimit)
);
}
#[test]
fn detect_block_passes_judge_json() {
assert_eq!(
detect_block(StatusCode::OK, r#"{"state":"SUCCESS","status_code":10}"#),
None
);
}
#[test]
fn detect_block_passes_non_cloudflare_html() {
assert_eq!(
detect_block(
StatusCode::FORBIDDEN,
"<!DOCTYPE html><html><head><title>Sign In</title></head></html>"
),
None
);
}
}