Beispiel #1
0
func consumeProduct(w http.ResponseWriter, r *http.Request) errors.Http {
	p := models.Product{}
	params := r.URL.Query()
	if err := FillProductIdWithUrlValue(&p, params); err != nil {
		return errors.BadRequest(err.Error())
	}

	qt, err := strconv.Atoi(params.Get("quantity"))

	if err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := p.Consume(db, qt); err != nil {
		return errors.InternalServerError(err.Error())
	}

	ps, err := p.Retreive(db)
	if err != nil {
		return errors.InternalServerError(err.Error())
	}

	if len(ps) != 1 {
		return errors.InternalServerError("[ERROR] Unexpected error occured during exeuction of /api/inventory/product/:id/consume/:quantity")
	}

	rend.JSON(w, http.StatusOK, ps[0])
	return nil
}
Beispiel #2
0
func deleteTreatment(w http.ResponseWriter, r *http.Request) errors.Http {
	t := models.Treatment{}
	if err := FillTreatmentIdWIthUrlValue(&t, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := t.Delete(db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	rend.JSON(w, http.StatusOK, t.ID)
	return nil
}
Beispiel #3
0
func insertProduct(w http.ResponseWriter, r *http.Request) errors.Http {
	p := models.Product{}
	if err := BuildStructFromReqBody(&p, r.Body); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := p.Save(db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	rend.JSON(w, http.StatusOK, p)
	return nil
}
Beispiel #4
0
func deleteMedication(w http.ResponseWriter, r *http.Request) errors.Http {
	m := models.Medication{}
	if err := FillMedicationIdWIthUrlValue(&m, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := m.Delete(db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	rend.JSON(w, http.StatusOK, m.ID)
	return nil
}
Beispiel #5
0
func deleteProduct(w http.ResponseWriter, r *http.Request) errors.Http {
	p := models.Product{}
	if err := FillProductIdWithUrlValue(&p, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := p.Delete(db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	rend.JSON(w, http.StatusOK, p)
	return nil
}
Beispiel #6
0
func validataTreatment(w http.ResponseWriter, r *http.Request) errors.Http {
	id, err := strconv.Atoi(r.URL.Query().Get("treatment_id"))
	if err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := db.Exec("UPDATE treatments SET status = 0 WHERE id = ?", id).Error; err != nil {
		return errors.InternalServerError(err.Error())
	}

	t := models.Treatment{ID: id}
	sendTreatmentApproved(&t)
	return nil
}
Beispiel #7
0
func cancelOrder(w http.ResponseWriter, r *http.Request) errors.Http {
	order := models.Order{}

	if err := FillOrderIdWithUrlValue(&order, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := order.Cancel(db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	rend.JSON(w, http.StatusOK, order.ID)
	return nil
}
Beispiel #8
0
func insertTreatment(w http.ResponseWriter, r *http.Request) errors.Http {
	t := models.Treatment{}
	if err := BuildStructFromReqBody(&t, r.Body); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := t.Save(db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	sendTreatmentCreated(&t)

	rend.JSON(w, http.StatusOK, t)
	return nil
}
Beispiel #9
0
func insertMedication(w http.ResponseWriter, r *http.Request) errors.Http {
	im := models.IntermediateMedication{}
	if err := BuildStructFromReqBody(&im, r.Body); err != nil {
		return errors.BadRequest(err.Error())
	}

	m := im.Medication()

	if err := m.Save(db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	sendProductCreated(m)

	rend.JSON(w, http.StatusOK, m)
	return nil
}
Beispiel #10
0
func updateTreatment(w http.ResponseWriter, r *http.Request) errors.Http {
	t := models.Treatment{}

	if err := BuildStructFromReqBody(&t, r.Body); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := FillTreatmentIdWIthUrlValue(&t, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := t.Update(db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	rend.JSON(w, http.StatusOK, t)
	return nil
}
Beispiel #11
0
func handleMedicUpdate(w http.ResponseWriter, r *http.Request) errors.Http {
	m := models.Medic{}

	if err := BuildStructFromReqBody(&m, r.Body); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := FillMedicIdWIthUrlValue(&m, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := m.Update(db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	rend.JSON(w, http.StatusOK, m)
	return nil
}
Beispiel #12
0
func retreiveProduct(w http.ResponseWriter, r *http.Request) errors.Http {
	p := models.Product{}
	if err := BuildStructFromQueryString(&p, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	products, err := p.Retreive(db)
	if err != nil {
		return errors.InternalServerError(err.Error())
	}

	if len(products) == 0 {
		return errors.NotFound("record not found")
	}
	rend.JSON(w, http.StatusOK, products)

	return nil
}
Beispiel #13
0
func handlePharmacistUpdate(w http.ResponseWriter, r *http.Request) errors.Http {
	p := models.Pharmacist{}

	if err := BuildStructFromReqBody(&p, r.Body); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := FillPharmacistIdWIthUrlValue(&p, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := p.Update(db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	rend.JSON(w, http.StatusOK, p)
	return nil
}
Beispiel #14
0
func retreiveOrderById(w http.ResponseWriter, r *http.Request) errors.Http {
	o := models.Order{}

	if err := FillOrderIdWithUrlValue(&o, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	orders, err := o.Retreive(db)
	if err != nil {
		return errors.InternalServerError(err.Error())
	}

	if len(orders) != 1 {
		return errors.NotFound("record not found")
	}

	rend.JSON(w, http.StatusOK, orders[0])
	return nil
}
func updatePurchaseProductOnValue(w http.ResponseWriter, r *http.Request) errors.Http {
	pp := models.PurchaseProduct{}

	if err := FillPurchaseProductIdWithUrlValue(&pp, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	value, err := strconv.ParseFloat(r.URL.Query().Get("value"), 64)
	if err != nil {
		errors.BadRequest(err.Error())
	}

	if err := pp.UpdateValue(db, value); err != nil {
		return errors.InternalServerError(err.Error())
	}

	rend.JSON(w, http.StatusOK, pp)
	return nil
}
func updatePurchaseProductOnQuantity(w http.ResponseWriter, r *http.Request) errors.Http {
	pp := models.PurchaseProduct{}

	if err := FillPurchaseProductIdWithUrlValue(&pp, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	quantity, err := strconv.Atoi(r.URL.Query().Get("quantity"))
	if err != nil {
		errors.BadRequest(err.Error())
	}

	if err := pp.UpdateQuantity(db, quantity); err != nil {
		return errors.InternalServerError(err.Error())
	}

	rend.JSON(w, http.StatusOK, pp)
	return nil
}
func retreivePurchaseProductsById(w http.ResponseWriter, r *http.Request) errors.Http {
	pp := models.PurchaseProduct{}

	if err := FillPurchaseProductIdWithUrlValue(&pp, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	pproducts, err := pp.Retreive(db)
	if err != nil {
		return errors.InternalServerError(err.Error())
	}

	if len(pproducts) != 1 {
		return errors.NotFound("record not found")
	}

	rend.JSON(w, http.StatusOK, pproducts[0])
	return nil
}
Beispiel #18
0
func uploadRecipe(w http.ResponseWriter, r *http.Request) errors.Http {
	prescriptionId := r.URL.Query().Get("prescription_id")
	file, _, err := r.FormFile("receipt")
	if err != nil {
		fmt.Println(err)
		return errors.BadRequest("Invalid file")
	}

	defer file.Close()

	pid, _ := strconv.Atoi(prescriptionId)
	rcpt := &models.Receipt{FilePath: "", Status: models.ReceiptStatusUndecided, PrescriptionId: pid}
	rcpt.Create(db)
	rcpt.FilePath = "upload/" + prescriptionId + "/" + strconv.Itoa(int(rcpt.ID))
	rcpt.Save(db) // ID incremental :'(
	prescr := models.Prescription{ID: rcpt.PrescriptionId}
	fmt.Println("[DEBUG] prescri query obj: ", prescr)
	prescrs, err := prescr.Retreive(db)
	if err != nil {
		fmt.Println("[ERROR] ", err.Error())
	}

	fmt.Println("[DEBUG] prescrs retrieved ", prescrs)
	if prescrs != nil && len(prescrs) >= 1 {
		fmt.Println("[DEBUG] Saving rcpt.id: ", rcpt.ID, " on prescriptionId: ", prescrs[0].ID)
		prescrs[0].ReceiptId = rcpt.ID
		if err := prescrs[0].Update(db); err != nil {
			fmt.Println("[ERROR] ", err.Error())
		}
	}

	os.MkdirAll("upload/"+prescriptionId, 0777)
	out, err := os.Create("upload/" + prescriptionId + "/" + strconv.Itoa(int(rcpt.ID)))
	fmt.Println(err)
	_, err = io.Copy(out, file)
	fmt.Println(err)
	if err != nil {
		return errors.InternalServerError("Error uploading image")
	}
	rend.JSON(w, 200, rcpt)
	return nil
}
Beispiel #19
0
func updateMedication(w http.ResponseWriter, r *http.Request) errors.Http {
	im := models.IntermediateMedication{}

	if err := BuildStructFromReqBody(&im, r.Body); err != nil {
		return errors.BadRequest(err.Error())
	}

	m := im.Medication()

	if err := FillMedicationIdWIthUrlValue(m, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	if err := m.Update(db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	rend.JSON(w, http.StatusOK, m)
	return nil
}
Beispiel #20
0
func retreiveOrder(w http.ResponseWriter, r *http.Request) errors.Http {
	queryString := r.URL.Query()
	var o models.Order
	decoder := decoder.NewDecoder()

	if err := decoder.DecodeURLValues(&o, queryString); err != nil {
		return errors.BadRequest(err.Error())
	}

	orders, err := o.Retreive(db)
	if err != nil {
		return errors.InternalServerError(err.Error())
	}

	if len(orders) == 0 {
		return errors.NotFound("record not found")
	}

	rend.JSON(w, http.StatusOK, orders)
	return nil
}
func retreiveWithdrawal(w http.ResponseWriter, r *http.Request) errors.Http {
	withd := models.Withdrawal{}
	if err := BuildStructFromQueryString(&withd, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	withd.Query = r.URL.Query()

	ws, err := withd.Retreive(db)
	if err != nil {
		return errors.InternalServerError(err.Error())
	}

	if len(ws) == 0 {
		return errors.NotFound("record not found")
	}

	rend.JSON(w, http.StatusOK, ws)

	return nil
}
Beispiel #22
0
func updateSubscription(w http.ResponseWriter, req *http.Request) errors.Http {
	subs := Subscription{}

	if err := BuildStructFromReqBody(&subs, req.Body); err != nil {
		return errors.BadRequest("[ERROR] Malformed request body")
	}

	email := req.URL.Query().Get("email")
	if email == "" {
		return errors.BadRequest("[ERROR] email is mandatory")
	}

	db := postgres.GetDatabase(DBConfig())
	if err := subs.UpdateByEmail(email, db); err != nil {
		return errors.InternalServerError(err.Error())
	}

	sendSubscriptionUpdated(&subs)

	rend := render.New()
	rend.JSON(w, http.StatusOK, subs)
	return nil
}