Forem: Sergey Gustun

Telegram Bot — NodeJS, Alpaca API, QuickChart

Sergey Gustun — Mon, 10 Aug 2020 10:33:45 +0000

Hello everyone

Today we will show you how to make a very simple telegram bot. To do this, we will use the Node JS programming language.

I've already written how to install NodeJS, so just go here - https://gaserd.xyz/?go=all/how-create-stock-screener-on-node-js-ep1/

Before you start programming, let's prepare our workplace a little.

creating a folder in which we will work
making the npm init command
creating a file main.js

To do this, you need to contact another bot - https://t.me/botfather enter the /new bot command and follow the instructions. as soon as you create a bot, botfather will send you the key to your bot and save it.

Now let's open our still empty main.js and get down to business.

We will also need a certain number of npm packages, so let's install them all at once.

npm install date-fns @alpaca/alpaca-trade-api node-fetch telegraf

A lot of packages, of course, but with them we will do things much faster.
Now let's write some code.

const dateFns = require('date-fns')
const apiKeyId = 'PUT YOUR API KEY'
const secretKey = 'PUT YOUR SECRET KEY'
const Alpaca = require('@alpacahq/alpaca-trade-api')
const quickchart = require('quickchart-js')
const format = 'yyyy-MM-dd'
const alpaca = new Alpaca({
    keyId: apiKeyId,
    secretKey: secretKey,
    paper: true,
    usePolygon: false
})
const nodeFetch = require('node-fetch')

const BOT_TOKEN = 'PUT YOUR BOT TOKEN'
const { Telegraf } = require('telegraf')

What do we use here? If you have already met the bot for the token, then apiKeyId and secretKey may not be familiar to you, so these are the keys for the Alpaca API, thanks to which we will get quotes.

How do I get them? I've already written about it here - https://gaserd.xyz/?go=all/how-create-stock-screener-on-node-js-ep2-alpacaapi-date-fns-and/

As soon as you have received everything, insert your keys and continue development.
Let's create a couple of commands for the bot and try them out:

const bot = new Telegraf(BOT_TOKEN)
bot.start((ctx) => ctx.reply('Hey, wellcome to the board! 👋 This bot is able to show easy information about the promotion that interests you'))
bot.command('about', (ctx) => {
    ctx.reply(`Hey, my name @gaserd and i create this bot, because i like programming, trading and betting. I create blog about it https://gaserd.xyz and twitter https://twitter.com/gaserdgg`)
})
bot.launch()
console.log('telegram bot start 🆙')

Launch the bot with the command node main.js in your terminal and open the bot in Telegram, enter the /about command.
Well? Did the bot answer you? Really great!

But let's try to complicate the task, let the bot give us the latest data on the desired action.

bot.command('lastq', (ctx) => {
    const stock = getValueOfBotCommand(ctx.message.text, 'lastq')
    alpaca
        .lastQuote(stock)
        .then(data => {
            ctx.reply(`symbol - ${data.symbol}\nask price - ${data.last.askprice}\nbid price - ${data.last.bidprice}`)
        })
        .catch((e) => {
            console.log(e)
            ctx.reply('Error, pls send message @gaserd')
        })
})

Let's run through this code and tell you what's what.
As always, we initialize the bot's command and set parameters for it to respond to.
What is the function of getValueOfBotCommand ? It returns the action that the person wrote from the string.

function getValueOfBotCommand(string, command) {
    return string.replace(`/${command}`, '').replace(/ /g, '')
}

Then our code requests data from the Alpaca API and returns it to the user. Launch the bot and try it!
I think you have managed it, if something doesn't work out, write to any of my contacts.

Moving on, let's complicate another challenge will be to change the action in the form of pictures over the last month. Cool?

quickCharts,date-fns will help us with this.

