Пример #1
0
// Handle writes the error from the context into the HttpResponseWriter with a
// 500 http.StatusInternalServerError status code.
func (h *DefaultErrorHandler) Handle(ctx context.Context) (stop bool, err error) {

	var handlerError HandlerError = ctx.Data().Get(DataKeyForError).(HandlerError)
	hostname, _ := os.Hostname()

	w := ctx.HttpResponseWriter()

	// write the error out
	w.Header().Set("Content-Type", "text/html")
	w.WriteHeader(http.StatusInternalServerError)
	w.Write([]byte("<!DOCTYPE html><html><head>"))
	w.Write([]byte("<style>"))
	w.Write([]byte("h1 { font-size: 17px }"))
	w.Write([]byte("h1 strong {text-decoration:underline}"))
	w.Write([]byte("h2 { background-color: #ffd; padding: 20px }"))
	w.Write([]byte("footer { margin-top: 20px; border-top:1px solid black; padding:10px; font-size:0.9em }"))
	w.Write([]byte("</style>"))
	w.Write([]byte("</head><body>"))
	w.Write([]byte(fmt.Sprintf("<h1>Error in <code>%s</code></h1><h2>%s</h2>", handlerError.Handler, handlerError)))
	w.Write([]byte(fmt.Sprintf("<h3><code>%s</code> error in Handler <code>%v</code></h3> <code><pre>%s</pre></code>", reflect.TypeOf(handlerError.OriginalError), &handlerError.Handler, handlerError.Handler)))
	w.Write([]byte(fmt.Sprintf("on %s", hostname)))
	w.Write([]byte("<footer>Learn more about <a href='http://github.com/stretchr/goweb' target='_blank'>Goweb</a></footer>"))
	w.Write([]byte("</body></html>"))

	// responses are actually ignored
	return false, nil
}
Пример #2
0
//helper function to translate args in URL query to samtools args
//manual: http://samtools.sourceforge.net/samtools.shtml
func ParseSamtoolsArgs(ctx context.Context) (argv []string, err error) {

	query := ctx.HttpRequest().URL.Query()
	var (
		filter_options = map[string]string{
			"head":     "-h",
			"headonly": "-H",
			"count":    "-c",
		}
		valued_options = map[string]string{
			"flag":      "-f",
			"lib":       "-l",
			"mapq":      "-q",
			"readgroup": "-r",
		}
	)

	for src, des := range filter_options {
		if _, ok := query[src]; ok {
			argv = append(argv, des)
		}
	}

	for src, des := range valued_options {
		if _, ok := query[src]; ok {
			if val := query.Get(src); val != "" {
				argv = append(argv, des)
				argv = append(argv, val)
			} else {
				return nil, errors.New(fmt.Sprintf("required value not found for query arg: %s ", src))
			}
		}
	}
	return argv, nil
}
Пример #3
0
// Before gets called before any other method.
func (r *BooksController) Before(ctx context.Context) error {

	// set a Books specific header
	ctx.HttpResponseWriter().Header().Set("X-Books-Controller", "true")
	return nil

}
Пример #4
0
// Before gets called before any other method.
func (r *DevelopersController) Before(ctx context.Context) error {
	// set a Developers specific header
	ctx.HttpResponseWriter().Header().Set("X-Developers-Controller", "true")
	ctx.HttpResponseWriter().Header().Set("Connection", "keep-alive")

	return nil
}
// GET /api/session
func (ctrl *SessionController) ReadMany(ctx context.Context) (err error) {
	session, _ := session_store.Get(ctx.HttpRequest(), session_name)
	if session.Values["username"] != nil {
		return goweb.API.RespondWithError(ctx, http.StatusBadRequest, "has session")
	}

	// check form value(not empty?)
	id := ctx.FormValue("id")
	passwd := ctx.FormValue("password")
	if id == "" || passwd == "" {
		return goweb.API.RespondWithError(ctx, http.StatusBadRequest, "not enough query")
	}

	// get userdata from database
	user, err := GetUser(id, passwd)
	if err != nil {
		return goweb.API.RespondWithError(ctx, http.StatusInternalServerError, "error on database")
	}

	if user == nil {
		return goweb.API.RespondWithError(ctx, http.StatusUnauthorized, "user not found")
	}

	session.Values["username"] = user.Name
	session.Save(ctx.HttpRequest(), ctx.HttpResponseWriter())
	return goweb.API.RespondWithData(ctx, nil)
}
Пример #6
0
// WriteResponseObject writes the status code and response object to the HttpResponseWriter in
// the specified context, in the format best suited based on the request.
//
// Goweb uses the WebCodecService to decide which codec to use when responding
// see http://godoc.org/github.com/stretchr/codecs/services#WebCodecService for more information.
//
// This method should be used when the Goweb Standard Response Object does not satisfy the needs of
// the API, but other Respond* methods are recommended.
func (a *GowebAPIResponder) WriteResponseObject(ctx context.Context, status int, responseObject interface{}) error {

	service := a.GetCodecService()

	acceptHeader := ctx.HttpRequest().Header.Get("Accept")
	extension := ctx.FileExtension()
	hasCallback := len(ctx.QueryValue(CallbackParameter)) > 0

	codec, codecError := service.GetCodecForResponding(acceptHeader, extension, hasCallback)

	if codecError != nil {
		return codecError
	}

	var options map[string]interface{}

	// do we need to add some options?
	if hasCallback {
		options = map[string]interface{}{constants.OptionKeyClientCallback: ctx.QueryValue(CallbackParameter)}
	}

	output, marshalErr := service.MarshalWithCodec(codec, responseObject, options)

	if marshalErr != nil {
		return marshalErr
	}

	// use the HTTP responder to respond
	ctx.HttpResponseWriter().Header().Set("Content-Type", codec.ContentType()) // TODO: test me
	a.httpResponder.With(ctx, status, output)

	return nil

}
Пример #7
0
func PreAuthRequest(ctx context.Context) {
	id := ctx.PathValue("id")
	if p, err := preauth.Load(id); err != nil {
		err_msg := "err:@preAuth load: " + err.Error()
		logger.Error(err_msg)
		responder.RespondWithError(ctx, 500, err_msg)
		return
	} else {
		if n, err := node.LoadUnauth(p.NodeId); err == nil {
			switch p.Type {
			case "download":
				filename := n.Id
				if fn, has := p.Options["filename"]; has {
					filename = fn
				}
				streamDownload(ctx, n, filename)
				preauth.Delete(id)
				return
			default:
				responder.RespondWithError(ctx, 500, "Preauthorization type not supported: "+p.Type)
			}
		} else {
			err_msg := "err:@preAuth loadnode: " + err.Error()
			logger.Error(err_msg)
			responder.RespondWithError(ctx, 500, err_msg)
		}
	}
	return
}
Пример #8
0
func (c *AccountTransactions) Create(ctx context.Context) (err error) {
	accountId := ctx.PathValue("account_id")
	data, err := ctx.RequestData()

	if err != nil {
		return goweb.API.RespondWithError(ctx, http.StatusInternalServerError, err.Error())
	}

	dataMap := data.(map[string]interface{})

	transaction := models.Transaction{
		AccountId: accountId,
		Debit:     dataMap["debit"].(float64),
		Credit:    dataMap["credit"].(float64),
		Kind:      dataMap["kind"].(string),
	}

	createServ := &transactions.CreateServ{}
	transactionOut, err := createServ.Run(c.DbSession, transaction)
	if err != nil {
		log.Print(err)
		return goweb.API.RespondWithError(ctx, http.StatusInternalServerError, err.Error())
	}

	return goweb.API.RespondWithData(ctx, transactionOut)
}
Пример #9
0
func serializeGowebResponse(
	c context.Context,
	syntaxName string,
	statements chan *goraptor.Statement) error {
	var str string
	if syntaxName == "trig" {
		// real trig mode is crashing

		serializer := goraptor.NewSerializer("ntriples")
		defer serializer.Free()
		ntriples, err := serializer.Serialize(statements, "")
		if err != nil {
			panic(err)
		}
		log.Printf("got %d bytes of ntriples", len(ntriples))
		str = "<http://projects.bigasterisk.com/room/laundryDoor> { " + ntriples + "}"
		log.Printf("str now %d bytes", len(str))
	} else {
		serializer := goraptor.NewSerializer(syntaxName)
		defer serializer.Free()

		var err error
		str, err = serializer.Serialize(statements, "")
		if err != nil {
			panic(err)
		}
	}

	c.HttpResponseWriter().Header().Set("Content-Type",
		goraptor.SerializerSyntax[syntaxName].MimeType)
	return goweb.Respond.With(c, 200, []byte(str))
}
Пример #10
0
func GetPopularLocations(ctx context.Context) error {
	var query bson.M
	isPersonal, err := strconv.ParseBool(ctx.FormValue("personal"))
	if err != nil {
		isPersonal = false
	}
	if isPersonal {
		var result m.PopularLocations
		var currentUser, ok = ctx.Data()["user"].(m.User)
		if ok {
			query = bson.M{"user": currentUser.Id}
			if err := m.GetDB("RecommendUser").Find(query).One(&result); err != nil {
				//respond with empty arrays it no recommendations/popular location for current user
				result = m.PopularLocations{PopularMarkers: make([]m.Marker, 0), Recommendations: make([]m.Recommendation, 0)}
				//fmt.Printf("%v  %v", err, result)
			}
			return goweb.API.RespondWithData(ctx, result)
		}
	}
	var trendResult []m.TrendingAllUsersEntry
	var recomResult []m.Recommendation
	m.GetDB("TrendingAllUsers").Find(query).All(&trendResult)
	m.GetDB("RecommendAllUsers").Find(query).All(&recomResult)
	result := m.AllUsersTrendingAndRecom{Trend: trendResult, Recom: recomResult}
	return goweb.API.RespondWithData(ctx, result)
}
Пример #11
0
func DeleteImage(ctx context.Context) error {
	var currentUser, ok = ctx.Data()["user"].(m.User)
	if ok {
		imageId := ctx.FormValue("imageId")

		if imageId == "" {
			return goweb.API.Respond(ctx, 200, nil, []string{"You have to specify an image to be deleted."})
		}

		var image m.Image

		err := m.GetDB("Image").FindId(bson.ObjectIdHex(imageId)).One(&image)
		if err != nil {
			log.Error("DeleteImage, remove query " + err.Error())
			return goweb.API.Respond(ctx, 200, nil, []string{"You have to specify an image to be deleted."})
		}
		if image.User.Hex() != currentUser.Id.Hex() {
			return goweb.API.Respond(ctx, 200, nil, []string{"You cannot delete this image."})
		} else {
			m.GetDB("Image").RemoveId(image.Id)
			err = os.Remove(image.Url)
		}

		return goweb.API.RespondWithData(ctx, "Image deleted.")
	} else {
		return goweb.API.Respond(ctx, 200, nil, []string{"Please log in to delete an images."})
	}
}
Пример #12
0
func GetUserInfo(ctx context.Context) error {
	var currentUser, ok = ctx.Data()["user"].(m.User)
	if ok {
		return goweb.API.RespondWithData(ctx, currentUser)
	} else {
		return goweb.API.Respond(ctx, 200, nil, []string{"Please log in."})
	}
}
Пример #13
0
// With writes a response to the request in the specified context.
func (r *GowebHTTPResponder) With(ctx context.Context, httpStatus int, body []byte) error {

	r.WithStatus(ctx, httpStatus)

	_, writeErr := ctx.HttpResponseWriter().Write(body)
	return writeErr

}
func getUserNameFromCtx(ctx context.Context) (name string) {
	session, _ := session_store.Get(ctx.HttpRequest(), session_name)
	user_raw := session.Values["username"]
	if user_raw == nil {
		return ""
	}
	name = user_raw.(string)
	return
}
Пример #15
0
func nuttyGetLength(c context.Context) error {
	sessionid := c.PathValue("sessionid")
	bs, err := ioutil.ReadFile(basedir + sessionid + "/rec.json")
	if err != nil {
		log.Println(err)
		return goweb.API.RespondWithError(c, http.StatusInternalServerError, "Unable to ReadFile")
	}
	return goweb.Respond.With(c, 200, bs)
}
Пример #16
0
func AowQuote(ctx context.Context) error {
	index := randInt(len(quotes))
	quote := quotes[index]
	key := ctx.PathParams().Get("apiKey").Str()

	if valid := isKeyValid(key); valid == true {
		return goweb.API.RespondWithData(ctx, objx.MSI("quote", quote))
	}
	return goweb.API.RespondWithError(ctx, 400, "Access Denied: Invalid API Key")
}
Пример #17
0
// WithStatus writes the specified HTTP Status Code to the Context's ResponseWriter.
//
// If the Always200ParamName parameter is present, it will ignore the httpStatus argument,
// and always write net/http.StatusOK (200).
func (r *GowebHTTPResponder) WithStatus(ctx context.Context, httpStatus int) error {

	// check for always200
	if len(ctx.FormValue(Always200ParamName)) > 0 {
		// always return OK
		httpStatus = http.StatusOK
	}

	ctx.HttpResponseWriter().WriteHeader(httpStatus)
	return nil
}
Пример #18
0
func UploadZip(ctx context.Context) error {
	var currentUser, ok = ctx.Data()["user"].(m.User)
	if ok {

		file, _, err := ctx.HttpRequest().FormFile("file")
		if err != nil {
			log.Error("Error on zip upload FormFile " + err.Error())
			return goweb.API.Respond(ctx, 200, nil, []string{"Failed to upload the zip."})
		}
		defer file.Close()

		outputZipPath := "../uploads/temp/" + base64.StdEncoding.EncodeToString([]byte(currentUser.Username+time.Now().String()))

		if err := os.MkdirAll("../uploads/temp/", 0777); err != nil {
			log.Error("Error in creating output dir " + err.Error())
			return goweb.API.Respond(ctx, 200, nil, []string{"Failed to upload the zip."})
		}

		outputZipFile, err := os.Create(outputZipPath)
		if err != nil {
			log.Error("Error in creating output file in zip " + err.Error())
			return goweb.API.Respond(ctx, 200, nil, []string{"Failed to upload the zip."})
		}
		defer outputZipFile.Close()

		if _, err = io.Copy(outputZipFile, file); err != nil {
			log.Error("Error in copying file " + err.Error())
			os.Remove(outputZipPath)
			return goweb.API.Respond(ctx, 200, nil, []string{"Failed to upload the zip."})
		}
		var extention = ""
		if runtime.GOOS == "windows" {
			extention = ".exe"
		}

		extractPath := "../uploads/temp/" + base64.StdEncoding.EncodeToString([]byte(currentUser.Username+time.Now().String()))
		commandString := fmt.Sprintf(`7za%s e %s -o%s -p%s -aoa`, extention, outputZipPath, extractPath, "SuperSecurePassword")
		commandSlice := strings.Fields(commandString)
		commandCall := exec.Command(commandSlice[0], commandSlice[1:]...)
		// err = commandCall.Run()
		value, err := commandCall.Output()
		if err != nil {
			log.Error("in unarchiving zip file: " + err.Error())
			log.Error("Full info about the error: " + string(value))
		}

		go utils.ProcessZip(currentUser, extractPath)

		return goweb.API.Respond(ctx, 200, nil, nil)
	} else {
		return goweb.API.Respond(ctx, 200, nil, []string{"Please log in to upload a zip."})
	}
}
Пример #19
0
// WithStatusText writes the specified HTTP Status Code to the Context's ResponseWriter and
// includes a body with the default status text.
func (r *GowebHTTPResponder) WithStatusText(ctx context.Context, httpStatus int) error {

	writeStatusErr := r.WithStatus(ctx, httpStatus)

	if writeStatusErr != nil {
		return writeStatusErr
	}

	// write the body header
	_, writeErr := ctx.HttpResponseWriter().Write([]byte(http.StatusText(httpStatus)))

	return writeErr
}
Пример #20
0
func nuttyGet(c context.Context) error {
	sessionid := c.PathValue("sessionid")
	tindex := c.PathValue("tindex")

	log.Println("GET ", sessionid, " ", tindex)

	bs, err := ioutil.ReadFile(basedir + sessionid + "/" + tindex)
	if err != nil {
		log.Println(err)
		return goweb.API.RespondWithError(c, http.StatusInternalServerError, "Unable to ReadFile")
	}
	return goweb.Respond.With(c, 200, bs)
}
// GET /api/statuses
func (ctrl *StatusesController) ReadMany(ctx context.Context) (err error) {
	count, err := strconv.Atoi(ctx.FormValue("count"))
	if err != nil {
		count = 15
	}

	dat, err := GetStatuses(count)
	if err != nil {
		logger.Debug(err)
		return goweb.API.RespondWithError(ctx, http.StatusInternalServerError, "error on db")
	}

	return goweb.API.RespondWithData(ctx, dat)
}
Пример #22
0
func UploadImgData(ctx context.Context) error {
	var currentUser, ok = ctx.Data()["user"].(m.User)
	if ok {
		file, _, err := ctx.HttpRequest().FormFile("file")
		if err != nil {
			log.Error("Error on image upload FormFile " + err.Error())
			return goweb.API.Respond(ctx, 200, nil, []string{"Failed to upload the image."})
		}
		defer file.Close()
		utils.ParseImageTable(currentUser, file)
		return goweb.API.Respond(ctx, 200, nil, nil)
	} else {
		return goweb.API.Respond(ctx, 200, nil, []string{"Please log in to upload your images."})
	}
}
Пример #23
0
func (c *Accounts) Adjust(ctx context.Context) (err error) {
	id := ctx.PathParams().Get("id").Str()

	getServ := &accounts.GetServ{}
	account, err := getServ.Run(c.DbSession, id)
	if err != nil {
		return goweb.API.RespondWithError(ctx, http.StatusNotFound, err.Error())
	}

	adjustServ := &account_balances.AdjustServ{}
	account, _, err = adjustServ.Run(c.DbSession, account)
	if err != nil {
		return goweb.API.RespondWithError(ctx, http.StatusInternalServerError, err.Error())
	}

	return goweb.API.RespondWithData(ctx, account)
}
Пример #24
0
func GetVideos(ctx context.Context) error {
	var result []m.Video

	// Get the info from the context
	fromDate, fromDateExists := utils.ParseDateFromContext("from_", ctx)
	toDate, toDateExists := utils.ParseDateFromContext("to_", ctx)

	limit, err := strconv.Atoi(ctx.FormValue("limit"))
	if err != nil {
		limit = 5
	}

	skip, err := strconv.Atoi(ctx.FormValue("skip"))
	if err != nil {
		skip = 0
	}

	var currentUser, ok = ctx.Data()["user"].(m.User)
	isPersonal, err := strconv.ParseBool(ctx.FormValue("personal"))
	if err != nil {
		isPersonal = false
	}

	query := bson.M{}
	if ok && isPersonal {
		if fromDateExists || toDateExists {
			query["date"] = bson.M{"$gte": fromDate, "$lte": toDate}
			query["user"] = currentUser.Id
		} else {
			query["user"] = currentUser.Id
		}
	} else {
		isPersonal = false
		if fromDateExists || toDateExists {
			query["date"] = bson.M{"$gte": fromDate, "$lte": toDate}
		}
	}

	if !fromDateExists && !toDateExists {
		var lastVideo m.Image
		var oneQuery = bson.M{}
		if isPersonal {
			oneQuery["user"] = currentUser.Id
		}
		if err = m.GetDB("Video").Find(oneQuery).Sort("-date").One(&lastVideo); err == nil {
			query["date"] = bson.M{"$gte": lastVideo.Date.AddDate(0, 0, -1), "$lte": lastVideo.Date.AddDate(0, 0, 1)}
		}
	}

	if err := m.GetDB("Video").Find(query).Skip(skip).Limit(limit).All(&result); err != nil {
		log.Error("Failed to search for tracks: " + err.Error())
		return goweb.API.Respond(ctx, 200, nil, []string{"Failed to find the tracks."})
	}

	return goweb.API.RespondWithData(ctx, result)
}
Пример #25
0
func ParseDateFromContext(prefix string, ctx context.Context) (time.Time, bool) {
	now := time.Now()

	if strings.Contains(prefix, "from") {
		now = now.AddDate(0, 0, -1)
	}
	if strings.Contains(prefix, "to") {
		now = now.AddDate(0, 0, 1)
	}

	anythingSelected := false

	year, err := strconv.Atoi(ctx.FormValue(prefix + "year"))
	if err != nil {
		year = now.Year()
	} else {
		anythingSelected = true
	}
	var month time.Month
	month_int, err := strconv.Atoi(ctx.FormValue(prefix + "month"))
	if err != nil {
		month = now.Month()
	} else {
		month = time.Month(month_int)
		anythingSelected = true
	}
	day, err := strconv.Atoi(ctx.FormValue(prefix + "day"))
	if err != nil {
		day = now.Day()
	} else {
		anythingSelected = true
	}
	hour, err := strconv.Atoi(ctx.FormValue(prefix + "hour"))
	if err != nil {
		hour = now.Hour()
	} else {
		anythingSelected = true
	}
	min, err := strconv.Atoi(ctx.FormValue(prefix + "min"))
	if err != nil {
		min = now.Minute()
	} else {
		anythingSelected = true
	}
	return time.Date(year, month, day, hour, min, 0, 0, time.UTC), anythingSelected
}
Пример #26
0
func CheckHeaderIsValidWithBasicAuth(c context.Context) (didpass bool, applicationid int, username string, password string) {

	data, dataError := c.RequestData()
	if dataError != nil {
		log.Println("Data error %s", dataError.Error())
		return false, 0, "", ""
	}

	dataMap := data.(map[string]interface{})

	appd, ok := dataMap["applicationid"]

	if !ok {
		log.Println("Header missing applicationid")
		return false, 0, "", ""
	}

	basicd, ok := dataMap["authorization"]

	if !ok {
		log.Println("Header missing authorization")
		return false, 0, "", ""
	}
	if basicd != "Basic" {
		log.Println("Header missing basic Authorization")
		return false, 0, "", ""
	}

	userd, ok := dataMap["username"]

	if !ok {
		log.Println("Header missing username")
		return false, 0, "", ""
	}

	passd, ok := dataMap["password"]

	if !ok {
		log.Println("Header missing password")
		return false, 0, "", ""
	}

	appi, _ := strconv.Atoi(appd.(string))
	return true, appi, userd.(string), passd.(string)
}
Пример #27
0
func CheckHeaderIsValidWithBasicAuthAndRawData(c context.Context) (didpass bool, applicationid int, username string, password string, raw string) {

	data, dataError := c.RequestData()
	if dataError != nil {
		log.Println("Data error %s", dataError.Error())
		return false, 0, "", "", ""
	}

	dataMap := data.(map[string]interface{})

	rawd, ok := dataMap["raw"]
	if !ok {
		log.Println("Header missing raw data")
		return false, 0, "", "", ""
	}
	valid, appid, userd, passd := CheckHeaderIsValidWithBasicAuth(c)
	return valid, appid, userd, passd, rawd.(string)
}
func isSessionValid(ctx context.Context) bool {
	session, _ := session_store.Get(ctx.HttpRequest(), session_name)
	session_token := session.Values["token"]

	session.Values["token"] = ""
	session.Save(ctx.HttpRequest(), ctx.HttpResponseWriter())

	if session_token == "" || session_token != ctx.FormValue("token") {
		return false
	}
	return true
}
Пример #29
0
func (r *ThingsController) Create(ctx context.Context) error {

	data, dataErr := ctx.RequestData()

	if dataErr != nil {
		return goweb.API.RespondWithError(ctx, http.StatusInternalServerError, dataErr.Error())
	}

	dataMap := data.(map[string]interface{})

	thing := new(Thing)
	thing.Id = dataMap["Id"].(string)
	thing.Text = dataMap["Text"].(string)

	r.Things = append(r.Things, thing)

	return goweb.Respond.WithStatus(ctx, http.StatusCreated)

}
Пример #30
0
// GET /api/session
func (ctrl *SearchController) ReadMany(ctx context.Context) (err error) {
	query := ctx.FormValue("q")
	if query == "" {
		return goweb.API.RespondWithError(ctx, http.StatusUnauthorized, "not enough query")
	}

	count, err := strconv.Atoi(ctx.FormValue("count"))
	if err != nil {
		count = 10
	}

	statuses, err := SearchStatuses(query, count)
	if err != nil {
		logger.Debug(err)
		return goweb.API.RespondWithError(ctx, http.StatusInternalServerError, "error on db")
	}

	return goweb.API.RespondWithData(ctx, statuses)
}