func (self *store) Dequeue(perma_blobref string, blobref string) (blobrefs []string, err os.Error) {
	parent := datastore.NewKey("perma", perma_blobref, 0, nil)
	key := datastore.NewKey("missing", blobref, 0, parent)
	var m missingStruct
	if err = datastore.Get(self.c, key, &m); err != nil {
		if err == datastore.ErrNoSuchEntity {
			return nil, nil
		}
	}
	err = datastore.Delete(self.c, key)
	if err != nil {
		return
	}
	for _, dep := range m.Pending {
		key := datastore.NewKey("pending", dep, 0, parent)
		var p pendingStruct
		if err = datastore.Get(self.c, key, &m); err != nil {
			if err != datastore.ErrNoSuchEntity {
				continue
			}
		}
		p.WaitingForCount--
		if p.WaitingForCount == 0 {
			blobrefs = append(blobrefs, dep)
			datastore.Delete(self.c, key)
		}
	}
	return
}

func TouchSuc(c appengine.Context, IdSuc string, IdEmp string) error {
	/* llave de Cta-Empresa */
	ce := &CtaEmpresa{IdEmp: IdEmp}
	ceKey := datastore.NewKey(c, "CtaEmpresa", ce.IdEmp, 0, nil)
	err := datastore.Get(c, ceKey, ce)
	if err == datastore.ErrNoSuchEntity {
		return nil
	}

	/* parent de Empresa */
	cta := &Cta{Email: ce.Email}
	ctaKey := datastore.NewKey(c, "Cta", cta.Email, 0, nil)
	err = datastore.Get(c, ctaKey, cta)
	if err == datastore.ErrNoSuchEntity {
		return nil
	}

	/* Key de empresa */
	empKey := datastore.NewKey(c, "Empresa", IdEmp, 0, ctaKey)

	suc := &Sucursal{IdSuc: IdSuc}
	sucKey := datastore.NewKey(c, "Sucursal", IdSuc, 0, empKey)
	err = datastore.Get(c, sucKey, suc)
	if err == datastore.ErrNoSuchEntity {
		return err
	}
	suc.FechaHora = time.Now().Add(time.Duration(GMTADJ) * time.Second)
	if _, err = datastore.Put(c, sucKey, suc); err != nil {
		return err
	}
	return nil
}

func edit(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	var now Period
	datastore.Get(c, currentSemesterKey(c), &now)
	arr := regexp.MustCompile("_").Split(r.FormValue("id"), 4)
	name := arr[0]
	count, cnterr := strconv.Atoi(arr[1])
	if cnterr != nil {
		log.Println("Something failed with counting for some reason")
	}

	sem, e1 := strconv.Atoi(arr[2])
	yr, e2 := strconv.Atoi(arr[3])
	if e1 != nil || e2 != nil {
		panic("neither year nor sem should be non-ints")
	}
	if now.Semester == sem && now.Year == yr {
		value := r.FormValue("value")
		k := datastore.NewKey(c, "Tile", strint(name, count), 0, tileRootKey(c, sem, yr))
		var uTile Tile
		datastore.Get(c, k, &uTile)
		//	log.Println(lcs.Diff(value, uTile.Desc))
		uTile.Desc = value
		uTile.LastUpdate = time.Now()
		datastore.Put(c, k, &uTile)
		w.Write([]byte(uTile.Desc))
	} else {
		w.Write([]byte("Edits discarded: cannot edit entries after the semester has ended"))
	}
}

// logHandler displays log text for a given hash.
// It handles paths like "/log/hash".
func logHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-type", "text/plain; charset=utf-8")
	c := contextForRequest(r)
	hash := r.URL.Path[strings.LastIndex(r.URL.Path, "/")+1:]
	key := datastore.NewKey(c, "Log", hash, 0, nil)
	l := new(Log)
	if err := datastore.Get(c, key, l); err != nil {
		if err == datastore.ErrNoSuchEntity {
			// Fall back to default namespace;
			// maybe this was on the old dashboard.
			c := appengine.NewContext(r)
			key := datastore.NewKey(c, "Log", hash, 0, nil)
			err = datastore.Get(c, key, l)
		}
		if err != nil {
			logErr(w, r, err)
			return
		}
	}
	b, err := l.Text()
	if err != nil {
		logErr(w, r, err)
		return
	}
	w.Write(b)
}