bot.command('agg', (ctx) => {
    const stock = getValueOfBotCommand(ctx.message.text, 'agg')
    let today = new Date()
    const to = dateFns.format(today, format)
    today.setMonth(today.getMonth() - 1)
    const from = dateFns.format(today, format)

    alpaca
        .getAggregates(
            stock,
            'day',
            from,
            to
        ).then(data => {
            const results = data.results
            let labels = []
            let dataChart = []
                results.map(res => {
                    labels.push(dateFns.format(res.startEpochTime, format))
                    dataChart.push(res.closePrice)
                })

            const chart = {
                chart: {
                    type: 'line',
                    data: {
                        labels: labels,
                        datasets: [{
                            label: stock,
                            data: dataChart,
                            fill: false,
                            borderColor:'green',
                            pointRadius : 0
                        }]
                    }
                }
            }

            nodeFetch('https://quickchart.io/chart/create', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(chart)
            })
                .then(res => res.json())
                .then(res => {
                    ctx.reply(res.url)
                })
                .catch(e => {
                    ctx.reply('Error, pls send message @gaserd')
                })


        })
        .catch(e => {
            console.log(e)
            ctx.reply('Error, pls send message @gaserd')
        })
})

Let's figure out what's going on here.

First we tell our bot to listen to the agg command, then we select two dates in the format we need, the date of today and the date a month ago, so we get the requested period of time - this is about 21 trading days.

After that, we collect data to a specific object, which we will later pass quick charts via the REST API, and then get a link to the graph that was generated.

I hope you have become a little clearer, and now what to expect, launch the bot and start playing.

That's it, here's the full code for your bot.

const dateFns = require('date-fns')
const apiKeyId = 'PUT YOUR API KEY'
const secretKey = 'PUT YOUR SECRET KEY'
const Alpaca = require('@alpacahq/alpaca-trade-api')
const format = 'yyyy-MM-dd'
const alpaca = new Alpaca({
    keyId: apiKeyId,
    secretKey: secretKey,
    paper: true,
    usePolygon: false
})
const nodeFetch = require('node-fetch')

const BOT_TOKEN = 'PUT YOUR BOT TOKEN'
const { Telegraf } = require('telegraf')

const bot = new Telegraf(BOT_TOKEN)
bot.start((ctx) => ctx.reply('Hey, wellcome to the board! 👋 This bot is able to show easy information about the promotion that interests you'))
bot.help((ctx) => ctx.reply(`
/lastq {stock} - this command get last quotes for the stock which you input\n
/agg {stock} - this command get aggregates info for last 1 month\n
/about - command get ingo about this bot and who developer\n`))

bot.command('about', (ctx) => {
    ctx.reply(`Hey, my name @gaserd and i create this bot, because i like programming, trading and betting. I create blog about it https://gaserd.xyz and twitter https://twitter.com/gaserdgg`)
})

bot.command('lastq', (ctx) => {
    const stock = getValueOfBotCommand(ctx.message.text, 'lastq')
    alpaca
        .lastQuote(stock)
        .then(data => {
            ctx.reply(`symbol - ${data.symbol}\nask price - ${data.last.askprice}\nbid price - ${data.last.bidprice}`)
        })
        .catch((e) => {
            console.log(e)
            ctx.reply('Error, pls send message @gaserd')
        })
})

bot.command('agg', (ctx) => {
    const stock = getValueOfBotCommand(ctx.message.text, 'agg')
    let today = new Date()
    const to = dateFns.format(today, format)
    today.setMonth(today.getMonth() - 1)
    const from = dateFns.format(today, format)

    alpaca
        .getAggregates(
            stock,
            'day',
            from,
            to
        ).then(data => {
            const results = data.results
            let labels = []
            let dataChart = []
                results.map(res => {
                    labels.push(dateFns.format(res.startEpochTime, format))
                    dataChart.push(res.closePrice)
                })

            const chart = {
                chart: {
                    type: 'line',
                    data: {
                        labels: labels,
                        datasets: [{
                            label: stock,
                            data: dataChart,
                            fill: false,
                            borderColor:'green',
                            pointRadius : 0
                        }]
                    }
                }
            }

            nodeFetch('https://quickchart.io/chart/create', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(chart)
            })
                .then(res => res.json())
                .then(res => {
                    ctx.reply(res.url)
                })
                .catch(e => {
                    ctx.reply('Error, pls send message @gaserd')
                })


        })
        .catch(e => {
            console.log(e)
            ctx.reply('Error, pls send message @gaserd')
        })
})

