Golang Event.Payload方法代码示例

// cents retrieves the cents out of the payload of an event.
func payloadCents(event cells.Event) int {
	cents, ok := event.Payload().Get(cells.DefaultPayload)
	if !ok {
		return -1
	}
	return cents.(int)
}

// ProcessEvent reads, validates and emits a configuration.
func (b *configuratorBehavior) ProcessEvent(event cells.Event) error {
	switch event.Topic() {
	case ReadConfigurationTopic:
		// Read configuration
		filename, ok := event.Payload().GetString(ConfigurationFilenamePayload)
		if !ok {
			logger.Errorf("cannot read configuration without filename payload")
			return nil
		}
		logger.Infof("reading configuration from %q", filename)
		config, err := configuration.ReadFile(filename)
		if err != nil {
			return errors.Annotate(err, ErrCannotReadConfiguration, errorMessages)
		}
		// If wanted then validate it.
		if b.validate != nil {
			err = b.validate(config)
			if err != nil {
				return errors.Annotate(err, ErrCannotValidateConfiguration, errorMessages)
			}
		}
		// All done, emit it.
		pvs := cells.PayloadValues{
			ConfigurationPayload: config,
		}
		b.ctx.EmitNew(ConfigurationTopic, pvs, event.Scene())
	}
	return nil
}

// newEventData returns the passed event as event data to collect.
func newEventData(event cells.Event) EventData {
	data := EventData{
		Topic:   event.Topic(),
		Payload: event.Payload(),
	}
	return data
}

// ProcessEvent calls a callback functions with the event data.
func (b *callbackBehavior) ProcessEvent(event cells.Event) error {
	for _, callbackFunc := range b.callbackFuncs {
		if err := callbackFunc(event.Topic(), event.Payload()); err != nil {
			return err
		}
	}
	return nil
}

func (lu *logUser) ProcessEvent(event cells.Event) (err error) {
	// TODO: would be nice to have an event.Source()
	if event.Topic() == SAYS_ALL {
		user, _ := event.Payload().Get("from")
		msg, _ := event.Payload().Get("message")
		log.Infof("%s heard %v say \"%v\"", lu.name, user, msg)
	}
	return
}

// ProcessEvent stores and flags the event in the event scene.
// So other code parts using the same scene can wait for the signal.
func (b *sceneBehavior) ProcessEvent(event cells.Event) error {
	scn := event.Scene()
	if scn != nil {
		err := scn.StoreAndFlag(event.Topic(), event.Payload())
		if err != nil {
			return err
		}
	}
	return nil
}

func (c *censor) filter(event cells.Event) bool {
	message, _ := event.Payload().Get("message")
	user, _ := event.Payload().Get("from")
	for _, w := range strings.Split(message.(string), " ") {
		if _, ok := c.words[w]; ok {
			log.Infof("%s said a bad word: %s", user, w)
			c.warnings[user.(string)]++
			return false
		}
	}
	return true
}

// Configuration returns the configuration payload
// of the passed event or an empty configuration.
func Configuration(event cells.Event) configuration.Configuration {
	payload, ok := event.Payload().Get(ConfigurationPayload)
	if !ok {
		logger.Warningf("event does not contain configuration payload")
		config, _ := configuration.ReadString("{config}")
		return config
	}
	config, ok := payload.(configuration.Configuration)
	if !ok {
		logger.Warningf("configuration payload has illegal type")
		config, _ := configuration.ReadString("{config}")
		return config
	}
	return config
}

func (c *censor) ProcessEvent(event cells.Event) (err error) {
	switch event.Topic() {
	case CENSOR:
		ok := c.filter(event)
		userID, _ := event.Payload().Get("from")
		event.Respond(ok)

		if _, ok := c.warnings[userID.(string)]; !ok {
			c.warnings[userID.(string)] = 0
		}

		if !ok {
			return c.ctx.EmitNew(SAYS_TO, cells.PayloadValues{
				"message": fmt.Sprintf("You can't say that! You've been warned %d times.", c.warnings[userID.(string)]),
				"from":    c.id,
				"to":      userID.(string),
			}, nil)
		}
	}
	return
}

func (b *building) ProcessEvent(event cells.Event) (err error) {
	switch event.Topic() {
	case ROOM_ADDED:
		room, _ := event.Payload().Get("room")
		b.rooms[room.(string)] = true
		log.Infof("added %v", room)
	case LIST_ROOMS:
		rooms := []string{}
		for room := range b.rooms {
			rooms = append(rooms, room)
		}
		event.Respond(rooms)
	case SAYS_ALL:
		user, ok := event.Payload().Get("from")
		if !ok || user.(string) != PublicAddressUserID {
			return fmt.Errorf("invalid public address request")
		}
		b.ctx.Emit(event)
	}
	return
}

func (r *room) ProcessEvent(event cells.Event) (err error) {
	switch event.Topic() {
	case SAYS_ALL, SAYS_TO:
		user, _ := event.Payload().Get("from")
		switch user.(string) {
		case PublicAddressUserID, r.censorID:
			r.ctx.Emit(event)
		default:
			env := r.ctx.Environment()
			ok, err := env.Request(r.censorID, CENSOR, event.Payload(), nil, time.Second)

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

			if ok.(bool) {
				r.ctx.Emit(event)
			}
		}
	case IN_ROOM:
		userID, _ := event.Payload().Get("user")
		ok, _ := r.users[userID.(string)]
		event.Respond(ok)
	case USER_ADDED:
		userID, _ := event.Payload().Get("user")
		if ok, _ := r.users[userID.(string)]; !ok {
			r.users[userID.(string)] = true
			r.ctx.Environment().EmitNew(r.ctx.ID(), SAYS_ALL, cells.PayloadValues{
				"message": fmt.Sprintf("%s has entered the room", userID),
				"from":    PublicAddressUserID,
			}, nil)
		}
	case USER_COUNT:
		event.Respond(len(r.users))
	}
	return
}

func (wsb *webSocketBehavior) ProcessEvent(event cells.Event) (err error) {
	switch event.Topic() {
	case SAYS_TO:
		to, ok := event.Payload().Get("to")
		if !ok || to.(string) != makeUserID(wsb.user) {
			return
		}
		msg, err := json.Marshal(payloadToValues(event.Payload()))
		if err != nil {
			log.Fatal(err)
		}
		wsb.output <- msg
	case SAYS_ALL:
		msg, err := json.Marshal(payloadToValues(event.Payload()))
		if err != nil {
			log.Fatal(err)
		}
		wsb.output <- msg
	}
	return
}

func (b *emitBehavior) ProcessEvent(event cells.Event) error {
	return b.ctx.EmitNew(sleepTopic, event.Payload(), nil)
}