some initial image stuff

lexicons/org/xcvr/lrc/media.json

···
+{
+	"lexicon": 1,
+	"id": "org.xcvr.lrc.media",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "A piece of media",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["signetURI", "media"],
+				"properties": {
+					"signetURI": {
+						"type": "string",
+						"format": "at-uri"
+					},
+          "media": {
+            "type": "union",
+            "required": ["image", "alt"],
+            "properties": {
+              "image": {
+                "type": "blob",
+                "accept": ["image/*"],
+                "maxSize": 1000000
+              },
+              "alt": {
+                "type": "string",
+                "description": "Alt text description of the image, for accessibility."
+              }
+            }
+          },
+					"color": {
+						"type": "integer",
+						"minimum": 0,
+						"maximum": 16777215
+					},
+					"nick": {
+						"type": "string",
+						"maxLength": 16,
+					},
+					"postedAt": {
+						"type": "string",
+						"format": "datetime"
+					}
+				}
+			}
+		}
+	}
+}

lexicons/org/xcvr/lrc/message.json

···
 						"format": "at-uri"
 					},
 					"body": {
-						"type": "string",
+						"type": "string"
 					}, 
 					"nick": {
 						"type": "string",
-						"maxLength": 16,
-						"default": "wanderer"
+						"maxLength": 16
 					},
 					"color": {
 						"type": "integer",
···
 			}
 		}
 	}
-}
+}

migrations/005_initimages.down.sql

···
+DROP INDEX IF EXISTS medias_signet_uri_idx;
+DROP TABLE IF EXISTS medias;

migrations/005_initimages.up.sql

