Example #1
0
func (c Topic) getTopics(page int, where string, order string, url string) ([]models.Topic, *Pagination) {
	if page < 1 {
		page = 1
		url = url[:strings.Index(url, "=")+1] + "1"
	}

	var topics []models.Topic
	var pagination *Pagination

	if page > models.CachePageSize {
		// 当前页超出缓存页,从数据库取数据
		topics, pagination = c.queryDb(page, where, order, url)

	} else {
		// 当前页在缓存中,从缓存中取数据
		if err := cache.Get("topics"+url, &topics); err != nil {
			// 缓存中没有找到,查数据库
			topics, pagination = c.queryDb(page, where, order, url)
			if len(topics) == 0 {
				return topics, pagination
			}
			// 写入缓存
			go cache.Set("topics"+url, topics, cache.FOREVER)
			go cache.Set("pagination"+url, pagination, cache.FOREVER)

		} else {
			// 从缓存中取分页
			if err := cache.Get("pagination"+url, &pagination); err != nil {
				revel.ERROR.Println(err)
			}
		}
	}

	return topics, pagination
}
Example #2
0
func (c Languages) Show() revel.Result {
	language := c.Params.Get("language")
	if language == "" {
		return c.Redirect(routes.Languages.Index())
	}
	lines, _ := c.Txn.SelectInt("select sum(code + comment + blank) as lines "+
		"from files where language = $1", language)
	var lineStats models.FileStat
	if err := cache.Get("language-show-linesStats", &lineStats); err != nil {
		c.Txn.SelectOne(&lineStats, "select sum(code) as code, sum(comment) as comment, "+
			"sum(blank) as blank from files where language = $1", language)
		go cache.Set("language-show-linesStats", lineStats, 30*time.Minute)
	}
	var fileCount int64
	if err := cache.Get("language-show-fileCount", &fileCount); err != nil {
		fileCount, _ = c.Txn.SelectInt("select count(*) from files "+
			"where language = $1", language)
		go cache.Set("language-show-fileCount", fileCount, 30*time.Minute)
	}
	var repoCount int64
	if err := cache.Get("language-show-repoCount", &repoCount); err != nil {
		repoCount, _ := c.Txn.SelectInt("select count(*) from repos where "+
			"language = $1", language)
		go cache.Set("language-show-repoCount", repoCount, 30*time.Minute)
	}
	return c.Render(language, lines, repoCount, fileCount, lineStats)
}
Example #3
0
// Used to get the list of top languages
func (c Languages) Top() revel.Result {
	type Language struct {
		Name  string
		Color string
	}
	var results []Language
	limit := 20
	if err := cache.Get("languages", &results); err == nil {
		return c.RenderJson(results)
	}

	results = make([]Language, limit)
	languages, _ := c.Txn.Select(models.RepoStat{},
		"select l.language from (select language from files where language != '' "+
			"group by language order by count(*) desc limit $1) l order by l.language", limit)
	colors := [...]string{"#FF0000", "#617C58", "#52D017",
		"#C0C0C0", "#0000FF", "#808080", "#0000A0", "#ADD8E6",
		"#FFA500", "#800080", "#A52A2A", "#FFFF00", "#800000",
		"#00FF00", "#008000", "#FF00FF", "#FF0000", "#57FEFF",
		"FFA62F", "#8E35EF"}
	for i := 0; i < len(languages); i++ {
		results[i] = Language{
			Name:  languages[i].(*models.RepoStat).Language,
			Color: colors[i],
		}
	}
	go cache.Set("languages", results, 1*time.Hour)
	return c.RenderJson(results)
}
Example #4
0
func CacheWithExpires(key string, target interface{}, loader CacheDataLoader, expires time.Duration) {
	if err := cache.Get(key, target); err != nil {
		values := loader(key)
		setValueToAddress(target, values)
		cacheKeys = append(cacheKeys, key)
		go cache.Set(key, values, expires)
	}
}
Example #5
0
func TopicsCountCached() (count int) {
	if err := cache.Get("topics/total", &count); err != nil {
		if err = db.Model(Topic{}).Count(&count).Error; err == nil {
			go cache.Set("topics/total", count, 30*time.Minute)
		}
	}

	return
}
Example #6
0
func RepliesCountCached() (count int) {
	if err := cache.Get("replies/total", &count); err != nil {
		if err = db.Model(Reply{}).Count(&count).Error; err == nil {
			go cache.Set("replies/total", count, 30*time.Minute)
		}
	}

	return
}
Example #7
0
func (c Product) getProducts() []models.Product {
	var products []models.Product
	if err := cache.Get("products", &products); err != nil {
		c.Engine.Find(&products)
		go cache.Set("products", products, cache.FOREVER)
	}

	return products
}
Example #8
0
func getCategories() []models.Category {
	var categories []models.Category
	if err := cache.Get("categories", &categories); err != nil {
		xormmodule.Engine.Find(&categories)
		go cache.Set("categories", categories, cache.FOREVER)
	}

	return categories
}
Example #9
0
func (c Repos) Index() revel.Result {
	var repoCount int64
	var fileCount int64
	var userCount int64
	var speed int
	if err := cache.Get("repoCount", &repoCount); err != nil {
		repoCount, _ = c.Txn.SelectInt("select count(*) from repos")
		go cache.Set("repoCount", repoCount, 1*time.Hour)
	}
	if err := cache.Get("fileCount", &fileCount); err != nil {
		fileCount, _ = c.Txn.SelectInt("select count(*) from files")
		go cache.Set("fileCount", fileCount, 1*time.Hour)
	}
	if err := cache.Get("userCount", &userCount); err != nil {
		userCount, _ = c.Txn.SelectInt("select count(distinct(owner)) from repos")
		go cache.Set("userCount", userCount, 1*time.Hour)
	}
	cache.Get("speed", &speed) // lines processed per second
	return c.Render(repoCount, userCount, fileCount, speed)
}
Example #10
0
func (c Topic) getReplies(id int64) []models.Reply {
	var replies []models.Reply
	str := strconv.Itoa(int(id))

	if err := cache.Get("replies"+str, &replies); err != nil {
		c.Engine.Where("topic_id = ?", id).Find(&replies)
		go cache.Set("replies"+str, replies, cache.FOREVER)
	}

	return replies
}
Example #11
0
// Method IsInBlocklist is checks against logged out tokens
func IsInBlocklist(token string) bool {
	var existingToken string
	cache.Get(token, &existingToken)

	if len(existingToken) > 0 {
		revel.WARN.Printf("Yes, blocklisted token [%v]", existingToken)
		return true
	}

	return false
}
Example #12
0
func (c Repos) Stat() revel.Result {
	limit := 15
	var results [][]int
	var buffer bytes.Buffer
	var mapResults map[string]interface{}
	if err := cache.Get("stats", &mapResults); err == nil {
		return c.RenderJson(mapResults)
	}
	languageResults := make([]Language, limit)
	languages, _ := c.Txn.Select(models.RepoStat{},
		"select l.language from (select language from files where language != '' "+
			"group by language order by sum(code + comment + blank) desc limit $1) "+
			"l order by l.language", limit)
	colors := [...]string{"#FF0000", "#617C58", "#52D017",
		"#C0C0C0", "#0000FF", "#808080", "#0000A0", "#ADD8E6",
		"#FFA500", "#800080", "#A52A2A", "#FFFF00", "#800000",
		"#00FF00", "#008000", "#FF00FF", "#FF0000", "#57FEFF",
		"FFA62F", "#8E35EF"}
	for i := 0; i < len(languages); i++ {
		languageResults[i] = Language{
			Name:  languages[i].(*models.RepoStat).Language,
			Color: colors[i],
		}
		buffer.WriteString("'" + languages[i].(*models.RepoStat).Language + "', ")
	}
	buffer.WriteString("'" + languages[len(languages)-1].(*models.RepoStat).Language + "'")
	mapResults = make(map[string]interface{})
	mapResults["languages"] = languageResults
	results = make([][]int, limit)
	for i := 0; i < len(languages); i++ {
		repoStats, _ := c.Txn.Select(models.RepoStat{},
			"select l.count, l.language from (select sum(code + comment + blank) as count, language "+
				"from files where repoid in (select id from repos where language = $1) "+
				"and language in ("+buffer.String()+") group by language order by "+
				"sum(code + comment + blank) desc) l order by l.language",
			languages[i].(*models.RepoStat).Language)
		row := make([]int, limit)
		for j := 0; j < len(repoStats); j++ {
			var index int
			for k := 0; k < limit; k++ {
				if languageResults[k].Name == repoStats[j].(*models.RepoStat).Language {
					index = k
					break
				}
			}
			row[index] = repoStats[j].(*models.RepoStat).Count
		}
		results[i] = row
	}
	mapResults["stats"] = results
	go cache.Set("stats", mapResults, 1*time.Hour)
	return c.RenderJson(mapResults)
}
Example #13
0
func (c Languages) Index() revel.Result {
	var dbLineStats []interface{}
	var dbRepoStats []interface{}
	lines := 0
	if err := cache.Get("dbLineStats", &dbLineStats); err != nil {
		dbLineStats, _ = c.Txn.Select(models.FileStat{},
			"select language, sum(code + comment + blank) as lines "+
				"from files group by language order by lines desc")
		go cache.Set("dbLineStats", dbLineStats, 30*time.Minute)
	}
	if err := cache.Get("dbRepoStats", &dbRepoStats); err != nil {
		dbRepoStats, _ = c.Txn.Select(models.RepoStat{},
			"select language, count(*) as count from repos where language != '' "+
				"group by language order by count desc")
		go cache.Set("dbRepoStats", dbRepoStats, 30*time.Minute)
	}

	fileStats := make([](*models.FileStat), 15)
	for i := 0; i < len(dbLineStats); i++ {
		f := dbLineStats[i].(*models.FileStat)
		lines += f.Lines
		if i < 15 {
			fileStats[i] = dbLineStats[i].(*models.FileStat)
		}
		dbLineStats[i].(*models.FileStat).Count = i + 1
	}
	repoStats := make([](*models.RepoStat), 15)
	var size int
	if len(repoStats) > len(dbRepoStats) {
		size = len(dbRepoStats)
	} else {
		size = len(repoStats)
	}
	for i := 0; i < size; i++ {
		repoStats[i] = dbRepoStats[i].(*models.RepoStat)
	}
	return c.Render(dbLineStats, lines, fileStats, repoStats)
}
Example #14
0
func GetSetting(key string) (out string) {
	out = ""
	if err := cache.Get(settingCacheKey(key), &out); err != nil {
		s := FindSettingByKey(key)
		if s.Id <= 0 {
			db.Save(&s)
		}

		out = s.Val
		s.RewriteCache()
	}

	return
}
Example #15
0
func initRevelTemplateFuncs() {
	revel.TemplateFuncs["webTitle"] = func(prefix string) (webTitle string) {
		const KEY = "cache.web.title"
		if err := cache.Get(KEY, &webTitle); err != nil {
			webTitle = utils.ForceGetConfig("web.title")
			go cache.Set(KEY, webTitle, 24*30*time.Hour)
		}
		return
	}

	revel.TemplateFuncs["logined"] = func(session revel.Session) bool {
		v, e := session["user"]
		return e == true && v != ""
	}
}
Example #16
0
func (c Admin) SocketConn(token string, ws *websocket.Conn) revel.Result {
	var access bool
	user := ""
	if err := cache.Get(token, &user); err != nil {
		access = false
	} else {
		access = true
	}
	cache.Delete(token)

	if access {
		subscription := roomevents.Subscribe()
		defer subscription.Cancel()

		roomevents.Join(user)
		defer roomevents.Leave(user)

		newMessages := make(chan string)
		go func() {
			var msg string
			for {
				err := websocket.Message.Receive(ws, &msg)
				if err != nil {
					close(newMessages)
					return
				}
				newMessages <- msg
			}
		}()
		for {
			select {
			case event := <-subscription.New:
				if websocket.JSON.Send(ws, &event) != nil {
					// They disconnected.
					return nil
				}
			case msg, ok := <-newMessages:

				if !ok {
					return nil
				}

				roomevents.Say(user, msg)
			}
		}
	}
	return nil
}
Example #17
0
// 帖子详细
func (c Topic) Show(id int64) revel.Result {
	topic := new(models.Topic)
	str := strconv.Itoa(int(id))

	if err := cache.Get("topic"+str, &topic); err != nil {
		has, _ := c.Engine.Id(id).Get(topic)
		if !has {
			return c.NotFound("帖子不存在")
		}
		go cache.Set("topic"+str, topic, cache.FOREVER)
	}

	topic.Hits += 1
	c.Engine.Id(id).Cols("hits").Update(topic)

	replies := c.getReplies(id)

	title := topic.Title
	return c.Render(title, topic, replies)
}
Example #18
0
func (c Article) Show(id string) revel.Result {
	dao, err := model.NewDao()
	defer dao.Close()
	if err != nil {
		c.Response.Status = 500
		return c.RenderError(err)
	}
	topic := dao.FindTopicById(id)
	if topic == nil {
		return c.Redirect("/")
	}
	if topic.Status == 0 {
		return c.RenderTemplate("Article/result.html")
	}
	ip := strings.Split(c.Request.RemoteAddr, ":")[0]
	revel.INFO.Printf("Ip : %s", ip)
	var obj CacheBean
	key := fmt.Sprintf("%s.%s", ip, id)
	err = cache.Get(key, &obj)
	if err == nil {
		revel.INFO.Printf("Cache : %v", obj)
	} else {
		revel.ERROR.Printf("Cache Errr : %v", err)
		if !obj.HasCache {
			obj.HasCache = true
			go cache.Set(key, obj, 10*time.Minute)
			topic.Read = topic.Read + 1
			dao.UpdateTopic(topic)
		}
	}
	content, ret := utils.GetHTMLContent(id)
	if ret != nil {
		c.Response.Status = 500
		return c.RenderError(ret)
	}
	topic.Body = template.HTML(content)
	replays, repcnt := dao.GetReplays(id)
	return c.Render(topic, replays, repcnt)
}