Golang Message.Text方法代码示例

func (r *MessageSchema) Apply(vars []*Var) sarif.Message {
	msg := sarif.Message{}
	msg.Action = r.Action
	pl := make(map[string]string)
	sort.Sort(sort.Reverse(byWeight(vars)))

	for _, v := range vars {
		switch v.Name {
		case "_action":
			msg.Action = v.Value
		case "text":
			msg.Text = v.Value
		case "to":
			fallthrough
		case "that":
			if msg.Text == "" {
				msg.Text = v.Value
			}
		default:
			if _, ok := r.Fields[v.Name]; ok {
				pl[v.Name] = v.Value
			}
		}
	}
	if len(vars) > 0 {
		msg.EncodePayload(&pl)
	}
	return msg
}

func (s *Service) handleEventLast(msg sarif.Message) {
	filter := make(map[string]interface{})
	if err := msg.DecodePayload(&filter); err != nil {
		s.ReplyBadRequest(msg, err)
		return
	}

	s.Log("debug", "get last by filter:", filter)
	var events []Event
	err := s.Store.Scan("events", store.Scan{
		Reverse: true,
		Only:    "values",
		Filter:  filter,
		Limit:   1,
	}, &events)
	if err != nil {
		s.ReplyInternalError(msg, err)
	}
	if len(events) == 0 {
		s.Reply(msg, MessageEventNotFound)
		return
	}
	s.Log("debug", "last - found", events)

	reply := sarif.Message{Action: "event/found"}
	if err := reply.EncodePayload(events[0]); err != nil {
		s.ReplyInternalError(msg, err)
		return
	}
	reply.Text = events[0].String()

	s.Reply(msg, reply)
}

func (app *App) Up() {
	if flag.NArg() <= 1 {
		app.Log.Fatal("Please specify an action to send to.")
	}
	action := flag.Arg(1)

	in, err := ioutil.ReadAll(os.Stdin)
	if err != nil {
		app.Log.Fatal(err)
	}

	msg := sarif.Message{
		Action: action,
	}

	pl := ContentPayload{
		Content: content.PutData(in),
	}
	if strings.HasPrefix(pl.Content.Type, "text/") {
		msg.Text = string(in)
	}
	if err := msg.EncodePayload(pl); err != nil {
		app.Log.Fatal(err)
	}

	msg, ok := <-app.Client.Request(msg)
	if !ok {
		app.Log.Fatal("No reply received.")
	}
	fmt.Println(strings.TrimSpace(msg.Text))
}

func (r *SentenceRule) Parse(s string) (sarif.Message, bool) {
	msg := sarif.Message{}
	match := r.Regexp.FindStringSubmatch(s)
	if match == nil {
		return msg, false
	}

	msg.Action = r.Action
	p := make(map[string]string)
	for i, field := range r.Regexp.SubexpNames() {
		if field == "" {
			continue
		}
		v := TrimQuotes(match[i])
		if field == "text" {
			msg.Text = strings.TrimSpace(msg.Text + " " + v)
			continue
		}
		if field == "_action" {
			msg.Action = strings.TrimSpace(msg.Action + "/" + v)
			continue
		}
		p[field] = v
	}
	if len(p) > 0 {
		msg.EncodePayload(p)
	}
	return msg, true
}

func FormatMessage(msg *sarif.Message) {
	if msg.Text == "" {
		return
	}

	msg.Text = reTimeIso.ReplaceAllStringFunc(msg.Text, formatTime)
}

func (s *Service) AnnotateReply(msg sarif.Message) sarif.Message {
	mu := sync.Mutex{}
	fin := make(chan bool)
	go func() {
		for name, a := range s.Cfg.Annotators {
			if a.Enabled && (time.Now().Sub(a.LastSeen) < s.ParserKeepAlive) {
				reply, ok := <-s.Request(sarif.Message{
					Action:      "natural/annotate/" + msg.Action,
					Destination: name,
					Text:        msg.Text,
					Payload:     msg.Payload,
				})
				if !ok || reply.IsAction("err") {
					continue
				}
				mu.Lock()
				if reply.Text != "" {
					msg.Text = reply.Text
				}
				if len(reply.Payload.Raw) > 0 {
					msg.Payload = reply.Payload
				}
				mu.Unlock()
			}
		}
		fin <- true
	}()

	select {
	case <-fin:
	case <-time.After(time.Second):
	}
	mu.Lock()
	defer mu.Unlock()

	natural.FormatMessage(&msg)
	msg.Text = s.TransformReply(msg.Text)
	return msg
}

func tableToMessage(L *lua.LState, t *lua.LTable) sarif.Message {
	msg := sarif.Message{}
	msg.Version = tableGetString(t, "sarif")
	msg.Id = tableGetString(t, "id")
	msg.Action = tableGetString(t, "action")
	msg.Source = tableGetString(t, "src")
	msg.Destination = tableGetString(t, "dest")
	msg.CorrId = tableGetString(t, "corr")
	msg.Text = tableGetString(t, "text")

	p := luareflect.DecodeToBasic(t.RawGetH(lua.LString("p")))
	msg.EncodePayload(p)
	return msg
}