// Increment increments the named counter.
func Increment(c appengine.Context, name string) error {
    // Get counter config.
    var cfg counterConfig
    ckey := datastore.NewKey(c, configKind, name, 0, nil)
    err := datastore.RunInTransaction(c, func(c appengine.Context) error {
        err := datastore.Get(c, ckey, &cfg)
        if err == datastore.ErrNoSuchEntity {
            cfg.Shards = defaultShards
            _, err = datastore.Put(c, ckey, &cfg)
        }
        return err
    }, nil)
    if err != nil {
        return err
    }
    err = datastore.RunInTransaction(c, func(c appengine.Context) error {
        shardName := fmt.Sprintf("%v%d", name, rand.Intn(cfg.Shards))
        key := datastore.NewKey(c, shardKind, shardName, 0, nil)
        var s shard
        err := datastore.Get(c, key, &s)
        // A missing entity and a present entity will both work.
        if err != nil && err != datastore.ErrNoSuchEntity {
            return err
        }
        s.Count++
		s.Name = name
        _, err = datastore.Put(c, key, &s)
        return err
    }, nil)
    if err != nil {
        return err
    }
    //memcache.Increment(c, memcacheKey(name), 1, 0)
    return nil
}

// Métodos de Empresa
func GetEmpresa(c appengine.Context, id string) *Empresa {
	/* llave de Cta-Empresa */
	ce := &CtaEmpresa{IdEmp: id}
	ceKey := datastore.NewKey(c, "CtaEmpresa", ce.IdEmp, 0, nil)
	err := datastore.Get(c, ceKey, ce)
	if err == datastore.ErrNoSuchEntity {
		return nil
	}

	/* parent de Empresa */
	cta := &Cta{Email: ce.Email}
	ctaKey := datastore.NewKey(c, "Cta", cta.Email, 0, nil)
	err = datastore.Get(c, ctaKey, cta)
	if err == datastore.ErrNoSuchEntity {
		return nil
	}

	/* Key de empresa */
	emp := &Empresa{IdEmp: id}
	empKey := datastore.NewKey(c, "Empresa", emp.IdEmp, 0, ctaKey)
	err = datastore.Get(c, empKey, emp)
	if err == datastore.ErrNoSuchEntity {
		return nil
	}
	return emp
}

func GetEmpSucursales(c appengine.Context, IdEmp string) *[]Sucursal {
	/* llave de Cta-Empresa */
	ce := &CtaEmpresa{IdEmp: IdEmp}
	ceKey := datastore.NewKey(c, "CtaEmpresa", ce.IdEmp, 0, nil)
	err := datastore.Get(c, ceKey, ce)
	if err == datastore.ErrNoSuchEntity {
		return nil
	}

	/* parent de Empresa */
	cta := &Cta{Email: ce.Email}
	ctaKey := datastore.NewKey(c, "Cta", cta.Email, 0, nil)
	err = datastore.Get(c, ctaKey, cta)
	if err == datastore.ErrNoSuchEntity {
		return nil
	}

	/* Key de empresa */
	empKey := datastore.NewKey(c, "Empresa", IdEmp, 0, ctaKey)
	q := datastore.NewQuery("Sucursal").Ancestor(empKey)
	n, _ := q.Count(c)
	sucursales := make([]Sucursal, 0, n)
	if _, err := q.GetAll(c, &sucursales); err != nil {
		return nil
	}
	return &sucursales
}

