ailistener-old

server.go (4887B)

---

 package wsListener
 
 import (
 	"fmt"
 	df "github.com/OpenHomeAuto/dialogflow-go-webhook"
 	"github.com/bjarneh/latinx"
 	"github.com/gorilla/mux"
 	"github.com/pquerna/ffjson/ffjson"
 	"io/ioutil"
 	"log"
 	"net/http"
 	"time"
 )
 
 func Main() {
 	r := mux.NewRouter()
 	r.HandleFunc("/", HomeHandler).Methods("GET")
 	r.HandleFunc("/dialogflow", DFHandler).Methods("POST")
 	http.ListenAndServe(":400", r)
 }
 
 func HomeHandler(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprintf(w, "Home")
 }
 
 func DFHandler(w http.ResponseWriter, r *http.Request) {
 	start := time.Now()
 
 	dfr := &df.Request{}
 
 	if r.Body == nil {
 		http.Error(w, "Please send a request body", http.StatusNotAcceptable)
 		log.Println("[WSERROR] request body missing")
 		return
 	}
 	defer r.Body.Close()
 	body, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		log.Println("[WSERROR] failed to convert to byte: " + err.Error())
 		return
 	}
 	err = dfr.UnmarshalJSON(body)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		log.Println("[WSERROR] failed to UnmarshalJSON: " + err.Error())
 		return
 	}
 
 	switch dfr.QueryResult.Action {
 	case "play_music":
 		dff := playMusicDispatch(dfr, w)
 		if dff == nil {
 			log.Println("[WSERROR] empty dff at play_music ")
 			return
 		}
 
 		// fetch converter for desired charset
 		converter := latinx.Get(latinx.ISO_8859_1)
 
 		// encode a UTF-8 stream as ISO_8859_1
 		dffb, err := ffjson.Marshal(dff)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			log.Println("[WSERROR] failed to marshal json: " + err.Error())
 			return
 		}
 		latin1resp, _, err := converter.Encode(dffb)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			log.Println("[WSERROR] failed to convert json to latin1: " + err.Error())
 			return
 		}
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 		w.Write(latin1resp)
 		elapsed := time.Since(start)
 		log.Printf("Took %s", elapsed)
 		return
 	default:
 		w.WriteHeader(http.StatusNotImplemented)
 		log.Println("[WSINFO] default resp")
 		elapsed := time.Since(start)
 		log.Printf("Took %s", elapsed)
 		return
 	}
 
 }
 
 func playMusicDispatch(dfr *df.Request, w http.ResponseWriter) *df.Fulfillment {
 	start := time.Now()
 	type MusicParams struct {
 		Artist string `json:"music-artist"`
 		Room   string `json:"room"`
 		Genre  string `json:"MusikGenre"`
 		Title  string `json:"title"`
 	}
 
 	var p MusicParams
 	var resp *df.Fulfillment
 
 	// Retrieve the params of the request
 	if err := dfr.GetParams(&p); err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		log.Println("[WSERROR] failed to get parmas: " + err.Error())
 		return nil
 	}
 	log.Printf("REQUEST: %+v\n", dfr.QueryResult)
 	log.Printf("PARAMS: %+v\n", p)
 
 	if p.Artist != "" {
 		// Send back a fulfillment
 		resp = &df.Fulfillment{
 			FulfillmentMessages: df.Messages{
 				df.ForGoogle(df.SingleSimpleResponse("Musik wird gestartet!", "Musik wird gestartet!")),
 				df.ForGoogle(
 					&df.BasicCard{
 						Title:         fmt.Sprintf("Musik von %s", p.Artist),
 						Subtitle:      "Künstler",
 						FormattedText: "Musik wird gestartet...",
 						Image:         nil,
 						Buttons:       nil,
 					},
 				),
 				{RichMessage: df.Text{Text: []string{"Musik wird gestartet!"}}},
 			},
 		}
 	} else if p.Genre != "" {
 		// Send back a fulfillment
 		resp = &df.Fulfillment{
 			FulfillmentMessages: df.Messages{
 				df.ForGoogle(df.SingleSimpleResponse("Musik wird gestartet!", "Musik wird gestartet!")),
 				df.ForGoogle(
 					&df.BasicCard{
 						Title:         fmt.Sprintf("%s", p.Genre),
 						Subtitle:      "Genre",
 						FormattedText: "Musik wird gestartet...",
 						Image:         nil,
 						Buttons:       nil,
 					},
 				),
 				{RichMessage: df.Text{Text: []string{"Musik wird gestartet!"}}},
 			},
 		}
 	} else if p.Title != "" {
 		// Send back a fulfillment
 		resp = &df.Fulfillment{
 			FulfillmentMessages: df.Messages{
 				df.ForGoogle(df.SingleSimpleResponse(fmt.Sprintf("%s wird gestartet...", p.Title), fmt.Sprintf("%s wird gestartet", p.Title))),
 				df.ForGoogle(
 					&df.BasicCard{
 						Title:         fmt.Sprintf("%s", p.Title),
 						Subtitle:      "Song",
 						FormattedText: fmt.Sprintf("%s wird gestartet...", p.Title),
 						Image:         nil,
 						Buttons:       nil,
 					},
 				),
 				{RichMessage: df.Text{Text: []string{fmt.Sprintf("%s wird gestartet...", p.Title)}}},
 			},
 		}
 	} else {
 		// Send back a fulfillment
 		resp = &df.Fulfillment{
 			FulfillmentMessages: df.Messages{
 				df.ForGoogle(df.SingleSimpleResponse("Musik wird gestartet!", "Musik wird gestartet!")),
 				{RichMessage: df.Text{Text: []string{"Musik wird gestartet!"}}},
 			},
 		}
 	}
 	elapsed := time.Since(start)
 	log.Printf("playMusicDispatch Took %s", elapsed)
 
 	return resp
 }