bot.launch()
console.log('telegram bot start 🆙')

How create Stock Screener on Node JS? EP3 Last episode

Sergey Gustun — Wed, 05 Aug 2020 11:12:25 +0000

Well, here it is the third final lesson, in which you and I will be able to get information on our Stock Market and output it to your console.

In the previous lessons, we learned how to work with the date, output it, get whether the exchange is working, and everything else, and the homework was to finish the program a little so that it showed US NY time relative to ours.

Actually, here is the answer. To start, install another package:

npm install date-fns-timezone

And let's add the function we need right away:

const { formatToTimeZone } = require('date-fns-timezone')

Now we need to understand, and in what part at all we have NY, so there it lies in the time zone America/Toronto, so we will write:

const timeZone = 'America/Toronto'

const edtFormat = 'YYYY-MM-DD HH:mm:ss.SSS [GMT]Z (z)'
const edtDate = formatToTimeZone(new Date(), edtFormat, { timeZone })

console.log(edtDate)

Well, as always, run your script, preferably before you comment on the old lines that we do not need yet.

2020-08-05 05:28:02.261 GMT-04:00 (EDT)

Great, now we have time with our time in mind.
Let's now output the time at which we open the exchange and the time that is relative to our current time in NY.

Well, did it work out? If suddenly something didn't work out or you don't understand something tweet me https://twitter.com/gaserd or email me gaserd123@gmail.com

Do you remember our code that we commented out so that we could output the code that we wrote? Let's bring it back to life, and add something.

But before that, we will write a code that will get data on Apple shares.

    const to = dateFns.format(today, format)
    today.setMonth(today.getMonth() - 3)
    const from = dateFns.format(today, format)
    const stock = 'AAPL' 

    alpaca
        .getAggregates(
            stock,
            'day',
            from,
            to
        )
        .then(data => {
            console.table(data.results)
        }).catch((e) => {
            console.log(e)
        })

I hope you made a mistake, right? This is an error due to the format we use for formatting the date, replace it with yyyy-MM-dd

Now run your program again. You may have noticed that instead of console. log we used console.table this is due to a more convenient perception of the large amount of data that we receive.

Interesting point, do you understand why we do setMonth ? All in order to get data for 3 months, each month has about 21 trading days, so we set our date to 3 months ago.

Well, can you now link the input code with the data received and check whether the exchange is working?

I'll write the ready-made code right away, but I really want you to try it yourself.

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
const date = dateFns.format(new Date(), format)
const timeZone = 'America/Toronto'

const etcFormat = 'YYYY-MM-DD HH:mm:ss.SSS [GMT]Z (z)'
const etcDate = formatToTimeZone(new Date(), etcFormat, { timeZone })

function inputStock() {
    rl.question('Input STOCK: ', (stock) => {
        let today = new Date()
        const to = dateFns.format(today, format)
        today.setMonth(today.getMonth() - 3)
        const from = dateFns.format(today, format)

        alpaca
            .getAggregates(
                stock,
                'day',
                from,
                to
            )
            .then(data => {
                const results = data.results.map(res => res.startEpochTime = dateFns.format(res.startEpochTime, format))
                console.table(data.results)
                rl.close()
                exit()
            }).catch((e) => {
                console.log(e)
                exit()
            })
    });
}

function main() {
    alpaca.getClock().then((clock) => {
        console.log(`###############################`)
        console.log(`The market is ${clock.is_open ? 'open.' : 'closed.'}`)
        alpaca.getCalendar({
            start: date,
            end: date
        }).then((calendars) => {
            console.log(`The market opened at ${calendars[0].open} and closed at ${calendars[0].close} on ${date}.`)
            console.log(`NEW YORK TIME - ${etcDate}`)
            console.log(`###############################`)
        }).then(() => {
            if (clock.is_open) {
                inputStock()
            } else {
                exit()
            }
        })
    })
}