func acceptSuggestion(w http.ResponseWriter, r *http.Request) {
	if csrf.ValidateToken(r, r.FormValue("CSRFToken")) {
		trimPath := strings.Trim(r.URL.Path, "/admin/post/suggestion/accept")

		postID, _ := strconv.Atoi(trimPath)
		postID64 := int64(postID)

		c := appengine.NewContext(r)

		keyS := datastore.NewKey(c, "PostSuggestion", "", postID64, nil)

		var suggestion PostSuggestion
		datastore.Get(c, keyS, &suggestion)

		var post Post
		keyP := datastore.NewIncompleteKey(c, "Post", nil)
		var counter Counter
		keyC := datastore.NewKey(c, "Counter", "", 1, nil)
		datastore.Get(c, keyC, &counter)
		counter.Count = counter.Count + 1

		// Add Cache Counter
		mCount := new(bytes.Buffer)
		encCount := gob.NewEncoder(mCount)
		encCount.Encode(counter)
		cache.AddCache(r, "Counter", mCount.Bytes())

		post.Content = suggestion.Content
		post.Sequence = counter.Count
		datastore.Put(c, keyP, &post)
		datastore.Put(c, keyC, &counter)
		datastore.Delete(c, keyS)
		http.Redirect(w, r, "/admin/post/suggestion", http.StatusFound)
	}
}

// GetProjects returns all projects owned by the given user.
// Optionally also include projects that are shared with the user.
func GetProjects(user string,
	include_shared bool,
	c *appengine.Context) ([]*datastore.Key, []*EncodedProject, error) {

	qr := datastore.NewQuery("EncodedProject").
		Filter("Owner = ", user).
		Order("-Created").Limit(100)

	keyset := make(map[string]bool)

	var projlist []*EncodedProject
	keylist, err := qr.GetAll(*c, &projlist)
	if err != nil {
		(*c).Errorf("GetProjects[1]: %v", err)
		return nil, nil, err
	}

	if !include_shared {
		return keylist, projlist, err
	}

	for _, k := range keylist {
		keyset[k.String()] = true
	}

	// Get project ids that are shared with this user
	ky2 := datastore.NewKey(*c, "SharingByUser", strings.ToLower(user),
		0, nil)
	var spu SharingByUser
	err = datastore.Get(*c, ky2, &spu)
	if err == datastore.ErrNoSuchEntity {
		// No projects shared with this user
		return keylist, projlist, nil
	}
	if err != nil {
		(*c).Errorf("GetProjects[2]: %v", err)
		return nil, nil, err
	}

	// Get the shared projects
	spvl := Clean_split(spu.Projects, ",")
	for _, spv := range spvl {
		ky := datastore.NewKey(*c, "EncodedProject", spv, 0, nil)
		_, ok := keyset[ky.String()]
		if ok {
			continue
		}
		keyset[ky.String()] = true
		pr := new(EncodedProject)
		err = datastore.Get(*c, ky, pr)
		if err != nil {
			(*c).Infof("GetProjects [3]: %v\n%v", spv, err)
			continue
		}
		keylist = append(keylist, ky)
		projlist = append(projlist, pr)
	}
	return keylist, projlist, nil
}

func SetProperty(c appengine.Context, ref ArticleRef, propertyName string, propertyValue bool) ([]string, error) {
	articleKey, err := ref.key(c)
	if err != nil {
		return nil, err
	}

	article := new(Article)
	if err := datastore.Get(c, articleKey, article); err != nil && !IsFieldMismatch(err) {
		return nil, err
	}

	if propertyValue != article.HasProperty(propertyName) {
		wasUnread := article.IsUnread()
		wasLiked := article.IsLiked()
		unreadDelta := 0

		article.SetProperty(propertyName, propertyValue)

		// Update unread counts if necessary
		if wasUnread != article.IsUnread() {
			if wasUnread {
				unreadDelta = -1
			} else {
				unreadDelta = 1
			}
		}

		if _, err := datastore.Put(c, articleKey, article); err != nil {
			return nil, err
		}

		if wasLiked != article.IsLiked() {
			if wasLiked {
				article.updateLikeCount(c, -1)
			} else {
				article.updateLikeCount(c, 1)
			}
		}

		if unreadDelta != 0 {
			// Update unread counts - not critical
			subscriptionKey := articleKey.Parent()
			subscription := new(Subscription)

			if err := datastore.Get(c, subscriptionKey, subscription); err != nil {
				c.Warningf("Unread count update failed: subscription read error (%s)", err)
			} else if subscription.UnreadCount+unreadDelta >= 0 {
				subscription.UnreadCount += unreadDelta
				if _, err := datastore.Put(c, subscriptionKey, subscription); err != nil {
					c.Warningf("Unread count update failed: subscription write error (%s)", err)
				}
			}
		}
	}

	return article.Properties, nil
}

