func (fs *dsFileSys) Remove(name string) error {
// log.Printf("trying to remove %-20v", name)
f, err := fs.fileByPath(name)
if err == nil {
// log.Printf(" found file %v", f.Dir+f.BName)
// log.Printf(" fkey %-26v", f.Key)
err = datastore.Delete(fs.Ctx(), f.Key)
if err != nil {
return fmt.Errorf("error removing file %v", err)
}
}
d, err := fs.dirByPath(name)
if err == nil {
// log.Printf(" dkey %v", d.Key)
err = datastore.Delete(fs.Ctx(), d.Key)
d.MemCacheDelete()
if err != nil {
return fmt.Errorf("error removing dir %v", err)
}
}
return nil
}
func deleteHandler(w http.ResponseWriter, r *http.Request) {
strThread := r.FormValue("thread")
c := appengine.NewContext(r)
threadId, _ := strconv.Atoi(strThread)
q := datastore.NewQuery(WebSubmissionEntityName).
Filter("Thread =", int64(threadId))
//TODO cleanup checks whatever for emtpy or otherwise other than 1 result
t := q.Run(c)
var x WebSubmission
key, err := t.Next(&x)
if err != nil {
serveError(c, w, err)
fmt.Fprintf(w, "nope %v", err.Error())
return
}
err2 := datastore.Delete(c, key)
if err != nil {
serveError(c, w, err2)
return
}
http.Redirect(w, r, "/", http.StatusFound)
}
// revert modifies Idiom and deletes IdiomHistory, but not in a transaction (for now)
func (a *GaeDatastoreAccessor) revert(c context.Context, idiomID int, version int) (*Idiom, error) {
q := datastore.NewQuery("IdiomHistory").
Filter("Id =", idiomID).
Order("-Version").
Limit(2)
histories := make([]*IdiomHistory, 0)
historyKeys, err := q.GetAll(c, &histories)
if err != nil {
return nil, err
}
if len(histories) == 0 {
return nil, PiError{ErrorText: fmt.Sprintf("No history found for idiom %v", idiomID), Code: 400}
}
if len(histories) == 1 {
return nil, PiError{ErrorText: fmt.Sprintf("Can't revert the only version of idiom %v", idiomID), Code: 400}
}
if histories[0].Version != version {
return nil, PiError{ErrorText: fmt.Sprintf("Can't revert idiom %v: last version is not %v", idiomID, version), Code: 400}
}
log.Infof(c, "Reverting idiom %v from version %v to version %v", idiomID, histories[0].Version, histories[1].Version)
idiomKey := newIdiomKey(c, idiomID)
idiom := &histories[1].Idiom
_, err = datastore.Put(c, idiomKey, idiom)
if err != nil {
return nil, err
}
return idiom, datastore.Delete(c, historyKeys[0])
}
func unfollow(res http.ResponseWriter, req *http.Request, ps httprouter.Params) {
ctx := appengine.NewContext(req)
// get session
memItem, err := getSession(req)
if err != nil {
log.Infof(ctx, "Attempt to unfollow from logged out user")
http.Error(res, "You must be logged in", http.StatusForbidden)
return
}
// declare a variable of type user
// initialize user with values from memcache item
var user User
json.Unmarshal(memItem.Value, &user)
// get the datastore key for the follower
followerKey := datastore.NewKey(ctx, "Users", user.UserName, 0, nil)
// get a datastore key for the followee
followeeKey := datastore.NewKey(ctx, "Follows", ps.ByName("user"), 0, followerKey)
// delete entry in datastore
err = datastore.Delete(ctx, followeeKey)
if err != nil {
log.Errorf(ctx, "error deleting followee: %v", err)
http.Error(res, err.Error(), 500)
return
}
http.Redirect(res, req, "/user/"+ps.ByName("user"), 302)
}
func serveDocumentsDelete(res http.ResponseWriter, req *http.Request, params httprouter.Params) {
serveAPI(res, req, func() interface{} {
ctx := appengine.NewContext(req)
session, _ := sessionStore.Get(req, "session")
email, ok := session.Values["email"].(string)
if !ok {
return HTTPError{403, "access denied"}
}
id := params.ByName("id")
userKey := datastore.NewKey(ctx, "User", email, 0, nil)
docKey := datastore.NewKey(ctx, "Document", id, 0, userKey)
var document Document
err := datastore.Get(ctx, docKey, &document)
if err != nil {
return err
}
err = datastore.Delete(ctx, docKey)
if err != nil {
return err
}
return true
})
}
func deleteData(res http.ResponseWriter, req *http.Request) {
ctx := appengine.NewContext(req)
u := user.Current(ctx)
keyVal := req.FormValue("keyVal")
key, err := datastore.DecodeKey(keyVal)
if err != nil {
http.Error(res, "Invalid data", http.StatusBadRequest)
log.Warningf(ctx, err.Error())
return
}
var l list
err = datastore.Get(ctx, key, &l)
if err != nil {
http.Error(res, "Invalid data", http.StatusBadRequest)
log.Warningf(ctx, err.Error())
return
}
if l.Owner != u.Email {
http.Error(res, "Not authorized to delete this entry", http.StatusUnauthorized)
log.Warningf(ctx, err.Error())
return
}
err = datastore.Delete(ctx, key)
if err != nil {
http.Error(res, "Server Error", http.StatusInternalServerError)
log.Errorf(ctx, err.Error())
return
}
}
func (s *DatastoreStorage) RemoveAuthorize(code string) error {
log.Infof(s.ctx, "RemoveAuthorize(%s)\n", code)
k := datastore.NewKey(s.ctx, "Authorize", code, 0, nil)
if err := datastore.Delete(s.ctx, k); err != nil {
return err
}
return nil
}
//Remove removes a card from the datastore, memcache, and stripe
func Remove(w http.ResponseWriter, r *http.Request) {
//get form values
datastoreId := r.FormValue("customerId")
datastoreIdInt, _ := strconv.ParseInt(datastoreId, 10, 64)
//make sure an id was given
if len(datastoreId) == 0 {
output.Error(ErrMissingInput, "A customer's datastore ID must be given but was missing. This value is different from your \"Customer ID\" and should have been submitted automatically.", w, r)
return
}
//init stripe
c := appengine.NewContext(r)
sc := createAppengineStripeClient(c)
//delete customer on stripe
custData, err := findByDatastoreId(c, datastoreIdInt)
if err != nil {
output.Error(err, "An error occured while trying to look up customer's Stripe information.", w, r)
}
stripeCustId := custData.StripeCustomerToken
sc.Customers.Del(stripeCustId)
//delete custome from datastore
completeKey := getCustomerKeyFromId(c, datastoreIdInt)
err = datastore.Delete(c, completeKey)
if err != nil {
output.Error(err, "There was an error while trying to delete this customer. Please try again.", w, r)
return
}
//delete customer from memcache
//delete list of cards in memcache since this list is now stale
//all memcache.Delete operations are listed first so error handling doesn't return if one fails...each call does not depend on another so this is safe
//obviously, if the card is not in the cache it cannot be removed
err1 := memcache.Delete(c, datastoreId)
err2 := memcache.Delete(c, custData.CustomerId)
err3 := memcache.Delete(c, listOfCardsKey)
if err1 != nil && err1 != memcache.ErrCacheMiss {
output.Error(err1, "There was an error flushing this card's data from the cache (by datastore id). Please contact an administrator and have them flush the cache manually.", w, r)
return
}
if err2 != nil && err2 != memcache.ErrCacheMiss {
output.Error(err2, "There was an error flushing this card's data from the cache (by customer id). Please contact an administrator and have them flush the cache manually.", w, r)
return
}
if err3 != nil && err3 != memcache.ErrCacheMiss {
output.Error(err3, "There was an error flushing the cached list of cards.", w, r)
return
}
//customer removed
//return to client
output.Success("removeCustomer", nil, w)
return
}
func deleteTask(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
c := appengine.NewContext(r)
id, _ := strconv.ParseInt(params.ByName("id"), 10, 64)
key := datastore.NewKey(c, "tasks", "", id, nil)
if err := datastore.Delete(c, key); err != nil {
sendJSONResponse(w, http.StatusNotModified, nil)
} else {
sendJSONResponse(w, http.StatusAccepted, nil)
}
}
func submissionsAddHandler(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
if err := r.ParseForm(); err != nil {
serveErr(ctx, err, w)
return
}
ID, _, err := datastore.AllocateIDs(ctx, "Podcast", nil, 1)
if err != nil {
serveErr(ctx, err, w)
return
}
date, err := time.Parse(yyyymmdd, r.FormValue("date"))
if err != nil {
serveErr(ctx, err, w)
return
}
podcast := Podcast{
ID: ID,
Show: r.FormValue("show"),
Title: r.FormValue("title"),
Desc: r.FormValue("desc"),
URL: template.URL(r.FormValue("url")),
MediaURL: template.URL(r.FormValue("media_url")),
RuntimeSec: r.FormValue("runtime"),
Size: r.FormValue("size"),
Date: date,
Added: time.Now(),
}
if _, err := datastore.Put(ctx, datastore.NewKey(ctx, "Podcast", "", ID, nil), &podcast); err != nil {
serveErr(ctx, err, w)
return
}
key, err := datastore.DecodeKey(r.FormValue("key"))
if err != nil {
serveErr(ctx, err, w)
return
}
if err := datastore.Delete(ctx, key); err != nil {
serveErr(ctx, err, w)
return
}
if err := memcache.Delete(ctx, cacheKey); err != nil {
log.Errorf(ctx, "memcache delete error %v", err)
}
successTmpl.ExecuteTemplate(w, "base", nil)
}
// Delete deletes the record based on the provided key.
//
func (goal *Goal) Delete(c context.Context) (err error) {
// TODO: need to check for existance before deleting. if NOT exists, then throw ErrorNoMatch error (err = ErrorNoMatch)
if err = goal.Get(c); err == types.ErrorNoMatch {
return
}
key := datastore.NewKey(c, "Goal", util.StringKey(goal.Name), 0, nil)
err = datastore.Delete(c, key)
return
}
func (a *GaeDatastoreAccessor) deleteIdiom(c context.Context, idiomID int, why string) error {
key, _, err := a.getIdiom(c, idiomID)
if err != nil {
return err
}
// Remove from text search index
err = a.unindex(c, idiomID)
if err != nil {
log.Errorf(c, "Failed to unindex idiom %d: %v", idiomID, err)
}
return datastore.Delete(c, key)
// The why param is ignored for now, because idiom doesn't exist anymore.
}
func adminDeleteTask(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
tid := r.FormValue("taskKey")
k, err := datastore.DecodeKey(tid)
if err != nil {
panic(err)
}
if err := datastore.Delete(c, k); err != nil {
panic(err)
}
w.WriteHeader(204)
}
func TestPostCompany(t *testing.T) {
company := model.Company{
Address: mail.Address{
Name: "companyName",
Address: "*****@*****.**",
},
}
r, err := http.NewRequest("POST", "/companies", requestBody(t, company))
if err != nil {
t.Fatal(err)
}
loginAsCompanyUser(r)
rr := record(t, r)
testRequestStatus(t, rr, 200, "Should be okay.")
// Check the entity the client recieves was indeed saved in the datastore.
var companyResponse = struct {
Name, Address, Nick, Key string
}{}
if err = json.NewDecoder(rr.Body).Decode(&companyResponse); err != nil {
t.Fatal(err)
}
var key *datastore.Key
key, err = datastore.DecodeKey(companyResponse.Key)
if err != nil {
t.Fatal(err)
}
ctx := backgroundContext()
var savedCompany model.Company
err = datastore.Get(ctx, key, &savedCompany)
if err != nil {
t.Fatal(err)
}
if savedCompany.Address != company.Address {
t.Fatal("Saved company is wrong")
}
datastore.Delete(ctx, key)
}
func DeleteProfile(ctx context.Context, w http.ResponseWriter, r *http.Request) (int, error) {
if r.Method != "DELETE" {
return http.StatusMethodNotAllowed, nil
}
key, err := datastore.DecodeKey(mux.Vars(r)["key"])
if err != nil {
return http.StatusBadRequest, err
}
if err = datastore.Delete(ctx, key); err != nil {
return http.StatusInternalServerError, err
}
return http.StatusOK, nil
}
// delete world data
func (a *MinecraftApi) Delete(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
u := user.Current(ctx)
if u == nil {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(http.StatusUnauthorized)
loginURL, err := user.LoginURL(ctx, "")
if err != nil {
log.Errorf(ctx, "get user login URL error, %s", err.Error())
w.WriteHeader(http.StatusInternalServerError)
return
}
w.Write([]byte(fmt.Sprintf(`{"loginURL":"%s"}`, loginURL)))
return
}
if user.IsAdmin(ctx) == false {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(http.StatusForbidden)
return
}
keyStr := r.FormValue("key")
key, err := datastore.DecodeKey(keyStr)
if err != nil {
log.Infof(ctx, "invalid key, %v", r.Body)
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(`{"message": "invalid key."}`))
return
}
err = datastore.RunInTransaction(ctx, func(c context.Context) error {
return datastore.Delete(ctx, key)
}, nil)
if err != nil {
log.Errorf(ctx, "Minecraft Delete Error. error = %s", err.Error())
w.WriteHeader(http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(`{}`)
}
func deleteHandler(w http.ResponseWriter, r *http.Request) {
urls := strings.Split(r.URL.Path, "/")
keyId := urls[4]
c := appengine.NewContext(r)
k := datastore.NewKey(c, "Slide", keyId, 0, nil)
//err
err := datastore.Delete(c, k)
if err != nil {
errorPage(w, "Delete Error", "Slide Delete", err.Error(), 500)
return
}
http.Redirect(w, r, "/me/", 301)
return
}
func handleFilesItem(w http.ResponseWriter, r *http.Request) {
id := r.URL.Path
if id == "" {
w.WriteHeader(404)
return
}
c := appengine.NewContext(r)
key := datastore.NewKey(c, "File", id, 0, nil)
switch r.Method {
case "GET":
var file File
err := datastore.Get(c, key, &file)
if err == datastore.ErrNoSuchEntity {
http.NotFound(w, r)
return
}
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Errorf(c, "query file: %s", err.Error())
return
}
w.Header().Set("Content-Type", "application/json")
err = json.NewEncoder(w).Encode(&file)
if err != nil {
log.Errorf(c, "json encode: %s", err.Error())
}
case "DELETE":
err := datastore.Delete(c, key)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Errorf(c, "delete file: %s", err.Error())
return
}
err = blobstore.Delete(c, appengine.BlobKey(id))
if err != nil {
log.Warningf(c, "delete file '%s': %s", id, err.Error())
}
w.WriteHeader(204)
default:
http.Error(w, "Valid methods are GET and DELETE", http.StatusMethodNotAllowed)
return
}
}
func delete(w http.ResponseWriter, r *http.Request) {
address, err := mail.ParseAddress(r.FormValue("email"))
if err != nil {
http.Error(w, "Invalid email address: "+err.Error(), 422)
return
}
token, err := hex.DecodeString(r.FormValue("token"))
if err != nil {
http.Error(w, "Invalid token: "+err.Error(), 422)
return
}
c := appengine.NewContext(r)
q := datastore.NewQuery("subscription").Filter("Address =", address.Address).Limit(1)
var subs []Subscription
keys, err := q.GetAll(c, &subs)
if len(subs) != 1 {
http.Error(w, "Unable to identify your subscription. Got "+fmt.Sprintf("%d", len(subs))+" matches on "+address.Address, http.StatusInternalServerError)
return
}
sub := subs[0]
if !bytes.Equal(sub.Token, token) {
http.Error(w, "Forbidden", http.StatusUnauthorized)
return
}
err = datastore.Delete(c, keys[0])
if err != nil {
http.Error(w, "Failed to delete your subscription. Please contact [email protected].", http.StatusInternalServerError)
return
}
w.Write([]byte("Your subscription was removed, we're sorry to see you go :("))
}
func submissionsDelHandler(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
if err := r.ParseForm(); err != nil {
serveErr(ctx, err, w)
return
}
key, err := datastore.DecodeKey(r.FormValue("key"))
if err != nil {
serveErr(ctx, err, w)
return
}
if err := datastore.Delete(ctx, key); err != nil {
serveErr(ctx, err, w)
return
}
successTmpl.ExecuteTemplate(w, "base", nil)
}
func deletepost(rw http.ResponseWriter, req *http.Request) {
c := appengine.NewContext(req)
u := user.Current(c)
s := req.FormValue("encoded_key")
k, err := datastore.DecodeKey(s)
if err != nil {
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}
mypost := Post{}
err = datastore.Get(c, k, &mypost)
if err != nil {
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}
if mypost.Author == u.String() {
if mypost.OP {
q := datastore.NewQuery("post").Ancestor(k).KeysOnly()
keys, err := q.GetAll(c, struct{}{})
if err != nil {
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}
err = datastore.DeleteMulti(c, keys)
if err != nil {
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}
} else {
err := datastore.Delete(c, k)
if err != nil {
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}
}
// http.Redirect(rw, req, "/view", http.StatusTemporaryRedirect)
// } else {
http.Redirect(rw, req, "/", http.StatusTemporaryRedirect)
}
}
func (mp *AppEngineProvider) SessionDestroy(c context.Context, sid string) error {
done := make(chan bool, 2)
go func() {
k := datastore.NewKey(c, "BeegoSessionStore", sid, 0, nil)
if ds_err := datastore.Delete(c, k); ds_err != nil {
log.Errorf(c, "session-appengine: error deleting session data from datastore: %v", ds_err)
}
done <- true
}()
go func() {
mem_err := memcache.Delete(c, sid)
if mem_err != nil {
log.Errorf(c, "session-appengine: error deleting session data from memcache: %v", mem_err)
}
done <- true
}()
_, _ = <-done, <-done
return nil
}
func unfollow(res http.ResponseWriter, req *http.Request, ps httprouter.Params) {
ctx := appengine.NewContext(req)
memItem, err := getSession(req)
if err != nil {
http.Redirect(res, req, "/form/login", http.StatusFound)
return
}
var user User
json.Unmarshal(memItem.Value, &user)
Following := ps.ByName("user")
if Following == user.UserName {
http.Redirect(res, req, "/", http.StatusFound)
return
}
key := datastore.NewKey(ctx, "Relation", user.UserName+Following, 0, nil)
err = datastore.Delete(ctx, key)
if err != nil {
log.Errorf(ctx, "error deleting todo: %v", err)
http.Error(res, err.Error(), 500)
return
}
http.Redirect(res, req, "/", http.StatusFound)
}
// DELETE http://localhost:8080/profiles/ahdkZXZ-ZmVkZXJhdGlvbi1zZXJ2aWNlc3IVCxIIcHJvZmlsZXMYgICAgICAgAoM
//
func (u *ProfileApi) remove(r *restful.Request, w *restful.Response) {
c := appengine.NewContext(r.Request)
// Decode the request parameter to determine the key for the entity.
k, err := datastore.DecodeKey(r.PathParameter("profile-id"))
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
// Retrieve the old entity from the datastore.
old := Profile{}
if err := datastore.Get(c, k, &old); err != nil {
if err.Error() == "datastore: no such entity" {
http.Error(w, err.Error(), http.StatusNotFound)
} else {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
return
}
// Check we own the profile before allowing them to delete it.
// Optionally, return a 404 instead to help prevent guessing ids.
// TODO: Allow admins access.
if old.Email != user.Current(c).String() {
http.Error(w, "You do not have access to this resource", http.StatusForbidden)
return
}
// Delete the entity.
if err := datastore.Delete(c, k); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
// Success notification.
w.WriteHeader(http.StatusNoContent)
}
func (va GaeVotesAccessor) saveIdiomVoteOrRemove(c context.Context, vote IdiomVoteLog, nickname string) (delta int, key *datastore.Key, storedVote *IdiomVoteLog, err error) {
key, existing, err := va.getIdiomVote(c, nickname, vote.IdiomId)
if err != nil {
return
}
if existing != nil {
// Well, this means the user has decided to click it again, it order to take back her vote
err = datastore.Delete(c, key)
if err == nil {
delta = -existing.Value
storedVote = nil
} else {
storedVote = existing
}
} else {
key = datastore.NewIncompleteKey(c, "IdiomVoteLog", va.createVoteIdiomLogNicknameAncestorKey(c, nickname))
key, err = datastore.Put(c, key, &vote)
if err == nil {
delta = vote.Value
storedVote = &vote
}
}
return
}
func handleTodos(res http.ResponseWriter, req *http.Request) {
ctx := appengine.NewContext(req)
u := user.Current(ctx)
todos := make([]ToDo, 0)
switch req.Method {
case "GET":
q := datastore.NewQuery("ToDo").Filter("Email =", u.Email)
iterator := q.Run(ctx)
for {
var todo ToDo
key, err := iterator.Next(&todo)
if err == datastore.Done {
break
} else if err != nil {
log.Errorf(ctx, "error retrieving todos: %v", err)
http.Error(res, err.Error(), 500)
return
}
todo.ID = key.IntID()
todos = append(todos, todo)
}
err := json.NewEncoder(res).Encode(todos)
if err != nil {
log.Errorf(ctx, "error marshalling todos: %v", err)
return
}
case "POST":
// get todo from user
var todo ToDo
err := json.NewDecoder(req.Body).Decode(&todo)
if err != nil {
log.Errorf(ctx, "error unmarshalling todos: %v", err)
http.Error(res, err.Error(), 500)
return
}
todo.Email = u.Email
// add to datastore
key := datastore.NewIncompleteKey(ctx, "ToDo", nil)
key, err = datastore.Put(ctx, key, &todo)
if err != nil {
log.Errorf(ctx, "error adding todo: %v", err)
http.Error(res, err.Error(), 500)
return
}
todo.ID = key.IntID()
// send back to user
err = json.NewEncoder(res).Encode(todo)
if err != nil {
log.Errorf(ctx, "error marshalling todo: %v", err)
return
}
case "DELETE":
id, _ := strconv.ParseInt(req.FormValue("id"), 10, 64)
if id == 0 {
http.Error(res, "not found", 404)
return
}
key := datastore.NewKey(ctx, "ToDo", "", id, nil)
var todo ToDo
err := datastore.Get(ctx, key, &todo)
if err != nil {
log.Errorf(ctx, "error getting todo: %v", err)
http.Error(res, err.Error(), 500)
return
}
if todo.Email != u.Email {
http.Error(res, "access denied", 401)
return
}
err = datastore.Delete(ctx, key)
if err != nil {
log.Errorf(ctx, "error deleting todo: %v", err)
return
}
default:
http.Error(res, "Method Not Allowed", 405)
}
}
//RemoveAccess removes access token from the datastore
func (s *AEStorage) RemoveAccess(c context.Context, code string) error {
key := datastore.NewKey(c, AccessDataKind, code, 0, nil)
return datastore.Delete(c, key)
}
// adminHandler serves an administrative interface.
func adminHandler(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
if !user.IsAdmin(c) {
http.Error(w, "forbidden", http.StatusForbidden)
return
}
var newLink *Link
var doErr error
if r.Method == "POST" {
key := r.FormValue("key")
switch r.FormValue("do") {
case "Add":
newLink = &Link{key, r.FormValue("target")}
doErr = putLink(c, newLink)
case "Delete":
k := datastore.NewKey(c, kind, key, 0, nil)
doErr = datastore.Delete(c, k)
default:
http.Error(w, "unknown action", http.StatusBadRequest)
}
err := memcache.Delete(c, cacheKey(key))
if err != nil && err != memcache.ErrCacheMiss {
log.Warningf(c, "%q: %v", key, err)
}
}
var links []*Link
_, err := datastore.NewQuery(kind).Order("Key").GetAll(c, &links)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Errorf(c, "%v", err)
return
}
// Put the new link in the list if it's not there already.
// (Eventual consistency means that it might not show up
// immediately, which might be confusing for the user.)
if newLink != nil && doErr == nil {
found := false
for i := range links {
if links[i].Key == newLink.Key {
found = true
break
}
}
if !found {
links = append([]*Link{newLink}, links...)
}
newLink = nil
}
var data = struct {
BaseURL string
Prefix string
Links []*Link
New *Link
Error error
}{baseURL, prefix, links, newLink, doErr}
if err := adminTemplate.Execute(w, &data); err != nil {
log.Criticalf(c, "adminTemplate: %v", err)
}
}
func (query Query) deleteByKey(key *datastore.Key) error {
return datastore.Delete(query.Context, key)
}
func example2() {
// [START delete]
key := datastore.NewKey(ctx, "Employee", "asalieri", 0, nil)
err = datastore.Delete(ctx, key)
// [END delete]
}
