hk_bot/automatization.ts

import Hero from "@ulixee/hero";
import * as telegram from 'telegram';
import { sleep } from "telegram/Helpers";
import { AccountInterface } from "./interfaces/databaseInterface";
import { prevTaskInterface } from "./interfaces/otherInterfaces";
import logger from "./logger";
import { waitNewMessages } from "./utils";
import {database as db,settings} from './database'
import BigInteger from "big-integer";
import { isNull } from "lodash";


export const vertification=async function (client: telegram.TelegramClient,worker: AccountInterface,hero: Hero,url: string,botEntity: telegram.Api.Chat | telegram.Api.User,idOfLastMessage: number) {
    await hero.goto(url,{timeoutMs:180_000});
    await hero.waitForLoad('AllContentLoaded',{timeoutMs:180_000});
    const captchaButton=hero.document.querySelector('button.g-recaptcha.btn.btn-primary');
    if (captchaButton!=null){
        let verify=hero.document.querySelector('body > section > h2');
        while (verify!=null && (await verify.textContent)!.includes('All right!')==false){
            const isCaptchaPassed=hero.document.querySelector("input[id='recaptcha-token']");
            if (isCaptchaPassed==null || await isCaptchaPassed.$isVisible==false){
                await hero.interact({click:{element: captchaButton, verification: 'exactElement'}});
                await sleep(5000);
                verify=hero.document.querySelector('body > section > h2');
            } else {
                logger.error("catpcha detected");
                throw new Error("Auhtung captcha detected");
            }
        }

    } else {
        throw new Error('Cant find captcha button');
    }
}

export const doSitesTasks=async function (client: telegram.TelegramClient,worker: AccountInterface,hero: Hero,botEntity: telegram.Api.Chat | telegram.Api.User,tasksSelector: telegram.Api.Message) {
    const taskSitesButton=tasksSelector.buttons![1][0];
    let prevTask: prevTaskInterface={
        task:tasksSelector,
        lastMessage:tasksSelector
    };
    mainLoop:
    while (true){
        await taskSitesButton.click({sharePhone: false});
        await waitNewMessages(client,worker,botEntity,prevTask.lastMessage.id);
        const task=(await client.getMessages(botEntity,{
            minId:prevTask.lastMessage.id,
            // search: (await settings.botMessages()).tasksSelector,
        }))[0];

        if (task.buttonCount==2){
            
            logger.debug(`New ad task | ${worker.phoneNumber}`);
           
            const urlButton=task.buttons![0][0];
            const skipButton=task.buttons![0][1];
            await hero.goto(urlButton.url!.replace("https","http"),{timeoutMs:180_000});
            await hero.waitForLoad('AllContentLoaded',{timeoutMs:180_000});
            
            let captchaButton=hero.document.querySelector('button.g-recaptcha.btn.btn-primary');
            if (isNull(captchaButton)){
                if (prevTask.task.message==task.message){
                    logger.warn(`Same tasks detected on ${worker.phoneNumber}... Skipping due captcha isnt detected......`);
                    await skipButton.click({sharePhone: false});
                } else {
                    prevTask.task=task;
                    logger.warn(`Captcha isnt detected... | ${worker.phoneNumber}`);
                }
               
                continue mainLoop;
            }
            prevTask.task=task;
            if (urlButton.url!.includes('hkbots')==true){
                if (await captchaButton.$isClickable!=true){
                    // timer page
                    logger.warn(`Found timer... | ${worker.phoneNumber}`)
                    if (settings.bypassMode==true){
                        logger.warn(`Bypassing timer... | ${worker.phoneNumber}`)
                        try {
                            await hero.executeJs("document.getElementById('form').setAttribute('style', '')");
                        } catch (err){
                            logger.error(`Something went wrong due bypass`);
                        }
                    } else {
                        while (hero.document.querySelector("i[id='timer']")!=null && await captchaButton.$isClickable!=true){
                            await sleep(1000);
                        }
                    }
                }
                
                    
                while (await hero.activeTab.url==urlButton.url!){
                        const isCaptchaPassed=hero.document.querySelector("input[id='recaptcha-token']");
                        if ((isCaptchaPassed==null || await isCaptchaPassed.$isVisible==false) ){
                            if (await captchaButton.$isClickable){
                                try {
                                    await hero.interact({click:{element: captchaButton, verification: 'exactElement'}});
                                } catch( err){
                                    
                                    logger.warn(`Some error due clicking | ${worker.phoneNumber}`);
                                    continue mainLoop;
                                }
                            }
                            await sleep(1000);
                            captchaButton=hero.document.querySelector('button.g-recaptcha.btn.btn-primary');
                        } else {
                            logger.error("catpcha detected");
                            throw new Error("Auhtung captcha detected");
                        }
                }
                
                
               
                await waitNewMessages(client,worker,botEntity,prevTask.task.id);
                let afterTask:telegram.Api.Message=(await client.getMessages(botEntity,{
                    minId: prevTask.task.id,
                    reverse: true
                    // search: settings.botMessages.tasksSelector,
                }))[0];
                if (afterTask!=null){
                    prevTask.lastMessage=afterTask;
                    if (afterTask.message.includes(settings.botMessages.taskComplete)==true){
                        logger.debug(`Site task complete | ${worker.phoneNumber}`);
                        continue
                    }
                }
                
            }
            
        } else if (task.message.includes(settings.botMessages.taskOver)==true){
            logger.info(`Ad tasks completed | ${worker.phoneNumber}`)
            break
        } else {
            logger.error(`Check out last message of ${worker.phoneNumber}`);
            throw new Error(`Check out last message of ${worker.phoneNumber}`)
        }

    }
}


