예제 #1
0
// HandleGetCharacteristics handles a get characteristic request like `/characteristics?id=1.4,1.5`
func (ctr *CharacteristicController) HandleGetCharacteristics(form url.Values) (io.Reader, error) {
	var b bytes.Buffer
	var chs []data.Characteristic

	// id=1.4,1.5
	paths := strings.Split(form.Get("id"), ",")
	for _, p := range paths {
		if ids := strings.Split(p, "."); len(ids) == 2 {
			aid := to.Int64(ids[0]) // accessory id
			iid := to.Int64(ids[1]) // instance id (= characteristic id)
			c := data.Characteristic{AccessoryID: aid, CharacteristicID: iid}
			if ch := ctr.GetCharacteristic(aid, iid); ch != nil {
				c.Value = ch.Value
			} else {
				c.Status = hap.StatusServiceCommunicationFailure
			}
			chs = append(chs, c)
		}
	}

	result, err := json.Marshal(&data.Characteristics{chs})
	if err != nil {
		log.Info.Panic(err)
	}

	b.Write(result)
	return &b, err
}
예제 #2
0
파일: database.go 프로젝트: tjbx/X10Bridge
func (db *database) DNSWithName(name string) DNS {
	config, err := db.storage.Get(configurationKeyForDNSName(name))
	state, err := db.storage.Get(stateKeyForDNSName(name))

	if len(config) > 0 && err == nil && len(state) > 0 {
		return NewDNS(name, to.Int64(string(config)), to.Int64(string(state)))
	}

	return nil
}
예제 #3
0
파일: parser.go 프로젝트: smitterson/hc
// ParseAccessoryAndCharacterID returns the accessory and characteristic id encoded in the argument string.
// The string must be in format "<accessory id>.<characteristic id>"
func ParseAccessoryAndCharacterID(str string) (accessoryID int64, characteristicID int64, err error) {
	ids := strings.Split(str, ".")
	if len(ids) != 2 {
		err = fmt.Errorf("Could not parse uid %s", str)
	} else {
		accessoryID = to.Int64(ids[0])
		characteristicID = to.Int64(ids[1])
	}

	return accessoryID, characteristicID, err
}
예제 #4
0
파일: mdns.go 프로젝트: smitterson/hc
func (s *MDNSService) txtRecords() []string {
	return []string{
		fmt.Sprintf("pv=%s", s.protocol),
		fmt.Sprintf("id=%s", s.id),
		fmt.Sprintf("c#=%d", s.configuration),
		fmt.Sprintf("s#=%d", s.state),
		fmt.Sprintf("sf=%d", to.Int64(s.reachable)),
		fmt.Sprintf("ff=%d", to.Int64(s.mfiCompliant)),
		fmt.Sprintf("md=%s", s.name),
		fmt.Sprintf("ci=%d", s.categoryIdentifier),
	}
}
예제 #5
0
파일: config.go 프로젝트: brutella/hklifx
// txtRecords returns the config formatted as mDNS txt records
func (cfg Config) txtRecords() []string {
	return []string{
		fmt.Sprintf("pv=%s", cfg.protocol),
		fmt.Sprintf("id=%s", cfg.id),
		fmt.Sprintf("c#=%d", cfg.version),
		fmt.Sprintf("s#=%d", cfg.state),
		fmt.Sprintf("sf=%d", to.Int64(cfg.discoverable)),
		fmt.Sprintf("ff=%d", to.Int64(cfg.mfiCompliant)),
		fmt.Sprintf("md=%s", cfg.name),
		fmt.Sprintf("ci=%d", cfg.categoryId),
	}
}
예제 #6
0
파일: context.go 프로젝트: astrata/tango
func newContext(server *Server, writer http.ResponseWriter, request *http.Request) *Context {

	context := &Context{}

	switch request.Method {
	case "GET":
		context.GET = true
	case "POST":
		context.POST = true
	case "DELETE":
		context.DELETE = true
	case "PUT":
		context.PUT = true
	}

	context.cookieMap = make(map[string]*http.Cookie)

	context.Server = server
	context.Request = request
	context.Writer = writer

	maxSize := to.Int64(config.Get("server/request_max_size"))

	request.ParseMultipartForm(maxSize)

	context.Params = context.getParams()
	context.Cookies = context.getCookies()
	context.Files = context.getFiles()

	server.Context = context

	return context
}
예제 #7
0
func (t *ipTransport) Start() {

	// Create server which handles incoming tcp connections
	config := http.Config{
		Port:      t.config.Port,
		Context:   t.context,
		Database:  t.database,
		Container: t.container,
		Device:    t.device,
		Mutex:     t.mutex,
		Emitter:   t.emitter,
	}

	s := http.NewServer(config)
	t.server = s

	// Publish server port which might be different then `t.config.Port`
	t.config.servePort = int(to.Int64(s.Port()))

	mdns := NewMDNSService(t.config)
	t.mdns = mdns

	mdns.Publish()

	// Publish accessory ip
	log.Info.Println("Accessory IP is", t.config.IP)

	// Send keep alive notifications to all connected clients every 10 minutes
	t.keepAlive = hap.NewKeepAlive(10*time.Minute, t.context)
	go t.keepAlive.Start()

	// Listen until server.Stop() is called
	s.ListenAndServe()
}
예제 #8
0
파일: morph.go 프로젝트: kdar/morphgen
// options:
//  url - url to generate codes from
//  notmog - turn off grabbing transmogged items from armory
func (g *Generator) Generate(options map[string]interface{}, w io.Writer) error {
	url := to.String(options["url"])
	var tmorphItems TMorphItems
	var err error
	switch {
	case strings.Contains(url, "wowhead.com"):
		tmorphItems, err = wowhead(options)
	case strings.Contains(url, "battle.net/wow"):
		tmorphItems, err = wowarmory(options)
	case strings.Contains(url, "http"):
		tmorphItems, err = generic(options)
	default:
		return errors.New("Do not recognize the URL.")
	}

	if err != nil {
		return err
	}

	g.lastTmorphItems = tmorphItems
	bonus := int(to.Int64(options["bonus"]))
	g.Bonus(bonus)
	g.Output(w)

	return nil
}
예제 #9
0
func (t *ipTransport) Start() {
	config := server.Config{
		Port:      t.config.Port,
		Context:   t.context,
		Database:  t.database,
		Container: t.container,
		Device:    t.device,
		Mutex:     t.mutex,
		Emitter:   t.emitter,
	}

	s := server.NewServer(config)
	t.server = s
	port := to.Int64(s.Port())

	mdns := NewMDNSService(t.name, t.device.Name(), int(port))
	t.mdns = mdns

	// Paired accessories must not be reachable for other clients since iOS 9
	if t.isPaired() {
		mdns.SetReachable(false)
	}

	mdns.Publish()

	// Listen until server.Stop() is called
	s.ListenAndServe()
}
예제 #10
0
파일: mail.go 프로젝트: tantra35/notifier
// Init read yaml config
func (sender *Sender) Init(senderSettings map[string]string, logger *logging.Logger) error {
	sender.SetLogger(logger)
	sender.From = senderSettings["mail_from"]
	sender.SMTPhost = senderSettings["mail_smtp_host"]
	sender.SMTPport = int(to.Int64(senderSettings["mail_smtp_port"]))
	sender.InsecureTLS = to.Bool(senderSettings["mail_insecure_tls"])
	sender.FrontURI = senderSettings["front_uri"]
	return nil
}
예제 #11
0
func (b *Base) getUser(c *gin.Context) {
	if userId := to.Int64(c.Params.ByName("user_id")); userId != 0 {
		var user User
		err := b.Db.SelectOne(&user, "SELECT * FROM users WHERE id = ? LIMIT 1", userId)
		checkErr(err)
		if err == nil {
			c.JSON(200, user)
			return
		}
	}
	c.JSON(404, "Not found")
}
예제 #12
0
func (t *ipTransport) Start() {
	s := server.NewServer(t.context, t.database, t.container, t.device, t.mutex)
	t.server = s
	port := to.Int64(s.Port())

	mdns := NewMDNSService(t.name, t.device.Name(), int(port))
	t.mdns = mdns

	mdns.Publish()
	// Listen until server.Stop() is called
	s.ListenAndServe()
}
예제 #13
0
파일: config.go 프로젝트: brutella/hklifx
// loads load the id, version and config hash
func (cfg *Config) load(storage util.Storage) {
	if b, err := storage.Get("uuid"); err == nil {
		cfg.id = string(b)
	}

	if b, err := storage.Get("version"); err == nil {
		cfg.version = to.Int64(string(b))
	}

	if b, err := storage.Get("configHash"); err == nil {
		cfg.configHash = b
	}
}
예제 #14
0
func (b *Base) deleteUser(c *gin.Context) {
	if userId := to.Int64(c.Params.ByName("user_id")); userId != 0 {
		var user User
		err := b.Db.SelectOne(&user, "SELECT * FROM users WHERE id = ? LIMIT 1", userId)
		checkErr(err)
		if err == nil {
			_, err = b.Db.Delete(&user)
			checkErr(err)
			c.Writer.WriteHeader(204)
			return
		}
	}
	c.JSON(400, "Bad request")
}
예제 #15
0
func (b *Base) editUser(c *gin.Context) {
	var jsonForm UserJSON
	if err := c.BindJSON(&jsonForm); err != nil {
		c.JSON(400, "Bad request")
		return
	}
	if userId := to.Int64(c.Params.ByName("user_id")); userId != 0 {
		user := User{Id: userId, Name: jsonForm.Name, Email: jsonForm.Email}
		_, err := b.Db.Update(&user)
		checkErr(err)
		c.JSON(200, user)
		return
	}
	c.JSON(404, "Not found")
}
예제 #16
0
파일: main.go 프로젝트: warmfusion/cache
func readConfig(configFileName *string) error {
	file, err := yaml.Open(*configFileName)
	if err != nil {
		return fmt.Errorf("Can't read config file %s: %s", *configFileName, err.Error())
	}
	pidFileName = to.String(file.Get("cache", "pid"))
	logFileName = to.String(file.Get("cache", "log_file"))
	listen = to.String(file.Get("cache", "listen"))
	retentionConfigFileName = to.String(file.Get("cache", "retention-config"))
	redisURI = fmt.Sprintf("%s:%s", to.String(file.Get("redis", "host")), to.String(file.Get("redis", "port")))
	graphiteURI = to.String(file.Get("graphite", "uri"))
	graphitePrefix = to.String(file.Get("graphite", "prefix"))
	graphiteInterval = to.Int64(file.Get("graphite", "interval"))
	return nil
}
예제 #17
0
func (t *ipTransport) Start() {
	s := server.NewServer(t.context, t.database, t.container, t.device, t.mutex)
	t.server = s
	port := to.Int64(s.Port())

	mdns := NewMDNSService(t.name, t.device.Name(), int(port))
	t.mdns = mdns

	dns := t.database.DNSWithName(t.name)
	if dns == nil {
		dns = db.NewDNS(t.name, 1, 1)
		t.database.SaveDNS(dns)
	}
	mdns.Publish()
	// Listen until server.Stop() is called
	s.ListenAndServe()
}
예제 #18
0
// InitMetrics inits graphite metrics and starts graphite flush cycle
func InitMetrics() {
	graphiteURI := config.Get("graphite", "uri")
	graphitePrefix := config.Get("graphite", "prefix")
	graphiteInterval := to.Int64(config.Get("graphite", "interval"))

	if graphiteURI != "" {
		graphiteAddr, err := net.ResolveTCPAddr("tcp", graphiteURI)
		if err != nil {
			log.Errorf("Can not resolve graphiteURI %s: %s", graphiteURI, err)
			return
		}
		hostname, err := os.Hostname()
		if err != nil {
			log.Errorf("Can not get OS hostname: %s", err)
			return
		}
		shortname := strings.Split(hostname, ".")[0]
		go graphite.Graphite(metrics.DefaultRegistry, time.Duration(graphiteInterval)*time.Second, fmt.Sprintf("%s.notifier.%s", graphitePrefix, shortname), graphiteAddr)
	}
}
예제 #19
0
func TestEventCharacteristicFromJSON(t *testing.T) {
	var b = []byte(`{"characteristics":[{"aid":2,"iid":13,"status":1,"ev":true}]}`)
	var cs Characteristics

	if err := json.Unmarshal(b, &cs); err != nil {
		t.Fatal(err)
	}
	if x := len(cs.Characteristics); x != 1 {
		t.Fatal(x)
	}

	c := cs.Characteristics[0]

	if x := c.AccessoryID; x != 2 {
		t.Fatal(x)
	}
	if x := c.CharacteristicID; x != 13 {
		t.Fatal(x)
	}

	if x, ok := c.Events.(bool); ok {
		if !x {
			t.Fatalf("want=true is=%v", x)
		}
	} else {
		t.Fatalf("invalid events type %v", reflect.TypeOf(x))
	}

	if x := to.Int64(c.Status); x != 1 {
		t.Fatal(x)
	}

	if c.Value != nil {
		t.Fatalf("want=nil is=%v", c.Value)
	}
}
예제 #20
0
파일: main.go 프로젝트: Olbitla/photopy
func startImport(name string, dest string) {

	defer func() {
		ok <- 1
	}()

	tags, err := getExifData(name)

	if err == nil {

		hash := checksum.File(name, crypto.SHA1)
		rename := ""

		switch tags["File Type"] {

		case "MP3":

			rename = strings.Join(
				[]string{
					dest,
					normalize(pick(tags["Artist"], "Unknown Artist")),
					normalize(pick(tags["Album"], "Unknown Album")),
					fmt.Sprintf("%s%s", normalize(tags["Track"], fmt.Sprintf("%s-%s", pick(tags["Title"], "Unknown Title"), hash[0:4])), pick(strings.ToLower(path.Ext(name)), ".mp3")),
				},
				Ps,
			)

		default:
			var taken string

			dateTimeFields := []string{
				"Date and Time (Original)",
				"Date/Time Original",
				"Media Create Date",
				"Track Create Date",
				"Create Date",
			}

			for _, field := range dateTimeFields {
				if tags[field] != "" {
					taken = tags[field]
					break
				}
			}

			if taken == "" {
				stats.unknown++
				return
			}

			all := reDateTime.FindAllStringSubmatch(taken, -1)

			timeTaken := time.Date(
				int(to.Int64(all[0][1])),
				time.Month(int(to.Int64(all[0][2]))),
				int(to.Int64(all[0][3])),
				int(to.Int64(all[0][4])),
				int(to.Int64(all[0][5])),
				int(to.Int64(all[0][6])),
				0,
				time.UTC,
			)

			rename = strings.Join(
				[]string{
					dest,
					to.String(timeTaken.Year()),
					fmt.Sprintf("%02d-%s", timeTaken.Month(), timeTaken.Month()),
					fmt.Sprintf("%02d-%s", timeTaken.Day(), timeTaken.Weekday()),
					fmt.Sprintf("%02d%02d%02d-%s%s", timeTaken.Hour(), timeTaken.Minute(), timeTaken.Second(), strings.ToUpper(hash[0:4]), strings.ToLower(path.Ext(name))),
				},
				Ps,
			)
		}

		if rename != "" {

			_, err := os.Stat(rename)

			if err != nil {

				if *flagDryRun == false {
					err = os.MkdirAll(path.Dir(rename), os.ModeDir|0750)
					if err != nil {
						panic(err)
					}
				}
				err = nil
				if *flagMove == true {
					log.Printf("Moving file: %s -> %s\n", name, rename)
					if *flagDryRun == false {
						err = fileMove(name, rename)
						stats.moved++
					}
				} else {
					log.Printf("Copying file: %s -> %s\n", name, rename)
					if *flagDryRun == false {
						err = copyFile(name, rename)
						stats.copied++
					}
				}
				if err != nil {
					panic(err)
				}

			} else {
				rehash := checksum.File(rename, crypto.SHA1)

				if hash == rehash {
					log.Printf("Destination already exists: %s, removing original: %s (same file).\n", rename, name)
					os.Remove(name)
					stats.deleted++
				} else {
					log.Printf("Destination already exists: %s, skipping original: %s (files differ).\n", rename, name)
					stats.skipped++
				}
			}

		} else {
			stats.unknown++
		}

	} else {
		stats.unknown++
	}

}
예제 #21
0
func TestApi(t *testing.T) {

	var err error

	client := New(&oauth.Credentials{
		to.String(conf.Get("twitter/app/key")),
		to.String(conf.Get("twitter/app/secret")),
	})

	client.SetAuth(&oauth.Credentials{
		to.String(conf.Get("twitter/user/token")),
		to.String(conf.Get("twitter/user/secret")),
	})

	_, err = client.VerifyCredentials(nil)

	if err != nil {
		t.Errorf("Test failed: %s\n", err.Error())
	}

	_, err = client.HomeTimeline(nil)

	if err != nil {
		t.Errorf("Test failed: %s\n", err.Error())
	}

	_, err = client.MentionsTimeline(nil)

	if err != nil {
		t.Errorf("Test failed: %s\n", err.Error())
	}

	_, err = client.UserTimeline(nil)

	if err != nil {
		t.Errorf("Test failed: %s\n", err.Error())
	}

	_, err = client.RetweetsOfMe(nil)

	if err != nil {
		t.Errorf("Test failed: %s\n", err.Error())
	}

	_, err = client.Retweets(int64(21947795900469248), nil)

	if err != nil {
		t.Errorf("Test failed: %s\n", err.Error())
	}

	var status *sugar.Map
	status, err = client.Update(fmt.Sprintf("Test message @ %s", time.Now()), nil)

	if err != nil {
		t.Errorf("Test failed: %s\n", err.Error())
	}

	tweetId := to.Int64(status.Get("id_str"))

	_, err = client.Destroy(tweetId, nil)

	if err != nil {
		t.Errorf("Test failed: %s\n", err.Error())
	}

	tweetId = to.Int64(status.Get("id_str"))

	files := []string{
		"_resources/test.jpg",
	}

	_, err = client.UpdateWithMedia("Hello", nil, files)

	if err != nil {
		t.Errorf("Test failed: %s\n", err.Error())
	}

	_, err = client.Retweet(int64(21947795900469248), nil)

	if err != nil {
		t.Errorf("Test failed: %s\n", err.Error())
	}

}
예제 #22
0
파일: battlenet.go 프로젝트: kdar/morphgen
// Get detailed codes from a character's armory page.
func wowarmory(options map[string]interface{}) (TMorphItems, error) {
	u, err := neturl.Parse(to.String(options["url"]))
	if err != nil {
		return nil, merry.Wrap(err)
	}

	parts := strings.Split(u.Path, "/")
	loc := -1
	for x := 0; x < len(parts); x++ {
		if parts[x] == "character" {
			loc = x + 1
			break
		}
	}

	if loc == -1 {
		return nil, errors.New("Could not parse battle.net URL")
	}

	// FIXME: this isn't exactly correct, because you can be in the US and want
	// to get the tmorph codes of a person in EU/China. So we need to probably
	// have settings to where the user of TMorphGen is.
	hostParts := strings.Split(u.Host, ".")
	if hostParts[0] == "cn" {
	} else if len(hostParts) == 2 {
		u.Host = "us.api." + strings.Join(hostParts, ".")
	} else {
		u.Host = hostParts[0] + ".api." + strings.Join(hostParts[1:], ".")
	}

	u.Scheme = "https"
	u.Path = fmt.Sprintf("/wow/character/%s/%s", parts[loc], parts[loc+1])
	u.RawQuery = "fields=items,appearance&locale=en_US"

	resp, err := apicall(u)
	if err != nil {
		return nil, merry.Wrap(err)
	}

	data, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, merry.Wrap(err)
	}
	resp.Body.Close()

	var tmorphItems TMorphItems
	var datam map[string]interface{}

	err = json.Unmarshal(data, &datam)
	if err != nil {
		return nil, merry.Wrap(err)
	}

	// get all armor, weapons, and enchants
	items := Map(datam["items"])
	for k, v := range items {
		if v, ok := v.(map[string]interface{}); ok {
			if canDisplayName(k) {
				id := to.Int64(v["id"])
				tooltipParams := Map(v["tooltipParams"])
				if !to.Bool(options["notmog"]) {
					transmogItem := tooltipParams["transmogItem"]
					if transmogItem != nil {
						id = to.Int64(transmogItem)
					}
				}

				tmorphItems = append(tmorphItems, &TMorphItem{
					Type: "item",
					Args: []int{nameSlotMap[k], int(id)},
				})

				// get enchants off the weapons
				if k == "mainHand" || k == "offHand" {
					if tooltipParams["enchant"] != nil {
						which := 1
						if k == "offHand" {
							which = 2
						}

						tmorphItems = append(tmorphItems, &TMorphItem{
							Type: "enchant",
							Args: []int{which, int(to.Int64(tooltipParams["enchant"]))},
						})
					}
				}
			}
		}
	}

	// set offhand to 0 if there is none.
	// TODO: maybe there should be defaults?
	if items["offHand"] == nil {
		tmorphItems = append(tmorphItems, &TMorphItem{
			Type: "item",
			Args: []int{nameSlotMap["offHand"], 0},
		})
	}

	// appearance stuff
	appearance := Map(datam["appearance"])
	for k, v := range appearance {
		if typ, ok := appearanceMap[k]; ok {
			tmorphItems = append(tmorphItems, &TMorphItem{
				Type: typ,
				Args: []int{int(to.Int64(v))},
			})
		}
	}
	tmorphItems = append(tmorphItems, &TMorphItem{
		Type: "race",
		Args: []int{int(to.Int64(datam["race"]))},
	}, &TMorphItem{
		Type: "gender",
		Args: []int{int(to.Int64(datam["gender"]))},
	})

	return tmorphItems, nil
}
예제 #23
0
파일: battlenet.go 프로젝트: kdar/morphgen
// Get the codes for the list of ids via the wow api.
func wowapi(ids []string) (TMorphItems, error) {
	var tmorphItems TMorphItems
	idslen := len(ids)
	errChan := make(chan error)
	doneChan := make(chan bool, idslen)

	for _, id := range ids {
		go func(id string) {
			defer func() {
				doneChan <- true
			}()

			contextUrl := ""

		REDO:
			// FIXME: using US api, ignoring user's location
			u, err := neturl.Parse("https://us.api.battle.net/wow/item/" + id + contextUrl)
			if err != nil {
				errChan <- err
				return
			}

			resp, err := apicall(u)
			if err != nil {
				errChan <- err
				return
			}

			data, err := ioutil.ReadAll(resp.Body)
			if err != nil {
				errChan <- err
				return
			}
			resp.Body.Close()

			var datam map[string]interface{}
			err = json.Unmarshal(data, &datam)
			if err != nil {
				errChan <- err
				return
			}

			if _, ok := datam["inventoryType"]; !ok {
				if contexts, ok := datam["availableContexts"]; ok {
					ctxs := contexts.([]interface{})
					contextUrl = "/" + ctxs[0].(string)
					goto REDO
				}
			}

			slot := int(to.Int64(datam["inventoryType"]))
			if v, ok := slotMap[slot]; ok {
				slot = v
			}
			if canDisplaySlot(slot) {
				tmorphItems = append(tmorphItems, &TMorphItem{
					Type: "item",
					Args: []int{slot, int(to.Int64(id))},
				})
			}
		}(id)
	}

	count := 0
	for count < idslen {
		select {
		case err := <-errChan:
			return nil, merry.Wrap(err)
		case <-doneChan:
			count++
			if count >= idslen {
				return tmorphItems, nil
			}
		}
	}

	return nil, nil
}