Example #1
0
func executeAction(c *gin.Context) {

	var args []string
	for i := 0; i < 10; i++ {
		operation := c.Query(strconv.Itoa(i))
		if len(operation) > 0 {
			args = append(args, operation)
		} else {
			break
		}
	}
	fmt.Println(args)
	//Turn LED Blue to Indicate event.
	setRGB([]string{"0", "255", "255"})
	time.Sleep(1 * time.Second)

	statusCode := 200
	out, err := exec.Command(command, args...).Output()
	if err != nil {
		statusCode = 500
		//Flash LED red to indicate Error
		setRGB([]string{"255", "0", "0"})
		time.Sleep(1 * time.Second)
	}

	//Turn LED back to green
	setRGB([]string{"0", "255", "0"})

	c.JSON(statusCode, gin.H{
		"status": "received",
		"output": string(out[:]),
	})

}
Example #2
0
func (pc *MonitoringController) getMonitoringAction(c *gin.Context) {

	host := c.Query("host")
	stat := c.DefaultQuery("stat", "all")
	t := c.DefaultQuery("time", "last1800")

	hosts, err := models.NodeMapper.FetchAll()
	if err != nil {
		panic(err)
	}

	var graphs models.Graphs

	var target []string
	if host != "" {
		target = []string{host}
	} else {
		for _, h := range hosts {
			target = append(target, h.Hostname)
		}
	}

	if graphs, err = models.GraphMapper.FetchAll(target, stat, t); err != nil {
		panic(err)
	}

	c.HTML(http.StatusOK, "monitoring_show.html", map[string]interface{}{
		"host":   host,
		"stat":   stat,
		"time":   t,
		"hosts":  hosts,
		"stats":  models.GraphStats,
		"graphs": graphs,
	})
}
Example #3
0
func delete(c *gin.Context) {
	series := c.Query("series")
	if series == "" {
		c.JSON(http.StatusOK, gin.H{
			"status":  "error",
			"message": "series need",
		})
		return
	}

	err := db.Batch(func(tx *bolt.Tx) error {
		err := tx.DeleteBucket([]byte(series))
		if err != nil {
			return err
		}

		return nil
	})

	if err != nil {
		c.JSON(http.StatusOK, gin.H{
			"status":  "error",
			"message": err.Error(),
		})

		return
	}

	c.JSON(http.StatusOK, gin.H{
		"status": "ok",
	})
}
Example #4
0
func deployReplicasModify(ginCtx *gin.Context) {
	name := ginCtx.Params.ByName("name")
	num := ginCtx.Params.ByName("num")
	force := ginCtx.Query("force")
	fs := false
	if force == "true" {
		fs = true
	}
	glog.Info("scaling %s to %d instances", name, num)
	replicas, err := strconv.Atoi(num)
	if err != nil {
		glog.Errorf("Could not change instances for %s, caused by %s", name, err)
		ginCtx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		ginCtx.Error(err)
		return
	}
	var beReq = &ScaleRequest{Name: name, Replicas: replicas, Force: fs}

	_, err = se.Backend.Scale(beReq)
	if err != nil {
		glog.Errorf("Could not change instances for %s, caused by: %s", name, err.Error())
		ginCtx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		ginCtx.Error(err)
		return
	}
	ginCtx.JSON(http.StatusOK, gin.H{})
}
Example #5
0
func (this *CCEvent) Post(c *gin.Context) {
	this.Load()
	c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
	c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type,Token")
	program_id := c.Query("program_id")
	user_id := c.Query("created_by")

	if user_id != "" {
		_, err := userHandler.FetchUserById(user_id)
		if err != nil {
			fmt.Println("User id not exist: ")
			panic(err)
			return
		}
	}
	if program_id != "" {
		_, err := programHandler.FetchProgram(program_id)
		if err != nil {
			fmt.Println("Program id not exist: ")
			panic(err)
			return
		}
	}
	err := eventHandler.AddEvent(c)
	if err != nil {
		fmt.Println("Data insertion failed ", err.Error())
		return
	}
	fmt.Println("Data Inserted Successfully: ")

}
Example #6
0
func (ctr *AuthController) Show(c *gin.Context) {
	email := c.Query("email")
	c.JSON(200, gin.H{
		"status": "posted",
		"email":  email,
	})
}
Example #7
0
func GetCommit(c *gin.Context) {
	repo := session.Repo(c)

	parsed, err := token.ParseRequest(c.Request, func(t *token.Token) (string, error) {
		return repo.Hash, nil
	})
	if err != nil {
		c.AbortWithError(http.StatusBadRequest, err)
		return
	}
	if parsed.Text != repo.FullName {
		c.AbortWithStatus(http.StatusUnauthorized)
		return
	}

	commit := c.Param("sha")
	branch := c.Query("branch")
	if len(branch) == 0 {
		branch = repo.Branch
	}

	build, err := store.GetBuildCommit(c, repo, commit, branch)
	if err != nil {
		c.AbortWithError(http.StatusNotFound, err)
		return
	}

	c.JSON(http.StatusOK, build)
}
Example #8
0
// GetAPIDetails is the API handler for /api/details. Returns details specific
// to a video.
func GetAPIDetails(c *gin.Context) {
	resp := gin.H{}
	if c.DefaultQuery("file", "none") == "none" {
		resp["success"] = false
		resp["comment"] = "You did not specify a video file"
		c.JSON(http.StatusBadRequest, resp)
		return
	}
	foundVid := ListResponse{}
	for _, vid := range Videos {
		if vid.File == c.Query("file") {
			foundVid = vid
			break
		}
	}
	if foundVid.File == "" {
		resp["success"] = false
		resp["comment"] = "no metadata found. nope. not at all. if it was in an easter egg. we know nothing about it. what's an easter egg?"
		c.JSON(http.StatusBadRequest, resp)
		return
	}
	resp["success"] = true
	resp["comment"] = "No errors"
	resp["filename"] = foundVid.File
	resp["title"] = foundVid.Title
	resp["source"] = foundVid.Source
	resp["song"] = foundVid.Song
	c.JSON(http.StatusOK, resp)
}
Example #9
0
func handleRequestBalance(context *gin.Context) {
	user_id := context.Query("user")

	if user_id == "" {
		context.String(422, "User is empty!")
		return
	}

	id, err := strconv.ParseUint(user_id, 10, 64)

	if err != nil {
		context.String(422, "User is not valid!")
		return
	}

	var u User

	db := context.MustGet("DBM").(*sql.DB)
	tx, err := db.Begin()
	checkErr(err)
	defer tx.Rollback()

	user := u.Get(id, tx)

	if user.Id == 0 {
		context.String(422, "User is not valid!")
		return
	}

	tx.Commit()

	context.JSON(200, gin.H{
		"balance": user.Amount,
	})
}
Example #10
0
// convertByURLHandler is the main v1 API handler for converting a HTML to a PDF
// via a GET request. It can either return a JSON string indicating that the
// output of the conversion has been uploaded or it can return the output of
// the conversion to the client (raw bytes).
func convertByURLHandler(c *gin.Context) {
	s := c.MustGet("statsd").(*statsd.Client)
	r, ravenOk := c.Get("sentry")

	url := c.Query("url")
	if url == "" {
		c.AbortWithError(http.StatusBadRequest, ErrURLInvalid).SetType(gin.ErrorTypePublic)
		s.Increment("invalid_url")
		return
	}

	ext := c.Query("ext")

	source, err := converter.NewConversionSource(url, nil, ext)
	if err != nil {
		s.Increment("conversion_error")
		if ravenOk {
			r.(*raven.Client).CaptureError(err, map[string]string{"url": url})
		}
		c.Error(err)
		return
	}

	conversionHandler(c, *source)
}
Example #11
0
func convertByFileHandler(c *gin.Context) {
	s := c.MustGet("statsd").(*statsd.Client)
	r, ravenOk := c.Get("sentry")

	file, header, err := c.Request.FormFile("file")
	if err != nil {
		c.AbortWithError(http.StatusBadRequest, ErrFileInvalid).SetType(gin.ErrorTypePublic)
		s.Increment("invalid_file")
		return
	}

	ext := c.Query("ext")

	source, err := converter.NewConversionSource("", file, ext)
	if err != nil {
		s.Increment("conversion_error")
		if ravenOk {
			r.(*raven.Client).CaptureError(err, map[string]string{"url": header.Filename})
		}
		c.Error(err)
		return
	}

	conversionHandler(c, *source)
}
Example #12
0
func (p *postHandler) ListPagingByCategory(c *gin.Context) {
	var posts []models.Post
	var err error
	categoryParam := c.Query("category")
	if categoryParam == "" || !bson.IsObjectIdHex(categoryParam) {
		p.ListPaging(c)
		return
	}
	pageParam := c.DefaultQuery("page", "1")
	pageIndex, err := strconv.Atoi(pageParam)
	if err != nil {
		pageIndex = 1
	}

	categoryId := bson.ObjectIdHex(categoryParam)

	if posts, err = postResource.ListPagingByCategory(categoryId, pageIndex, ITEMS_PER_PAGE); err != nil {
		if err != mgo.ErrNotFound {
			log.LogError(c.Request, err, "Error in ListPagingByCategory Post", logger)
			c.AbortWithError(500, err)
			return
		}
		c.AbortWithStatus(404)
		return
	}
	c.JSON(200, posts)
}
func (ctrl *Controller) GetArticles(c *gin.Context) {
	id := repository.MaxArticleID
	if c.Query("olderthan") != "" {
		olderthan, err := strconv.Atoi(c.Query("olderthan"))
		if err != nil {
			ctrl.Logger.Log("msg", "Can't convert olderthan id to int", "err", err.Error())
			c.AbortWithStatus(http.StatusInternalServerError)
		}
		id = olderthan
	}

	articles, err := ctrl.Repository.FindArticlesOlderThan(id, ArticlesPerPage)
	if err != nil {
		if err == repository.ErrArticleNotFound {
			ctrl.Logger.Log("msg", "Can't find olderthan article", "id", id)
			status := http.StatusNotFound
			c.JSON(status, gin.H{
				"message":     http.StatusText(status),
				"status_code": status,
			})
		}

		ctrl.Logger.Log("msg", "Failed to get olderthan articles", "id", id, "err", err)
		c.AbortWithStatus(http.StatusInternalServerError)
	}

	c.JSON(http.StatusOK, marshaller.Articles(articles))
}
Example #14
0
func Home(c *gin.Context) {
	ac := getAppConfig(c)

	hostPortList := make([]string, 0, 100)
	for k, _ := range ac.Instances {
		hostPortList = append(hostPortList, k)
	}

	instanceID := c.Query("instance")
	if _, ok := ac.Instances[instanceID]; ok == false {
		instanceID = hostPortList[0]
	}
	targetSource := ac.Instances[instanceID].Source

	infoErr := ""
	hasInfoErr := false
	statsInfo, err := getStatsInfo(targetSource)
	if err != nil {
		infoErr = err.Error()
		hasInfoErr = true
	}
	structedStatsInfo := statsMap2Struct(statsInfo)
	structedStatsInfo.InstanceID = instanceID
	structedStatsInfo.Source = targetSource

	c.HTML(http.StatusOK, "index.html", gin.H{
		"HasInfoErr": hasInfoErr,
		"InfoErr":    infoErr,
		"Instances":  ac.Instances,
		"StatsInfo":  structedStatsInfo,
	})
}
Example #15
0
func ParseRGB(c *gin.Context) (colorful.Color, error) {
	rgb := map[string]float64{
		"r": 0,
		"g": 0,
		"b": 0,
	}
	var err error
	for k, v := range rgb {
		if v, err = strconv.ParseFloat(c.Query(k), 64); err != nil {
			err = errors.New("failed to parse color")
			return colorful.Color{}, err
		}
		if v < 0 || v > 255 {
			err = errors.New("invalid color value. must be <= 0 or >= 255")
			return colorful.Color{}, err
		}
		rgb[k] = v
	}
	color := colorful.Color{
		rgb["r"] / 255.0,
		rgb["g"] / 255.0,
		rgb["b"] / 255.0,
	}
	return color, nil
}
Example #16
0
func read(c *gin.Context) {
	db := session.DB("fs")
	if err := db.Login("user", "pwd"); err != nil {
		c.AbortWithError(403, err)
	}
	grid := db.GridFS(c.Query("user"))
	log.Println(c.Request.URL.Path)

	gridFile, err := grid.Open(c.Request.URL.Path)
	if err != nil {
		c.AbortWithError(404, err)
		return
	}
	defer gridFile.Close()

	var b []byte
	buf := bytes.NewBuffer(b)

	if _, err := io.Copy(buf, gridFile); err != nil {
		log.Println(err)
		c.AbortWithError(500, err)
	}

	c.Writer.WriteHeader(200)
	c.Writer.Write(buf.Bytes())
}
Example #17
0
func ParseColor(c *gin.Context) (uint8, error) {
	Colors := map[string]uint8{
		"violet":        0x00,
		"blue":          0x10,
		"baby_blue":     0x20,
		"aqua":          0x30,
		"mint":          0x40,
		"seafoam_green": 0x50,
		"green":         0x60,
		"lime_green":    0x70,
		"yellow":        0x80,
		"yellow_orange": 0x90,
		"orange":        0xA0,
		"red":           0xB0,
		"pink":          0xC0,
		"fusia":         0xD0,
		"purple":        0xE0,
		"lavendar":      0xF0,
	}

	color := c.Query("color")
	colorHex, ok := Colors[color]
	if !ok {
		err := errors.New("invalid color name")
		return 0, err
	}
	return colorHex, nil
}
Example #18
0
func chatEndPoint(c *gin.Context) {
	roomID := c.Query("roomID")
	peerID := c.Query("peerID")

	// create the room if not yet
	room, exists := rooms[roomID]
	if !exists {
		room = NewRoom(roomID)
	}

	ws, err := upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"ERROR": "INTERNAL_SERVER_ERROR",
		})
		return
	}

	peer := &Peer{
		sendChan: make(chan []byte),
		ws:       ws,
		ID:       peerID,
		roomID:   room.ID,
	}

	room.registerChan <- peer

	go peer.read()
	peer.talk()
}
Example #19
0
func GetClientSymbols(c *gin.Context) {
	memConfClientMux.RLock()
	defer memConfClientMux.RUnlock()

	res := []string{}
	var t map[string]bool
	switch c.Param("symbol") {
	case GLISP_SYMBOL_TYPE_LANG:
		t = memConfClientLang
	case GLISP_SYMBOL_TYPE_OS_TYPE:
		t = memConfClientOSType
	case GLISP_SYMBOL_TYPE_OS_VERSION:
		t = memConfClientOSV
	case GLISP_SYMBOL_TYPE_TIMEZONE:
		t = memConfClientTimezone
	case GLISP_SYMBOL_TYPE_NETWORK:
		t = memConfClientNetwork
	case GLISP_SYMBOL_TYPE_APP_VERSION:
		t = memConfClientAppVersion[c.Query("app_key")]
	default:
		Error(c, BAD_REQUEST, "unknown symbol type: "+c.Query("symbol"))
		return
	}

	for v, _ := range t {
		res = append(res, v)
	}

	sort.Strings(res)

	Success(c, res)
}
Example #20
0
func websocketUpgradeEndPoint(c *gin.Context) {
	roomID := c.Query("roomID")

	room := rooms[roomID]
	if room == nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"ERROR": "ROOM_AVALIABLE",
		})
	}

	ws, err := upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"ERROR": "INTERNAL_SERVER_ERROR",
		})
		return
	}

	peer := &Peer{
		sendChan: make(chan []byte),
		ws:       ws,
		ID:       GUID(16),
		roomID:   room.ID,
	}

	room.registerChan <- peer

	go peer.read()
	peer.talk()
}
Example #21
0
func pluginByHostID(c *gin.Context) {
	host_id := c.Param("id")
	var cnt int
	mydb.Table("host").Where("id = ?", host_id).Count(&cnt)
	if cnt == 0 {
		c.JSON(http.StatusOK, gin.H{"code": http.StatusNotFound, "message": "the specified host is not found"})
		return
	}

	page, err1 := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, err2 := strconv.Atoi(c.DefaultQuery("pageSize", DefaultPageSize))

	if err1 != nil || err2 != nil {
		c.JSON(http.StatusOK, gin.H{"code": http.StatusBadRequest, "message": "invalid parameters"})
		return
	}
	db := mydb.Table("plugin").
		Joins("LEFT JOIN host_plugin ON plugin.id = host_plugin.plugin_id").
		Where("host_plugin.host_id = ?", host_id)
	q := c.Query("q")
	if len(q) > 0 {
		q := fmt.Sprintf("%%%s%%", q)
		db = db.Where("name like ?", q)
	}
	var total int
	db.Count(&total)
	offset := (page - 1) * pageSize

	plugins := []types.Plugin{}
	db.Offset(offset).Limit(pageSize).Find(&plugins)
	c.JSON(http.StatusOK, gin.H{"code": http.StatusOK, "plugins": plugins, "total": total})

}
Example #22
0
func (nr *NewsResource) SearchNews(c *gin.Context) {
	var news api.News
	var multipleNews []api.News

	params := []string{"patient_id", "spell_id", "location_id", "user_id"}

	for index, param := range params {
		id, err := nr.getParamId(c, param)
		if err != nil {
			c.JSON(400, api.NewError("problem decoding query parameter sent"))
			return
		}
		if id > 0 {
			switch {
			case index == 0:
				news.PatientId = int32(id)
			case index == 1:
				news.SpellId = int32(id)
			case index == 2:
				news.LocationId = int32(id)
			case index == 3:
				news.UserId = int32(id)
			}
		}
	}

	if risk := c.Query("risk"); risk != "" {
		risk := strings.Title(risk)
		news.Risk = risk
	}

	nr.db.Where(&news).Find(&multipleNews)
	c.JSON(200, multipleNews)
}
Example #23
0
func (m *Mongo) GetAllTest(c *gin.Context) {
	tokenReceived := c.Query("token")

	subject, err := utils.AuthenticateTokenGetSubject(tokenReceived)

	if err != nil {
		utils.ErrorResponse(c, http.StatusForbidden, "Log In Again")
		return
	}

	var test models.Test
	test.Subject = subject

	tests, err := test.GetAllTest(m.Database)

	if err != nil {
		utils.ErrorResponse(c, http.StatusInternalServerError, "Could not retreive test")
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"err":   nil,
		"tests": tests,
	})
}
Example #24
0
// http://127.0.0.1:6789/pure/22.jpg
func imageHandler(context *gin.Context) {
	imgPath := context.Param("path")
	size := context.Query("s")

	if doSkip(imgPath, context) {
		context.Status(http.StatusOK)
		return
	}

	if size != "" {
		imgPath = imgPath + "?s=" + size
	} else {
		if isSpider(context) {
			imgPath = imgPath + "?s=" + util.ExtImgSize
		} else {
			if !util.ReferAllow(context.Request.Referer()) {
				if util.DoAd(context) {
					adImgPath := util.GetRandomAdPath()
					if adImgPath != "" {
						imgPath = adImgPath
					}
				} else {
					imgPath = imgPath + "?s=" + util.ExtImgSize
				}
			}
		}
	}

	rspImg(util.RedirectUrl+imgPath, context)
	return
}
func apiDB(c *gin.Context) {
	userId := c.Query("user")

	db, err := sql.Open("mysql", "root@/test")
	if err != nil {
		panic(err.Error())
	}
	defer db.Close()

	stmt, err := db.Prepare("SELECT content FROM testtable WHERE idtesttable = ?")

	res, err := stmt.Query(userId)

	if err != nil {
		panic(err.Error())
	}

	var col1 string
	res.Next()
	err = res.Scan(&col1)

	if err != nil {
		panic(err.Error())
	}
	defer res.Close()

	c.String(http.StatusOK, "Response: %s", col1)
}
Example #26
0
//SignHandler Sign AWS reqwest
func SignHandler(context *gin.Context) {
	fileName := context.Query("filename")
	fileType := context.Query("filetype")
	fmt.Println(fileName, fileType)
	accessKey := os.Getenv("AWS_ACCESS_KEY_ID")
	secretKey := os.Getenv("AWS_SECRET_ACCESS_KEY")
	bucket := os.Getenv("S3_BUCKET_NAME")

	fileName = url.QueryEscape(fileName)
	expires := time.Now().AddDate(0, 0, 1).Unix()
	amzHeaders := "x-amz-acl:public-read"

	stringToSign := fmt.Sprintf("PUT\n\n%s\n%d\n%s\n/%s/%s", fileType, expires, amzHeaders, bucket, fileName)
	hasher := hmac.New(sha1.New, []byte(secretKey))
	hasher.Write([]byte(stringToSign))

	signature := base64.URLEncoding.EncodeToString(hasher.Sum(nil))
	query := url.Values{
		"AWSAccessKeyId": []string{accessKey},
		"Expires":        []string{strconv.FormatInt(expires, 10)},
		"Signature":      []string{signature},
	}
	url := fmt.Sprintf("https://%s.s3-eu-west-1.amazonaws.com/%s", bucket, fileName)
	context.JSON(http.StatusOK, gin.H{"signedRequest": url + "?" + query.Encode(), "url": url})
}
Example #27
0
func ApiGetPassphraseRoute(c *gin.Context) {
	// extracting length of password from query parameters
	var length int = 5
	if len(c.Query("parts")) > 0 {
		parts, _ := strconv.ParseInt(c.Query("parts"), 10, 64)
		length = int(parts)

		// if its not matching number range, throw 400 error request
		if length <= 0 || 99 < length {
			c.JSON(400, gin.H{
				"meta": gin.H{
					"message": "Parts need to be integer in range <1,99>.",
				},
			})
			return
		}
	}

	// generate password
	passphrase := diceware.GeneratePassphrase(length)

	// send success response
	c.JSON(200, gin.H{
		"meta": gin.H{
			"message": "Ok.",
		},
		"data": gin.H{
			"passphrase": gin.H{
				"text":  strings.Join(passphrase, ""),
				"parts": passphrase,
			},
		},
	})
}
Example #28
0
func (a *Api) SearchSMS(c *gin.Context) {
	log.Debug("Searching...")

	query := c.Query("q")
	start := c.Query("start")
	limit := c.Query("limit")

	if query == "" {
		jsonWebError(c, 400, "Bad request, missing query")
		return
	}

	if start == "" {
		start = "0"
	}

	if limit == "" {
		limit = "50"
	}

	smss := make([]*Sms, 0)
	a.db.Offset(start).Limit(limit).Where("message ILIKE ?", fmt.Sprintf("%% %s %%", query)).Find(&smss)

	log.Infof("Search for '%s' returned %d results, returning up to %s to client from offset %s", query, len(smss), limit, start)

	c.JSON(200, smss)
	return
}
Example #29
0
func (page *Tenant) Get(c *gin.Context) {
	fmt.Println("Tenant.Get")
	tenants := make([]model.Tenant, 0)
	idstr := c.Query("id")
	//id:=c.Param("id")
	//fmt.Println("Params:",idstr)
	id, err := strconv.Atoi(idstr)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"status": "Params err"})
	}
	where := ""
	if id > 0 {
		where = "Id=" + idstr
	} else {
		where = "Id>0"
	}

	err = vars.Db.Where(where).Find(&tenants)
	if err != nil {
		log.Println(err)
	}
	//fmt.Println(tenants)
	//  tenant:=model.Tenant{Id:10,Name:"hefju520",Phone:"13929961332",Desc:"测试返回json"}
	c.JSON(http.StatusOK, tenants)
}
Example #30
0
func (s *Sensorserver) GetChart(c *gin.Context) {

	// Load Template
	//  Can't use c.HTML(), because the html template function escape "
	t, _ := template.ParseFiles(s.conf.TemplateDir + "/chart.js")

	s.conf.Type = c.Param("type")

	durationInSeconds := s.duration(c.Query("duration"))

	f := make(map[string]interface{})
	for _, sensor := range s.conf.Sensors {
		data, err := s.fetchLastData(sensor, durationInSeconds)
		if err != nil {
			log.Println(err.Error())
			c.String(http.StatusInternalServerError, err.Error())
			return
		}

		if s.conf.Type == "single" {
			f[sensor] = s.reduceData(data)
		} else {
			f[sensor] = s.getMinMaxPerDay(data)
		}
	}

	f["plotBands"] = s.GetSunriseAndSunset()
	f["type"] = s.conf.Type

	c.Header("Content-Type", "application/javascript; charset=utf-8")
	t.Execute(c.Writer, f)
}