func (s *Service) handleEventNew(msg sarif.Message) {
	isTargeted := msg.IsAction("event/new")

	var e Event
	e.Text = msg.Text
	e.Time = time.Now()
	e.Value = 1
	if s, v, ok := parseDataFromAction(msg.Action, "event/new"); ok {
		e.Action, e.Value = s, v
	}
	if err := msg.DecodePayload(&e); err != nil && isTargeted {
		s.ReplyBadRequest(msg, err)
		return
	}

	if err := msg.DecodePayload(&e.Meta); err != nil {
		s.ReplyBadRequest(msg, err)
		return
	}
	if e.Time.IsZero() {
		e.Time = time.Now()
	}

	if _, err := s.Store.Put(e.Key(), &e); err != nil {
		s.Log("err/internal", "could not store finished task: "+err.Error())
		return
	}

	if isTargeted {
		reply := sarif.Message{Action: "event/created"}
		if err := reply.EncodePayload(e); err != nil {
			s.ReplyInternalError(msg, err)
			return
		}
		reply.Text = "New event: " + e.String()
		s.Reply(msg, reply)
	}
}

func (s *Service) handleGeofenceCreate(msg sarif.Message) {
	var g Geofence
	if err := msg.DecodePayload(&g); err != nil {
		s.ReplyBadRequest(msg, err)
		return
	}

	if g.Address != "" {
		geo, err := Geocode(g.Address)
		if err != nil {
			s.ReplyBadRequest(msg, err)
			return
		}
		if len(geo) == 0 {
			s.Publish(msg.Reply(MsgAddressNotFound))
			return
		}
		g.BoundingBox = BoundingBox(geo[0].BoundingBox)
	}
	if g.Name == "" {
		g.Name = sarif.GenerateId()
	}
	g.GeohashMin = EncodeGeohash(g.BoundingBox.LatMin, g.BoundingBox.LngMin, 12)
	g.GeohashMax = EncodeGeohash(g.BoundingBox.LatMax, g.BoundingBox.LngMax, 12)

	if _, err := s.Store.Put(g.Key(), &g); err != nil {
		s.ReplyInternalError(msg, err)
	}

	reply := sarif.Message{Action: "location/fence/created"}
	if err := reply.EncodePayload(g); err != nil {
		s.ReplyInternalError(msg, err)
		return
	}
	reply.Text = "Geofence '" + g.Name + "' created."
	s.Publish(reply)
}

func (s *Server) handleRestPublish(w http.ResponseWriter, req *http.Request) {
	defer req.Body.Close()
	s.Client.Log("debug", "new REST request: "+req.URL.Path)

	// Parse form values.
	if err := req.ParseForm(); err != nil {
		s.Client.Log("warn", "REST bad request: "+err.Error())
		w.WriteHeader(400)
		fmt.Fprintln(w, "Bad request:", err)
		return
	}

	// Check authentication.
	name := s.checkAuthentication(req)
	if name == "" {
		w.WriteHeader(401)
		fmt.Fprintln(w, "Not authorized")
		s.Client.Log("info", "authentication failed for "+req.RemoteAddr)
		return
	}
	s.Client.Log("info", "authenticated "+req.RemoteAddr+" for "+name)
	client := s.getApiClientByName(name)

	// Create message from form values.
	msg := sarif.Message{
		Id:     sarif.GenerateId(),
		Source: name,
	}
	if strings.HasPrefix(req.URL.Path, REST_URL) {
		msg.Action = strings.TrimPrefix(req.URL.Path, REST_URL)
	}
	pl := make(map[string]interface{})
	for k, v := range req.Form {
		if k == "authtoken" {
			continue
		}
		if k == "_device" {
			msg.Destination = v[0]
		} else if k == "text" {
			msg.Text = strings.Join(v, "\n")
		} else if len(v) == 1 {
			pl[k] = parseValue(v[0])
		} else if k == "_device" {
			pl[k] = v
		}
	}
	_ = msg.EncodePayload(pl)

	if !s.clientIsAllowed(name, msg) {
		w.WriteHeader(401)
		fmt.Fprintf(w, "'%s' is not authorized to publish '%s'", name, msg.Action)
		s.Client.Log("warn", "REST '"+name+"' is not authorized to publish on "+msg.Action)
		return
	}

	// Publish message.
	if err := client.Publish(msg); err != nil {
		s.Client.Log("warn", "REST bad request: "+err.Error())
		w.WriteHeader(400)
		fmt.Fprintln(w, "Bad Request:", err)
		return
	}
	w.Write([]byte(msg.Id))
}

func ParseSimple(text string) (sarif.Message, bool) {
	msg := sarif.Message{}

	// Raw JSON message
	if strings.HasPrefix(text, "{") {
		if err := json.Unmarshal([]byte(text), &msg); err == nil {
			return msg, true
		}
	}

	if strings.HasPrefix(text, "sarif://") {
		if msg, err := sarif.ConvertURL(text); err == nil {
			return msg, true
		}
	}

	if strings.HasPrefix(text, ".") || strings.HasPrefix(text, "/") {
		text = strings.TrimLeft(text, "./ ")
		parts, _ := SplitQuoted(text, " ")
		if parts[0] == "" {
			return msg, false
		}
		msg.Action = parts[0]

		msg.Text = ""
		payload := make(map[string]interface{}, 0)
		for _, part := range parts[1:] {
			keyval, _ := SplitQuoted(part, "=")
			if len(keyval) == 1 {
				if msg.Text != "" {
					msg.Text += " "
				}
				msg.Text += TrimQuotes(keyval[0])
				continue
			}

			k := TrimQuotes(keyval[0])
			vtext := strings.Join(keyval[1:], "=")
			quoted := strings.ContainsAny(vtext, "\"`")
			vtext = TrimQuotes(vtext)
			var v interface{} = vtext
			if !quoted {
				v = ParseValue(vtext)
			}
			switch k {
			case "text":
				msg.Text = vtext
			case "device":
				fallthrough
			case "destination":
				msg.Destination = vtext
			default:
				payload[k] = v
			}
		}
		if len(payload) > 0 {
			msg.EncodePayload(payload)
		}
		return msg, true
	}

	return msg, false
}