DEV Community: YourTech John

GoNetNinja: Day 5

YourTech John — Fri, 24 Jun 2022 16:42:02 +0000

Day 5

Today I worked on handlers to add and update activity records. I want to make use of AJAX type calls to submit and replace a row, but to get things going, I went ahead and just made each addition redirect and refresh the net page.

I made a new html template form for new activity.

<tr class="activity-new" id="activity-new">
    <%= form_for( newactivity, {action: createActivityPath(), method: "POST"}) { %>
    <%= f.InputTag("Net", {value: net.ID, hidden: true}) %>

    <td>
        <%= f.SelectTag("Action",
        {
        hide_label: true,
        size: 1,
        options:
        { "Check In": "checkin",
        "Comment": "comment",
        "Check Out": "checkout",
        "Close Net": "close",
        "Open Net": "open",
        "Assume Net Control": "netcontrol",
        },
        value: "checkin"
        }
        ) %>
    </td>
    <td><i>New</i>
    </td>
    <td class="left">
        <%= f.InputTag("Name", {value: newactivity.Name, hide_label: true, size: 8}) %>
    </td>
    <td>
        <%= f.TextAreaTag("Description", {value: newactivity.Description, hide_label: true, rows:1}) %>
    </td>
    <td>
        <%= f.DateTimeTag("TimeAt", {value: net.PlannedStart.Format("2006-01-02T15:04:00")} ) %>

        <button class="btn btn-success" role="submit" title="save"><i class='fa fa-cloud-upload-alt'></i> </button>
    </td>
    <% } %>
</tr>

I also made a copy of this for _activityrow.plus.html with just a few changes between newaction and action.

