Merge pull request #97 from pgulb/45-add-button-to-edit-flush-in-pwa

45 add button to edit flush in pwa

Author: pgulb

api/main.py

@@ -9,6 +9,7 @@
 import dateutil
 import fastapi
 import pymongo
+from bson.errors import InvalidId
 from bson.objectid import ObjectId
 from db import (
     create_mock_client,
@@ -424,3 +425,66 @@ def give_feedback(
 def get_feedback_count(username: str) -> int:
     feedbacks = client.flush.feedbacks
     return feedbacks.count_documents({"user_id": username})
+
+
+@app.get("/flush/{flush_id}", status_code=status.HTTP_200_OK)
+def get_flush_by_id(
+    flush_id: str,
+    credentials: HTTPBasicCredentials = Depends(security),
+):
+    check_creds(credentials)
+    flushes = client.flush.flushes
+    try:
+        flush = flushes.find_one(
+            filter={"_id": ObjectId(flush_id), "user_id": credentials.username}
+        )
+    except InvalidId as e:
+        logger.error(f"malformed flush id (cannot convert to ObjectId) - {e}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Flush not found"
+        ) from e
+    if flush is None:
+        logger.error("flush not found by id")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Flush not found"
+        )
+    del flush["user_id"]
+    flush["_id"] = str(flush["_id"])
+    flush["time_start"] = flush["time_start"].isoformat()
+    flush["time_end"] = flush["time_end"].isoformat()
+    return flush
+
+
+@app.put("/flush/{flush_id}", status_code=status.HTTP_200_OK)
+def edit_flush_by_id(
+    flush_id: str,
+    flush: Flush = Query(),
+    credentials: HTTPBasicCredentials = Depends(security),
+):
+    check_creds(credentials)
+    flushes = client.flush.flushes
+    try:
+        result = flushes.update_one(
+            filter={"_id": ObjectId(flush_id), "user_id": credentials.username},
+            update={
+                "$set": {
+                    "time_start": dateutil.parser.isoparse(flush.time_start),
+                    "time_end": dateutil.parser.isoparse(flush.time_end),
+                    "rating": flush.rating,
+                    "note": sanitize(flush.note),
+                    "phone_used": flush.phone_used,
+                }
+            },
+            upsert=False,
+        )
+    except Exception as e:
+        logger.error(f"error updating flush by id - {e}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail="Error updating flush"
+        ) from e
+    if result.matched_count != 1:
+        logger.error("flush not found by id")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Flush not found"
+        )
+    return Response(status_code=status.HTTP_200_OK)

api/tests/universal/test_flush_edit.py

