Ejemplo n.º 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
}
Ejemplo n.º 2
0
func DefRoutes() *router.Router {
	r := router.NewRouter()
	r.Handle("/api/discovery", router.GET, func(w http.ResponseWriter, r *http.Request) errors.Http {
		fmt.Fprint(w, "NOTIFICATION MODULE - TODO")
		return nil
	}, []router.Interceptor{})

	r.Handle("/api/mailTest", router.GET, func(w http.ResponseWriter, r *http.Request) errors.Http {
		m := mailer.Mail{
			To:      []string{"*****@*****.**"},
			Subject: "Está na hora de tomar sua medicação!",
			Body:    mailer.TemplatePackTime,
		}

		b, err := json.Marshal(&m)
		if err != nil {
			return errors.BadRequest(err.Error())
		}

		producer.Publish("send_mail", b)
		fmt.Fprintf(w, "[INFO] Email sent")
		return nil
	}, []router.Interceptor{})

	return r
}
Ejemplo n.º 3
0
func validateRecipe(w http.ResponseWriter, r *http.Request) errors.Http {
	pres_id, err := strconv.Atoi(r.URL.Query().Get("prescription_id"))
	if err != nil {
		return errors.BadRequest(err.Error())
	}

	rcpt := models.FetchReceipt(pres_id, db)
	if r.ParseForm() != nil {
		return errors.BadRequest("Invalid input")
	}
	if rcpt.UpdateStatus(models.RecipeStringToStatus(r.Form.Get("status")), db) != nil {
		return errors.NotFound("Not found")
	}
	rend.JSON(w, 200, "{}")
	return nil
}
Ejemplo n.º 4
0
func retreiveOpenOrder(w http.ResponseWriter, r *http.Request) errors.Http {
	order, err := models.GetOpenOrder(db)
	if err != nil {
		return errors.BadRequest(err.Error())
	}

	rend.JSON(w, http.StatusOK, order)
	return nil
}
Ejemplo n.º 5
0
func updateProduct(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 := FillProductIdWithUrlValue(&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
}
Ejemplo n.º 6
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
}
Ejemplo n.º 7
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
}
Ejemplo n.º 8
0
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
}
Ejemplo n.º 9
0
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
}
Ejemplo n.º 10
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
}
Ejemplo n.º 11
0
func retreiveMedication(w http.ResponseWriter, r *http.Request) errors.Http {
	m := models.Medication{}
	if err := BuildStructFromQueryString(&m, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	m.Base.Query = r.URL.Query()

	medications, err := m.Retrieve(db)
	if err != nil {
		return errors.BadRequest(err.Error())
	}

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

	return nil
}
Ejemplo n.º 12
0
func retrievePacks(w http.ResponseWriter, r *http.Request) errors.Http {
	p := models.Pack{}
	if err := BuildStructFromQueryString(&p, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	p.Base.Query = r.URL.Query()

	packs, err := p.Retrieve(db)
	if err != nil {
		return errors.BadRequest(err.Error())
	}

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

	return nil
}
Ejemplo n.º 13
0
func retrieveBoxes(w http.ResponseWriter, r *http.Request) errors.Http {
	b := models.Box{}
	if err := BuildStructFromQueryString(&b, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	b.Base.Query = r.URL.Query()

	boxes, err := b.Retrieve(db)
	if err != nil {
		return errors.BadRequest(err.Error())
	}

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

	return nil
}
Ejemplo n.º 14
0
func retreiveTreatments(w http.ResponseWriter, r *http.Request) errors.Http {
	t := models.Treatment{}
	if err := BuildStructFromQueryString(&t, r.URL.Query()); err != nil {
		return errors.BadRequest(err.Error())
	}

	t.Base.Query = r.URL.Query()

	treatments, err := t.Retrieve(db)
	if err != nil {
		return errors.BadRequest(err.Error())
	}

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

	return nil
}
Ejemplo n.º 15
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
}
Ejemplo n.º 16
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
}
Ejemplo n.º 17
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
}
Ejemplo n.º 18
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
}
Ejemplo n.º 19
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
}
Ejemplo n.º 20
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
}
Ejemplo n.º 21
0
func handleGetFeed(w http.ResponseWriter, req *http.Request) errors.Http {
	patientId := req.URL.Query().Get("patient_id")
	from := time.Now().AddDate(0, 0, -1)
	patientID, err := strconv.Atoi(patientId)
	if err != nil {
		return errors.BadRequest("Invalid patient id")
	}

	es, err := models.FindFeedEvents(from, patientID, db)
	if err != nil {
		return errors.NotFound("No events")
	}
	rend.JSON(w, 200, es)
	return nil
}
Ejemplo n.º 22
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
}
Ejemplo n.º 23
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
}
Ejemplo n.º 24
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
}
Ejemplo n.º 25
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
}
Ejemplo n.º 26
0
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
}
Ejemplo n.º 27
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
}
Ejemplo n.º 28
0
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
}
Ejemplo n.º 29
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
}