···
+CREATE TABLE medias (
+	uri TEXT PRIMARY KEY,
+	did TEXT NOT NULL,
+	signet_uri TEXT NOT NULL,
+	FOREIGN KEY (signet_uri) REFERENCES signets(uri) ON DELETE CASCADE,
+	media_cid TEXT,
+	media_mime TEXT,
+	alt TEXT,
+	nick TEXT NOT NULL,
+	color INTEGER CHECK (color BETWEEN 0 AND 16777215),
+	cid TEXT NOT NULL,
+	posted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+	indexed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX ON medias (signet_uri);

server/internal/db/lexicon.go

···
 		`, uri)
 	return err
 }
+
+func (s *Store) StoreImage(image *types.Image, ctx context.Context) error {
+	_, err := s.pool.Exec(ctx, `INSERT INTO medias (
+		uri,
+		did,
+		signet_uri,
+		image_cid,
+		image_mime,
+		alt,
+		nick,
+		color,
+		cid,
+		posted_at
+		) VALUES (
+		$1, $2, $3, $4, $5, $6, $7, $8, $9, $10
+		) ON CONFLICT (uri) DO NOTHING`,
+		image.URI,
+		image.DID,
+		image.SignetURI,
+		image.ImageCID,
+		image.ImageMIME,
+		image.Alt,
+		image.Nick,
+		image.Color,
+		image.CID,
+		image.PostedAt)
+	if err != nil {
+		return errors.New("effor storing image: " + err.Error())
+	}
+	return nil
+}
+
+func (s *Store) UpdateImage(image *types.Image, ctx context.Context) error {
+	_, err := s.pool.Exec(ctx, `INSERT INTO medias (
+		uri,
+		did,
+		signet_uri,
+		image_cid,
+		image_mime,
+		alt,
+		nick,
+		color,
+		cid,
+		posted_at
+		) VALUES (
+		$1, $2, $3, $4, $5, $6, $7, $8, $9, $10
+		)`,
+		image.URI,
+		image.DID,
+		image.SignetURI,
+		image.ImageCID,
+		image.ImageMIME,
+		image.Alt,
+		image.Nick,
+		image.Color,
+		image.CID,
+		image.PostedAt)
+	if err != nil {
+		return errors.New("effor updating image: " + err.Error())
+	}
+	return nil
+}
+
+func (s *Store) DeleteImage(uri string, ctx context.Context) error {
+	_, err := s.pool.Exec(ctx, `DELETE from medias m WHERE m.uri = $1`, uri)
+	if err != nil {
+		return errors.New("bep bep bop: " + err.Error())
+	}
+	return nil
+}
+
+func (s *Store) GetImage(uri string, ctx context.Context) (*types.Image, error) {
+	row := s.pool.QueryRow(ctx, `SELECT FROM medias (
+		did,
+		signet_uri,
+		media_cid,
+		media_mime,
+		alt,
+		nick,
+		color,
+		cid,
+		posted_at
+		) WHERE uri = $1`, uri)
+	var image types.Image
+	err := row.Scan(&image.DID,
+		&image.SignetURI,
+		&image.ImageCID,
+		&image.ImageMIME,
+		&image.Alt,
+		&image.Nick,
+		&image.Color,
+		&image.CID,
+		&image.PostedAt)
+	if err != nil {
+		return nil, errors.New("effor storing image: " + err.Error())
+	}
+	image.URI = uri
+	return &image, nil
+}

server/internal/handler/handler.go

···
 	mux.HandleFunc("DELETE /lrc/{user}/{rkey}/ws", h.oauthMiddleware(h.deleteChannel))
 	mux.HandleFunc("POST /lrc/channel", h.oauthMiddleware(h.postChannel))
 	mux.HandleFunc("POST /lrc/message", h.oauthMiddleware(h.postMessage))
+	mux.HandleFunc("POST /lrc/image", h.oauthMiddleware(h.uploadImage))
+	mux.HandleFunc("POST /lrc/media", h.oauthMiddleware(h.postMedia))
+	// mux.HandleFunc("GET  /lrc/image", h.getImage)
+	mux.HandleFunc("POST /lrc/imagePub", h.oauthMiddleware(h.postImagePub))
 	mux.HandleFunc("POST /lrc/mymessage", h.postMyMessage)
 	// xcvr handlers
 	mux.HandleFunc("POST /xcvr/profile", h.oauthMiddleware(h.postProfile))

server/internal/handler/lrcHandlers.go

···
 	"encoding/json"
 	"errors"
 	"fmt"
-	atoauth "github.com/bluesky-social/indigo/atproto/auth/oauth"
 	"net/http"
 	"os"
 	"rvcx/internal/atputils"
 	"rvcx/internal/types"
+	"strings"
+
+	atoauth "github.com/bluesky-social/indigo/atproto/auth/oauth"
 )
 
 func (h *Handler) acceptWebsocket(w http.ResponseWriter, r *http.Request) {
···
 	}
 	f(w, r)
 }
+
+func (h *Handler) uploadImage(cs *atoauth.ClientSession, w http.ResponseWriter, r *http.Request) {
+	if cs == nil {
+		h.badRequest(w, errors.New("must be authorized to post image"))
+		return
+	}
+	err := r.ParseMultipartForm(1 << 20)
+	if err != nil {
+		h.badRequest(w, errors.New("beep bop bad image: "+err.Error()))
+		return
+	}
+	file, fheader, err := r.FormFile("image")
+	if err != nil {
+		h.badRequest(w, errors.New("failed to formfile: "+err.Error()))
+		return
+	}
+	defer file.Close()
+	ct := fheader.Header.Get("Content-Type")
+	if !strings.HasPrefix(ct, "image/") {
+		h.badRequest(w, errors.New("must post an image"))
+		return
+	}
+	blob, err := h.rm.PostImage(cs, file, r.Context())
+	if err != nil {
+		h.serverError(w, errors.New("failed to upload: "+err.Error()))
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	encoder := json.NewEncoder(w)
+	encoder.Encode(blob)
+}
+
+func (h *Handler) postMedia(cs *atoauth.ClientSession, w http.ResponseWriter, r *http.Request) {
+	if cs == nil {
+		h.badRequest(w, errors.New("must be authorized to post media"))
+	}
+	mr, err := parseMediaRequest(r)
+	if err != nil {
+		h.badRequest(w, err)
+		return
+	}
+	h.rm.PostMedia(cs, mr, r.Context())
+}
+
+func parseMediaRequest(r *http.Request) (*types.ParseMediaRequest, error) {
+	beep := json.NewDecoder(r.Body)
+	var mr types.ParseMediaRequest
+	err := beep.Decode(&mr)
+	if err != nil {
+		return nil, errors.New("A aaaaaa : " + err.Error())
+	}
+	return &mr, nil
+}
+
+// func (h *Handler) getImage(w http.ResponseWriter, r *http.Request) {
+// 	vals := r.URL.Query()
+// 	uri := vals.Get("uri")
+// 	if uri == "" {
+// 		h.badRequest(w, errors.New("must provide a did and cid"))
+// 		return
+// 	}
+// 	image, err := h.db.GetImage(uri, r.Context())
+// 	if err != nil {
+// 		h.notFound(w, err)
+// 		return
+// 	}
+// 	uploadDir := fmt.Sprintf("./uploads/%s", image.DID)
+// 	_, err = os.Stat(uploadDir)
+// 	if os.IsNotExist(err) {
+// 		os.Mkdir(uploadDir, 0755)
+// 	}
+//
+// 	imgPath := fmt.Sprintf("./uploads/%s", image.ImageCID)
+// 	_, err = os.Stat(imgPath)
+// 	if err != nil {
+// 		syncGetBlob(image.DID, image.ImageCID)
+// 	}
+//
+// 	img, err := os.Open(fmt.Sprintf("%s/%s", uploadDir, image.ImageCID))
+// 	img.WriteTo(w)
+// }
+
+// func syncGetBlob(did string, cid *string) {
+// 	//TODO: impl
+// }
+
+func (h *Handler) postImagePub(cs *atoauth.ClientSession, w http.ResponseWriter, r *http.Request) {
+
+}

server/internal/lex/types.go

···
 	AuthorHandle  string  `json:"authorHandle" cborgen:"authorHandle"`
 	StartedAt     *string `json:"startedAt,omitempty" cborgen:"startedAt,omitempty"`
 }
+
+type MediaRecord struct {
+	LexiconTypeID string  `json:"$type,const=org.xcvr.lrc.media" cborgen:"$type,const=org.xcvr.lrc.media"`
+	SignetURI     string  `json:"signetURI" cborgen:"signetURI"`
+	Media         Media   `json:"media" cborgen:"media"`
+	Nick          *string `json:"nick,omitempty" cborgen:"nick,omitempty"`
+	Color         *uint64 `json:"color,omitempty" cborgen:"color,omitempty"`
+	PostedAt      string  `json:"postedAt" cborgen:"postedAt"`
+}
+
+type Media struct {
+	Image *Image
+}
+
+type Image struct {
+	LexiconTypeID string           `json:"$type,const=org.xcvr.lrc.image" cborgen:"$type,const=org.xcvr.lrc.image"`
+	Alt           string           `json:"alt" cborgen:"alt"`
+	AspectRatio   *AspectRatio     `json:"aspectRatio,omitempty" cborgen:"aspectRatio,omitempty"`
+	Image         *util.BlobSchema `json:"image,omitempty" cborgen:"image,omitempty"`
+}
+
+type AspectRatio struct {
+	Height int64 `json:"height" cborgen:"height"`
+	Width  int64 `json:"width" cborgen:"width"`
+}

server/internal/oauth/oauthclient.go

···
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 
 	"github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/atproto/auth/oauth"
+	atpclient "github.com/bluesky-social/indigo/atproto/client"
 	"github.com/bluesky-social/indigo/atproto/syntax"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 
+	"mime/multipart"
 	"rvcx/internal/lex"
 	"rvcx/internal/log"
 	"rvcx/internal/types"
···
 	}
 	return profile, nil
 }
+
+func UploadBLOB(cs *oauth.ClientSession, file multipart.File, ctx context.Context) (*lexutil.BlobSchema, error) {
+	client := cs.APIClient()
+
+	req := atpclient.NewAPIRequest("POST", "com.atproto.repo.uploadBlob", file)
+	resp, err := client.Do(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("upload failed withy status %d", resp.StatusCode)
+	}
+	var result lexutil.BlobSchema
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&result)
+	if err != nil {
+		return nil, errors.New("failed to decode: " + err.Error())
+	}
+	return &result, nil
+}
+
+func CreateXCVRMedia(cs *oauth.ClientSession, imr *lex.MediaRecord, ctx context.Context) (uri string, cid string, err error) {
+	c := cs.APIClient()
+	body := map[string]any{
+		"collection": "org.xcvr.lrc.message",
+		"repo":       *c.AccountDID,
+		"record":     imr,
+	}
+	var out atproto.RepoCreateRecord_Output
+	err = c.Post(ctx, "com.atproto.repo.createRecord", body, &out)
+	if err != nil {
+		err = errors.New("oops! failed to create a media: " + err.Error())
+		return
+	}
+	uri = out.Uri
+	cid = out.Cid
+	return
+}

server/internal/recordmanager/media.go

···
+package recordmanager
+
+import (
+	"context"
+	"errors"
+	atoauth "github.com/bluesky-social/indigo/atproto/auth/oauth"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+	"mime/multipart"
+	"rvcx/internal/lex"
+	"rvcx/internal/oauth"
+	"rvcx/internal/types"
+	"time"
+)
+
+func (rm *RecordManager) PostImage(cs *atoauth.ClientSession, file multipart.File, ctx context.Context) (*lexutil.BlobSchema, error) {
+	return oauth.UploadBLOB(cs, file, ctx)
+}
+
+func (rm *RecordManager) PostMedia(cs *atoauth.ClientSession, mr *types.ParseMediaRequest, ctx context.Context) error {
+	switch mr.Type {
+	case "image":
+		return rm.postImageRecord(cs, mr, ctx)
+	default:
+		return nil
+	}
+}
+
+func (rm *RecordManager) postImageRecord(cs *atoauth.ClientSession, mr *types.ParseMediaRequest, ctx context.Context) error {
+	imr, now, err := rm.validateImageRecord(mr)
+	if err != nil {
+		return errors.New("coudlnt validate media record: " + err.Error())
+	}
+	img, err := rm.createImageRecord(cs, imr, now, ctx)
+	if err != nil {
+		return errors.New("coudlnt validate media record: " + err.Error())
+	}
+	err = rm.db.StoreImage(img, ctx)
+	if err != nil {
+		return errors.New("beeped that up!: " + err.Error())
+	}
+	return nil
+}
+
+func (rm *RecordManager) validateImageRecord(mr *types.ParseMediaRequest) (*lex.MediaRecord, *time.Time, error) {
+	var imr lex.MediaRecord
+	imr.SignetURI = mr.SignetURI
+	imr.Nick = mr.Nick
+	cptr := mr.Color
+	if cptr != nil {
+		cnum := uint64(*cptr)
+		imr.Color = &cnum
+	}
+	imr.Media.Image = mr.Image
+	nowsyn := syntax.DatetimeNow()
+	imr.PostedAt = nowsyn.String()
+	nt := nowsyn.Time()
+	now := &nt
+	return &imr, now, nil
+}
+
+func (rm *RecordManager) createImageRecord(cs *atoauth.ClientSession, imr *lex.MediaRecord, now *time.Time, ctx context.Context) (*types.Image, error) {
+	uri, cid, err := oauth.CreateXCVRMedia(cs, imr, ctx)
+	if err != nil {
+		return nil, errors.New("beeped up: " + err.Error())
+	}
+	var img types.Image
+	img.URI = uri
+	img.DID = cs.Data.AccountDID.String()
+	img.SignetURI = imr.SignetURI
+	if imr.Media.Image != nil {
+		img.Alt = imr.Media.Image.Alt
+		if imr.Media.Image.Image != nil {
+			img.ImageMIME = &imr.Media.Image.Image.MimeType
+			icid := imr.Media.Image.Image.Ref.String()
+			img.ImageCID = &icid
+		}
+	}
+	img.Nick = imr.Nick
+	img.CID = cid
+	if imr.Color != nil {
+		c := uint32(*imr.Color)
+		img.Color = &c
+	}
+	if now != nil {
+		img.PostedAt = *now
+	} else {
+		img.PostedAt = time.Now()
+	}
+	return &img, nil
+}

server/internal/types/lexicons.go

···
 
 import (
 	"encoding/json"
+	"rvcx/internal/lex"
 	"time"
 )
 
···
 	Messages []SignedMessageView `json:"messages"`
 	Cursor   *string             `json:"cursor,omitempty"`
 }
+
+type Image struct {
+	URI       string
+	DID       string
+	SignetURI string
+	ImageCID  *string
+	ImageMIME *string
+	Alt       string
+	Nick      *string
+	Color     *uint32
+	CID       string
+	PostedAt  time.Time
+	IndexedAt time.Time
+}
+
+type ParseMediaRequest struct {
+	Nick      *string    `json:"nick,omitempty"`
+	Color     *uint32    `json:"color,omitempty"`
+	SignetURI string     `json:"signetURI"`
+	Image     *lex.Image `json:"image,omitempty"`
+	Type      string     `json:"type"`
+}