tenpi / pixiv.ts Goto Github PK

const img_dir = "./downloaded";
await client.util.downloadIllust(url, img_dir, "original");

// should be downloaded by now
let exit = false;
let prev_hash = "";
let images: string[] = [];
while(true) {
    let images_stats = fs.readdirSync(img_dir);
    let curr_hash = "";
    images = [];
    for (const image_stats of images_stats) {
        const file = img_dir + "/" + image_stats;
        images.push(file);
        curr_hash += await getFileHash(file);
    }
    if(exit) {
        break;
    }
    if (prev_hash != curr_hash || !curr_hash.length) {
        debug(`hash mismatch, waiting... (${prev_hash} || ${curr_hash})`);
    }
    exit = prev_hash == curr_hash && curr_hash.length > 0;
    prev_hash = curr_hash;
    await sleep(1000);
}

// by this point the images are downloaded, but the solution is mega-crap

import Pixiv from 'pixiv.ts';
import { env } from './environment';

let client: Pixiv;

export async function usePixivClient() {
  if (!client) {
    client = await Pixiv.login(env.pixiv.username, env.pixiv.password);
  }

  async function getUserIllustrations(params: Parameters<typeof client['user']['illusts']>[0]) {
    return await client.user.illusts(params);
  }

  return {
    getUserIllustrations,
  };
}

await client.util.downloadIllust(url, "./downloads", "original");

const files = fs.readdirSync(path.join(__dirname, "../downloads")).map((p) => {
    return path.join(__dirname, "../downloads", p)
})
const hash = crypto.createHash("md5").update(fs.readFileSync(files[0])).digest("hex")
console.log(hash);
for(let i = 1; i < 5; i++) {
    setTimeout(() => {
        const hash2 = crypto.createHash("md5").update(fs.readFileSync(files[0])).digest("hex")
        console.log(hash2)
        console.log(hash === hash2)
    }, i * 1000)
}

const illust = await client.illust.get(url);
const img_dir = "./downloaded";
await sendToChannel(channel, `📥 Downloading from pixiv`);
await client.util.downloadIllust(illust, img_dir, "original");

let images = walk(img_dir);

for (const image of images) {
    const new_file_name = getFileName(image);
    const new_file_path = await getFilePath(new_file_name, channel);
    if(new_file_path) {
    await processAndSaveImage(fs.createReadStream(image));
    fs.unlinkSync(image);
}