Тестикулировать
Simple nats
https://nats.io/
https://github.com/nats-io/nats.go
Neo4j + triplet
package main
import (
"context"
"github.com/neo4j/neo4j-go-driver/v5/neo4j"
"log"
"os"
"fmt"
)
type Triplet struct {
Object string
Predicate string
Subject string
}
func main() {
ctx := context.TODO()
uri := "bolt://localhost:7687"
username := "neo4j"
password := "neo4jneo4j"
var driver neo4j.DriverWithContext
var session neo4j.SessionWithContext
var triplet Triplet
triplet.Object = os.Args[1]
triplet.Predicate = os.Args[2]
triplet.Subject = os.Args[3]
driver, err := createDriver(uri, username, password)
if err != nil {
log.Fatal(err)
}
session, err = createSession(ctx, driver)
if err != nil {
log.Fatal(err)
}
message, err := createTriplet(ctx, triplet, session)
if err != nil {
log.Fatal(err)
}
log.Println("message: ", message)
defer driver.Close(ctx)
defer session.Close(ctx)
}
func createDriver(uri, username, password string) (neo4j.DriverWithContext, error) {
driver, err := neo4j.NewDriverWithContext(uri, neo4j.BasicAuth(username, password, ""))
if err != nil {
return nil, err
}
return driver, nil
}
func createSession(ctx context.Context, driver neo4j.DriverWithContext) (neo4j.SessionWithContext, error) {
session := driver.NewSession(ctx, neo4j.SessionConfig{AccessMode: neo4j.AccessModeWrite})
return session, nil
}
func createTriplet(ctx context.Context, t Triplet, session neo4j.SessionWithContext) (string, error) {
var template = "MERGE (o:Node {name: \"%s\"}) " +
"MERGE (s:Node {name: \"%s\"}) " +
"MERGE (o)-[:%s]-(s)"
request := fmt.Sprintf(template, t.Object, t.Subject, t.Predicate)
_, err := session.ExecuteWrite(
ctx,
func(transaction neo4j.ManagedTransaction) (any, error) {
result, err := transaction.Run(ctx, request, map[string]any{})
if err != nil {
return nil, err
}
if result.Next(ctx) {
return result.Record().Values[0], nil
}
return nil, result.Err()
})
if err != nil {
return "", err
}
return "", nil
}
Running list
//show.go
package main
import (
"fmt"
"time"
)
func PrintTasks(tasks []Task) {
printCanvas()
for _, t := range tasks {
printTasks(t)
}
}
func printCanvas() {
day := time.Now()
fmt.Printf("\tsun\tmon\ttue\twen\tthu\tfri\tsat\t\t Weeknumber %d\n", (day.YearDay() / 7))
fmt.Printf("\t#############################################################################################\n")
}
func printTasks(t Task) {
day := time.Now()
week := [7]int{0, 0, 0, 0, 0, 0, 0}
switch t.Done {
case -1:
for i := t.CreateDay; i < day.Weekday(); i++ {
week[i] = 2
}
default:
for i := t.CreateDay; i < t.Done; i++ {
week[i] = 2
}
week[t.Done] = 1
}
fmt.Printf(
"\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
printDays(week[0]),
printDays(week[1]),
printDays(week[2]),
printDays(week[3]),
printDays(week[4]),
printDays(week[5]),
printDays(week[6]),
t.Description,
)
}
func printDays(i int) string {
switch i {
case 1:
return "[X]"
case 2:
return "[ ]"
default:
return " "
}
}
//struct.go
package main
import "time"
type Task struct {
Description string
Done time.Weekday
CreateDay time.Weekday
Week int
}
func (t *Task) NewTask(description string) {
day := time.Now()
t.Description = description
t.Done = -1
t.CreateDay = day.Weekday()
t.Week = day.YearDay() / 7
}
//main.go
package main
import "time"
func main() {
week := time.Now().YearDay()
tasks := []Task{
Task{
Description: "Test 123",
Done: time.Wednesday,
CreateDay: time.Monday,
Week: week,
},
Task{
Description: "Test 32",
Done: -1,
CreateDay: time.Monday,
Week: week,
},
Task{
Description: "Test 32",
Done: time.Tuesday,
CreateDay: time.Tuesday,
Week: week,
},
Task{
Description: "Test 32",
Done: time.Monday,
CreateDay: time.Sunday,
Week: week,
},
}
PrintTasks(tasks)
}
package main
import (
"log"
"net"
)
func echoServer(c net.Conn) {
for {
buf := make([]byte, 512)
nr, err := c.Read(buf)
if err != nil {
return
}
data := buf[0:nr]
println("Server got:", string(data))
_, err = c.Write(data)
if err != nil {
log.Fatal("Write: ", err)
}
}
}
func main() {
l, err := net.Listen("unix", "/tmp/echo.sock")
if err != nil {
log.Fatal("listen error:", err)
}
for {
fd, err := l.Accept()
if err != nil {
log.Fatal("accept error:", err)
}
go echoServer(fd)
}
}
package main
import (
"io"
"log"
"net"
"time"
)
func reader(r io.Reader) {
buf := make([]byte, 1024)
for {
n, err := r.Read(buf[:])
if err != nil {
return
}
println("Client got:", string(buf[0:n]))
}
}
func main() {
c, err := net.Dial("unix", "/tmp/echo.sock")
if err != nil {
panic(err)
}
defer c.Close()
go reader(c)
for {
_, err := c.Write([]byte("hi"))
if err != nil {
log.Fatal("write error:", err)
break
}
time.Sleep(1e9)
}
}
package main
import "github.com/martinlindhe/notify"
func main() {
// show a notification
notify.Notify("app name", "notice", "some text", "path/to/icon.png")
// show a notification and play a alert sound
notify.Alert("app name", "alert", "some text", "path/to/icon.png")
}
ponzu
https://github.com/ponzu-cms/ponzu