add getimage

server/internal/atputils/blob.go

···
+package atputils
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/bluesky-social/indigo/api/atproto"
+	"github.com/bluesky-social/indigo/atproto/client"
+)
+
+func SyncGetBlob(did string, cid string, ctx context.Context) ([]byte, error) {
+	host, err := GetPDSFromDid(ctx, did, http.DefaultClient)
+	if err != nil {
+		return nil, err
+	}
+	c := client.NewAPIClient(host)
+	return atproto.SyncGetBlob(ctx, c, cid, did)
+}

server/internal/db/lexicon.go

···
 	image.URI = uri
 	return &image, nil
 }
+
+func (s *Store) GetImageDidCID(did string, cid string, ctx context.Context) (*types.Image, error) {
+	row := s.pool.QueryRow(ctx, `SELECT FROM images (
+		uri,
+		signet_uri,
+		blob_cid,
+		blob_mime,
+		alt,
+		height,
+		width,
+		nick,
+		color,
+		posted_at
+		) WHERE did = $1 AND cid = $2`, did, cid)
+	var image types.Image
+	err := row.Scan(&image.URI,
+		&image.SignetURI,
+		&image.BlobCID,
+		&image.BlobMIME,
+		&image.Alt,
+		&image.Height,
+		&image.Width,
+		&image.Nick,
+		&image.Color,
+		&image.PostedAt)
+	if err != nil {
+		return nil, errors.New("effor storing image: " + err.Error())
+	}
+	image.DID = did
+	image.CID = cid
+	return &image, nil
+}

server/internal/handler/handler.go

···
 	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("GET  /lrc/image", h.WithCORS(h.getImage))
 	mux.HandleFunc("POST /lrc/mymessage", h.postMyMessage)
 	// xcvr handlers
 	mux.HandleFunc("POST /xcvr/profile", h.oauthMiddleware(h.postProfile))

server/internal/handler/lrcHandlers.go

···
 	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 (h *Handler) getImage(w http.ResponseWriter, r *http.Request) {
+	vals := r.URL.Query()
+	var did string
+	var cid string
+	uri := vals.Get("uri")
+	var image *types.Image
+	var err error
+	if uri != "" {
+		image, err = h.db.GetImage(uri, r.Context())
+		if err == nil {
+			did = image.DID
+			if image.BlobCID != nil {
+				cid = *image.BlobCID
+			}
+		}
+	}
+	if did == "" {
+		did = vals.Get("did")
+		if did == "" {
+			handle := vals.Get("handle")
+			if handle == "" {
+				h.badRequest(w, errors.New("must provide an identity"))
+				return
+			}
+			did, err = h.db.ResolveHandle(handle, r.Context())
+			if err != nil {
+				h.badRequest(w, errors.New("failed to resolve handle"))
+				return
+			}
+		}
+	}
+	if did == "" {
+		h.serverError(w, errors.New("empty did"))
+		return
+	}
+	if cid == "" {
+		cid = vals.Get("cid")
+	}
+	if cid == "" {
+		h.serverError(w, errors.New("empty cid"))
+	}
+	uploadDir := "./uploads"
+	_, err = os.Stat(uploadDir)
+	if os.IsNotExist(err) {
+		os.Mkdir(uploadDir, 0755)
+	}
+
+	imgPath := fmt.Sprintf("%s/%s%s", uploadDir, did, cid)
+	_, err = os.Stat(imgPath)
+	if err != nil {
+		blob, err := atputils.SyncGetBlob(did, cid, r.Context())
+		if err != nil {
+			h.serverError(w, err)
+			return
+		}
+		file, err := os.Create(imgPath)
+		if err != nil {
+			h.serverError(w, err)
+			return
+		}
+		_, err = file.Write(blob)
+		if err != nil {
+			h.serverError(w, err)
+			return
+		}
+	}
+
+	stats, err := os.Stat(imgPath)
+	if err != nil {
+		h.serverError(w, errors.New("yikes, file not there even though it should?: "+err.Error()))
+		return
+	}
+
+	if image == nil {
+		image, err = h.db.GetImageDidCID(did, cid, r.Context())
+		if err != nil {
+			h.serverError(w, err)
+			return
+		}
+		if image == nil {
+			h.serverError(w, errors.New("beep obop i didn't cache it"))
+			return
+		}
+	}
+	mime := "application/octet-stream"
+	if image.BlobMIME != nil {
+		mime = *image.BlobMIME
+	}
+	w.Header().Add("Content-Type", mime)
+	w.Header().Add("Content-Length", fmt.Sprintf("%d", stats.Size()))
 
-// func syncGetBlob(did string, cid *string) {
-// 	//TODO: impl
-// }
+	img, err := os.Open(imgPath)
+	if err != nil {
+		h.serverError(w, err)
+		return
+	}
+	img.WriteTo(w)
+}