export const doChatsTasks=async function (client: telegram.TelegramClient,worker: AccountInterface,hero: Hero,botEntity: telegram.Api.Chat | telegram.Api.User,tasksSelector: telegram.Api.Message){
    const taskChatsButton=tasksSelector.buttons![1][1];
    let prevTask: prevTaskInterface={
        task:tasksSelector,
        lastMessage:tasksSelector
    };
    mainLoop:
    while (true){
        await taskChatsButton.click({sharePhone: false});
        await waitNewMessages(client,worker,botEntity,prevTask.lastMessage.id);
        const task=(await client.getMessages(botEntity,{
            minId:prevTask.lastMessage.id,
            // search: (await settings.botMessages()).tasksSelector,
        }))[0];
        if (task.buttonCount==3){
            
            logger.info(`New chat task | ${worker.phoneNumber}`);
            
            const urlButton=task.buttons![0][0];
            const confirmButton=task.buttons![0][1];
            const skipButton=task.buttons![0][2];


            let groupLink='';
            if (urlButton.url?.includes('hkbot')==true){
                await hero.goto(urlButton.url.replace("https","http"),{timeoutMs:180_000});
                await hero.waitForLoad('AllContentLoaded',{timeoutMs:180_000});
                let captchaButton=hero.document.querySelector('button.g-recaptcha.btn.btn-primary');
                if (isNull(captchaButton)){
                    if (prevTask.task.message==task.message){
                        logger.warn(`Same tasks detected on ${worker.phoneNumber}... Skipping due captcha isnt detected......`);
                        await skipButton.click({sharePhone: false});
                    } else {
                        prevTask.task=task;
                        logger.warn(`Captcha isnt detected... | ${worker.phoneNumber}`);
                    }
                   
                    continue mainLoop;
                }
                while (captchaButton!=null && await hero.activeTab.url==urlButton.url!){
                    const isCaptchaPassed=hero.document.querySelector("input[id='recaptcha-token']");
                    if ((isCaptchaPassed==null || await isCaptchaPassed.$isVisible==false) ){
                        if (await captchaButton.$isClickable){
                            try {
                                await hero.interact({click:{element: captchaButton, verification: 'exactElement'}});
                            } catch( err){
                                
                                logger.warn(`Some error due clicking | ${worker.phoneNumber}`);
                                continue mainLoop;
                            }
                        }
                        await sleep(1000);
                        captchaButton=hero.document.querySelector('button.g-recaptcha.btn.btn-primary');
                        
                    } else {
                        logger.error("catpcha detected");
                        throw new Error("Auhtung captcha detected");
                    }
                }
                groupLink=await hero.url;
                
            } else {
                groupLink=urlButton.url!;
            }
            // https://gram.js.org/tl/messages/GetFullChat
            // hash checking
            let group:telegram.Api.Channel | undefined;
            if (!/(^\w+:|^)\/\/(?:t|telegram)\.(?:me|dog)\/(joinchat\/|\+)([\w-]+)/i.test(groupLink)){
                groupLink=groupLink.replace(/(^\w+:|^)\/\/(?:t|telegram)\.(?:me|dog)\//i,'');
                try {
                    group=(((await client.invoke(
                        new telegram.Api.channels.JoinChannel({
                            channel:groupLink
                        })
                    )) as telegram.Api.Updates).chats[0] as telegram.Api.Channel)
                } catch (err: unknown){
                    if (err instanceof telegram.errors.RPCError){
                        switch (err.errorMessage) {
                            case 'CHANNELS_TOO_MUCH':
                                logger.warn(`Too much groups | ${worker.phoneNumber}`);
                                return;
                                
                            case 'USER_ALREADY_PARTICIPANT':
                                logger.warn(`Already in group | ${worker.phoneNumber}`)
                                group=(await client.invoke(
                                    new telegram.Api.channels.GetChannels({
                                        id:[groupLink]
                                    })
                                ))[0]
                                break;
                            default:
                                logger.warn(`Something wrong with chat ${err.errorMessage} | ${worker.phoneNumber}`)
                                await skipButton.click({sharePhone: false});
                                prevTask.task=task;
                                await waitNewMessages(client,worker,botEntity,task.id);
                                const afterTask=(await client.getMessages(botEntity,{
                                    minId:task.id,
                                    reverse: true
                                    // search: (await settings.botMessages()).tasksSelector,
                                }));
                                prevTask.lastMessage=afterTask[afterTask.length-1];
                                continue mainLoop;
                                
                        }
                    }
                }
            } else {
                // hash 
                groupLink=groupLink.replace(/(^\w+:|^)\/\/(?:t|telegram)\.(?:me|dog)\/(joinchat\/|\+)/i,'');
                try {
                    group=(((await client.invoke(
                        new telegram.Api.messages.ImportChatInvite({
                            hash:groupLink
                        })
                    )) as telegram.Api.Updates).chats[0] as telegram.Api.Channel)
                } catch (err: unknown){
                    if (err instanceof telegram.errors.RPCError){
                        switch (err.errorMessage) {
                            case 'CHANNELS_TOO_MUCH':
                                logger.warn(`Too much groups | ${worker.phoneNumber}`);
                                return;
                                
                            case 'USER_ALREADY_PARTICIPANT':
                                logger.warn(`Already in group | ${worker.phoneNumber}`)
                                group=((await client.invoke(
                                    new telegram.Api.messages.CheckChatInvite({
                                        hash:groupLink
                                    })
                                )) as telegram.Api.ChatInviteAlready).chat as telegram.Api.Channel
                                break;
                            default:
                                logger.warn(`Something wrong with chat ${err.errorMessage} | ${worker.phoneNumber}`)
                                await skipButton.click({sharePhone: false});
                                prevTask.task=task;
                                await waitNewMessages(client,worker,botEntity,task.id);
                                const afterTask=(await client.getMessages(botEntity,{
                                    minId:task.id,
                                    reverse: true
                                    // search: (await settings.botMessages()).tasksSelector,
                                }));
                                prevTask.lastMessage=afterTask[afterTask.length-1];
                                continue mainLoop;
                                
                        }
                    }
                }
            }
            
            await confirmButton.click({sharePhone: false});
            await waitNewMessages(client,worker,botEntity,prevTask.task.id);
            let afterTask:telegram.Api.Message=(await client.getMessages(botEntity,{
                    minId: prevTask.task.id,
                    reverse: true
                    
            }))[0];
            if (afterTask!=null && group){
                prevTask.task=task;
                prevTask.lastMessage=afterTask;
                if (afterTask.message.includes(settings.botMessages.taskComplete)==true){
                        worker.completedGroupsTasks.push(
                            {
                                timeToLeave: +(new Date())+Number(afterTask.message.replace(/\D/g,''))*3600*1_000,
                                groupID:BigInteger(`-100${group.id}`)
                            }
                        )
                        logger.debug(`Chat task complete | ${worker.phoneNumber}`);
                        continue
                
                } else if (afterTask.message.includes(settings.botMessages.notInGroup)==true){
                    logger.warn(`User joined but hk says not. Skipping...`)
                    await skipButton.click({sharePhone: false});
                    prevTask.task=task;
                    await waitNewMessages(client,worker,botEntity,task.id);
                    const afterTask=(await client.getMessages(botEntity,{
                                    minId:task.id,
                                    reverse: true
                                    // search: (await settings.botMessages()).tasksSelector,
                    }));
                    prevTask.lastMessage=afterTask[afterTask.length-1];
                } else {
                    logger.debug(`Anomaly | ${worker.phoneNumber}`)
                }
            }
            


            


        }else if (task.message.includes(settings.botMessages.taskOver)==true){
            logger.info(`Chats tasks completed | ${worker.phoneNumber}`)
            break
        } else {
            logger.error(`Check out last message of ${worker.phoneNumber}`);
            throw new Error(`Check out last message of ${worker.phoneNumber}`)
        }
    }
}