main()

Oops, it seems like too much code at a time. But let's try to understand.

I wrapped our previous code in functions to make it more convenient, now we have the main function main and the inputStock function that calls a request to enter the name of the Stock and then outputs data. this function should still be divided into several, but let's not do it yet.

the main function is the entry point to the execution of our script, it checks whether the exchange is working now and if it is working, it shows historical data, if it is not working, it tells us about it.

You may have noticed another thing, it's exit() this is a function that exits the script and stops executing it.

const { exit } = require('process')

Actually, this is all, this is a very light version of StockScreneer, then you can dive more and more into the financial world and start processing the received data, as well as do not hesitate to get data from the Alpaca API in real time.

Share your code lessons for developers 🔥

Sergey Gustun — Tue, 04 Aug 2020 09:53:32 +0000

Hello, developers! Share you code lessons for developers and I feedback you 🔥🔥🔥

I'll start first!
Recently I started doing small lessons for Node JS developers who would like to try doing something trading.
I've already done two lessons:
https://gaserd.xyz/?go=all/how-create-stock-screener-on-node-js-ep2-alpacaapi-date-fns-and/
https://gaserd.xyz/?go=all/how-create-stock-screener-on-node-js-ep1/

I also did a lesson for my react native developers: https://dev.to/gaserd/small-trick-for-your-app-to-react-native---side-menu-with-overlay-52be

And there is a very old lesson from me on how to make your Google low-cost:
https://dev.to/gaserd/how-to-create-small-search-engine-for-your-awesome-project-40m

How create Stock Screener on Node JS? EP2 AlpacaAPI, date-fns and 🔥

Sergey Gustun — Tue, 04 Aug 2020 09:35:50 +0000

Are you ready for a new challenge?

Great, because today we will work with dates and with the Alpaca API and try to find out if the exchange is working now.

Work with Date

Let's start with something new and add an NPM package that will allow us to work with dates in a more convenient way.

Open the terminal and write:

npm install date-fns

What is the date-fns? Yes read directly on the package page - https://date-fns.org/

Now let's connect it at the beginning of our file, who guessed how, try it yourself, and then look at the following code.

const dateFns = require('date-fns')

Great, let's now try to output today's date.

console.log(new Date())

Oh Yes, don't forget to comment on our code, which relates to the question about Input STOCK. How is this done? Just wrap the code in /* CODE */

Here is an example:

/*
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question('Input STOCK: ', (stock) => {
        console.log(`You choose stock: ${stock}`)
        rl.close()
});
*/

Now we should only have this code with you:

const readline = require('readline')
const dateFns = require('date-fns')

console.log(new Date())

And run it, if you forgot how, just enter the command in the terminal:

node main.js

If you have any questions or something went wrong, just tweet me https://twitter.com/gaserdgg or email me gaserd123@gmail.com

I see something like this in my terminal:

2020-08-04T08:33:28.769Z

It's not the most convenient form to read the date, is it? Let's come up with a format for the date.
Let it be yyyy-MM-dd HH:mm:ss

So we will write:

const format = `yyyy-MM-dd HH:mm:ss` 
const today = new Date()

And we'll also make a variable for today's date.

Now let's do a little trick, print our date in the format we need.

console.log(dateFns.format(today, format))

Now run your script, how about it? Cool!

Install Alpaca API

Ready for something more complex? I believe in you.
It's time for us to get busy and check whether the exchange is working. In my examples, I will use AlpacaAPI - a special API for working with the stock market and trading algorithms.

To start, go to https://alpaca.markets/ and sign up, we only need to generate a key for your work right now.

Go to the Paper Trading API and you will see a button where you can generate a key for yourself.
Now add these keys to our code, we will need them.

const apiKeyId = 'PUT API KEY HERE'
const secretKey = 'PUT SECRET KEY HERE'