func handleOpen(r *http.Request, c appengine.Context, u *user.User) (
	interface{}, error) {
	if r.Method != "POST" {
		return nil, ErrMethodNotAllowed
	}
	k, err := ds.DecodeKey(r.FormValue("doorKey"))
	if err != nil {
		return nil, ErrNoDoorKey
	}

	cnt := 0
	if cnt, err = ds.NewQuery("Permission").
		Filter("userKey=", ds.NewKey(c, "User", u.ID, 0, nil)).
		Filter("doorKey=", k).
		Filter("level>=", LevelOpener).
		Count(c); err != nil {
		return nil, err
	}
	if cnt == 0 {
		return nil, ErrNoOpenerPermission
	}

	config := Config{}
	if err = ds.Get(c, ds.NewKey(c, "Config", "singleton", 0, nil), &config); err != nil {
		if err == ds.ErrNoSuchEntity {
			err = ErrNoConfig
		}
		return nil, err
	}
	if config.ApiKey == "" {
		return nil, ErrNoConfig
	}

	door := Door{}
	if err = ds.Get(c, k, &door); err != nil {
		if err == ds.ErrNoSuchEntity {
			err = ErrNoOpenerPermission
		}
		return nil, err
	}

	client := urlfetch.Client(c)
	sender := gcm.Sender{config.ApiKey, client}
	msg := &gcm.Message{
		RegistrationIDs: []string{door.RegId},
		Data:            map[string]string{"action": "OPEN"}}

	var response *gcm.Response
	response, err = sender.SendNoRetry(msg)
	if err != nil {
		c.Errorf("Error while sending message to GCM service: %s", err.Error())
		return nil, Err{"Failed to open door.", http.StatusInternalServerError}
	}

	return response, nil
}

// Increment increments the named counter.
func Increment(c appengine.Context, valName string) error {

	// Get counter config.
	wNumShards := dsu.WrapInt{}
	dsu.McacheGet(c, mCKNumShards(valName), &wNumShards)
	if wNumShards.I < 1 {
		ckey := datastore.NewKey(c, dsKindNumShards, mCKNumShards(valName), 0, nil)
		errTx := datastore.RunInTransaction(c,
			func(c appengine.Context) error {
				err := datastore.Get(c, ckey, &wNumShards)
				if err == datastore.ErrNoSuchEntity {
					wNumShards.I = defaultNumShards
					_, err = datastore.Put(c, ckey, &wNumShards)
				}
				return err
			}, nil)
		if errTx != nil {
			return errTx
		}
		dsu.McacheSet(c, mCKNumShards(valName), dsu.WrapInt{wNumShards.I})
	}

	// pick random counter and increment it
	errTx := datastore.RunInTransaction(c,
		func(c appengine.Context) error {
			shardId := rand.Intn(wNumShards.I)
			dsKey := datastore.NewKey(c, dsKindShard, dSKSingleShard(valName, shardId), 0, nil)
			var sd WrapShardData
			err := datastore.Get(c, dsKey, &sd)
			// A missing entity and a present entity will both work.
			if err != nil && err != datastore.ErrNoSuchEntity {
				return err
			}
			sd.Name = valName
			sd.ShardId = shardId
			sd.I++
			_, err = datastore.Put(c, dsKey, &sd)
			c.Infof("ds put %v %v", dsKey, sd)
			return err
		}, nil)
	if errTx != nil {
		return errTx
	}

	memcache.Increment(c, mCKValue(valName), 1, 0)

	// collect number of updates
	//    per valName per instance in memory
	//    for every interval of 10 minutes
	//
	//  a batch job checks if the number of shards should be increased or decreased
	//    and truncates this map
	updateSamplingFrequency[valName+util.TimeMarker()[:len("2006-01-02 15:0")]] += 1

	return nil
}