@@ -0,0 +1,107 @@
+from fastapi import status
+from fastapi.testclient import TestClient
+from httpx import BasicAuth
+from universal.helpers import create_flush, create_user
+
+from api.main import app
+
+client = TestClient(app)
+
+
+def test_flush_edit():
+    flushes = [
+        {
+            "time_start": "2021-01-01T00:00:00",
+            "time_end": "2021-01-01T01:00:00",
+            "rating": 5,
+            "note": "dddd",
+            "phone_used": True,
+        },
+        {
+            "time_start": "2021-01-01T01:00:00",
+            "time_end": "2021-01-01T02:00:00",
+            "rating": 8,
+            "note": "test",
+            "phone_used": True,
+        },
+        {
+            "time_start": "2021-01-01T02:00:00",
+            "time_end": "2021-01-01T03:00:00",
+            "rating": 9,
+            "note": "essa",
+            "phone_used": False,
+        },
+    ]
+    username, password = "testedittingflushes", "testedittingflushes"
+    create_user(client, username, password)
+    for f in flushes:
+        create_flush(client, username, password, f)
+    response = client.get(
+        "/flushes",
+        auth=BasicAuth(username=username, password=password),
+    )
+    assert response.status_code == status.HTTP_200_OK
+    js = response.json()["flushes"]
+    js.reverse()
+    assert len(js) == len(flushes)
+    response = client.put(
+        f"/flush/{js[0]['_id']}",
+        auth=BasicAuth(username=username, password=password),
+        params={
+            "time_start": "2021-01-01T02:00:00",
+            "time_end": "2021-01-01T03:00:00",
+            "rating": 10,  # changed
+            "note": "essa+edit",  # changed
+            "phone_used": False,
+        },
+    )
+    assert response.status_code == status.HTTP_200_OK
+    response = client.put(
+        f"/flush/{js[2]['_id']}",
+        auth=BasicAuth(username=username, password=password),
+        params={
+            "time_start": "2021-01-01T01:00:00",  # changed
+            "time_end": "2021-01-01T01:10:00",  # changed
+            "rating": 5,
+            "note": "dddd",
+            "phone_used": False,  # changed
+        },
+    )
+    assert response.status_code == status.HTTP_200_OK
+    flushes[2]["rating"] = 10
+    flushes[2]["note"] = "essa+edit"
+    flushes[0]["time_start"] = "2021-01-01T01:00:00"
+    flushes[0]["time_end"] = "2021-01-01T01:10:00"
+    flushes[0]["phone_used"] = False
+    response = client.get(
+        "/flushes",
+        auth=BasicAuth(username=username, password=password),
+    )
+    assert response.status_code == status.HTTP_200_OK
+    js = response.json()["flushes"]
+    js.reverse()
+    assert len(js) == len(flushes)
+    for i, f in enumerate(js):
+        response = client.get(
+            f"/flush/{f['_id']}", auth=BasicAuth(username=username, password=password)
+        )
+        assert response.status_code == status.HTTP_200_OK
+        f_js = response.json()
+        assert f_js["time_start"] == flushes[i]["time_start"]
+        assert f_js["time_end"] == flushes[i]["time_end"]
+        assert f_js["rating"] == flushes[i]["rating"]
+        assert f_js["note"] == flushes[i]["note"]
+        assert f_js["phone_used"] == flushes[i]["phone_used"]
+    fake_id = "fakeid"
+    response = client.put(
+        f"/flush/{fake_id}",
+        auth=BasicAuth(username=username, password=password),
+        params={
+            "time_start": "2021-01-01T01:00:00",
+            "time_end": "2021-01-01T01:10:00",
+            "rating": 5,
+            "note": "dddd",
+            "phone_used": False,
+        },
+    )
+    assert response.status_code == status.HTTP_400_BAD_REQUEST

api/tests/universal/test_getting_flushes.py

@@ -164,3 +164,95 @@ def test_getting_flushes_with_skip():
     assert len(js) == 0
     if response.json()["more_data_available"]:
         raise AssertionError
+
+
+def test_getting_flushes_by_id():
+    flushes = [
+        {
+            "time_start": "2021-01-01T00:00:00",
+            "time_end": "2021-01-01T01:00:00",
+            "rating": 5,
+            "note": "dddd",
+            "phone_used": True,
+        },
+        {
+            "time_start": "2021-01-01T01:00:00",
+            "time_end": "2021-01-01T02:00:00",
+            "rating": 8,
+            "note": "test",
+            "phone_used": True,
+        },
+        {
+            "time_start": "2021-01-01T02:00:00",
+            "time_end": "2021-01-01T03:00:00",
+            "rating": 9,
+            "note": "essa",
+            "phone_used": False,
+        },
+    ]
+    username, password = "testgettingflushesbyid", "testgettingflushesbyid"
+    create_user(client, username, password)
+    for f in flushes:
+        create_flush(client, username, password, f)
+    response = client.get(
+        "/flushes",
+        auth=BasicAuth(username=username, password=password),
+    )
+    assert response.status_code == status.HTTP_200_OK
+    js = response.json()["flushes"]
+    js.reverse()
+    assert len(js) == len(flushes)
+    for i, f in enumerate(js):
+        response = client.get(
+            f"/flush/{f['_id']}", auth=BasicAuth(username=username, password=password)
+        )
+        assert response.status_code == status.HTTP_200_OK
+        f_js = response.json()
+        assert f_js["time_start"] == flushes[i]["time_start"]
+        assert f_js["time_end"] == flushes[i]["time_end"]
+        assert f_js["rating"] == flushes[i]["rating"]
+        assert f_js["note"] == flushes[i]["note"]
+        assert f_js["phone_used"] == flushes[i]["phone_used"]
+
+
+def test_getting_flushes_by_id_wrong_id():
+    flushes = [
+        {
+            "time_start": "2021-01-01T00:00:00",
+            "time_end": "2021-01-01T01:00:00",
+            "rating": 5,
+            "note": "dddd",
+            "phone_used": True,
+        },
+        {
+            "time_start": "2021-01-01T01:00:00",
+            "time_end": "2021-01-01T02:00:00",
+            "rating": 8,
+            "note": "test",
+            "phone_used": True,
+        },
+        {
+            "time_start": "2021-01-01T02:00:00",
+            "time_end": "2021-01-01T03:00:00",
+            "rating": 9,
+            "note": "essa",
+            "phone_used": False,
+        },
+    ]
+    username, password = "testgettingflushesbyid2", "testgettingflushesbyid2"
+    create_user(client, username, password)
+    for f in flushes:
+        create_flush(client, username, password, f)
+    response = client.get(
+        "/flushes",
+        auth=BasicAuth(username=username, password=password),
+    )
+    assert response.status_code == status.HTTP_200_OK
+    js = response.json()["flushes"]
+    js.reverse()
+    assert len(js) == len(flushes)
+    response = client.get(
+        "/flush/randomwrongid",
+        auth=BasicAuth(username=username, password=password),
+    )
+    assert response.status_code == status.HTTP_404_NOT_FOUND