Just don't forget to insert your keys here.

Now let's install the package for the Alpaca API

npm install @alpacahq/alpaca-trade-api

And as always, we'll add it to our code.

const Alpaca = require('@alpacahq/alpaca-trade-api')

const alpaca = new Alpaca({
    keyId: apiKeyId,
    secretKey: secretKey,
    paper: true,
    usePolygon: false
})

If you are at this moment, something is unclear or you have something that does not work, just tweet me https://twitter.com/gaserdgg or email me gaserd123@gmail.com

Let's now try to get the state of the exchange, find out whether it works now or not.

alpaca
.getClock()
.then((clock) => {
    console.log(`The market is ${clock.is_open ? 'open.' : 'closed.'}`)
})

And try to execute the command, well? In my time zone, the exchange is not working yet, so I get this response:

2020-08-04 11:55:39
The market is closed.

But we would also like to know when the exchange is working, so that we know at what point it is time to start trading.

const date = dateFns.format(today, format)
alpaca.getCalendar({
    start: date,
    end: date
}).then((calendars) => {
    console.log(calendars)
})

Let's run our script and get something like this answer:

[
  {
    date: '2020-08-04',
    open: '09:30',
    close: '16:00',
    session_open: '0700',
    session_close: '1900'
  }
]
The market is closed.

Great, let's now edit our code a little and put it out in full.

const readline = require('readline')
const dateFns = require('date-fns')
const format = `yyyy-MM-dd HH:mm:ss`
const today = new Date()
const apiKeyId = 'PUT YOU API KEY'
const secretKey = 'PUT YOU SECRET KEY'
const Alpaca = require('@alpacahq/alpaca-trade-api')
const alpaca = new Alpaca({
    keyId: apiKeyId,
    secretKey: secretKey,
    paper: true,
    usePolygon: false
})
const date = dateFns.format(today, format)

alpaca
.getClock()
.then((clock) => {
    console.log(`The market is ${clock.is_open ? 'open.' : 'closed.'}`)
})
.then(() => alpaca.getCalendar({
    start: date,
    end: date
}))
.then((calendars) => {
    console.log(`The market opened at ${calendars[0].open} and closed at ${calendars[0].close} on ${date}.`)
})

/*
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question('Input STOCK: ', (stock) => {
        console.log(`You choose stock: ${stock}`)
        rl.close()
});
*/

Great! You have managed and now I have a small task for you.

Most likely, not everyone lives in NY and just like me have a time offset relative to the NY exchange, so it would be nice to transfer your time to NY time.

Homework

Task:

learn how to translate your current time to NY time and output it.

Hint:

you will need to look in the date-fns-timezonepackage
You can send your code to me anywhere, I will check each one and give you my feedback.

Thank you for reading my little episodes! In the next lesson, we will start getting data for the campaign we set.

How create Stock Screener on Node JS? EP1

Sergey Gustun — Mon, 03 Aug 2020 10:53:11 +0000

Hello everyone

Today we will start a small series of lessons in which we will understand what it is Node.js.
I don't like boring lessons, I suggest you go straight into battle.

Let's set ourselves the following tasks:

install NodeJS and NPM
create your first script
learn how to get a string from the terminal
learn how to work with dates
get data from the Alpaca API based on the line we entered in the terminal, namely, find data on Stock

Simply put, we will make a very easy Stock Market Checker with you, at the same time we can earn money if we find a correlation between the current price and previous prices.

Install NodeJS & NPM

First of all, let's install NodeJS, all the information that we need to install is here:
https://nodejs.org/en/

Nothing complicated, click the big green button, download the installer and that's it.
Was it difficult? Great, you are already halfway there, because, with the installation of NodeJS, NPM comes as a gift.

If you have any questions about the installation or something went wrong, just tweet me @gaserdgg or email me gaserd123@gmail.com

To understand that everything works, let's open the terminal and run the command:

node -v

In my case, it is shown that this version of the v12.18.1