func viewpage(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	url := r.URL.Path[len(viewpage_prefix):]
	if url == "" || strings.HasSuffix(url, "/") {
		url += "index"
	}
	hostkey := datastore.NewKey(c, "Host", r.URL.Host+"/", 0, nil)

	// check for a static first
	static := &Static{Url: url}
	key := datastore.NewKey(c, "Static", static.Key(), 0, hostkey)
	err := datastore.Get(c, key, static)
	if err != nil && err != datastore.ErrNoSuchEntity {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	} else if err == nil {
		static.PostLoad()

		// guess the MIME type based on the extension
		if dot := strings.LastIndex(static.Url, "."); dot >= 0 && len(static.Url) > dot+1 {
			ext := static.Url[dot:]
			if mimetype := mime.TypeByExtension(ext); mimetype != "" {
				w.Header()["Content-Type"] = []string{mimetype}
			} else {
				w.Header()["Content-Type"] = []string{http.DetectContentType(static.Contents)}
			}
		}
		w.Write(static.Contents)
		return
	}

	// try a rendered page
	page := NewPage(url)
	if !page.Validate() {
		http.Error(w, "Invalid page URL", http.StatusBadRequest)
		return
	}

	// get the page
	key = datastore.NewKey(c, "Page", page.Key(), 0, hostkey)
	err = datastore.Get(c, key, page)
	if err != nil && err == datastore.ErrNoSuchEntity {
		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
		return
	} else if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	page.PostLoad()
	page.Render()
	if err = render(c, w, r.URL.Host, page); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
}

// Remove_sharing removes the given users from the access list for the given project.
func Remove_sharing(project_name string,
	user_names []string,
	c *appengine.Context) error {

	// Map whose keys are the users to remove.
	rmu := make(map[string]bool)
	for i := 0; i < len(user_names); i++ {
		rmu[user_names[i]] = true
	}

	// Update SharingByProject.
	key := datastore.NewKey(*c, "SharingByProject", project_name, 0, nil)
	sproj := new(SharingByProject)
	err := datastore.Get(*c, key, sproj)
	if err == datastore.ErrNoSuchEntity {
		// OK
	} else if err != nil {
		return err
	} else {
		users := Clean_split(sproj.Users, ",")
		users = unique_svec(users)
		users = sdiff(users, rmu)
		sproj.Users = strings.Join(users, ",")
		_, err = datastore.Put(*c, key, sproj)
		if err != nil {
			return err
		}
	}

	// Update SharingByUser.
	for _, name := range user_names {
		pkey := datastore.NewKey(*c, "SharingByUser", strings.ToLower(name), 0, nil)
		suser := new(SharingByUser)
		err := datastore.Get(*c, pkey, suser)
		if err == datastore.ErrNoSuchEntity {
			// should not reach here
		} else if err != nil {
			return err
		} else {
			projlist := Clean_split(suser.Projects, ",")
			projlist = unique_svec(projlist)
			projlist = sdiff(projlist, map[string]bool{project_name: true})
			suser.Projects = strings.Join(projlist, ",")

			_, err = datastore.Put(*c, pkey, suser)
			if err != nil {
				return err
			}
		}
	}

	return nil
}

