Esempio n. 1
0
File: main.go Progetto: samertm/play
func main() {
	u, _ := url.Parse("something.com/samer")
	uq, _ := url.Parse(u.String() + "?blahblah=ya")
	var q1 blahQuery
	log.Println(schema.NewDecoder().Decode(&q1, u.Query()))
	log.Println(q1)
	var q2 blahQuery
	log.Println(schema.NewDecoder().Decode(&q2, uq.Query()))
	log.Println(q2)
	uqq, _ := url.Parse(uq.String() + "&lala=yo")
	var q3 blahQuery
	log.Println(schema.NewDecoder().Decode(&q3, uqq.Query()))
	log.Println(q3)
}
Esempio n. 2
0
func main() {
	db := sqlx.MustOpen("sqlite3", ":memory:")

	db.MustExec(`CREATE TABLE Products (
                        id INTEGER PRIMARY KEY, 
                        name TEXT
                );
                INSERT INTO Products VALUES (1, 'TV');
                INSERT INTO Products VALUES (2, 'Microwave');`)

	inventory := &DatabaseInventoryRepository{db}

	env := &Env{
		inventory: inventory,
		decoder:   schema.NewDecoder(),
	}

	r := mux.NewRouter()

	r.Handle("/products", handlers.LoggingHandler(os.Stdout, Handler{env, ProductsHandler}))
	r.Handle("/products/search", handlers.LoggingHandler(os.Stdout, Handler{env, SearchHandler}))
	r.Handle("/docs/", http.StripPrefix("/docs/", http.FileServer(http.Dir("docs"))))

	http.ListenAndServe(":8080", r)
}
Esempio n. 3
0
func commandHandler(res http.ResponseWriter, req *http.Request) {
	req.ParseForm()
	command := new(SlackCommand)
	decoder := schema.NewDecoder()

	err := decoder.Decode(command, req.PostForm)
	if err != nil {
		res.WriteHeader(400)
		io.WriteString(res, "Invalid form data\n")
		return
	}

	if command.Token != config.IncomingToken {
		res.WriteHeader(403)
		io.WriteString(res, "Invalid token\n")
		return
	}

	user, created := userStore.GetOrAdd(command.UserID)
	if created {
		user.UserName = command.UserName
	}

	commandFunc, exists := commands[command.getSubCommand()]
	if !exists {
		commandFunc = commands["help"]
	}
	err = commandFunc(command, user)
	if err != nil {
		res.WriteHeader(400)
		io.WriteString(res, err.Error())
	}
}
Esempio n. 4
0
// create creates a new user in the system.
func (u userAdminForm) create(request *http.Request) error {
	err := request.ParseForm()

	if err != nil {
		return err
	}

	decoder := schema.NewDecoder()
	form := new(userAdminForm)

	err = decoder.Decode(form, request.PostForm)

	if err != nil {
		return err
	}

	_, err = database.CreateUser(
		form.Email,
		form.FirstName,
		form.LastName,
		form.Password,
		form.Admin,
	)

	return err
}
Esempio n. 5
0
func (gmo *GMO) HandleRawRequest(action string, params url.Values, output interface{}) (err error) {
	if gmo.Debug {
		log.Println("GMO Request [Debug]:", gmo.Endpoint+action)
	}
	resp, err := http.PostForm(gmo.Endpoint+action, params)
	if err != nil {
		return
	}
	bytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return
	}
	results, err := url.ParseQuery(string(bytes))
	if err != nil {
		return
	}

	decoder := schema.NewDecoder()
	decoder.IgnoreUnknownKeys(true)
	errd := decoder.Decode(output, results)

	if code := results.Get("ErrCode"); code != "" {
		err = fmt.Errorf("%v: %s", code, results.Get("ErrInfo"))
		return
	}

	if errd != nil {
		err = errd
	}

	return
}
func noteUpdateHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	apiApplyCorsHeaders(w, r)

	// Authenticate
	user := apiAuthenticateUser(r)

	// Find the note or share
	noteIDStr := mux.Vars(r)["id"]
	noteID, _ := strconv.ParseInt(noteIDStr, 10, 64)
	note := findNoteByID(noteID)
	share := findShareByAuthKey(noteIDStr)

	if share != nil {
		note = findNoteByID(int64(share.NoteID))
	} else if user == nil {
		w.WriteHeader(http.StatusForbidden)
		return
	}

	if share != nil && share.Permissions != "readwrite" {
		w.WriteHeader(http.StatusForbidden)
		return
	}

	// Note not found or invalid owner
	if note == nil || (user != nil && note.UserID != user.ID) {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	err := r.ParseForm()
	checkErr(err, "parsing form")

	noteParameters := new(noteRequestParameters)
	decoder := schema.NewDecoder()
	err = decoder.Decode(noteParameters, r.PostForm)
	checkErr(err, "decoding note create")

	var errors []APIError

	// Validate Title
	if len(noteParameters.Title) == 0 {
		errors = append(errors, APIError{Field: "title", Message: "is required"})
	}

	// Validate Body
	if len(noteParameters.Body) == 0 {
		errors = append(errors, APIError{Field: "body", Message: "is required"})
	}

	if len(errors) > 0 {
		apiErrorHandler(w, r, http.StatusBadRequest, errors)
		return
	}

	note.Update(noteParameters.Title, noteParameters.Body)

	w.Write(noteJSON(note))
}
Esempio n. 7
0
func (lqa *LiveQA) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	err := r.ParseForm()

	if err != nil {
		log.Println(err)
		return
	}

	q := &Question{}
	decoder := schema.NewDecoder()
	err = decoder.Decode(q, r.Form)
	if err != nil {
		log.Println(err)
		return
	}
	q.ReceivedTime = time.Now()

	// Drop query if without a proper Qid
	if len(q.Qid) == 0 {
		w.WriteHeader(http.StatusBadRequest)
		return
	}
	log.Println("IP", r.RemoteAddr, "QID", q.Qid)

	// Process query here
	a := lqa.ProcessQuestion(q)

	log.Println("Got answer `", a.Answer.Content, "` for", q.Qid, "in time", a.Answer.Time)

	fmt.Fprintf(w, "%s%s\n", xml.Header, a)
}
Esempio n. 8
0
func CommandHandler(w http.ResponseWriter, r *http.Request) {
	err := r.ParseForm()
	hook := r.URL.Path == "/slack_hook"
	if err == nil {
		decoder := schema.NewDecoder()
		command := new(robots.SlashCommand)
		err := decoder.Decode(command, r.PostForm)
		if err != nil {
			log.Println("Couldn't parse post request:", err)
		}
		if hook {
			c := strings.Split(command.Text, " ")
			command.Command = c[1]
			command.Text = strings.Join(c[2:], " ")
		} else {
			command.Command = command.Command[1:]
		}
		robot := GetRobot(command.Command)
		w.WriteHeader(http.StatusOK)
		if robot != nil {
			if hook {
				JSONResp(w, robot.Run(command))
			} else {
				plainResp(w, robot.Run(command))
			}
		} else {
			r := "No robot for that command yet :("
			if hook {
				JSONResp(w, r)
			} else {
				plainResp(w, r)
			}
		}
	}
}
Esempio n. 9
0
func (controller *usersController) newPost(rw http.ResponseWriter, req *http.Request) (int, error) {
	err := req.ParseForm()
	if err != nil {
		return http.StatusInternalServerError, err
	}

	decoder := schema.NewDecoder()
	// Ignore unknown keys to prevent errors from the CSRF token.
	decoder.IgnoreUnknownKeys(true)
	formUser := new(viewmodels.UsersEditViewModel)
	err = decoder.Decode(formUser, req.PostForm)
	if err != nil {
		return http.StatusInternalServerError, err
	}

	valErrors := validateUserForm(formUser, false)
	if len(valErrors) > 0 {
		isAuthenticated, user := getCurrentUser(rw, req, controller.authorizer)
		vm := viewmodels.NewUserViewModel(formUser, controller.roles, isAuthenticated, user, valErrors)
		vm.CsrfField = csrf.TemplateField(req)
		return http.StatusOK, controller.newTemplate.Execute(rw, vm)
	}

	var user httpauth.UserData
	user.Username = formUser.Username
	user.Email = formUser.Email
	password := formUser.Password
	user.Role = formUser.Role
	err = controller.authorizer.Register(rw, req, user, password)
	if err != nil {
		return http.StatusInternalServerError, err
	}
	http.Redirect(rw, req, "/settings/users", http.StatusSeeOther)
	return http.StatusSeeOther, nil
}
Esempio n. 10
0
func HandleBalancerCreate(w http.ResponseWriter, r *http.Request) {
	err := r.ParseForm()
	if err != nil {
		http.Error(w, "Bad Request", http.StatusBadRequest)
		return
	}
	body := struct {
		Label string `schema:"label"`
	}{}
	err = schema.NewDecoder().Decode(&body, r.PostForm)
	if err != nil {
		http.Error(w, "Bad Request", http.StatusBadRequest)
		return
	}

	bal := data.Balancer{}
	bal.Label = body.Label
	err = bal.Put()
	if err != nil {
		panic(err)
	}

	err = feline.Commit(&bal)
	if err != nil {
		panic(err)
	}

	http.Redirect(w, r, "/balancers/"+bal.Id.Hex()+"/edit", http.StatusSeeOther)
}
Esempio n. 11
0
func TestPullRequestsService_Get(t *testing.T) {
	setup()
	defer teardown()

	want := &PullRequest{PullRequest: github.PullRequest{Number: github.Int(1)}}
	opts := &PullRequestGetOptions{Checklist: true}

	var called bool
	mux.HandleFunc(urlPath(t, router.RepoPullRequest, map[string]string{"RepoSpec": "r.com/x", "Pull": "1"}), func(w http.ResponseWriter, r *http.Request) {
		called = true
		testMethod(t, r, "GET")

		var gotOpts PullRequestGetOptions
		schema.NewDecoder().Decode(&gotOpts, r.URL.Query())
		if !reflect.DeepEqual(&gotOpts, opts) {
			t.Errorf("got requested opts %+v, but got %+v", &gotOpts, opts)
		}

		writeJSON(w, want)
	})

	pull, _, err := client.PullRequests.Get(PullRequestSpec{Repo: RepoSpec{URI: "r.com/x"}, Number: 1}, opts)
	if err != nil {
		t.Errorf("PullRequests.Get returned error: %v", err)
	}

	if !called {
		t.Fatal("!called")
	}

	if !reflect.DeepEqual(pull, want) {
		t.Errorf("PullRequests.Get returned %+v, want %+v", pull, want)
	}
}
Esempio n. 12
0
func decodePerson(r *http.Request) *person.Person {
	// Decode the form data and add the resulting Person type to the Profile.
	p := &person.Person{}
	decoder := schema.NewDecoder()
	decoder.Decode(p, r.Form)
	return p
}
Esempio n. 13
0
func TestEncodeDecodeQuery(t *testing.T) {

	const expected = "entities=c%2F1&entities=c%2F2&origin=mysystem"

	q := Query{}
	q.Origin = "mysystem"
	q.Entities = []string{"c/1", "c/2"}

	v, err := query.Values(q)

	if err != nil {
		t.Fatal(err)
	}

	t.Log(v.Encode())

	if v.Encode() != expected {
		t.Fatalf("Expected %s, got %s", expected, v.Encode())
	}

	q2 := new(Query)
	decoder := schema.NewDecoder()
	err = decoder.Decode(q2, v)

	if err != nil {
		t.Fatal(err)
	}

	if q.Origin != q2.Origin {
		t.Fatalf("Expected %s, got %s", q.Origin, q2.Origin)
	}
}
Esempio n. 14
0
func (controller *profileController) post(rw http.ResponseWriter, req *http.Request) (int, error) {
	err := req.ParseForm()
	if err != nil {
		return http.StatusInternalServerError, err
	}

	decoder := schema.NewDecoder()
	// Ignore unknown keys to prevent errors from the CSRF token.
	decoder.IgnoreUnknownKeys(true)
	formUser := new(viewmodels.ProfileEditViewModel)
	err = decoder.Decode(formUser, req.PostForm)
	if err != nil {
		return http.StatusInternalServerError, err
	}

	valErrors := validateProfileForm(formUser, true)
	if len(valErrors) > 0 {
		isAuthenticated, user := getCurrentUser(rw, req, controller.authorizer)
		vm := viewmodels.EditProfileViewModel(formUser, isAuthenticated, user, valErrors)
		vm.CsrfField = csrf.TemplateField(req)
		return http.StatusOK, controller.template.Execute(rw, vm)
	}

	// Update the user.
	err = controller.authorizer.Update(rw, req, "", formUser.Password, formUser.Email)
	if err != nil {
		return http.StatusInternalServerError, err
	}
	http.Redirect(rw, req, "/", http.StatusSeeOther)
	return http.StatusSeeOther, nil
}
Esempio n. 15
0
File: main.go Progetto: abh/v6test
func init() {

	beanCh = make(chan []byte, 200)

	decoder = schema.NewDecoder()
	decoder.ZeroEmpty(true)
	decoder.IgnoreUnknownKeys(true)
	decoder.RegisterConverter(Latency(0), func(v string) reflect.Value {
		i, err := strconv.Atoi(v)
		if err != nil {
			l := Latency(0)
			return reflect.ValueOf(l)
		}
		l := Latency(i)
		return reflect.ValueOf(l)
	})

	pn := []string{"10.220.0.0/24", "207.171.3.0/27"}
	for _, p := range pn {
		_, ipnet, err := net.ParseCIDR(p)
		if err != nil {
			panic(err)
		}
		localNets = append(localNets, ipnet)
	}
}
Esempio n. 16
0
func (c commandAdminForm) create(request *http.Request, repo *database.Repository) error {
	err := request.ParseForm()

	if err != nil {
		return err
	}

	decoder := schema.NewDecoder()
	form := new(commandAdminForm)

	err = decoder.Decode(form, request.PostForm)

	if err != nil {
		return err
	}

	_, err = database.CreateCommand(
		repo,
		form.Name,
		form.Execute,
		form.Branch,
		form.Kind,
	)

	return err
}
Esempio n. 17
0
func init() {
	Decoder = schema.NewDecoder()
	RegisterMeatHandlers(route.Router)
	RegisterUserHandlers(route.Router)
	http.Handle("/static/",
		http.StripPrefix("/static/", http.FileServer(http.Dir("resources/static/"))))
}
Esempio n. 18
0
func doInit(projectName, appName string, requireConfig bool, logFormatterFactory LogFormatterFactory) *App {
	app := &App{
		common: common{
			Decoder: schema.NewDecoder(),
		},
		AppName:             appName,
		ProjectName:         projectName,
		GorillaRouter:       mux.NewRouter(),
		wantReq:             make(chan *wantReq),
		doneReq:             make(chan *Req),
		getReqs:             make(chan chan *Req),
		getStats:            make(chan chan AppStats),
		loggerMap:           make(map[string]int),
		logFormatterFactory: logFormatterFactory,
	}

	app.loadAppConfigFile(requireConfig)

	// Linux setuid() doesn't work with threaded procs :-O
	// and the go runtime threads before we can get going.
	//
	// http://homepage.ntlworld.com/jonathan.deboynepollard/FGA/linux-thread-problems.html
	//    app.setUserAndGroup()

	app.initLogging()

	maxProcs, _ := app.Cfg.GetInt("gop", "maxprocs", 4*runtime.NumCPU())
	app.Debug("Setting maxprocs to %d", maxProcs)
	runtime.GOMAXPROCS(maxProcs)

	app.initStatsd()

	return app
}
Esempio n. 19
0
// decodeRequestQuery decodes a request form.
func decodeRequestQuery(r *http.Request, v interface{}) error {
	if err := schema.NewDecoder().Decode(v, r.URL.Query()); err != nil {
		log.WithField("err", err).Info("Invalid request query")
		return err
	}
	return nil
}
Esempio n. 20
0
func (l loginForm) authenticate(request *http.Request) (string, error) {
	err := request.ParseForm()

	if err != nil {
		return "", err
	}

	decoder := schema.NewDecoder()
	form := new(loginForm)

	err = decoder.Decode(form, request.PostForm)

	if err != nil {
		return "", err
	}

	user, err := database.GetUser(form.Email)

	if err != nil {
		return "", err
	}

	auth := database.ComparePassword(form.Password, user.Password)

	if auth == false {
		return "", errors.New("Username and password do not match.")
	}

	return user.NewSession(), nil
}
Esempio n. 21
0
func HandleOrganizationCreate(w http.ResponseWriter, r *http.Request) {
	ctx := GetContext(r)

	if ctx.Account == nil {
		http.Redirect(w, r, "/login", http.StatusSeeOther)
		return
	}

	err := r.ParseForm()
	catch(r, err)

	body := struct {
		Name string `schema:"name"`
	}{}

	err = schema.NewDecoder().Decode(&body, r.PostForm)
	catch(r, err)

	switch {
	case body.Name == "":
		RedirectBack(w, r)
		return
	}

	org := data.Organization{
		Name:      body.Name,
		OwnerID:   ctx.Account.ID,
		CreatorID: ctx.Account.ID,
	}
	err = org.Put()
	catch(r, err)

	http.Redirect(w, r, "/organizations/"+org.ID.Hex()+"/projects", http.StatusSeeOther)
}
Esempio n. 22
0
// ServeHTTP implementation.
func (c *Client) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		log.Println("invalid " + r.Method + " connection from " + r.RemoteAddr)
		http.NotFound(w, r)
		return
	}
	msg := IMessage{}
	err := r.ParseForm()
	if err != nil {
		log.Println(err)
		http.NotFound(w, r)
		return
	}
	defer r.Body.Close()
	decoder := schema.NewDecoder()
	err = decoder.Decode(&msg, r.PostForm)
	if err != nil {
		log.Println(err)
		http.NotFound(w, r)
		return
	}
	if msg.Token == "" {
		log.Println("no token from " + r.RemoteAddr)
		http.NotFound(w, r)
		return
	}
	if c.Token != "" {
		if msg.Token != c.Token {
			log.Println("invalid token " + msg.Token + " from " + r.RemoteAddr)
			http.NotFound(w, r)
			return
		}
	}
	c.In <- msg
}
Esempio n. 23
0
func PopulateInterface(document Document, StructType reflect.Type) (reflect.Value, error) {
	decoder := schema.NewDecoder()
	decoder.IgnoreUnknownKeys(true)

	gorillaMap := make(map[string][]string)

	for key, field := range document.Fields {

		var fieldString []string

		switch fieldType := field.(type) {
		case string:
			fieldString = []string{fieldType}
		case bool:
			fieldString = []string{strconv.FormatBool(fieldType)}
		case float64:
			fieldString = []string{strconv.FormatFloat(fieldType, 'f', -1, 64)}
		}

		if len(fieldString) > 0 {
			gorillaMap[key] = fieldString
		}
	}

	documentStruct := reflect.New(StructType)

	err := decoder.Decode(documentStruct.Interface(), gorillaMap)

	if err != nil {
		return reflect.Value{}, err
	}

	return documentStruct, nil

}
Esempio n. 24
0
func updatePrinter(writer http.ResponseWriter, request *http.Request) {
	request.ParseForm()
	printer := new(data.Printer)
	decoder := schema.NewDecoder()
	id := request.FormValue("id")
	request.Form.Del("id")
	err := decoder.Decode(printer, request.Form)
	fmt.Println(request.Form)
	if check(err, 400, &writer) {
		return
	}
	if printer.Name == "" {
		log.Println(errors.New("No Name Provided"))
		http.Error(writer, http.StatusText(400), 400)
		return
	}
	printer.Id, err = uuid.FromString(id)
	if check(err, 400, &writer) {
		return
	}
	err = printerQueue.Update(*printer, &configImpl)
	if check(err, 400, &writer) {
		return
	}
	json, err := json.MarshalIndent(printerQueue.Queue, "", "    ")
	if check(err, 500, &writer) {
		return
	}
	writer.Write(json)
}
Esempio n. 25
0
func slashCommandHandler(w http.ResponseWriter, r *http.Request) {
	err := r.ParseForm()
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}
	d := schema.NewDecoder()
	command := new(robots.SlashCommand)
	err = d.Decode(command, r.PostForm)
	if err != nil {
		log.Println("Couldn't parse post request:", err)
	}
	if command.Command == "" || command.Token == "" {
		log.Printf("[DEBUG] Ignoring request from unidentified source: %s - %s", command.Token, r.Host)
		w.WriteHeader(http.StatusBadRequest)
		return
	}
	command.Robot = command.Command[1:]

	if token := os.Getenv(fmt.Sprintf("%s_SLACK_TOKEN", strings.ToUpper(command.Robot))); token != "" && token != command.Token {
		log.Printf("[DEBUG] Ignoring request from unidentified source: %s - %s", command.Token, r.Host)
		w.WriteHeader(http.StatusBadRequest)
	}
	robots := getRobots(command.Robot)
	if len(robots) == 0 {
		plainResp(w, "No robot for that command yet :(")
		return
	}
	resp := ""
	for _, robot := range robots {
		resp += fmt.Sprintf("\n%s", robot.Run(&command.Payload))
	}
	plainResp(w, strings.TrimSpace(resp))
}
Esempio n. 26
0
func nameTagSubmit(writer http.ResponseWriter, request *http.Request) {
	defer http.Redirect(writer, request, "/manager", 301)
	log.Println("Name Tags Submited")
	err := request.ParseForm()
	if check(err, 500, &writer) {
		return
	}
	if request.MultipartForm != nil && request.MultipartForm.Value != nil {
		configImpl.DebugLog(request.MultipartForm.Value)
	}
	wrapper := new(data.DataWrapper)
	decoder := schema.NewDecoder()
	err = decoder.Decode(wrapper, request.PostForm)
	if err != nil {
		log.Println("Decoding form data failed:", err)
		http.Error(writer, http.StatusText(400), 400)
		return
	}
	for i := 0; i < len(wrapper.NameTagQueue.Queue); i++ {
		if len(wrapper.NameTagQueue.Queue) >= i+1 && wrapper.NameTagQueue.Queue[i].Name != "" {
			log.Println(wrapper.NameTagQueue.Queue[i].Id)
			if len(wrapper.Delete) >= i+1 && wrapper.Delete[i] == true {
				err := nameTagQueue.Remove(wrapper.NameTagQueue.Queue[i].Id, &configImpl)
				if err != nil {
					log.Println(err)
				}
			} else {
				nameTagQueue.Queue[i] = wrapper.NameTagQueue.Queue[i]
			}
		}
	}
	nameTagQueue.Save(&configImpl)
	fmt.Println("Name Tags written")
}
Esempio n. 27
0
// update updates an existing user based on the form.
func (u userAdminForm) update(request *http.Request, uid int64) error {
	err := request.ParseForm()

	if err != nil {
		return err
	}

	decoder := schema.NewDecoder()
	form := new(userAdminForm)

	err = decoder.Decode(form, request.PostForm)

	if err != nil {
		return err
	}

	user, err := database.GetUserByID(uid)

	if err != nil {
		return err
	}

	_, err = user.Update(
		form.Email,
		form.FirstName,
		form.LastName,
		form.Password,
		form.Admin,
	)

	return err
}
Esempio n. 28
0
func printersSubmit(writer http.ResponseWriter, request *http.Request) {
	defer http.Redirect(writer, request, "/manager#printersTab", 301)
	fmt.Println("Printers Submited")
	err := request.ParseMultipartForm(0)
	if err != nil {
		fmt.Println("Parsing form data failed:", err)
		http.Error(writer, http.StatusText(500), 500)
		return
	}
	if request.MultipartForm != nil && request.MultipartForm.Value != nil {
		configImpl.DebugLog(request.MultipartForm.Value)
	}
	wrapper := new(data.DataWrapper)
	decoder := schema.NewDecoder()
	err = decoder.Decode(wrapper, request.MultipartForm.Value)
	if err != nil {
		fmt.Println("Decoding form data failed:", err)
		http.Error(writer, http.StatusText(400), 400)
		return
	}
	//	fmt.Printf("%v\n", wrapper.PrinterQueue.Queue)
	for i := 0; i < len(wrapper.PrinterQueue.Queue); i++ {
		if len(wrapper.PrinterQueue.Queue) >= i+1 && wrapper.PrinterQueue.Queue[i].Name != "" {
			if len(wrapper.Delete) >= i+1 && wrapper.Delete[i] == true {
				printerQueue.Remove(wrapper.PrinterQueue.Queue[i].Id, &configImpl)
			} else {
				fmt.Printf("Setting printer: %s to positon: %d\n", wrapper.PrinterQueue.Queue[i].Name, i)
				fmt.Printf("%v\n", wrapper.PrinterQueue.Queue[i])
				printerQueue.Queue[i] = wrapper.PrinterQueue.Queue[i]
			}
		}
	}
	printerQueue.Save(&configImpl)
	fmt.Println("Printers written")
}
Esempio n. 29
0
func adminornot(w http.ResponseWriter, q *http.Request) {
	err := q.ParseForm()

	if err != nil {
		// Handle error
		fmt.Println(err)
	}

	decoder := schema.NewDecoder()
	adm := new(authUser)

	decoder.Decode(adm, q.PostForm)

	if adm.checkstaffloginpassword() == true {
		session, _ := store.Get(q, sessionname)
		ulin := staffLogedIn{
			UserLogin:     adm.Login,
			IsUserLogedIn: true,
		}

		session.Values["staffLogedIn"] = ulin

		session.Save(q, w)
		render(w, "admin", nil)
	} else {
		newmap := map[string]interface{}{"metatitle": "Registration", "errormessage": "Wrong login or password"}
		render(w, "adminlogin", newmap)
	}

}
Esempio n. 30
0
func QueryFromValues(u url.Values) (*Query, error) {
	decoder := schema.NewDecoder()
	decoder.RegisterConverter(time.Time{}, convertTime)
	q := new(Query)
	err := decoder.Decode(q, u)
	return q, err
}