Exemple #1
0
func (p *loginAccountContext) SetFromUrlEncoded(values url.Values) {
	p.username = values.Get("username")
	p.password = values.Get("password")
	p.inputValidated = false
	p.user = nil
	p.result = nil
}
Exemple #2
0
func intFromQuery(ps url.Values, name string, defaultVal int) (int, error) {
	s := ps.Get(name)
	if s == "" {
		return defaultVal, nil
	}
	return strconv.Atoi(s)
}
Exemple #3
0
func challengeFromForm(form url.Values) (Challenge, error) {
	var err error
	c := Challenge{}
	fmt.Println(form)
	c.Title = form.Get("title")
	if c.Title == "" {
		return c, errors.New("No Title")
	}
	c.Description = template.HTML(form.Get("description"))
	if c.Title == "" {
		return c, errors.New("No Description")
	}
	c.Alias = form.Get("path")
	if c.Alias == "" {
		return c, errors.New("No path")
	}
	c.MaxScore, err = strconv.Atoi(form.Get("points"))
	if err != nil || c.MaxScore <= 0 || c.MaxScore > MaxChallengeScore {
		return c, errors.New("Wrong Points Format or Missing")
	}
	c.Category = form.Get("category")
	if c.Category == "" {
		return c, errors.New("No Category")
	}
	return c, nil
}
Exemple #4
0
//磁盘保存文件
func saveFile(reader io.Reader, query url.Values) error {
	fileName := query.Get("name")

	if fileName == "" {
		return errors.New("name is empty")
	}

	if err := ensureDir("static"); err != nil {
		return err
	}

	body, err := ioutil.ReadAll(reader)
	if err != nil {
		return err
	}

	filePath := path.Join("static", fileName)
	file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0777)
	defer file.Close()

	if err != nil {
		return err
	}

	_, err = file.Write(body)
	if err != nil {
		return err
	}

	return nil
}
Exemple #5
0
func handleFrontendPost(self *dialogNode, form url.Values, conf *configparser.Configuration) (*dialogNode, error) {
	if form.Get("back") == "true" {
		return self.parent, nil
	}
	var next *dialogNode

	sect, _ := conf.Section("frontend")
	name := form.Get("name")
	locale := form.Get("locale")

	allow_files := form.Get("allow_files")
	if allow_files != "1" {
		allow_files = "0"
	}

	json_api := form.Get("json")
	if json_api != "1" {
		json_api = "0"
		next = self.children["next"]
	} else {
		next = self.children["json"]
	}

	sect.Add("name", name)
	sect.Add("locale", locale)
	sect.Add("allow_files", allow_files)
	sect.Add("json-api", json_api)

	err := checkLocale(locale)
	if err != nil {
		return self, err
	}

	return next, nil
}
Exemple #6
0
// Dispatch inspects the "command" parameter and dispatches the request to the
// appropriate handler function.
func Dispatch(params url.Values) (response JSONResponse) {
	switch params.Get("command") {
	case "fetch-meal-list":
		return fetchMealList(params)
	case "toggle-favourite":
		return toggleFavourite(params)
	case "delete-meal":
		return deleteMeal(params)
	case "fetch-all-tags":
		return fetchAllTags(params)
	case "fetch-servings":
		return fetchServings(params)
	case "fetch-suggestions":
		return fetchSuggestions(params)
	case "update-serving":
		return updateServing(params)
	case "delete-serving":
		return deleteServing(params)
	case "update-notes":
		return updateNotes(params)
	case "fetch-meal-plans":
		return fetchMealPlans(params)
	}

	return JSONResponse{Error: "Invalid or missing command"}
}
Exemple #7
0
// Update 更新用户信息
func (self UserLogic) Update(ctx context.Context, me *model.Me, form url.Values) (errMsg string, err error) {
	objLog := GetLogger(ctx)

	if form.Get("open") != "1" {
		form.Set("open", "0")
	}

	user := &model.User{}
	err = schemaDecoder.Decode(user, form)
	if err != nil {
		objLog.Errorln("userlogic update, schema decode error:", err)
		errMsg = "服务内部错误"
		return
	}

	cols := "name,open,city,company,github,weibo,website,monlog,introduce"
	// 变更了邮箱
	if user.Email != me.Email {
		cols += ",email,status"
		user.Status = model.UserStatusNoAudit
	}
	_, err = MasterDB.Id(me.Uid).Cols(cols).Update(user)
	if err != nil {
		objLog.Errorf("更新用户 【%d】 信息失败:%s", me.Uid, err)
		errMsg = "对不起,服务器内部错误,请稍后再试!"
		return
	}

	// 修改用户资料,活跃度+1
	go self.IncrUserWeight("uid", me.Uid, 1)

	return
}
Exemple #8
0
// Modify 修改主题
// user 修改人的(有可能是作者或管理员)
func (TopicLogic) Modify(ctx context.Context, user *model.Me, form url.Values) (errMsg string, err error) {
	objLog := GetLogger(ctx)

	change := map[string]interface{}{
		"editor_uid": user.Uid,
	}

	fields := []string{"title", "content", "nid"}
	for _, field := range fields {
		change[field] = form.Get(field)
	}

	tid := form.Get("tid")
	_, err = MasterDB.Table(new(model.Topic)).Id(tid).Update(change)
	if err != nil {
		objLog.Errorf("更新主题 【%s】 信息失败:%s\n", tid, err)
		errMsg = "对不起,服务器内部错误,请稍后再试!"
		return
	}

	// 修改主题,活跃度+2
	go DefaultUser.IncrUserWeight("uid", user.Uid, 2)

	return
}
Exemple #9
0
func verifySign(c Config, u url.Values) (err error) {
	p := kvpairs{}
	sign := ""
	for k := range u {
		v := u.Get(k)
		switch k {
		case "sign":
			sign = v
			continue
		case "sign_type":
			continue
		}
		p = append(p, kvpair{k, v})
	}
	if sign == "" {
		err = fmt.Errorf("sign not found")
		return
	}
	p = p.RemoveEmpty()
	p.Sort()
	fmt.Println(u)
	if md5Sign(p.Join(), c.Key) != sign {
		err = fmt.Errorf("sign invalid")
		return
	}
	return
}
Exemple #10
0
func parseInt(vals url.Values, v string, def, min, max int) int {
	rv, err := strconv.ParseInt(vals.Get(v), 10, 32)
	if err != nil || int(rv) < min || int(rv) > max {
		return def
	}
	return int(rv)
}
Exemple #11
0
func testUpdatePost(t *testing.T, title string, markdown string) {
	// create JSON payload
	var p Post
	p.Title = title
	p.Markdown = markdown
	p.Content = string(blackfriday.MarkdownCommon([]byte(markdown)))
	apiPayload, _ := json.Marshal(p)

	// save changes to global object for further testing comparison
	post.Title = p.Title
	post.Content = string(blackfriday.MarkdownCommon([]byte(markdown)))
	post.Markdown = markdown
	post.Excerpt = excerpt.Make(p.Content, 15)

	testUpdatePostAPI(t, apiPayload)

	// creates form-encoded payload
	p2 := url.Values{}
	p2.Set("title", title)
	p2.Add("markdown", markdown)
	frontendPayload := p2.Encode()

	// save changes to global object for further testing comparison
	post.Title = p2.Get("title")
	post.Markdown = p2.Get("markdown")
	post.Excerpt = excerpt.Make(post.Content, 15)

	testUpdatePostFrontend(t, frontendPayload)
	TestReadPost(t)
}
Exemple #12
0
// ParseURL parses s into a ConnectionURL struct.
func ParseURL(s string) (conn ConnectionURL, err error) {
	var u *url.URL

	if strings.HasPrefix(s, connectionScheme+"://") == false {
		return conn, fmt.Errorf(`Expecting file:// connection scheme.`)
	}

	if u, err = url.Parse(s); err != nil {
		return conn, err
	}

	conn.Database = u.Host + u.Path
	conn.Options = map[string]string{}

	var vv url.Values

	if vv, err = url.ParseQuery(u.RawQuery); err != nil {
		return conn, err
	}

	for k := range vv {
		conn.Options[k] = vv.Get(k)
	}

	return conn, err
}
Exemple #13
0
// New creates the HTML for a select menu instance with the specified parameters.
func New(options []string, defaultOption string, query url.Values, queryParameter string) template.HTML {
	selectElement := &html.Node{Type: html.ElementNode, Data: "select"}

	var selectedOption = defaultOption
	if query.Get(queryParameter) != "" {
		selectedOption = query.Get(queryParameter)
	}
	if !contains(options, selectedOption) {
		options = append(options, selectedOption)
	}
	for _, option := range options {
		o := &html.Node{Type: html.ElementNode, Data: "option"}
		o.AppendChild(htmlg.Text(option))
		if option == selectedOption {
			o.Attr = append(o.Attr, html.Attribute{Key: "selected"})
		}
		selectElement.AppendChild(o)
	}

	selectElement.Attr = append(selectElement.Attr, html.Attribute{
		Key: "oninput",
		// HACK: Don't use Sprintf, properly encode (as json at this time).
		Val: fmt.Sprintf(`SelectMenuOnInput(event, this, %q, %q);`, strconv.Quote(defaultOption), strconv.Quote(queryParameter)),
	})

	return htmlg.Render(selectElement)
}
// fetchMealPlans handles an API call to return a list of meal plans that
// overlap with a specified inclusive date range. Expected parameters: from, to.
// Returns: an array of meal plan objects.
func fetchMealPlans(params url.Values) (response JSONResponse) {
	from, err := time.Parse(mpdata.JSONDateFormat, params.Get("from"))
	if err != nil {
		return JSONResponse{Error: "Invalid or missing 'from' parameter"}
	}

	to, err := time.Parse(mpdata.JSONDateFormat, params.Get("to"))
	if err != nil {
		return JSONResponse{Error: "Invalid or missing 'to' parameter"}
	}

	var mps []*mpdata.MealPlan

	err = mpdb.WithConnection(func(db *sql.DB) (err error) {
		return mpdb.WithTransaction(db, func(tx *sql.Tx) (err error) {
			mps, err = mpdb.ListMealPlansBetween(tx, from, to)
			return err
		})
	})

	if err != nil {
		log.Printf("Database error: %s\n", err.Error())
		return JSONResponse{Error: "Database error"}
	}

	return JSONResponse{Success: mps}
}
func Test_client_buildWriteFileRequest(t *testing.T) {
	c := client{
		options: ClientOptions{
			Locale: "init__locale",
			Root:   "init__root",
			Token:  "init__token",
		}}

	var f bytes.Buffer

	p := url.Values{}
	p.Set("locale", "callers__locale")

	r, e := c.buildWriteFileRequest("somepath", &f, 100, p)
	assert.NoError(t, e)
	assert.Equal(t, r.Method, "PUT")

	auth := r.Header.Get("Authorization")
	assert.Contains(t, auth, "Bearer")
	assert.Contains(t, auth, "init__token")

	clen := r.Header.Get("Content-Length")
	assert.Equal(t, clen, "100")

	u := r.URL
	assert.Equal(t, u.Scheme, "https")
	assert.Equal(t, u.Host, "api-content.dropbox.com")
	assert.Equal(t, u.Path, "/1/files_put/init__root/somepath")

	p = u.Query()
	assert.Equal(t, p.Get("locale"), "callers__locale")
	assert.Equal(t, len(p), 1)
}
Exemple #16
0
func (oat *OAuthToken) HeaderValue(method string, fullUrl string, query url.Values, form url.Values) string {
	var pairs = url.Values{}
	nonce := make([]byte, 32)
	io.ReadFull(rand.Reader, nonce)
	timestamp := fmt.Sprintf("%d", time.Now().Unix())
	if query != nil {
		for k, _ := range query {
			pairs.Set(k, query.Get(k))
		}
	}
	if form != nil {
		for k, _ := range form {
			pairs.Set(k, form.Get(k))
		}
	}
	pairs.Set("oauth_consumer_key", oat.ConsumerKey)
	pairs.Set("oauth_nonce", string(nonce))
	pairs.Set("oauth_signature_method", OAUTH_SIGNATURE_METHOD)
	pairs.Set("oauth_timestamp", timestamp)
	pairs.Set("oauth_token", oat.Token)
	pairs.Set("oauth_version", OAUTH_VERSION)
	signature := oat.createSignature(method, fullUrl, pairs)
	return fmt.Sprintf(
		OAUTH_AUTH_HEADER,
		percentEncode(oat.ConsumerKey),
		percentEncode(string(nonce)),
		percentEncode(signature),
		OAUTH_SIGNATURE_METHOD,
		timestamp,
		percentEncode(oat.Token),
		OAUTH_VERSION,
	)
}
Exemple #17
0
func (ph *patHandler) Path(values ...url.Values) string {
	// TODO refactor to build string in place or from preprocessed parts

	// find captures
	var i int
	captures := make([]string, 0)
	for i < len(ph.pat) {
		switch {
		default:
			i++
		case ph.pat[i] == ':':
			var name string
			name, _, i = match(ph.pat, isAlnum, i+1)
			captures = append(captures, name)
		}
	}

	// setup url values
	v := url.Values{}
	if len(values) > 0 {
		v = values[0]
	}
	path := ph.pat
	for _, capture := range captures {
		first := v.Get(capture)
		path = strings.Replace(path, ":"+capture, first, -1)
		v.Del(capture)
	}
	if query := v.Encode(); len(query) > 0 {
		path += strings.Join([]string{"?", query}, "")
	}
	return path
}
Exemple #18
0
func getFloat64(q url.Values, key string, d float64) float64 {
	f, err := strconv.ParseFloat(q.Get(key), 64)
	if err != nil {
		return d
	}
	return f
}
func (p *ProviderData) Redeem(redirectURL, code string) (s *SessionState, err error) {
	if code == "" {
		err = errors.New("missing code")
		return
	}

	params := url.Values{}
	params.Add("redirect_uri", redirectURL)
	params.Add("client_id", p.ClientID)
	params.Add("client_secret", p.ClientSecret)
	params.Add("code", code)
	params.Add("grant_type", "authorization_code")
	var req *http.Request
	req, err = http.NewRequest("POST", p.RedeemURL.String(), bytes.NewBufferString(params.Encode()))
	if err != nil {
		return
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

	var resp *http.Response
	resp, err = http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	var body []byte
	body, err = ioutil.ReadAll(resp.Body)
	resp.Body.Close()
	if err != nil {
		return
	}

	if resp.StatusCode != 200 {
		err = fmt.Errorf("got %d from %q %s", resp.StatusCode, p.RedeemURL.String(), body)
		return
	}

	// blindly try json and x-www-form-urlencoded
	var jsonResponse struct {
		AccessToken string `json:"access_token"`
	}
	err = json.Unmarshal(body, &jsonResponse)
	if err == nil {
		s = &SessionState{
			AccessToken: jsonResponse.AccessToken,
		}
		return
	}

	var v url.Values
	v, err = url.ParseQuery(string(body))
	if err != nil {
		return
	}
	if a := v.Get("access_token"); a != "" {
		s = &SessionState{AccessToken: a}
	} else {
		err = fmt.Errorf("no access token found %s", body)
	}
	return
}
Exemple #20
0
func ValidateMetricParams(queries url.Values) []ErrorResponse {

	var errs []ErrorResponse

	if queries["exec_time"] == nil {
		errs = append(errs, ErrorResponse{
			Message: "exec_time not set",
			Code:    fmt.Sprintf("%d", http.StatusBadRequest),
			Details: fmt.Sprintf("Please use exec_time url parameter in zulu format (like %s) to indicate the exact probe execution time", zuluForm),
		})
	} else {
		execDate := queries.Get("exec_time")
		errExec := validateDate(execDate)
		if errExec != nil {
			errs = append(errs, ErrorResponse{
				Message: "exec_time parsing error",
				Code:    fmt.Sprintf("%d", http.StatusBadRequest),
				Details: fmt.Sprintf("Error parsing date string %s please use zulu format like %s", execDate, zuluForm),
			})
		}
	}

	return errs

}
Exemple #21
0
// parseControlInfo builds ControlInfo from url.Values.
func parseControlInfo(values url.Values) *ControlInfo {
	mode := values.Get("mode")
	pow := values.Get("pow")
	if mode == "" || pow == "" {
		return nil
	}

	info := &ControlInfo{Power: (pow == "1")}
	info.token, _ = strconv.Atoi(values.Get("shum"))
	info.User = (info.token == tokenNoControl)

	stemp, err := strconv.ParseFloat(values.Get("stemp"), 64)
	if err == nil {
		info.SetPoint = &stemp
	}

	m := ModeOther
	switch values.Get("mode") {
	case "0", "1", "7":
		m = ModeAuto
	case "3":
		m = ModeCool
	case "4":
		m = ModeHeat
	}
	info.Mode = m

	return info
}
Exemple #22
0
// NewKey creates a new OTP key.
// keyType must be either TypeTotp or TypeHotp.
// label is required. keyLen <= 0, defaults to 10.
// algorithm == "", defaults to "sha1".
// digits <= 0, defaults to 6
func NewKey(keyType string, keyLen int, label, issuer, algorithm string, digits int, extraParams url.Values) (Key, error) {
	switch keyType {
	case TypeTotp:
		// TOTP
		// parse period parameter
		p := extraParams.Get("period")
		var (
			err error
			pp  int
		)
		if p != "" {
			pp, err = strconv.Atoi(p)
			if err != nil {
				return nil, &Error{ECInvalidPeriod, fmt.Sprintf("invalid period: %v", p), err}
			} else if pp == 0 {
				pp = DefaultPeriod
			}
		}
		return NewTotp(keyLen, label, issuer, algorithm, digits, pp)
	case TypeHotp:
		// HOTP
		// check for counter parameter
		c := extraParams.Get("counter")
		if c == "" {
			return nil, &Error{ECMissingCounter, "counter parameter is missing", nil}
		}
		cc, err := strconv.Atoi(c)
		if err != nil {
			return nil, &Error{ECInvalidCounter, fmt.Sprintf("bad counter: %v", c), err}
		}
		return NewHotp(keyLen, label, issuer, algorithm, digits, cc)
	default:
		return nil, &Error{ECInvalidOtpType, fmt.Sprintf("invalid OTP authentication type: %v", keyType), nil}
	}
}
Exemple #23
0
func (srv *Server) makeHealthCheck(value url.Values) elb.HealthCheck {
	ht := 10
	timeout := 5
	ut := 2
	interval := 30
	target := "TCP:80"
	if v := value.Get("HealthCheck.HealthyThreshold"); v != "" {
		ht, _ = strconv.Atoi(v)
	}
	if v := value.Get("HealthCheck.Timeout"); v != "" {
		timeout, _ = strconv.Atoi(v)
	}
	if v := value.Get("HealthCheck.UnhealthyThreshold"); v != "" {
		ut, _ = strconv.Atoi(v)
	}
	if v := value.Get("HealthCheck.Interval"); v != "" {
		interval, _ = strconv.Atoi(v)
	}
	if v := value.Get("HealthCheck.Target"); v != "" {
		target = v
	}
	return elb.HealthCheck{
		HealthyThreshold:   ht,
		Interval:           interval,
		Target:             target,
		Timeout:            timeout,
		UnhealthyThreshold: ut,
	}
}
Exemple #24
0
func (tm *TaskManager) NewTask(s *Store, args url.Values) (tid string, e error) {
	tm.lock.Lock()
	defer tm.lock.Unlock()
	tt := args.Get("task")
	vid := args.Get("volume")
	tid = tt + "-" + vid
	if _, ok := tm.taskList[tid]; ok {
		return tid, ErrTaskExists
	}

	var tw TaskWorker
	switch tt {
	case TaskVacuum:
		tw, e = NewVacuumTask(s, args)
	case TaskReplicate:
		tw, e = NewReplicaTask(s, args)
	case TaskBalance:
	}
	if e != nil {
		return
	}
	if tw == nil {
		return "", ErrTaskInvalid
	}
	tm.taskList[tid] = newTask(tw, tid)
	return tid, nil
}
Exemple #25
0
// queryBool returns the query parameter parsed as a boolean. An empty value
// ("?foo") is considered true, as is any value string except false
// ("?foo=false").
func queryBool(q url.Values, key string) bool {
	if _, ok := q[key]; !ok {
		return false
	}

	return q.Get(key) != "false"
}
Exemple #26
0
func buildAuthHeader(vals url.Values) string {
	var buf bytes.Buffer
	if _, ok := vals["oauth_version"]; !ok {
		vals.Set("oauth_version", "1.0")
	}
	fmt.Fprintf(&buf, "OAuth")
	remove := []string{}
	for k := range vals {
		if !strings.HasPrefix(k, "oauth_") {
			continue
		}
		remove = append(remove, k)
	}
	sort.Strings(remove)
	for n, k := range remove {
		if n > 0 {
			buf.WriteByte(',')
		}
		v := vals.Get(k)
		if k == "oauth_signature" {
			v = url.QueryEscape(v)
		}
		fmt.Fprintf(&buf, " %s=%q", k, v)
		delete(vals, k)
	}
	return buf.String()
}
Exemple #27
0
func (k *Kraken) SendAuthenticatedHTTPRequest(method string, values url.Values) (interface{}, error) {
	path := fmt.Sprintf("/%s/private/%s", KRAKEN_API_VERSION, method)
	values.Set("nonce", strconv.FormatInt(time.Now().UnixNano(), 10))
	secret, err := Base64Decode(k.APISecret)

	if err != nil {
		return nil, err
	}

	shasum := GetSHA256([]byte(values.Get("nonce") + values.Encode()))
	signature := Base64Encode(GetHMAC(HASH_SHA512, append([]byte(path), shasum...), secret))

	if k.Verbose {
		log.Printf("Sending POST request to %s, path: %s.", KRAKEN_API_URL, path)
	}

	headers := make(map[string]string)
	headers["API-Key"] = k.ClientKey
	headers["API-Sign"] = signature

	resp, err := SendHTTPRequest("POST", KRAKEN_API_URL+path, headers, strings.NewReader(values.Encode()))

	if err != nil {
		return nil, err
	}

	if k.Verbose {
		log.Printf("Recieved raw: \n%s\n", resp)
	}

	return resp, nil
}
Exemple #28
0
func hc(values url.Values) {
	var color, message string

	switch values.Get("Status") {
	case "Up":
		color = getColor(config.UpColor)
		message = formatMessage(values, config.MessageUp)
	case "Down":
		color = getColor(config.DownColor)
		message = formatMessage(values, config.MessageDown)
	}

	c := hipchat.Client{AuthToken: config.AuthToken}
	req := hipchat.MessageRequest{
		RoomId:        config.RoomId,
		From:          config.From,
		Message:       message,
		Color:         color,
		MessageFormat: hipchat.FormatText,
		Notify:        config.Notify,
	}

	if err := c.PostMessage(req); err != nil {
		fmt.Println("Expected no error, but got %q", err)
	}
}
Exemple #29
0
func ParseAuthCodeRequest(q url.Values) (AuthCodeRequest, error) {
	acr := AuthCodeRequest{
		ResponseType: q.Get("response_type"),
		ClientID:     q.Get("client_id"),
		State:        q.Get("state"),
		Scope:        make([]string, 0),
	}

	qs := strings.TrimSpace(q.Get("scope"))
	if qs != "" {
		acr.Scope = strings.Split(qs, " ")
	}

	err := func() error {
		if acr.ClientID == "" {
			return NewError(ErrorInvalidRequest)
		}

		redirectURL := q.Get("redirect_uri")
		if redirectURL != "" {
			ru, err := url.Parse(redirectURL)
			if err != nil {
				return NewError(ErrorInvalidRequest)
			}
			acr.RedirectURL = ru
		}

		return nil
	}()

	return acr, err
}
Exemple #30
0
func parseStr(values url.Values, key, defaultValue string) (string, bool) {
	value := values.Get(key)
	if value == "" {
		return defaultValue, false
	}
	return value, true
}