func SetTags(c appengine.Context, ref ArticleRef, tags []string) ([]string, error) {
	articleKey, err := ref.key(c)
	if err != nil {
		return nil, err
	}

	article := new(Article)
	if err := datastore.Get(c, articleKey, article); err != nil && !IsFieldMismatch(err) {
		return nil, err
	}

	article.Tags = tags

	if _, err := datastore.Put(c, articleKey, article); err != nil {
		return nil, err
	}

	var userKey *datastore.Key
	if key, err := ref.UserID.key(c); err != nil {
		return nil, err
	} else {
		userKey = key
	}

	batchWriter := NewBatchWriter(c, BatchPut)
	for _, tagTitle := range tags {
		tagKey := datastore.NewKey(c, "Tag", tagTitle, 0, userKey)
		tag := Tag{}

		if err := datastore.Get(c, tagKey, &tag); err == nil || IsFieldMismatch(err) {
			// Already available
		} else if err == datastore.ErrNoSuchEntity {
			// Not yet available - add it
			tag.Title = tagTitle
			tag.Created = time.Now()

			if err := batchWriter.Enqueue(tagKey, &tag); err != nil {
				c.Errorf("Error queueing tag for batch write: %s", err)
				return nil, err
			}
		} else {
			// Some other error
			return nil, err
		}
	}

	if err := batchWriter.Flush(); err != nil {
		c.Errorf("Error flushing batch queue: %s", err)
		return nil, err
	}

	return article.Tags, nil
}

func matcherVagas(c appengine.Context, r render.Render, req *http.Request) {
	log.Println(req.FormValue("vaga"))
	vagaId, err := strconv.ParseInt(req.FormValue("vaga"), 10, 64)
	if err != nil {
		// log.Println(err)
		// r.JSON(http.StatusInternalServerError, err.Error())
		return
	}
	vagaKey := datastore.NewKey(c, "Vaga", "", vagaId, nil)
	vaga := new(Vaga)
	err = datastore.Get(c, vagaKey, vaga)
	if err != nil {
		log.Println(err)
		r.JSON(http.StatusInternalServerError, err.Error())
		return
	}

	var curriculos []Curriculo
	q := datastore.NewQuery("Curriculo")
	_, err = q.GetAll(c, &curriculos)
	if err != nil {
		log.Println(err)
		r.JSON(http.StatusInternalServerError, err.Error())
		return
	}

	empresaKey := datastore.NewKey(c, "Empresa", vaga.Email, 0, nil)
	empresa := new(Empresa)
	err = datastore.Get(c, empresaKey, empresa)
	if err != nil {
		log.Println(err)
		r.JSON(http.StatusInternalServerError, err.Error())
		return
	}

	for _, curriculo := range curriculos {
		analise := &Analise{
			EmpresaId:     vaga.Email,
			VagaId:        vagaKey.IntID(),
			CurriculoId:   curriculo.Email,
			EmpresaNome:   empresa.Nome,
			VagaTitulo:    vaga.Titulo,
			CurriculoNome: curriculo.Nome,
		}

		necessidades := vaga.Habilidades
		capacidades := curriculo.Habilidades
		go matchSuperDesinteressante(necessidades, capacidades, analise, c)
	}

	r.JSON(http.StatusOK, "success")
}

func TestDatastoreFixture(t *testing.T) {
	filepath := mkTempfile(`[{
    "_kind": "FixtureKind",
    "_key": "key1",
    "IntValue": 10,
    "FloatValue": 2.4,
    "BoolValue": true,
    "StringValue": "foobar",
    "BytesValue": "[]bytesfoobar",
    "DateTimeValue": "2014-01-02T14:02:50Z",
    "DateValue": "2014-01-02",
    "Children": [{
      "_kind": "FixtureKindChildren",
      "_key": "keyc1",
      "Foo": "bar"
    }]
  },{
    "_kind": "FixtureKind",
    "_key": "key1",
    "_ns": "ns1",
    "StringValue": "withns1"
  }
]`)

	assert := wcg.NewAssert(t)
	RunTestServer(func(ts *TestServer) {
		var fk FixtureKind
		var fkc1 FixtureKindChildren
		DatastoreFixture(ts.Context, filepath, nil)
		key := datastore.NewKey(ts.Context, "FixtureKind", "key1", 0, nil)
		keyc1 := datastore.NewKey(ts.Context, "FixtureKindChildren", "keyc1", 0, key)

		assert.Nil(datastore.Get(ts.Context, key, &fk), "datastore.Get('key1') ")
		assert.Nil(datastore.Get(ts.Context, keyc1, &fkc1), "datastore.Get('keyc1') ")

		assert.EqInt(10, fk.IntValue, "IntValue should be 10")
		assert.EqFloat32(2.4, fk.FloatValue, "FloatValue should be 2.4")
		assert.EqStr("foobar", fk.StringValue, "StringValue should be 'foobar'")
		assert.EqStr("bytesfoobar", string(fk.BytesValue), "BytesValue should be 'foobar'")

		assert.EqTime(time.Date(2014, 01, 02, 14, 02, 50, 0, time.UTC), fk.DateTimeValue, "DateTimeValue should be 2014-01-02T14:02:50Z")
		assert.EqTime(time.Date(2014, 01, 02, 0, 0, 0, 0, time.UTC), fk.DateValue, "DateTimeValue should be 2014-01-02T00:00:00Z")

		// namespace
		ns1, _ := appengine.Namespace(ts.Context, "ns1")
		key = datastore.NewKey(ns1, "FixtureKind", "key1", 0, nil)
		assert.Nil(datastore.Get(ns1, key, &fk), "datastore.Get('key1') /w ns1")
		assert.EqStr("withns1", fk.StringValue, "StringValue should be 'withns1'")
	})

}

