func locations(server *sift.Server) { // Get the locations from database siftDB, err := server.DB() checkErr(err) locs := []db.Location{} siftDB.Select(&locs, "SELECT * FROM location") // Print the prompt fmt.Printf("-- Locations --\n") for _, loc := range locs { fmt.Printf(" %v %v\n", loc.ID, loc.Name) } fmt.Printf("[enter R to refresh, A to add a location, an ID to edit, or blank to go back]\n") bio := bufio.NewReader(os.Stdin) lineByte, _, err := bio.ReadLine() checkErr(err) line := string(lineByte) switch { case line == "": topLevel(server) // return to top level case strings.HasPrefix(line, "r"), strings.HasPrefix(line, "R"): locations(server) // refresh by recalling the function case strings.HasPrefix(line, "a"), strings.HasPrefix(line, "A"): addLocation(server) default: // Try to parse the input as a number id, err := strconv.Atoi(string(line)) if err != nil { locations(server) } editLocation(server, int64(id)) } }
func editLocationName(server *sift.Server, id int64) { // Print the prompt fmt.Printf("-- Edit name for Location %v--\n", id) fmt.Printf("Name? (blank to go back):\n") bio := bufio.NewReader(os.Stdin) lineByte, _, err := bio.ReadLine() checkErr(err) line := string(lineByte) switch { case line == "": locations(server) // go back up to locations default: siftDB, err := server.DB() checkErr(err) res, err := siftDB.Exec("UPDATE location SET name=? WHERE id=?", line, id) checkErr(err) n, err := res.RowsAffected() checkErr(err) if n == 0 { fmt.Printf(">> no rows affected, try again?\n") } else { fmt.Printf(">> location %v is now named %v\n", id, line) } locations(server) } }
func editLocation(server *sift.Server, id int64) { // Print the prompt fmt.Printf("-- Edit Location %v --\n", id) fmt.Printf("[enter N to change name, D to delete, or blank to go back]\n") bio := bufio.NewReader(os.Stdin) lineByte, _, err := bio.ReadLine() checkErr(err) line := string(lineByte) switch { case line == "": locations(server) // go back up to locations case strings.HasPrefix(line, "d"), strings.HasPrefix(line, "D"): // perform delete siftDB, err := server.DB() checkErr(err) _, err = siftDB.Exec("DELETE FROM location WHERE id=?", id) checkErr(err) fmt.Printf(">> deleted location %v\n", id) locations(server) case strings.HasPrefix(line, "n"), strings.HasPrefix(line, "N"): // change the name editLocationName(server, id) default: // if unknown, repeat prompt editLocation(server, id) } }
// This SIFT app will randomly alter any detected lights func ghostInTheCircuits(server *sift.Server, minMS, maxMS int) { for { // Wait for a random amount of time <-time.After(randTime(minMS, maxMS)) // Get all lights connected to the system lightsQuery := ` SELECT c.name, c.device_id FROM component c JOIN device d ON c.device_id=d.id WHERE is_online=1 AND type=?` lights := []db.Component{} db, err := server.DB() if err != nil { color.Red("could not open DB: %v", err) } // run the query if err = db.Select(&lights, lightsQuery, types.LightEmitter{}.Type()); err != nil { color.Red("could not run query to get light ids: %v", err) } if len(lights) == 0 { color.Red("no lights found for the circuit ghosts to play with...") } else { // For each light found... for _, light := range lights { // ...assemble a component ID... lightID := types.ComponentID{ Name: light.Name, DeviceID: types.DeviceID(light.DeviceID), } // ...generate a random brightness value (0-100)... randBrightness := uint8(rand.Intn(100)) // ...then create and submit an intent newLightIntent := types.SetLightEmitterIntent{ BrightnessInPercent: randBrightness, } if err := server.EnactIntent(lightID, newLightIntent); err != nil { color.Red("could not enact intent: %v", err) } else { color.Blue("set light %v to %v", lightID, randBrightness) } } } } }
// main starts a sift server and listens for updates, printing any to console. func repeatUpdatesToConsole(server *sift.Server) { myToken := server.Login() updateChan := server.Listen(myToken) // without specifying filters, this will listen to everything fmt.Println("listening to SIFT server and printing updates to console...") for { update := <-updateChan //TODO: uncaught panic if updateChan is closed switch typed := update.(type) { case notif.ComponentNotification: color.Blue("component %+v %v: %+v\n", typed.ID, typed.Action, typed.Component) //case notif.DriverNotification: // fmt.Printf("driver %v: %v", typed.NotificationType, typed.Component) default: color.Red("unhandled update type from updateChan: %T (%v)\n", update, update) } } }
func editDeviceLocation(server *sift.Server, id int64) { // Get available locations from database siftDB, err := server.DB() checkErr(err) locs := []db.Location{} siftDB.Select(&locs, "SELECT * FROM location") // Print the prompt fmt.Printf("-- Set Location for Device %v --\n", id) fmt.Printf("Available Locations:\n") for _, loc := range locs { fmt.Printf(" %v %v\n", loc.ID, loc.Name) } fmt.Printf("[enter an ID to set Location, R to refresh Locations, or blank to go back]\n") bio := bufio.NewReader(os.Stdin) lineByte, _, err := bio.ReadLine() checkErr(err) line := string(lineByte) switch { case line == "": editDevice(server, id) // return to top level case strings.HasPrefix(line, "r"), strings.HasPrefix(line, "R"): editDeviceLocation(server, id) // refresh by recalling the function default: // Try to parse the input as a number locID, err := strconv.Atoi(string(line)) if err != nil { editDeviceLocation(server, id) } res, err := siftDB.Exec("UPDATE device SET location_id=? WHERE id=?", locID, id) checkErr(err) n, err := res.RowsAffected() checkErr(err) if n == 0 { fmt.Printf(">> no rows affected, try again?\n") } else { fmt.Printf(">> device %v is now in location %v\n", id, locID) } devices(server) } }
func addLocation(server *sift.Server) { // Print the prompt fmt.Printf("-- Add Location --\n") fmt.Printf("[Enter name (blank to go back)]:\n") bio := bufio.NewReader(os.Stdin) lineByte, _, err := bio.ReadLine() checkErr(err) line := string(lineByte) switch { case line == "": locations(server) // go back up to locations default: siftDB, err := server.DB() checkErr(err) res, err := siftDB.Exec("INSERT INTO location (name) VALUES (?)", line) checkErr(err) id, err := res.LastInsertId() checkErr(err) fmt.Printf(">> inserted %v as location %v\n", line, id) locations(server) } }
// This SIFT app will turn the lights down in any room with a running media // player. If there are no running media players, the lights will be set to // high. func moviesAndChill(server *sift.Server) { if server == nil { // sanity check return } token := server.Login() // authenticate with SIFT // SIFT apps can request notifications from SIFT to determine when they // should do something. For this app, we'll want to know when media players // change (e.g. if they are added or their states change), and when lights // change (e.g. if they are added, moved, or removed) mediaFilter := notif.ComponentFilter{Type: types.ComponentTypeMediaPlayer} lightsFilter := notif.ComponentFilter{Type: types.ComponentTypeLightEmitter} listener := server.Listen(token, lightsFilter, mediaFilter) // this starts listening for range listener { // Each time the listener receives a notification, this example will // recalculate the lighting values for each light. // (A better implementation might look at the updates and only // recalculate those that need to be recalculated) // Run a query against the SIFT sqlite database to find each available // light and the number of PLAYING media players in the same room. lightsQuery := ` SELECT c1.device_id, c1.name, num_playing_mpls_in_room FROM light_emitter_state l1 JOIN component c1 ON l1.id=c1.id JOIN device d1 ON c1.device_id=d1.id JOIN (SELECT d.location_id loc, SUM (CASE WHEN m.play_state="PLAYING" THEN 1 ELSE 0 END) as num_playing_mpls_in_room FROM media_player_state m JOIN component c ON m.id=c.id JOIN device d ON c.device_id=d.id GROUP BY d.location_id) ON d1.location_id=loc;` type result struct { DeviceID int64 `db:"device_id"` Name string NumPlayingMediaPlayersInRoom int `db:"num_playing_mpls_in_room"` } results := []result{} db, _ := server.DB() // run the query if err := db.Select(&results, lightsQuery); err != nil { panic(fmt.Sprintf("could not run query to get active media players: %v", err)) } // Check out the results and determine how each light should be set. In // SIFT, this is done using Intents. for _, result := range results { var intent types.SetLightEmitterIntent if result.NumPlayingMediaPlayersInRoom > 0 { // a movie is playing in the room ... intent.BrightnessInPercent = lightsLow // ...bring the lights down low } else { // no movies in this room... intent.BrightnessInPercent = lightsHigh // ...bring the lights up } target := types.ComponentID{ DeviceID: types.DeviceID(result.DeviceID), Name: result.Name, } // Send the intent to the SIFT server, which will make it real if err := server.EnactIntent(target, intent); err != nil { fmt.Printf("warning: could not enact intent: %v\n", err) } } } }