288 lines
6.1 KiB
V
288 lines
6.1 KiB
V
module main
|
|
|
|
import vweb
|
|
import db.sqlite
|
|
import time
|
|
import net.http
|
|
import arrays
|
|
import maps
|
|
import math.stats
|
|
|
|
const http_port = 8080
|
|
|
|
enum Status {
|
|
besteld = 0
|
|
bakken = 1
|
|
klaar = 2
|
|
afgegeven = 3
|
|
}
|
|
|
|
pub fn (s Status) str() string {
|
|
return match s {
|
|
.besteld { 'Pannenkoek besteld' }
|
|
.bakken { 'Pannenkoek aan het bakken' }
|
|
.klaar { 'Pannenkoek klaar' }
|
|
.afgegeven { 'Pannenkoek afgegeven' }
|
|
}
|
|
}
|
|
|
|
struct Person {
|
|
id int @[primary; sql: serial]
|
|
status int
|
|
name string
|
|
remark string
|
|
order_time time.Time
|
|
delivery_time time.Time
|
|
}
|
|
|
|
pub fn (p Person) str() string {
|
|
return 'Person[id:${p.id}, name: ${p.name}, status:${p.status}, time:${p.order_time}, end:${p.delivery_time}]'
|
|
}
|
|
|
|
pub fn (p Person) order_time_humanized() string {
|
|
return p.order_time.relative()
|
|
}
|
|
|
|
pub fn (p Person) remark() string {
|
|
return if p.remark.len > 0 {
|
|
'(${p.remark})'
|
|
} else {
|
|
''
|
|
}
|
|
}
|
|
|
|
pub fn (p Person) status_str() string {
|
|
unsafe {
|
|
s := Status(p.status)
|
|
return s.str()
|
|
}
|
|
}
|
|
|
|
// === Database ===
|
|
|
|
pub fn create_db_connection() !sqlite.DB {
|
|
return sqlite.connect('pancakes.db')!
|
|
}
|
|
|
|
fn get_people() ![]Person {
|
|
mut db := create_db_connection()!
|
|
status_filter := int(Status.afgegeven)
|
|
people := sql db {
|
|
select from Person where status < status_filter
|
|
}!
|
|
return people
|
|
}
|
|
|
|
fn get_finished_count() !int {
|
|
mut db := create_db_connection()!
|
|
people := sql db {
|
|
select from Person where status == 3
|
|
}!
|
|
return people.len
|
|
}
|
|
|
|
struct PerHour {
|
|
t time.Time
|
|
label string
|
|
amount int
|
|
percentage int
|
|
color string
|
|
}
|
|
|
|
fn get_all() ![]Person {
|
|
mut db := create_db_connection()!
|
|
return sql db {
|
|
select from Person order by id desc
|
|
}!
|
|
}
|
|
|
|
fn get_last_delivered() ![]Person {
|
|
mut db := create_db_connection()!
|
|
return sql db {
|
|
select from Person order by delivery_time desc limit 1
|
|
}!
|
|
}
|
|
|
|
fn get_finished_per_hour() ![]PerHour {
|
|
mut db := create_db_connection()!
|
|
people := sql db {
|
|
select from Person where status == 3
|
|
}!
|
|
|
|
grouped := arrays.group_by(people, fn (p Person) string {
|
|
return '${p.order_time.hour}:${int(p.order_time.minute / 30) * 30} ${p.order_time.day}/${p.order_time.month}'
|
|
})
|
|
|
|
max_per_hour := arrays.max(grouped.values().map(it.len)) or { 1 } + 10
|
|
|
|
mut grouped_arr := maps.to_array(grouped, fn [max_per_hour] (k string, v []Person) PerHour {
|
|
return PerHour{
|
|
t: v[0].order_time
|
|
label: k
|
|
amount: v.len
|
|
percentage: int(v.len * 100 / max_per_hour)
|
|
color: (if v[0].order_time.hour % 2 == 0 { 'green' } else { 'red' })
|
|
}
|
|
})
|
|
grouped_arr.sort(a.t < b.t)
|
|
return grouped_arr
|
|
}
|
|
|
|
fn get_ppu() !f64 {
|
|
mut db := create_db_connection()!
|
|
mut people := sql db {
|
|
select from Person where status == 3
|
|
}!
|
|
if people.len == 0 {
|
|
return 0
|
|
}
|
|
people.sort(a.order_time < b.order_time)
|
|
time_range := people.last().order_time - people.first().order_time
|
|
return people.len / time_range.hours()
|
|
}
|
|
|
|
fn get_mean_time_between_pannenkoeken() !time.Duration {
|
|
mut db := create_db_connection()!
|
|
time_zero := time.Time{
|
|
unix: 0
|
|
}
|
|
mut people := sql db {
|
|
select from Person where (status == 3 && delivery_time > time_zero) order by delivery_time desc limit 10
|
|
}!
|
|
return stats.mean(arrays.window(people, size: 2).map(it[0].delivery_time - it[1].delivery_time))
|
|
}
|
|
|
|
fn status_update(user_id int) !Person {
|
|
mut db := create_db_connection()!
|
|
people := sql db {
|
|
select from Person where id == user_id
|
|
}!
|
|
person := people.first()
|
|
sql db {
|
|
update Person set status = person.status + 1 where id == person.id
|
|
}!
|
|
if person.status == 2 {
|
|
sql db {
|
|
update Person set delivery_time = time.now() where id == person.id
|
|
}!
|
|
}
|
|
return person
|
|
}
|
|
|
|
fn add_person(name string, remark string) ! {
|
|
mut db := create_db_connection()!
|
|
people := sql db {
|
|
select from Person where name == name && status < 3
|
|
}!
|
|
|
|
if people.len == 0 {
|
|
p := Person{
|
|
status: 0
|
|
order_time: time.now()
|
|
name: name
|
|
remark: remark
|
|
}
|
|
sql db {
|
|
insert p into Person
|
|
}!
|
|
}
|
|
}
|
|
|
|
// === WEB ===
|
|
|
|
struct App {
|
|
vweb.Context
|
|
}
|
|
|
|
pub fn (app App) before_request() {
|
|
println('[Vweb] ${app.Context.req.method} ${app.Context.req.url}')
|
|
}
|
|
|
|
fn main() {
|
|
println('Start 🥞 webserver')
|
|
mut db := create_db_connection() or { panic(err) }
|
|
|
|
sql db {
|
|
create table Person
|
|
} or { panic('error on create table: ${err}') }
|
|
|
|
db.close() or { panic(err) }
|
|
|
|
vweb.run(&App{}, http_port)
|
|
}
|
|
|
|
@['/'; get]
|
|
pub fn (mut app App) home() vweb.Result {
|
|
people := get_people() or {
|
|
app.set_status(400, '')
|
|
return app.text('${err}')
|
|
}
|
|
person_finished_count := get_finished_count() or {
|
|
app.set_status(400, '')
|
|
return app.text('${err}')
|
|
}
|
|
finished_per_hour := get_finished_per_hour() or {
|
|
app.set_status(400, '')
|
|
return app.text('${err}')
|
|
}
|
|
// pannenkoek per uur
|
|
ppu := get_ppu() or {
|
|
app.set_status(400, '')
|
|
return app.text('${err}')
|
|
}
|
|
all_people := get_all() or {
|
|
app.set_status(400, '')
|
|
return app.text('${err}')
|
|
}
|
|
mean_time := get_mean_time_between_pannenkoeken() or {
|
|
app.set_status(400, '')
|
|
return app.text('${err}')
|
|
}
|
|
mut last_delivered := get_last_delivered() or {
|
|
app.set_status(400, '')
|
|
return app.text('${err}')
|
|
}
|
|
if last_delivered.len == 0 {
|
|
last_delivered << Person{
|
|
delivery_time: time.now()
|
|
}
|
|
}
|
|
// Time to pannenkoek
|
|
time_since_last := (time.now() - last_delivered.first().delivery_time)
|
|
ttp := time.unix(i64(mean_time.seconds() - time_since_last.seconds())) - time.unix(0)
|
|
|
|
return $vweb.html()
|
|
}
|
|
|
|
@['/status_update'; post]
|
|
pub fn (mut app App) status_update() vweb.Result {
|
|
if person := status_update(app.form['id'].int()) {
|
|
if person.status == 1 {
|
|
spawn fn () {
|
|
http.post('http://10.1.0.224:8080/blink', '') or {}
|
|
}()
|
|
spawn fn (name string) {
|
|
http.post('http://10.1.2.3', 'ScrollingText >>> ${name} <<< Enjoy! ') or {}
|
|
http.post('http://10.1.2.3', 'Option text_trailingWhitespace 1') or {}
|
|
}(person.name)
|
|
}
|
|
}
|
|
|
|
return app.redirect('/')
|
|
}
|
|
|
|
@['/add_person'; post]
|
|
pub fn (mut app App) add_person() vweb.Result {
|
|
name := app.form['name']
|
|
if name.len == 0 {
|
|
return app.redirect('/')
|
|
}
|
|
|
|
add_person(app.form['name'], app.form['remark']) or {
|
|
app.set_status(400, '')
|
|
return app.text('${err}')
|
|
}
|
|
|
|
return app.redirect('/')
|
|
}
|