Oh, you don't know what a terminal is? This is how you will communicate with the computer, but without the help of a special UI that you see every day.

I will ask you if you have never used the terminal, Google what it is, take into account your operating system.

Let's check again whether we have NPM with you, have you already guessed how?

npm -v

Again, if something doesn't work, don't be afraid to write to me.

Now let's move on to creating your first script, here we will also stop a little, because you will need to choose a code editor, I will not go long and tell you, just download VSCode and do not suffer.

https://code.visualstudio.com/

Downloaded it? So we go further.

Open your code editor, since I work with VSCode, all screenshots will be from it.
Let's create a workspace where we can create. Go to VSCode and create a folder, call it StockScreener

Now let's open the terminal, for this purpose in VSCode there is a separate line in the menu, which is called Terminal - > New Terminal , it will open the terminal with the path to your folder. Conveniently.

Let's initialize our NPM, if you haven't read what NPM is yet, I'll tell you, especially for those who have played MMORPG World of Warcraft, NPM is Addons for your code that other developers write, so you don't have to write anything with your own hands, by the way, you can help them write these Addons.

Let's enter the command:

npm init

At this stage, you can not fill in anything yet, NPM will fill in everything itself, it is not important for us now, the main thing is not to forget to enter YES.

Create your first script

Great! Now let's create our first script. Create a file with the name main.js

Maybe it's time to write something and see how it works?
Let's write something standard, but with a little tuning.

console.log(`Hello, I'm StockScreneer`)

Now open the terminal and run the command

node main.js

Beauty? High? Cool!
Now we would like the terminal to send something to us in the same way as NPM, we answered something to it, and our program remembered it.

For this purpose, there is a readline in NodeJS, which means something to you right now, but let me show you how it works.

Let's write this code. You can delete the old one.

const readline = require('readline')

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question('Input STOCK: ', (stock) => {
    console.log(`You choose stock: ${stock}`)
    rl.close()
});

It's not clear yet is it? Okay, let's get this straight.

Our first line

const readline = require('readline')

Here we declared a variable, said she was now going to be our reader of the lines of badass.

The following

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

We told our program that we have some interface for processing the string that we will write in the terminal.

And after

rl.question('Input STOCK: ', (stock) => {
    console.log(`You choose stock: ${stock}`)
    rl.close()
});

We ask a question to our terminal and want to get an answer, and when we get it, we close our question and output the answer.

It seems nothing complicated, but while you are most likely scared by the lack of understanding of all sorts of const, interface, require and other things, I honestly want to omit these points, I want you to enjoy the moment when the program works and it knows how to do something.

At this stage, you can experiment a little, for example, try entering other questions and output a different answer. Try it, programming is a constant experiment.

Have you played enough? Going further?

And then we will go a little later, I want you to play with this code and try different pribludy for it.

The next block will be soon and we will work with the dates in it and will output whether our exchange is working today and how long we still have to wait before opening.

If you want to read about development in trading, betting or other gambling things, then subscribe to my blog, it is listed in the BIO.

Good luck and have fun!

I start to create open-source for betting, Ask Me Anything!

Sergey Gustun — Fri, 21 Feb 2020 09:21:30 +0000

Hey, my name is Edward and i like esports/betting and programming.

One evening, I decided to start posting my small developments in open source.

I know quite a lot about the betting world and everything related to it if you want to learn something or want to have fun with me and write open-source, then welcome - https://github.com/BETTING-CODE

GL&HF!

How I create value bet scanner for Starcraft2

Sergey Gustun — Wed, 19 Feb 2020 12:41:02 +0000

Hello everyone!

I am a free developer and I love esports very much.

And where there is a sport, there are bookmakers. I have long understood how bookmakers work and try to write a lot of software to identify interesting points in this area.

Relatively recently, I decided to create a small open source community where I will post my small developments, and at the same time, if you are interested, you could participate in this.

That's it https://github.com/BETTING-CODE

But let's get to the point of this article.

I wondered how often bookmakers make mistakes and overestimate a particular bet. The answer lay on the surface, very often, which means we could find such bids.