func SavePortalHttp(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	vars := mux.Vars(r)
	stringkey := vars["key"]
	defer r.Body.Close()
	body, _ := ioutil.ReadAll(r.Body)
	var portal Portal
	err := json.Unmarshal(body, &portal)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	if !portalExists(c, portal.Id) {
		c.Infof("Saving new portal %s id %s", portal.Title, portal.Id)
		portal.Address = GetGeoCode(c, portal.Lat/1000000, portal.Lon/1000000)
	} else {
		c.Infof("Portal EXISTS!!!")
		var existingPortal Portal
		if err := datastore.Get(c, datastore.NewKey(c, "Portal", portal.Id, 0, nil), &existingPortal); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		portal.Address = existingPortal.Address
		if len(portal.Address) == 0 {
			portal.Address = GetGeoCode(c, portal.Lat/1000000, portal.Lon/1000000)
		} else {
			c.Infof("Dato geoCode ya existe, no lo consulto de nuevo")
		}
	}

	key, err := portal.save(c, stringkey)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	var p1 Portal
	if err := datastore.Get(c, key, &p1); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	c.Infof("Success ! key = %s", key)
	b, _ := json.Marshal(portal)
	w.Header().Set("content-type", "application/json")
	fmt.Fprintf(w, string(b))

}

func getNoteChunk(c appengine.Context, notebookID int64, period string) (*datastore.Key, NoteChunk, error) {
	var chunk NoteChunk
	notebookKey := datastore.NewKey(c, "Notebook", "", notebookID, nil)
	chunkKey := datastore.NewKey(c, "NoteChunk", period, 0, notebookKey)
	err := datastore.Get(c, chunkKey, &chunk)
	return chunkKey, chunk, err
}

func accept(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	id := r.FormValue("id")
	intID, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	pkg := &Package{}
	key := datastore.NewKey(c, "Package", "", intID, nil)
	err = datastore.Get(c, key, pkg)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	// check if the package is already present
	acceptQuery := datastore.NewQuery("Package").
		Filter("Accepted =", true).
		Filter("Repo =", pkg.Repo)

	var packages []*Package
	keys, err := acceptQuery.GetAll(c, &packages)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	if len(packages) > 1 {
		// just print an error to let admin know
		c.Errorf("More tha one package for repo: %v", pkg.Repo)
	}

	if len(packages) > 0 {
		// update the package and delete
		oldKey := keys[0]
		oldPkg := packages[0]
		oldPkg.Name = pkg.Name
		oldPkg.Description = pkg.Description
		oldPkg.IsLibrary = pkg.IsLibrary
		oldPkg.Category = pkg.Category
		oldPkg.Updated = time.Now()
		if _, err = datastore.Put(c, oldKey, oldPkg); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		if err = datastore.Delete(c, key); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	} else {
		// accept the new package
		pkg.Accepted = true
		if _, err = datastore.Put(c, key, pkg); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
	memcache.Delete(c, pkg.Repo)
	memcache.Delete(c, CAT)
	memcache.Delete(c, ALL_QUERY)
}