func (catalog *Catalog) ship_item(w http.ResponseWriter, r *http.Request) {
	item := catalog.get_item(w, r)
	if item == nil {
		return
	}
	username := r.FormValue("user")
	timestamp := r.FormValue("ts")
	qtyString := r.FormValue("qty")
	qty, err := strconv.ParseUint(qtyString, 10, 64)
	if err != nil {
		services.Http_respond_error(w, r, "Failed to parse 'qty' parameter to uint: "+err.Error(), http.StatusBadRequest)
		return
	}
	if shipment, existed, err := item.Ship(username, qty, timestamp); err != nil {
		services.Http_respond_error(w, r, "Failed to ship item: "+err.Error(), http.StatusInternalServerError)
	} else {
		var code int
		if existed {
			code = http.StatusOK
		} else {
			code = http.StatusCreated
		}
		services.Http_respond(w, r, ([]byte)(shipment.id), code)
	}
}
func (catalog *Catalog) get_item(w http.ResponseWriter, r *http.Request) *Item {
	item_name := mux.Vars(r)["name"]
	item, err := catalog.GetItem(item_name)
	if err != nil {
		services.Http_respond_error(w, r, "Failed to retrieve item: "+err.Error(), http.StatusInternalServerError)
		return nil
	} else if item == nil {
		services.Http_respond_error(w, r, "Item does not exist: "+item_name, http.StatusNotFound)
		return nil
	}
	return item
}
func (payments *Payments) get_payment(w http.ResponseWriter, r *http.Request, lockPayment bool) *Payment {
	id := mux.Vars(r)["id"]
	payment := payments.MakePayment(id)
	existed, err := payment.LoadExisting(lockPayment, true)
	if err != nil {
		services.Http_respond_error(w, r, "Error fetching payment "+id+": "+err.Error(), http.StatusInternalServerError)
		return nil
	} else if !existed {
		services.Http_respond_error(w, r, "Payment "+id+" does not exist", http.StatusNotFound)
		return nil
	}
	return payment
}
func (catalog *Catalog) get_shipment(w http.ResponseWriter, r *http.Request) *Shipment {
	shipment_id := mux.Vars(r)["id"]
	shipment := catalog.MakeShipment(shipment_id)
	existed, err := shipment.LoadExisting()
	if err != nil {
		services.Http_respond_error(w, r, "Failed to retrieve shipment: "+err.Error(), http.StatusInternalServerError)
		return nil
	} else if !existed {
		services.Http_respond_error(w, r, "Shipment does not exist: "+shipment_id, http.StatusNotFound)
		return nil
	}
	return shipment
}
func (catalog *Catalog) show_items(w http.ResponseWriter, r *http.Request) {
	if items, err := catalog.GetAllItems(); err != nil {
		services.Http_respond_error(w, r, "Error retrieving all items: "+err.Error(), http.StatusInternalServerError)
	} else {
		services.Http_respond_json(w, r, items)
	}
}
func (store *AccountStore) get_value_query(w http.ResponseWriter, r *http.Request) (float64, bool) {
	value, err := strconv.ParseFloat(r.FormValue("value"), 64)
	if err != nil {
		services.Http_respond_error(w, r, "Failed to parse 'value' parameter to float: "+err.Error(), http.StatusBadRequest)
		return 0, false
	}
	return value, true
}
func (store *AccountStore) get_account(w http.ResponseWriter, r *http.Request) *Account {
	username := mux.Vars(r)["id"]
	if account := store.GetAccount(username); account == nil {
		services.Http_respond_error(w, r, "Account not found: "+username, http.StatusNotFound)
		return nil
	} else {
		return account
	}
}
func (payments *Payments) new_payment(w http.ResponseWriter, r *http.Request) {
	value, err := strconv.ParseFloat(r.FormValue("value"), 64)
	if err != nil {
		services.Http_respond_error(w, r, "Failed to parse 'value' parameter to float: "+err.Error(), http.StatusBadRequest)
		return
	}
	username := r.FormValue("user")
	timestamp := r.FormValue("ts")
	payment, existed, err := payments.NewPayment(username, value, timestamp)
	if err != nil {
		services.Http_respond_error(w, r, "Error creating payment: "+err.Error(), http.StatusInternalServerError)
	} else {
		var code int
		if existed {
			code = http.StatusOK
		} else {
			code = http.StatusCreated
		}
		services.Http_respond(w, r, ([]byte)(payment.id), code)
	}
}
func (store *AccountStore) optionally_commit_transaction(trans *Transaction, w http.ResponseWriter, r *http.Request) bool {
	commit := false
	if commitStr := r.FormValue("commit"); commitStr == "true" {
		commit = true
	}
	if commit {
		err := trans.Commit()
		if err != nil {
			services.Http_respond_error(w, r, "Unexpected failure to commit transaction: "+err.Error(), http.StatusInternalServerError)
			return false
		}
	}
	return true
}
Exemplo n.º 10
0
func (store *AccountStore) get_transaction(w http.ResponseWriter, r *http.Request) *Transaction {
	trans_id := mux.Vars(r)["id"]
	var trans *Transaction
	var ok bool
	func() {
		store.transactionsLock.Lock()
		defer store.transactionsLock.Unlock()
		trans, ok = store.transactions[trans_id]
	}()
	if !ok || trans == nil {
		services.Http_respond_error(w, r, "Transaction not found: "+trans_id, http.StatusNotFound)
		return nil
	}
	return trans
}
Exemplo n.º 11
0
func (store *AccountStore) handle_transfer(w http.ResponseWriter, r *http.Request) {
	account := store.get_account(w, r)
	value, ok := store.get_value_query(w, r)
	if !ok {
		return
	}

	target := r.FormValue("target")
	if target == "" {
		services.Http_respond_error(w, r, "Need 'target' string parameter", http.StatusBadRequest)
		return
	}
	targetAccount := store.GetAccount(target)

	trans := store.NewTransaction(account, value, targetAccount)
	if store.optionally_commit_transaction(trans, w, r) {
		services.Http_respond(w, r, ([]byte)(trans.Id), http.StatusOK)
	}
}