pwa/flush/apicalls.go

@@ -340,3 +340,92 @@ func GiveFeedback(creds Creds, note string) (int, error) {
 	defer CloseBody(r)
 	return r.StatusCode, nil
 }
+
+func SubmitEditedFlush(creds Creds, flush Flush) (int, error) {
+	apiUrl, err := GetApiUrl()
+	if err != nil {
+		return 0, err
+	}
+	req, err := http.NewRequest("PUT", apiUrl+"/flush/"+flush.ID, nil)
+	if err != nil {
+		return 0, err
+	}
+	req.Header.Add("Authorization", "Basic "+creds.UserColonPass)
+	q := url.Values{}
+	q.Add("time_start", flush.TimeStart.Format("2006-01-02 15:04:05"))
+	q.Add("time_end", flush.TimeEnd.Format("2006-01-02 15:04:05"))
+	if flush.PhoneUsed {
+		q.Add("phone_used", "true")
+	} else {
+		q.Add("phone_used", "false")
+	}
+	q.Add("rating", strconv.Itoa(flush.Rating))
+	q.Add("note", flush.Note)
+	req.URL.RawQuery = q.Encode()
+	r, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return 0, err
+	}
+	defer CloseBody(r)
+	if r.StatusCode >= 400 {
+		b, err := io.ReadAll(r.Body)
+		if err != nil {
+			log.Println("error while reading body")
+			log.Println(err)
+		} else {
+			log.Println(string(b))
+		}
+	}
+	return r.StatusCode, nil
+}
+
+func GetFlushByID(ctx app.Context, flushID string) (Flush, int, error) {
+	apiUrl, err := GetApiUrl()
+	if err != nil {
+		return Flush{}, 0, err
+	}
+	req, err := http.NewRequest("GET", apiUrl+"/flush/"+flushID, nil)
+	if err != nil {
+		return Flush{}, 0, err
+	}
+	var c Creds
+	ctx.GetState("creds", &c)
+	req.Header.Add("Authorization", "Basic "+c.UserColonPass)
+	r, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return Flush{}, 0, err
+	}
+	defer CloseBody(r)
+	bytes, err := io.ReadAll(r.Body)
+	if err != nil {
+		return Flush{}, 0, err
+	}
+	var temp TempFlush
+	err = json.Unmarshal(bytes, &temp)
+	if err != nil {
+		return Flush{}, 0, err
+	}
+	flush := Flush{
+		Rating:    temp.Rating,
+		PhoneUsed: temp.PhoneUsed,
+		Note:      temp.Note,
+		ID:        temp.ID,
+	}
+	flush.TimeStart, err = time.Parse(
+		"2006-01-02T15:04:05",
+		temp.TimeStart,
+	)
+	if err != nil {
+		return Flush{}, 0, err
+	}
+	flush.TimeEnd, err = time.Parse(
+		"2006-01-02T15:04:05",
+		temp.TimeEnd,
+	)
+	if err != nil {
+		return Flush{}, 0, err
+	}
+	log.Println("temporary flush struct: ", temp)
+	log.Println("Flush: ", flush)
+	return flush, r.StatusCode, nil
+}