What is a discipline in esports is the most simple outcomes of events? Star StarCraft2!

For this discipline, the bookmaker does not give too many betting options, there are only two of them - either the first or second player will win.

Our first task will be to get the coefficients for each player. How do we do this?

"Puppeteer".

Like this.

const puppeteer = require('puppeteer');

async function get_money_line() {
    const browser = await puppeteer.launch();
    const page = await browser.newPage();
    await page.goto('https://gg22.bet/en/starcraft2', { waitUntil: 'networkidle2' });
    await browser.close();
}

Well, we opened the browser, opened the page we need with the bookmaker's odds and closed it.

What can we do with all the content on the page?
Yes, everything is the same as in a normal browser.

For example, get all the games that are currently displayed on the page.

const starcraft2matches = await page.evaluate(() => {
        let object = []
        let j = 0
        let names = document.querySelectorAll('.__app-LogoTitle-name.LogoTitle__name___2LTlu')
        let odds = document.querySelectorAll('.odd__ellipsis___3b4Yk')
        let date_time = document.querySelectorAll('.dateTime__date___147AU')

        function get_day(text) {
            if (text.indexOf('TODAY') !== -1) {
                let day = new Date()
                day = day.toLocaleDateString('en-EN', { month: 'short', day: 'numeric' })
                day = day.toUpperCase()
                return text.replace('TODAY', day)
            } else {
                return text
            }
        }

        for (let i = 0; i < names.length; i++) {
            if (i == 0)
                object[j] = []
            if (i % 2 == 0 && i != 0) {
                j++
                object[j] = []
                object[j].push({ time: get_day(date_time[j].innerText), name: names[i].innerText, odds: odds[i].innerText })
            } else {
                object[j].push({ time: get_day(date_time[j].innerText), name: names[i].innerText, odds: odds[i].innerText })
            }
        }

        return object
    })

As you may have noticed, working with a page is very similar to what we can do in dev tools.

This way we take all the matches from the page and create an array. How cool is that?

Now we have all the matches we need. But where can we get the possible winning percentages?

After all, the odds that we see at the bookmaker are nothing but percentages, try dividing the unit by the coefficient, what did you get?

Here we will come to the aid of a rather interesting site called aligulac, which is a huge database of matches in Starcraft2 if this site is also open source.

Let's learn how to get data from aligulac.

First, let's go here and get the API key http://aligulac.com/about/api/

Great, now let's add a few packages to our script.

const fs = require('fs')
const sc2 = require('./sc2moneyline')
const aligulac_api_key = 'your-api-key'
const node_fetch = require('node-fetch')

What is node-fetch? This is an implementation of the fetch function from the browser for NodeJS.

Let's now write a few functions for our aligulac.

async function search_players(name) {
    return node_fetch(`http://aligulac.com/search/json/?q=${name}&search_for=players`)
        .then(res => res.json())
}

async function get_info_player(id) {
    return node_fetch(`http://aligulac.com/api/v1/player/?id=${id}&apikey=${aligulac_api_key}`)
        .then(res => res.json())
}

async function get_predictmatch(id1, id2) {
    return node_fetch(`http://aligulac.com/api/v1/predictmatch/${id1},${id2}/?apikey=${aligulac_api_key}&bo=3`)
        .then(res => res.json())
}

Great, now we have with you, the bookmaker's line, all the information on the players and everything is ready to find value bets.

How do you find them at all?

The formula is quite simple, knowing how the players play with each other, we can estimate the percentage of victory of one player over another, we denote it as P, we also have the bookmaker's coefficient, we denote it as K, then our formula will look something like this.

K * P > 1

If > 1 then this is the overvalued bid.

Can you now generate an HTML page yourself?

I created a repository for this so that you can see how it works.
https://github.com/BETTING-CODE/starcraft2-value-bet-generator

I hope you are a little interested in this topic and will be able to understand such technologies as parsing and information collection.
Happy coding!

I create open source betting calculators