<tr class="activity-<%= activity.Action %>" id="activity-row-<%= activity.ID %>">
    <%= form_for( activity, {action: updateActivityPath({id: activity.ID}), method: "POST"}) { %>
    <td>
...
    <td>
        <%= f.DateTimeTag("TimeAt", {value: activity.TimeAt.Format("2006-01-02T15:04:00")}) %>
        <button class="btn btn-success" role="submit" title="save"><i class="fa fa-cloud-upload-alt"></i> </button>
    </td>

Then in netedit.plush.html, we include these partials.

          <tbody>
          <%= partial("newactivity.plush.html") %>
          <%= for (activity) in activities { %>
            <%= partial("activityrow.plush.html") %>
          <% } %>
          </tbody>

I added newactivity as a blank struct pointer in _LearnNet function.

func _LearnNet(c buffalo.Context, net models.Net) buffalo.Context {

    activities := models.Activities{}
    query := models.DB.Where("net = (?)", net.ID)
    query.Order("time_at desc").All(&activities)

    c.Set("newactivity", &models.Activity{})
    c.Set("activities", activities)

Create and Update activity are pretty similiar, which is often the case with CRUD like functions.


func CreateActivity(c buffalo.Context) error {
    activity := &models.Activity{}
    if err := c.Bind(activity); err != nil {
        return err
    }

    newId, err := uuid.NewV1()
    if err != nil {
        return err
    }
    activity.ID = newId

    // Validate the data from the html form
    verrs, err := models.DB.ValidateAndCreate(activity)
    if err != nil {
        return errors.WithStack(err)
    }
    if verrs.HasAny() {
        c.Set("activity", activity)
        // Make the errors available inside the html template
        c.Set("errors", verrs)
        return c.Render(422, r.HTML("home/_newactivity.plush.html"))
    }
    c.Flash().Add("success", "Net was created successfully")
    return c.Redirect(302, "/nets/%s?editmode=true", activity.Net)
}

func UpdateActivity(c buffalo.Context) error {

    activity := &models.Activity{}

    if err := models.DB.Find(activity, c.Param("id")); err != nil {
        return c.Error(http.StatusNotFound, err)
    }

    // Bind Widget to the html form elements
    if err := c.Bind(activity); err != nil {
        return err
    }

    logrus.Info("got activity ", activity.ID, " of ", activity.Action, " for net ", activity.ID)

    verrs, err := models.DB.ValidateAndUpdate(activity)
    if err != nil {
        return errors.WithStack(err)
    }

    if verrs.HasAny() {
        c.Set("activity", activity)
        // Make the errors available inside the html template
        c.Set("errors", verrs)
        return c.Render(422, r.HTML("_activityrow.plush.html"))
    }

    logrus.Info("activity updated ok")
    c.Flash().Add("success", "Activity was updated successfully")
    return c.Redirect(302, "/nets/%s?editmode=true", activity.Net)
}

One thing of note is that verrs will render _activityrow or _newrow, which is just a row of the overall table. I don't actually have any validation in activities yet - so someone could create a blank Name, timeAt, and Description. But this does pave the way for a future dynamic page load. In htmx, I can have a post replace the outer div (or table row id) with the returned html. So I should be able to do a GetActivity for a single row of activity and return that. I can also start setting up partials for the main net page which also get refreshed when an activity is updated.

Despite not implementing the dynamic concept, this app is almost feature complete. Remaining short-term features:

Fix the timestamp handling so there is a consistent usage of local time zone and UTC between the web browser and database.
Ability to edit a net name, planned star, and planned end
Ability to delete individual activities
Ability to delete a net and all associated activities

Longer term goals (in no particular order):

add tags/categories/labels to individual nets
Toggling between editable and readonly view
Exports
- Text summary for email
- Printable PDF
Authentication, local and oauth
activity reporting such as:
- how often does someone take net control?
- average length of a net, possibly by tag
- most checkins (possibly by net tag)
- most consecutive checkins (possibly by net tag)
- people we haven't heard from in a while (checkin aging report)
dynamic editing

Day 5 Wrap Up

Timer is at 18 hours, 40 minutes. I've gotten the bulk of the program implemented, hopefully I'll find time in the next couple of weeks to implement the remaining short time features.

More importantly, I got a good grasp of using go, even if I'm in a safety bubble provided by Buffalo. I didn't implement the Resources concept they document, and that is a better way to organize the various handlers and methods.

I found that Buffalo's documentation, while good, does leave a lot to be figured out. I also didn't find much help for buffalo/pop specific question on the main Q&A sites. In fact, there are only 51 questions tagged "buffalo", with only 2 asked in 2022. Gorilla has 535 questions, Beego has 287 questions (24 this year). Revel has 198 questions. Maybe all the activity is in a forum. Maybe it's so easy, no questions needed, or maybe the askers don't use the buffalo tag.

If I hadn't used buffalo or some other web framework, I'm certain I would have spent a lot more time working through the http routing. The buffalo.Context is incredibly useful. It's nice to use the Context.Bind to tie a form to a model. Their actual form helper (called tags) is helpful, but not necessary. I didn't like it applying some css classes to my input tags, which make the input field fill the container. I will ultimately either override the css, try to disable that feature, or rebuild the forms by hand.

GoNetNinja: Day 4

YourTech John — Fri, 24 Jun 2022 02:06:18 +0000

Day 4

Today I'm working html and javascript. Very little Go. I'm adding an editmode toggle link and a query param to set edit mode.

I'll have elements with the "editelement" class, and a toggle to set a class called "edithidden"

HTML:

    <a id="toggleeditor" title="toggle edit mode">
      <i class="fas fa-user-edit" tooltip="toggle edit mode"></i>Toggle Edit Mode
    </a>
    <div class="editelement"><p>I show up in edit mode</p></div>

CSS

".edithidden {
display: none;
}"

JS:

// editments is my shorthand for edit mode elements
let editments = document.getElementsByClassName("editelement")
let queryParams = new URLSearchParams(window.location.search);

function toggleeditmode() {
    for (let i = 0; i < editments.length; i++) {
        editments[i].classList.toggle("edithidden")
    }
}

function hideeditments() {
    console.log("hide edit mode")
    for (let i = 0; i < editments.length; i++) {
        editments[i].classList.add("edithidden")
    }
}

function showeditments() {
    console.log("edit mode enabled");
    for (let i = 0; i < editments.length; i++) {
        editments[i].classList.remove("edithidden")
    }
}


function initialeditmode() {
    editmode = queryParams.get("editmode",);
    // This is the way I know to turn ?editmode=something
    // into a boolean. If there is a better way, let me
    // know.
    if (editmode === null) { editmode = "false"; }
    if (JSON.parse(editmode.toLowerCase())) {
        showeditments();
    } else {
        hideeditments();
    }
}

document.addEventListener("load", initialeditmode());
document.getElementById('toggleeditor').addEventListener('click', toggleeditmode);

Making a quick net form and model.

I'm creating a form by hand for a quick net entry. This will have fields of netcontrol, opened, closed, early_checkins, and regular_checkins. This form is only going to show if there are not activity records for the net in question.

    <%= if (len(activities) < 1) { %>
    <%= partial("quicknetform.plush.html") %>
    <% } %>

Now I'm going to try and use a pop generated model to setup validation and parsing. The main idea here is that this form data will be used to generate a number of individual activity records.

I'll use buffalo to generate the model, skipping migrations.

buffalo pop generate model -s quicknet

Now we'll review the Binding Docs to work on the handler.

I edit the model to only have json/form fields that are in my form. I also make a new Validate without the tx/pop requirement. From my netcreate experience, I don't really think I need the form variation, but I'll add it for completeness.

// Quicknet is not tied to any database table
type Quicknet struct {
    Opened          time.Time `json:"opened" form:"opened"`
    Closed          time.Time `json:"closed" form:"closed"`
    NetControl      string    `json:"netcontrol" form:"netcontrol"`
    EarlyCheckins   string    `json:"early_checkins" form:"early_checkins"`
    RegularCheckins string    `json:"regular_checkins" form:"regular_checkins"`
}


func (q *Quicknet) Validate() (*validate.Errors, error) {
    return validate.NewErrors(), nil
}

Now in my handler, I should be able to bind the form and log the netcontrol value.

func QuickNetHandler(c buffalo.Context) error {

    qn := &models.Quicknet{}
    if err := c.Bind(qn); err != nil {
        return err
    }

    logrus.Info("netcontrol", qn.NetControl)
    net := models.Net{}
    if err := models.DB.Find(&net, c.Param("id")); err != nil {
        return errors.WithStack(err)
    }

    return c.Redirect(302, "/nets/%s?editmode=true", net.ID)

And indeed that works

time="2022-06-23T13:35:49-04:00" level=info msg=netcontrolsdfas

Now I'll go back to my Validate and add two checks.

func (q *Quicknet) Validate() (*validate.Errors, error) {

    verrs := validate.NewErrors()
    if q.NetControl == "" {
        verrs.Add("netcontrol", "Netcontrol must not be blank")
    }
    if q.Opened.IsZero() {
        verrs.Add("opened", "Opened must not be empty")
    }
    //verrs.Add(&validators.StringIsPresent{Field: n.Name, Name: "Name", Message: "Name can not be blank"})
    return verrs, nil
}

Ok, I ended up doing a lot of work, going to visit family, then coming back. So let's see if I can capture the highlights. The first is that I redid my form to make use of Buffalo's built in tags and form helpers. I also have it rendering the form directly instead of redirecting. This caused me to have near identical code between my NetHandler and my QuickNetHandler. I can see very soon combining the two together, and having some check to tell if the quicknet form was POSTed or not.

In the meantime, I moved all the context set from NetHandler and QuickNetHandler into a common function called _LearnNet.

func _LearnNet(c buffalo.Context, net models.Net) buffalo.Context {
    activities := models.Activities{}
    query := models.DB.Where("net = (?)", net.ID)
    query.Order("time_at desc").All(&activities)
    c.Set("activities", activities)
    c.Set("opened", GetOpen(net.ID))
    c.Set("closed", GetClose(net.ID))
    c.Set("netcontrols", NetControls(net.ID))
    c.Set("participants", NetParticipants(net.ID))
    return c
}

My QuickNetHandler has grown quite large now, so I'm going to take it in sections.

First, we query the net from the database and set that to the context. Then we set and Bind quicknet to the context, before running it through Validate. Notice this is the validate that does not have a Pop Tx database connection. If validation errors occur, we render the template again.

func QuickNetHandler(c buffalo.Context) error {
    net := models.Net{}
    if err := models.DB.Find(&net, c.Param("id")); err != nil {
        return errors.WithStack(err)
    }
    c.Set("net", net)
    quicknet := &models.Quicknet{}
    c.Set("quicknet", quicknet)
    if err := c.Bind(quicknet); err != nil {
        return err
    }

    // Validate the data from the html form
    verrs, err := quicknet.Validate()
    if err != nil {
        return errors.WithStack(err)
    }
    if verrs.HasAny() {
        c = _LearnNet(c, net)
        logrus.Info("quicknet has verrs")

        // Make the errors available inside the html template
        c.Set("errors", verrs)
        //c.Flash().Add("alert", "verrs")
        return c.Render(422, r.HTML("home/netedit.plush.html"))
    }
    logrus.Info("quicknet  has no verrs, continuing")

My html template is using the form_for. I've got text areas for both checkins, followed by net control, open and close. I can set the default values with an iso format based on the scheduled start and close. I haven't figured it out, but the form is not modifying the form group with validation errors like it does in my netnew.plush.html template. I can see the errors in the context, and I've played with the input ids and validation ids. I really want to get that working, but for now I'm just dumping the raw errors.

    <%= form_for( quicknet, {action: quicknetPath({id: net.ID}), method: "POST"}) { %>
    <%= if (errors) { %>
        <%= errors %>
    <% } %>
    <div class="row ">
        <div class="col-md-3">
            <%= f.TextAreaTag("EarlyCheckins", {rows:7}) %>
        </div>
        <div class="col-md-3">
            <%= f.TextAreaTag("RegularCheckins", {rows:7    }) %>
        </div>
        <div class="col-md-6">
            <%= f.InputTag("NetControl") %>

            <div class="form-group">
                <label for="quicknet-opened">Open Net At</label>
                <%= f.DateTimeTag("Opened", {value: net.PlannedStart.Format("2006-01-02T15:04")}) %>

            </div>
            <div class="form-group">
                <label for="quicknet-closed">Close Net At</label>
                <%= f.DateTimeTag("Closed", {value: net.PlannedEnd.Format("2006-01-02T15:04")}) %>
            </div>
            <div class="form-group">
                <button class="btn btn-success" role="submit">Update</button>
            </div>
        </div>

    </div>
    <% } %>

Now, going back into my QuickNetHandler, if we pass all the validation, we start creating activity records. We have already validated that NetControl is not empty, and that Opened is a NotZero value.

I want to assume net control at 5 minutes before the net open. GoLang's time.Time allows you to .Add durations quite easily. There is a .Sub method, but it's not the opposite of Add. To subtract, you .Add a negative duration. I'm skipping all sort of error validation here because I'm trusting my code to be correct, I already know the net.ID exists. Obviously, some race conditions can occur, but since I haven't even written the ability to delete a net yet, I'm fine with this. Also, I hope to move these operations out of the QuickNetHandler and into their own service layer at some point.

    // Assume Net Control
    _ = models.DB.Create(&models.Activity{
        //ID:          ncr_id,
        Net:         net.ID,
        Action:      "netcontrol",
        Name:        quicknet.NetControl,
        TimeAt:      quicknet.Opened.Add(-time.Minute * 5),
        Description: "Assumed Net Control",
    })

Next, we open the net.

    // Open the net
    _ = models.DB.Create(&models.Activity{
        Net:         net.ID,
        Action:      "open",
        Name:        quicknet.NetControl,
        TimeAt:      quicknet.Opened,
        Description: "Opened the net",
    })

Now, I want to close the net, if they specified a close time. For this quick form, I am doing a strong opinion that a net is at least 5 minutes long. If quicknet.Closed is non-zero, but less than 5 minutes after quicknet.Opened, I'll set it to be 5 minutes after quicknet.Opened. I'll add this to the model's Validate function.

    // force Closed (if set) to be at least 5 minutes after Open
    if !q.Closed.IsZero() && !q.Opened.IsZero() {
        if q.Closed.Before(q.Opened.Add(time.Minute * 5)) {
            q.Closed = q.Opened.Add(time.Minute * 5)
        }
    }

Then back in the handler, we can close the net.

    // Close the net if set
    if !quicknet.Closed.IsZero() {
        // In validate, we forced quicknet.Closed to be at least 5
        // minutes after the quicknet.Open
        _ = models.DB.Create(&models.Activity{
            Net:         net.ID,
            Action:      "close",
            Name:        quicknet.NetControl,
            TimeAt:      quicknet.Closed,
            Description: "Opened the net",
        })
    }

I tested these with all sorts of input values and so far everything is working great. If I blank opened, or leave netcontrol blank, I get errors. If I blank out "closed", no Closed activity is created. If I set closed to an earlier time, or the same time as opened, then the time is automatically adjusted.

Side note - I still haven't touched timezones. These activities are being created in the database with a string like "2022-06-23 15:40:29.099776-04:00", which shows the local -4 offset. Basically, I'm ignoring this for now, planning to come back in the future and fix all my timestamps all at once.

Bulk checkins

I still need to handle doing bulk checkins. I'm going to create a function in my model to parse the checkins field and return an array of checkin names.

Awesome builting strings.FieldsFunc

I anticipate users pasting in from various editors. Mostly space separated, but possibly CSV or others. I was searching on ways to split on either a comma or a whitespace and I discover the strings.FieldFunc and the main documentation does exactly what I want.

package main

import (
    "fmt"
    "strings"
    "unicode"
)

func main() {
    f := func(c rune) bool {
        return !unicode.IsLetter(c) && !unicode.IsNumber(c)
    }
    fmt.Printf("Fields are: %q", strings.FieldsFunc(" name foo1;bar2,baz3..., bag,base", f))
}
// Output: Fields are: ["name" "foo1" "bar2" "baz3" "bag" "base"]

I can make a ParseNames function pretty easily that eliminates most garbage and creates list of unique names.

func ParseNames(raw string) []string {

    f := func(c rune) bool {
        return !unicode.IsLetter(c) && !unicode.IsNumber(c)
    }
    fields := strings.FieldsFunc(raw, f)
    set := make(map[string]struct{})
    for _, f := range fields {
        _, isPresent := set[f]
        if !isPresent {
            // If the name is just a number, skip
            // ex: "1. John" => ["1", "John"]
            _, err := strconv.Atoi(f)
            if err != nil {
                set[f] = struct{}{}
            }
        }
    }
    keys := make([]string, 0, len(set))
    for k := range set {
        keys = append(keys, k)
    }
    return keys
}

Then to finish this up, I make activity records the assorted _checkins.

    // now do the early checkins
    if quicknet.EarlyCheckins != "" {
        early_names := ParseNames(quicknet.EarlyCheckins)
        early_time := quicknet.Opened.Add(-time.Second * 60)
        for _, n := range early_names {
            _ = models.DB.Create(&models.Activity{
                Net:         net.ID,
                Action:      "checkin",
                Name:        n,
                TimeAt:      early_time,
                Description: "Early checkin",
            })
        }
    }

    if quicknet.RegularCheckins != "" {
        regular_names := ParseNames(quicknet.RegularCheckins)
        regular_time := quicknet.Opened.Add(time.Second * 30)
        for _, n := range regular_names {
            _ = models.DB.Create(&models.Activity{
                Net:         net.ID,
                Action:      "checkin",
                Name:        n,
                TimeAt:      regular_time,
                Description: "Regular checkin",
            })
        }
    }

Day 4 Wrap Up

My timer is reading 16 hours, 16 minutes. Since I finished yesterday around 10 hours, it seems I put in almost a full "workday" today. Playing with html, javascript, and others is so iterative I really got into a flow. I had lots of breaks during the day, but overall that's more time than I planned to put in today. I was also hoping to get into a more dynamic ajax (htmx) process of editing the net metadata and individual activity records by now.

My QuickNetHandler has bloated in size. If I saw this on one of our python projects, I'd be cringing. I am also certain a number of my "for .. range" loops can be done in a much more sophisticated manner, and if I asked on stackoverflow, I'd probably get comments like "why don't you just the map.unique.splitfield builtin function and save yourself 100 lines of repetitive code?"

Despite all that, I am really happy with my progress. I think I'm starting to get a "feel" for golang now. With a rather quick form fill out, I can quickly populate a net's activity with reasonable approximations. Once I add in-line activity editing, it gets even better.

These two screen shots show filling out the form with a series of "humanisms" in how I enter the list of call signs. I also "accidentally" leave the close time before the start time. The second screenshot shows how that form populated the activity records.

Populated

GoNetNinja: Day 3

YourTech John — Wed, 22 Jun 2022 22:45:29 +0000

Day 3

(Project is published to github ytjohn/gonetninja)

To start off, I made an activity table. This has an id, a net foreign key id, an action, name, and description. The
time_at column is the time the net control operator says the activity happened. This is important since my most
anticipated use case is for recording the information after the fact. Live during the net recording is also a
goal, but will require a lot of focus on the frontend ui.

My original plan was to have a callsign column, but decided at the last minute to put
name here to make it a bit more flexible. But an FCC or equivalent issued callsign is
the expected value.

CREATE TABLE activity
(
    id          uuid      not null
        constraint activity_pk
            primary key,
    created_at  timestamp not null,
    updated_at  timestamp not null,
    net         uuid      not null
        constraint activity_nets_id_fk
            references nets,
    action      text      not null,
    time_at     timestamp not null,
    name        text      not null,
    description text
);
CREATE UNIQUE INDEX activity_id_uindex
    on activity (id);
CREATE INDEX activity_name_index
    on activity (name);

Actions will be an enumerated list in code. Currently this set is planned as:

open (open the net)
close (close the net)
netcontrol - assume net control
checkin check an operator into the net
checkout check an operator out of the net
comment - add a comment to the net

I created some data by hand using Jetbrains/GoLand's database IDE. It showed the
iso format, but saves it as integer. I don't know if pop is going to read that properly,
but I do agree that integer based timestamps will make for better performance and when
I get around to fixing the timezone, I'll want to set the rest up to write as timestamps
instead of iso formatted strings.

sqlite> select net, action, time_at, name, description from activity order by time_at desc;
786829ca-f1c3-11ec-a9d5-ce5390833a0f|close|1655894167000|n0call|close net
786829ca-f1c3-11ec-a9d5-ce5390833a0f|checkin|1655894047000|n3call|regular checkin
786829ca-f1c3-11ec-a9d5-ce5390833a0f|checkin|1655894047000|n4call|regular checkin
786829ca-f1c3-11ec-a9d5-ce5390833a0f|open|1655893987000|n0call|open net
786829ca-f1c3-11ec-a9d5-ce5390833a0f|checkin|1655893927000|n1call|early checkin
786829ca-f1c3-11ec-a9d5-ce5390833a0f|checkin|1655893927000|n2call|early checkin
786829ca-f1c3-11ec-a9d5-ce5390833a0f|netcontrol|1655893867000|n0call|assume net control

Now, to create the model, I'll do the generate and add my other columns like I did with nets.

buffalo pop generate model activity
rm migrations/*.fizz

And the go model.

// Activity is used by pop to map your activities database table to your go code.
type Activity struct {
    ID          uuid.UUID `json:"id" db:"id"`
    CreatedAt   time.Time `json:"created_at" db:"created_at"`
    UpdatedAt   time.Time `json:"updated_at" db:"updated_at"`
    Net         uuid.UUID `json:"net" db:"net"`
    Action      string    `json:"action"  db:"action"`
    Name        string    `json:"name" db:"name"`
    TimeAt      time.Time `json:"time_at" db:"time_at"`
    Description string    `json:"description" db:"description"`
}

// TableName overrides the table name used by Pop.
func (a Activity) TableName() string {
    return "activity"
}

Next steps for Net Activity

First is to display a net with the activity above. This will require a change to the single net handler to query all the activity for the net id, and display these in chronological order. I'll do this the lazy way as two queries, but for optimization, a database view would be the way to go long term.

Second step is I want to make my "easy" form. This is easy for the user, not for the development.

There will be fields for a net name, net control, opened time, closed time, followed by "early checkins" and "regular checkins". The handler will read these fields, create a net with the planned open/start times, then create activity for netcontrol, open, and checkins. It will need to use the open time smartly. The activity for netcontrol and "early checkins" will take place one minute before the net start time. The "open" action will be created at net time, as will checkin actions for "regular checkins".

Once all the data is saved, it should redirect back to the single net form.

Future step is to start working on a net editor, where one can edit the invidivual net information and activity.

View Net Activity

To query the activities, we update our NetHandler. After retrieving the net, we then fetch the Activities order by time_at, and add that to our context.

func NetHandler(c buffalo.Context) error {
    //tx := c.Value("tx").(*pop.Connection)
    net := models.Net{}

    if err := models.DB.Find(&net, c.Param("id")); err != nil {
        return errors.WithStack(err)
    }

    activities := models.Activities{}
    query := models.DB.Where("net = (?)", net.ID)
    if err := query.Order("time_at").All(&activities); err != nil {
        return errors.WithStack(err)
    }
    c.Set("net", net)
    c.Set("activities", activities)
    return c.Render(http.StatusOK, r.HTML("home/netview.plush.html"))
}

Then update the template to display this fanciness.

    <table class="table table-striped">
          <thead>
          <tr text-align="left">
            <th>Action</th>
            <th>Callsign/Name</th>
            <th>Description</th>
            <th>At</th>
          </tr>
          </thead>
          <tbody>
          <%= for (activity) in activities { %>
          <tr>
            <td>
              <%= activity.Action %>
            </td>
            <td class="left">
              <%= activity.Name %>
            </td>
            <td>
              <%= activity.Description %>
            </td>
            <td>
              <%= activity.TimeAt %>
            </td>
          </tr>
          <% } %>
          </tbody>
        </table>

This all amazingly worked right off the bat. The timestamp ints read from the database get converted into human readable strings, and activity is displayed in order. If there is no activity, no rows are displayed.

Now we're going to update the handler to find the list of netcontrols, the first net open time, and the last net closed. There's no validation yet decided on adding activity. Ie, someone could checkin before the net opens, add comments after it closes, close but never open the net, or open and close it several times. Our plan is to attempt to guide users through the most likely scenarios, but otherwise try to make the best of whatever is passed in.

I went ahead and created a function to find the first open, by time_at. I left error handling out.

func GetOpen(id uuid.UUID) time.Time {
    activity := models.Activity{}
    query := models.DB.Where("net = (?) AND action = (?)", id, "open")
    query.Order("time_at asc").First(&activity)
    // SELECT activity.action, activity.created_at, activity.description, activity.id, activity.name,
    //  activity.net, activity.time_at, activity.updated_at FROM activity AS activity
    // WHERE net = (?) AND action = (?)
    // ORDER BY time_at asc LIMIT 1 $1=786829ca-f1c3-11ec-a9d5-ce5390833a0f $2=open
    return activity.TimeAt
}

Then in my NetHandler function, I add this result to the context.

    c.Set("opened", GetOpen(net.ID))

I created a GetClose that is nearly identical, but with action = close and time_at desc. Creating a few extra open and close records shows the desired behavior. Alternatively, I could do time_at asc and choose Last record.

    query := models.DB.Where("net = (?) AND action = (?)", id, "close")
    query.Order("time_at desc").First(&activity)

That works, though if no action with "open" or "clsoe" is found, the time.Time defaults to Jan 1st, 0001. This is correctable in the html template, but I wonder if there's a way to have a None/Null time.Time.

      <p>
        Actual Open: <%= if (!opened.IsZero()) { %>  <b><%= opened %></b> <% } else { %> - <% } %>
        Closed: <%= if (!closed.IsZero()) { %> <b><%= closed %></b>  <% } else { %> - <% } %>
      </p>

While still working on presenting the data, we get into some fun bits with golang and queries. I wanted a list of the net control operators, as well as all the participants. This is identically the same thing, just whether you query on "netcontrol" action or not. My first stab was to make a slice of strings and then reduce that to a unique set. But various Q&A sites suggest that I make a map instead. Once I did that, I realized my sorting was out the window. So I worked out how to do a map, then throw the keys into a slice, and sort that.

I'm iterating over things twice, so I don't believe it's really performant. With a raw database query, I would do a DISTINCT select, but I'm not yet sure if that's a feature of buffalo's "pop".


func NetControls(id uuid.UUID) []string {
    //err = models.DB.Select("name").All(&users)
    set := make(map[string]struct{})

    activities := models.Activities{}
    query := models.DB.Where("net = (?) AND action = (?)", id, "netcontrol")
    query.Order("name desc").All(&activities)

    for _, a := range activities {
        logrus.Info("checking participant ?", a.Name)
        _, isPresent := set[a.Name]
        if !isPresent {
            logrus.Info("found new participant ?", a.Name)
            set[a.Name] = struct{}{}
        }
    }
    keys := make([]string, 0, len(set))
    for k := range set {
        keys = append(keys, k)
    }
    sort.Strings(keys)

    logrus.Info(keys)
    return keys
}

Then, in the template, I add in some if/else logic.

    <p><b>Net Control Operator<%= if (len(netcontrols) > 1) { %>s (<%= len(netcontrols) %>)<% } %>:
      <%= for (n) in netcontrols { %>
        <%= n %>
      <% } %>
      </b>
    <br />
    <b>Net Participant<%= if (len(participants) > 1) { %>s (<%= len(participants) %>)<% } %>:
        <%= for (p) in participants { %> <%= p %><% } %>
      </b>
    </p>

Day 3 Wrap-Up

At this point, my timer is reading 7hrs, 4 minutes. I went ahead and added 3 hours for my Monday/Tuesday work, so total time in this project is around 10 hours.

I did some further playing with the templates, adding activity-{name} classes to the rows (mainly for colors), putting some logic to create an "early" or "late" flag for checkins that happen before the net was opened or after the net was closed.

I didn't get to a point of making any forms, and I may work on this some more this evening. But the more I work on how the net details page will look, the more it helps me in thinking how the form will look. Ultimately, my net details page will also be the editable form. There would be a button to switch from readonly to an editable view. I've used htmx in the past to simplify the live ajax style of page updating, and I think it will fit here. Basically buttons to assume net control, open and close the net, and an in-line form to add activity (mainly checkins or comments). I can see a relatively seamless UI path for the "quick entry" and individual action entry, though I know there will be lots more to learn on the backend.

GoNetNinja: Days 1 and 2

YourTech John — Wed, 22 Jun 2022 13:50:10 +0000

Background

I've made a few attempts to learn go, including some online courses. These fizzled out after some time. What I've generally found is that to start learning a new programming language, you need a specific goal and time to focus on that goal. If you have an ambitious goal, you won't have enough time. Things like "finish this course" is not really a good enough goal for me.

Program goal

I finally settled on a goal, a radio net checkin manager. In amateur radio, we often have what we call "directed nets", which is something like a conference call, but one person is designation as "net control". They start the by making an annoucement on the air, ask for check-ins, and they direct the conversation. A typical small net requests check-ins, takes
5 or so comments, asks for more check-ins, and continues taking comments in 2 or more rounds, before "closing" the net.

After the net, they send out a net report stating when the net started, finished, and who checked in. They may also inclue a roster of who checked in, as well as any noteworthy
news from the net. These simple nets are usually simple to track and write a quick email summarizing the net activity.

A longer, more complicated net may change net control operators several times, and regular operators may check in and out of the net multiple times.

Specific Goals

I want a web app to

Allow members to schedule nets, list upcoming and past nets.
Record each action (net open, checkin, comments, change net control) for the net
Able to view all activity for a single net, or all activity across multiple nets
Have a simple "after action" net report form to create and record net activity all at once
1. The net start and stop
2. Net control operator(s)
3. Net checkins (early, regular)
4. Net comments
5. Upon submitting the form, a planned net will be recorded, with individual activites populated, timestamps calculated based on net start/stop fields.
Have an interface to edit net activity after the fact. The simple net after action would go here.
Have an interface to record net activity in real time, timestamps defaulting to "now". This would probably be about the same form as the net edit page.

I'm also circumventing a lot of my normal process. Like I am an API-first type of backend developer. I typically write the API, generate the swagger documentation, and work on the frontend last. Either another team is doing the frontend, or I might make one as way of demonstrating the API. In this case, I am writing everything for the frontend, pretty much all HTML forms. Things like auth, testing, and api docs are in the "nice but not needed for MVP" (I can always implement basic http auth if needed).

A future goal of this project is to setup a local call sign lookup database, with the ability to lookup from a service like hammcall.dev.

Timing

I have about 5 days while on vacation, Monday through Friday. Saturday I drive home. Yes, I'm spending part of my vacation time writing code, but I really take pleasure in producing things. This is a bit of a gamble, because if I fail to make most of this work, I might get frustrated.

Process

The consensus of the go community is to eschew heavy frameworks and learn by writing from scratch. In fact, as someone from Python that moved from Django to Flask to FastApi, I can agree with that. However, I have 5 days, so I dived through a bunch of options and settled on Buffalo. It has a router, model, and controller that seems familiar to me, and some django-like generators. I don't know if it's the best framework, too much framework, if it will get in my way, etc. There were some other frameworks I wanted to check out such as Beego and Gorilla. Beego seems even more like django, and Gorilla calls itself a toolkit (you pick and choose). Martini reminded me a lot of Flask. I ended up going with Buffalo because it claimed hot code reload, a frontend pipeline, uses gorilla under the hood for routing, and packs an ORM with it.

Database will be sqlite3 to start, since if you're not needing HA, sqlite is pretty performant and low friction.

Getting Started

The getting started documents worked, I was able to do the install, generate my project, add a few temporary custom pages. There is a main app.go for your router, and each route is mapped to a Handler. The handler has a Context which includes all the variables it should need, and you can access that context within a plush template.

Database

I did end up recreating the project a time or two to before setting the db-type to sqlite database instead of Postgres
default.

buffalo new --db-type sqlite3 gonetninja

I made a data/ directory for my database files, added those to .gitignore, edited the database.yml file to correct the path, and then ran buffalo pop create to create the
empty database files. With sqlite, I don't really think you need to do that last step, since most sqlite drives create the file automatically.

models

I went to do database models. I found this is where the documentation first let me down. If you soda generate mode {modelname}, it creates a relatively empty model and some migration files with a base set of columns (ID, CreatedAt, UpdatedAt). If I edit that model and run try to regenerate migration files, those files come out empty.

In tools like django, sqlalchemy, and alembic, I expect to make my model, then make my migrations, which will create a file with the changes necessary to get the database up to
speed.

buffalo pop generate model foo -d  # creates model, migration up, migration down
# edit model to add Name column
buffalo pop generate fizz foo2  # creates empty migration files

I also tried making the table first, and pop/soda does not inspect the database to make the models or fixtures.

sqlite> create table otherfoo (id uuid NOT NULL, created_at timestamp NOT NULL, updated_at timestamp NOT NULL, name character varying(255));

Followed by

buffalo pop generate model otherfoo

So for now, I ended up creating the for Nets and I created the tables by hand. I don't have migration files for this table, I'll just have to come back and figure out how that is supposed to work later.

My modified models/net.go:

type Net struct {
    ID           uuid.UUID `json:"id" db:"id"`
    CreatedAt    time.Time `json:"created_at" db:"created_at"`
    UpdatedAt    time.Time `json:"updated_at" db:"updated_at"`
    Name         string    `json:"name" db:"name"`
    PlannedStart time.Time `json:"planned_start" db:"planned_start"`
    PlannedEnd   time.Time `json:"planned_end" db:"planned_end"`
}

My sql by hand:

sqlite> CREATE TABLE nets (id uuid NOT NULL, created_at timestamp NOT NULL, updated_at timestamp NOT NULL, name character varying(255), planned_start timestamp, planned_end timestamp);
sqlite> insert into nets values (uuid(), strftime('%Y-%m-%d %H-%M-%S','now'), strftime('%Y-%m-%d %H-%M-%S','now'), "test one", strftime('%Y-%m-%d %H-%M-%S','now'), strftime('%Y-%m-%d %H-%M-%S','now'));
sqlite> insert into nets values (uuid(), strftime('%Y-%m-%d %H-%M-%S','now'), strftime('%Y-%m-%d %H-%M-%S','now'), "test two", strftime('%Y-%m-%d %H-%M-%S','now'), strftime('%Y-%m-%d %H-%M-%S','now'));
sqlite> insert into nets values (uuid(), strftime('%Y-%m-%d %H-%M-%S','now'), strftime('%Y-%m-%d %H-%M-%S','now'), "test three", strftime('%Y-%m-%d %H-%M-%S','now'), strftime('%Y-%m-%d %H-%M-%S','now'));
sqlite> insert into nets values (uuid(), strftime('%Y-%m-%d %H-%M-%S','now'), strftime('%Y-%m-%d %H-%M-%S','now'), "test the fourth", strftime('%Y-%m-%d %H-%M-%S','now'), strftime('%Y-%m-%d %H-%M-%S','now')); 
sqlite> .dump nets
PRAGMA foreign_keys=OFF;
BEGIN TRANSACTION;
CREATE TABLE nets (id uuid NOT NULL, created_at timestamp NOT NULL, updated_at timestamp NOT NULL, name character varying(255), planned_start timestamp, planned_end timestamp);
INSERT INTO nets VALUES('c31911fc-5d3c-4b18-b4b1-1e081aa6effd','2022-06-20 23-47-29','2022-06-20 23-47-29','test one','2022-06-20 23-47-29','2022-06-20 23-47-29');
INSERT INTO nets VALUES('ccad3aad-c9ea-4891-a604-8d02e0968ce8','2022-06-20 23-47-47','2022-06-20 23-47-47','test two','2022-06-20 23-47-47','2022-06-20 23-47-47');
INSERT INTO nets VALUES('66b685a9-ea20-4a14-b766-4d23f362be4b','2022-06-20 23-48-17','2022-06-20 23-48-17','test three','2022-06-20 23-48-17','2022-06-20 23-48-17');
INSERT INTO nets VALUES('2bc9c10a-4056-45bc-bbb6-6a482bbb30a9','2022-06-21 13-20-20','2022-06-21 13-20-20','test the fourth','2022-06-21 13-20-20','2022-06-21 13-20-20');
COMMIT;
sqlite>

I am pretty sure at this point in time, I have an issue with my timestamp and timezones. To be solved later ^tm.

Displaying Data

Now that I have my Nets, time to read it to a page. The querying page gave some basic idea, but not enough to get me anywhere. This is probably because of a lack of familiarity with go. I remembered from other learning that methods will return an err, and if you find that set, you throw an exception. But their query example for all rows is basically this:

// To retrieve records from the database in a specific order, you can use the Order method
users := []User{}
err := models.DB.Order("id desc").All(&users)

I could see it emitting SQL statements in debug logs, and I even learned to set the "users" (net in my case) to the context. But ultimately found I needed to setup a connection,
wrap that err inside an if to get a proper raise, then set the context.

func NetListHandler(c buffalo.Context) error {
    tx := c.Value("tx").(*pop.Connection)
    nets := models.Nets{}
    if err := tx.Order("name").All(&nets); err != nil {
        return errors.WithStack(err)
    }
    c.Set("nets", nets)
    return c.Render(http.StatusOK, r.HTML("home/netlist.plush.html"))
}

The "models.Nets" is predefined. A number of other examples had you do something like nets := []models.Net{}, but that already existed inside the generated models/nets.go.

The plush template will know of a "nets" variable, which you can iterate over.

        <%= for (net) in nets { %>
        <tr>
          <td class="left">
            <a href="/nets/<%= net.ID %>"><%= net.Name %></a>
          </td>
          <td>
            <%= net.PlannedStart %>
          </td>
          <td>
            <%= net.PlannedEnd %>
          </td>
        </tr>
        <% } %>

Some examples I saw had <%= variablename => which gave me all sorts of interesting errors, but the <%= variablename %>

Paths

I hard-coded /nets/{netid} in the url, but the bufallo/gorilla router lets me name these paths. There are auto-generated ones, but I like naming them explicitly.

        app.GET("/nets", NetListHandler).Name("netlistPath")
        //app.GET("/nets/{id}", func(c buffalo.Context) error {
        //  return c.Render(200, r.String(c.Param("id")))
        //}).Name("netViewPath")
        app.GET("/nets/{id}", NetHandler).Name("netViewPath")

Then back in my template, I can put the net.ID as a parameter.

   <a href="<%= netViewPath({id: net.ID}) %>"><%= net.Name %></a>

Single entry

To view a single net, it's almost identical, but I get the id from the router.

app.GET("/nets/{id}", NetHandler).Name("netViewPath")

The router add Params and Param to the context, so c.Param("id") gets me the {id} part of the path.

Additionally, I learned that models.DB replaces that tx pop.Connection!

func NetHandler(c buffalo.Context) error {
   //tx := c.Value("tx").(*pop.Connection)
   net := models.Net{}
   //if err := tx.Find(&net, c.Param("id")); err != nil {
   //   return errors.WithStack(err)
   //}
   if err := models.DB.Find(&net, c.Param("id")); err != nil {
     return errors.WithStack(err)
   }

   c.Set("net", net)
   return c.Render(http.StatusOK, r.HTML("home/netview.plush.html"))
}

Hot Reload Sadness

Running in Development says

The dev command will watch your .go and .html files and the asset folder by default. It will rebuild and restart your binary for you automatically, so you don’t have to worry about such things.

In my experience, only html file edits were live reloaded. I don't believe it actually rebuilt the binary, but just sees the new template. I didn't see any relevant issues, except for #602 from 2017 related to docker and NFS mounts. But this could be a new issue with MacOS Montery (on M1). If it keeps bugging me, I'll dig deeper and maybe submit a request. It's going to be related to inotify/fsnotify.

https://github.com/gobuffalo/buffalo/issues/510
https://github.com/fsnotify/fsnotify/issues/152

(Timer note: started tracking 6/21 @ 7:03PM. Probably have 3 hours in?)

go: upgraded github.com/fsnotify/fsnotify v1.5.1 => v1.5.4
go: upgraded golang.org/x/sys v0.0.0-20211205182925-97ca703d548d => v0.0.0-20220412211240-33da011f77ad

Create a Net

After creating the form with a name, started time and stopped time, making CreateNetHandler was really straightforward.

The models.DB.ValidateAndCreate(net) kind of exists by default. My database however, didn't originally make "name" a required field.


func CreateNetHandler(c buffalo.Context) error {
    net := &models.Net{}
    if err := c.Bind(net); err != nil {
        return err
    }

    newId, err := uuid.NewV1()
    if err != nil {
        return err
    }
    net.ID = newId

    // Validate the data from the html form
    verrs, err := models.DB.ValidateAndCreate(net)
    if err != nil {
        return errors.WithStack(err)
    }
    if verrs.HasAny() {
        c.Set("net", net)
        // Make the errors available inside the html template
        c.Set("errors", verrs)
        return c.Render(422, r.HTML("home/netnew.plush.html"))
    }
    c.Flash().Add("success", "Net was created successfully")
    return c.Redirect(302, "/nets/%s", net.ID)
}

What I did discover is that even after updating nets table to enforce not null on every column, I can still submit forms with an empty name. It appears that we're getting an empty
string, which isn't actually a null. This I think I do want to fix now instead of later.

My first attempt was to block this on the Validate function. If we had lots of data with blank names, I would do it at ValidateCreate. But in this stage of development, I plan to purge any bad data in the database.

// Validate gets run every time you call a "pop.Validate*" (pop.ValidateAndSave, pop.ValidateAndCreate, pop.ValidateAndUpdate) method.
// This method is not required and may be deleted.
func (n *Net) Validate(tx *pop.Connection) (*validate.Errors, error) {
    if n.Name == "" {
        return validate.NewErrors(), errors.New("Name can not be blank")
    }
    return validate.NewErrors(), nil
}

The problem with this validation is that it throws a 500 with stack trace. I'd rather get a smaller error that is flashed at the form. Fortunately, this is documented in the buffalo validation usage. Unfortunately, no clear examples on using that in concert with validate.NewErrors().

func (n *Net) Validate(tx *pop.Connection) (*validate.Errors, error) {
    verrs := validate.NewErrors()
    if n.Name == "" {
        verrs.Add("name", "Name must not be blank!")
    }
    //verrs.Add(&validators.StringIsPresent{Field: n.Name, Name: "Name", Message: "Name can not be blank"})
    return verrs, nil
}

There is a different syntax of &validators.StringIsPresent but the usage is different and the example given is a different use case than the prior examples. My best hint at how to implement comes from issue 2177, which demonstrates using the validate.NewErrors().Add / verrs.Add approach.

Day 2 Wrap-Up

I started writing the app Monday evening, and spent most time on Tuesday. It wasn't till a couple hours in that I started making these notes and setup a timer. I'll say I've got 2-3
hours unaccounted for, and according to my timer now, I am at 1 hour, 37 minutes.

An festering issue is the timestamps. I do want to store date time in UTC, but display it in the user's local timezone. The dates from the web form are being submitted using local time, and stored in the database as UTC (+0000). In other (Python) projects, I was able to use javascript to get the browser's timezone, and I could use datetime tz methods in the backend to save as UTC. I'm sure there's a similiar approach here, so hopefully I'll find time to implement correct time zoning here.

Another future validation is to not allow a net to end before it starts.

Project is published to github ytjohn/gonetninja

Screenshots

Here is the net listing page

Here is creating a new net with blank name validation. Basically clicking on the name and hitting enter.

Creating a net with a proper name and choosing the time

And finally, viewing that single net we just created.

Keybase File Sync On Demand

YourTech John — Thu, 09 Jul 2020 14:46:51 +0000

Keybase file sharing

I do 90% of my development inside a Linux VM and use VSCode + Remote SSH. In addition, I maintain a sprawling notebook on this development vm. On occasion, I'd like a copy of some of these notes on another device. Up until today, I usually have to copy/paste the contents or use scp to extradite the file. Obviously there are better solutions.

I don't necessarily want these to be synchronized to all my other devices automatically, and I don't need the ability to edit these notes on my phone. What I want is the ability to browse the files from another device and access it on demand. I've been a long-time keybase user (ytjohn), and decided to make use of their file sharing. Unlike Dropbox, Google Drive, and Box, there is no sync model. The files stream in on demand. I decided to create a a one-way rsync of my notebook to the keybase filesystem. I also decided to use a separate keybase account for my VM.

I installed the keybase client on my development vm and gave it its own separate account. I could have used my main account, but I feel more comfortable keeping the account on this VM separate from my main account. All it's going to be used for is files. I registered my second keybase account as "ytjohndev".

I did the basic install and you can sign up with only providing an email address. No need for a password just yet. For safety, you should do a keybase paperkey and back that up somewhere.

ytjohn@dev:~$ keybase signup
Your email address: hidden@example.cpm
Your desired username: ytjohndev
A public name for this device [home computer]: dev
▶ INFO Signed up and provisioned a device. [tags:ENG=...]

Welcome to keybase.io!

   - you are now logged in as ytjohndev
   - your profile on keybase is https://keybase.io/ytjohndev
   - type 'keybase help' for more instructions

Found a bug? Please report it with `keybase log send`

Enjoy!

The next step is to share files with myself. On Linux, keybase creates a series of mounts at "/keybase".

On Linux, you want to browse to "/keybase/private". One will exist of "/keybase/private/yourusername", and you can immediately
start copying files there. There are also implicit directories that don't appear, but the kbfs will report as already existing. To
share with another user, you would put a file into a directory of "/keybase/private/yourusername,friendsusername".

ytjohn@dev:/keybase/private$ mkdir ytjohndev,ytjohn
mkdir: cannot create directory ytjohndev,ytjohn: File exists
ytjohn@dev:/keybase/private$ cd ytjohndev,ytjohn
ytjohn@dev:/keybase/private/ytjohndev,ytjohn$ ls
ytjohn@dev:/keybase/private/ytjohndev,ytjohn$ echo hi > hi.txt

On my regular keybase, I received no notification of this. On my Mac, keybase was in "/Volumes/Keybase". The private directory was
not showing my shared files. However, once I cd'd into "ytjohn,ytjohndev", then keybase gave me a notification about shared files, and I was
able to see the shared file.

jh1:~ ytjohn$ cd /Volumes/Keybase
jh1:Keybase ytjohn$ ls private
ytjohn  ytjohn,friend1  ytjohn,friend2  ytjohn,doesnothaveathirdfriendintheworld
jh1:Keybase ytjohn$ cd private/ytjohn,ytjohndev  # keybase popped up a sharing notification at this point
jh1:ytjohn,ytjohndev ytjohn$ ls
hi.txt

Now I just needed to sync my files back on my dev vm.

ytjohn@dev:~$ rsync -aqr $HOME/Documents/notebook /keybase/private/ytjohndev,ytjohn/

Then back on my MBP, I can see them.

jh1:ytjohn,ytjohndev ytjohn$ ls /Volumes/Keybase/private/ytjohn,ytjohndev/notebook/
2020  inbox

Finally, I put this in crontab on my dev VM for every 10 minutes. Run crontab -e to edit my personal crontab.

*/10 * * * * rsync -ah /home/ytjohn/Documents/notebook/ /keybase/private/ytjohndev,ytjohn/notebook --delete

Note: the --delete will delete files in "notebook/" not existing in my source of $HOME/Documents/notebook. As such,
if I want to send back a file from another system, I should not put it in the notebook directory.
Now I'll lets make a few test cases.

ytjohn@dev:~/Documents/notebook$ echo "this is a cronjob test" > crontest.txt
ytjohn@dev:~/Documents/notebook$ echo "this is a delete test" > /keybase/private/ytjohndev,ytjohn/notebook/deletetest.txt

Let's sit here for many minutes waiting for crontab to run. Make sure to do nothing else except watch the clock tick every 2 seconds.

ytjohn@dev:~/Documents/notebook$ watch ls -l /keybase/private/ytjohndev,ytjohn/notebook

Watching...

Every 2.0s: ls -l /keybase/private/ytjohndev,ytjohn/notebook/     dev: Thu Jul  9 13:38:27 2020

total 2
drwx------ 1 ytjohn root 990 Jul  7 14:49 2020
-rw------- 1 ytjohn root   0 Jul  9 13:36 deletetest.txt
drwx------ 1 ytjohn root 566 Jul  9 13:02 inbox

And success:

Every 2.0s: ls -l /keybase/private/ytjohndev,ytjohn/notebook/     dev: Thu Jul  9 13:41:14 2020

total 3
drwx------ 1 ytjohn root 990 Jul  7 14:49 2020
-rw------- 1 ytjohn root  23 Jul  9 13:36 crontest.txt
drwx------ 1 ytjohn root 566 Jul  9 13:02 inbox

Final Thoughts

If the goal is a two-way sync, syncthing would be a better fit. If you want to share with a larger group, Keybase Teams makes that possible. In fact, what we did was create a two-person private team. I had also considered just pointing my editor to edit directly in keybase directory, but this would create traffic to keybase on each save. Additionally, if keybase was having issues, it could render the directory unavailable.