Sergey Gustun — Wed, 12 Feb 2020 15:12:07 +0000

Hi, my name is Sergey and I like three things - programming, betting, and esport.

Now if I have free time, I create open source betting calculators/arbitrage/live dota2 generator links on dotapicker, etc.

Check it and get feedback, thx for attention!

https://gaserd.github.io/oddslootcalculator/

I think to learn C for wasm

Sergey Gustun — Thu, 18 Apr 2019 12:12:00 +0000

Hey 👋

I think start learn C for wasm because it's a very interesting technology, but last time I write code on C in the 2013 year.

And now I want to start again. Maybe I start challenge and write what I do and how I fell it.

What do you think about this?

Three problems in mobile web

Sergey Gustun — Wed, 17 Apr 2019 07:13:06 +0000

Overscroll

Overscroll in mobile devices is only on windows. And if you have a block that has its own scroll, it, unfortunately, will not work, but for this, too, there was a solution:

if (this.el.scrollTop <= 0) {
   this.el.scrollTop = 1;
} else if (this.el.scrollTop >= this.el.scrollHeight - this.el.offsetHeight) {
   this.el.scrollTop = this.el.scrollHeight - this.el.offsetHeight - 1;
}

Fixed+Transform

Most likely, everyone is familiar with the problem: if there is a fixed block, and one of his parents applies the transformation, then all the fixed blocks begin to leave.
This is a very sneaky bug that sometimes makes the animation of our mobile interface very bad.

Solution: remember the position of the fixed blocks before the transformation and turn them into absolute with the top property.

It's a little complicated, but in general, you can handle it if you need to.

Safe-insets

Since we are on the mobile web, we have a huge number of devices, one of them is iPhone X with new frames.

What to do if these frameworks at you get out and your interface looks not so beautiful as you wanted?

Solution: use this documentation https://ayogo.com/blog/ios11-viewport/

What problems do you know in the mobile web?

My first Web Assembly, interesting.

Sergey Gustun — Wed, 10 Apr 2019 10:10:02 +0000

Please be patient 😂

Hi, if you as well as I decided to understand this topic, then you will need to be a little patient.

I did not succeed the first time.

So, first, let's install emcc
Install:

git clone https://github.com/emscripten-core/emsdk.git

further

cd emsdk
./emsdk install latest

and further

./emsdk activate latest

and further...

source ./emsdk_env.sh --build=Release

Nice, you install emcc and now you can use compiler C/C++ to wasm , but you need install Python 2.7

Yeah, finish!

echo "source $(pwd)/emsdk_env.sh --build=Release > /dev/null" >> ~/.bashrc

Okay, let's go check.

Create index.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>WASM Demo</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>

    <h1>WASM Demo</h1>

    <script src="script.js"></script>
    <div id="container"></div>    
</body>
</html>

Create squarer.c

#include <emscripten.h>

EMSCRIPTEN_KEEPALIVE
int fib(int n) {
  int i, t, a = 0, b = 1;
  for (i = 0; i < n; i++) {
    t = a + b;
    a = b;
    b = t;
  }
  return b;
}

EMSCRIPTEN_KEEPALIVE
int squarer(int num) {
    return num * num;
}

And create script.js

fetch('squarer.wasm').then(response =>
  response.arrayBuffer()
).then(bytes => WebAssembly.instantiate(bytes)).then(results => {
  instance = results.instance;
  document.getElementById("container").textContent = instance.exports._squarer(2) + instance.exports._fib(2);
}).catch(console.error);

And now go to compile file squarer.c

emcc -O3 -s WASM=1 squarer.c -o squarer.wasm

Wooohoo! We compile file squarer.wasm
And now, we check our site with Web Server Chrome , he need a fetch

Rules in your open space for work

Sergey Gustun — Thu, 04 Oct 2018 08:34:51 +0000

Hi, folks!

I think more people work in the company and main the room is open space.

Which you have rules in your open space room?

Because in my company we have open space where seats 30+ people and this room very noisy and very active.

I think this a bad practice.