func DeleteMember(c common.WSContext) error { return c.Transact(func(c common.WSContext) error { decodedId, err := kol.DecodeId(c.Match()[1]) if err != nil { return err } game := &Game{Id: decodedId} if err := c.DB().Get(game); err != nil { return fmt.Errorf("Game not found: %v", err) } if game.State != common.GameStateCreated { return fmt.Errorf("%+v already started", game) } member := Member{} if _, err := c.DB().Query().Where(kol.And{kol.Equals{"GameId", decodedId}, kol.Equals{"UserId", kol.Id(c.Principal())}}).First(&member); err != nil { return err } if err := c.DB().Del(&member); err != nil { return err } left, err := game.Members(c.DB()) if err != nil { return err } if len(left) == 0 { if err := c.DB().Del(game); err != nil { return err } } return nil }) }
func SubscribeGame(c common.WSContext) error { base64DecodedId, err := base64.URLEncoding.DecodeString(c.Match()[1]) if err != nil { return err } s := c.Pack().New(c.Match()[0]) s.Call = func(i interface{}, op string) error { game := i.(*Game) members, err := game.Members(c.DB()) if err != nil { return err } member := members.Get(c.Principal()) isMember := member != nil if !game.Private || isMember { state, err := game.ToState(c.DB(), members, member) if err != nil { return err } return s.Send(state, op) } else if op == gosubs.FetchType { return s.Send(GameState{}, op) } return nil } return s.Subscribe(&Game{Id: base64DecodedId}) }
func CreateMessage(c common.WSContext) (err error) { // load the message provided by the client message := &Message{} c.Data().Overwrite(message) if message.RecipientIds == nil { message.RecipientIds = map[string]bool{} } message.Body = strings.TrimSpace(message.Body) if message.Body == "" { return } // and the game game := &Game{Id: message.GameId} if err := c.DB().Get(game); err != nil { return err } // and the member sender, err := game.Member(c.DB(), c.Principal()) if err != nil { return } return message.Send(c.Diet(), game, sender) }
func SetOrder(c common.WSContext) (result interface{}, err error) { var base64DecodedId []byte if base64DecodedId, err = base64.URLEncoding.DecodeString(c.Data().GetString("GameId")); err != nil { return } err = c.DB().Transact(func(d *kol.DB) (err error) { game := Game{Id: base64DecodedId} if err = d.Get(&game); err != nil { return } var member *Member if member, err = game.Member(d, c.Principal()); err != nil { return } var phase *Phase if _, phase, err = game.Phase(d, 0); err != nil { return } if phase == nil { err = fmt.Errorf("No phase for %+v found", game) return } nationOrders, found := phase.Orders[member.Nation] if !found { nationOrders = map[dip.Province][]string{} phase.Orders[member.Nation] = nationOrders } order := c.Data().GetStringSlice("Order") if len(order) == 1 { delete(nationOrders, dip.Province(order[0])) } else { var parsedOrder dip.Order parsedOrder, err = orders.Parse(order) if err != nil { return } var state *state.State state, err = phase.State() if err != nil { return } if err = parsedOrder.Validate(state); err != nil { return } nationOrders[dip.Province(order[0])] = order[1:] } if err = d.Set(phase); err != nil { return } return }) return }
func setPhaseCommitted(c common.WSContext, commit bool) (err error) { phaseId, err := base64.URLEncoding.DecodeString(c.Data().GetString("PhaseId")) if err != nil { return } return c.Transact(func(c common.WSContext) (err error) { phase := &Phase{Id: phaseId} if err = c.DB().Get(phase); err != nil { return } game, err := phase.Game(c.DB()) if err != nil { return } members, err := game.Members(c.DB()) if err != nil { return } member := members.Get(c.Principal()) if member == nil { err = fmt.Errorf("Not member of game") return } if member.NoOrders { c.Infof("%+v has no orders to give", member) err = fmt.Errorf("No orders to give") return } member.Committed = commit member.NoWait = false if err = c.DB().Set(member); err != nil { return } if !phase.Resolved { count := 0 for _, m := range members { if m.Committed || m.NoWait { count++ } } if count == len(members) { if err = game.resolve(c.Diet(), phase); err != nil { return } c.Infof("Resolved %v", game.Id) return } } err = c.DB().Set(phase) return }) }
func SeeMessage(c common.WSContext) (result interface{}, err error) { messageId, err := base64.URLEncoding.DecodeString(c.Data().GetString("MessageId")) if err != nil { err = fmt.Errorf("Error trying to decode %#v: %v", c.Data().GetString("MessageId"), err) return } err = c.Transact(func(c common.WSContext) (err error) { message := &Message{Id: messageId} if err = c.DB().Get(message); err != nil { return } game := &Game{Id: message.GameId} if err = c.DB().Get(game); err != nil { return } var member *Member if member, err = game.Member(c.DB(), c.Principal()); err != nil { return } if message.SeenBy == nil { message.SeenBy = map[string]bool{} } if !message.SeenBy[member.Id.String()] { message.SeenBy[member.Id.String()] = true if err = c.DB().Set(message); err != nil { return } } return }) return }
func subscribeOthers(c common.WSContext, filter kol.QFilter, preLimiter func(source Games) (result Games), postLimiter func(source GameStates) (result GameStates)) error { if c.Principal() == "" { return websocket.JSON.Send(c.Conn(), gosubs.Message{ Type: gosubs.FetchType, Object: &gosubs.Object{ URI: c.Match()[0], }, }) } s := c.Pack().New(c.Match()[0]) s.Query = s.DB().Query().Where(filter) s.Call = func(i interface{}, op string) error { games := i.([]*Game) if preLimiter != nil { games = ([]*Game)(preLimiter(Games(games))) } states := GameStates{} isMember := false me := &user.User{Id: kol.Id(c.Principal())} if err := c.DB().Get(me); err != nil { return err } for _, game := range games { if !game.Disallows(me) { members, err := game.Members(c.DB()) if err != nil { return err } if disallows, err := members.Disallows(c.DB(), me); err != nil { return err } else if !disallows { isMember = members.Contains(c.Principal()) if !isMember { state, err := game.ToState(c.DB(), members, nil) if err != nil { return err } states = append(states, state) } } } } if op == gosubs.FetchType || len(states) > 0 { if postLimiter != nil { states = postLimiter(states) } return s.Send(states, op) } return nil } return s.Subscribe(&Game{}) }
func SubscribeGamePhase(c common.WSContext) error { base64DecodedId, err := base64.URLEncoding.DecodeString(c.Match()[1]) if err != nil { return err } game := &Game{Id: base64DecodedId} if err = c.DB().Get(game); err != nil { return err } phaseOrdinal, err := strconv.Atoi(c.Match()[2]) if err != nil { return err } members, err := game.Members(c.DB()) if err != nil { return err } member := members.Get(c.Principal()) isMember := member != nil if !game.Private || isMember { state, err := game.ToStateWithPhaseOrdinal(c.DB(), members, member, phaseOrdinal) if err != nil { return err } return websocket.JSON.Send(c.Conn(), gosubs.Message{ Type: gosubs.FetchType, Object: &gosubs.Object{ URI: c.Match()[0], Data: state, }, }) } return nil }
func SubscribeMessages(c common.WSContext) (err error) { base64DecodedId, err := base64.URLEncoding.DecodeString(c.Match()[1]) if err != nil { return err } game := &Game{Id: base64DecodedId} if err = c.DB().Get(game); err != nil { return } variant, found := common.VariantMap[game.Variant] if !found { err = fmt.Errorf("Unknown variant for %+v", game) return } member, err := game.Member(c.DB(), c.Principal()) if err != nil && err != kol.NotFound { return } memberId := "" if member != nil { memberId = member.Id.String() } s := c.Pack().New(c.Match()[0]) s.Query = s.DB().Query().Where(kol.Equals{"GameId", base64DecodedId}) s.Call = func(i interface{}, op string) (err error) { messages := i.([]*Message) result := Messages{} for _, message := range messages { if len(message.RecipientIds) == len(variant.Nations) || message.RecipientIds[memberId] { result = append(result, *message) } } if op == gosubs.FetchType || len(result) > 0 { sort.Sort(result) return s.Send(result, op) } return } return s.Subscribe(&Message{}) }
func SubscribeMessages(c common.WSContext) (err error) { base64DecodedId, err := base64.URLEncoding.DecodeString(c.Match()[1]) if err != nil { return err } game := &Game{Id: base64DecodedId} if err = c.DB().Get(game); err != nil { return } member, err := game.Member(c.DB(), c.Principal()) if err != nil && err != kol.NotFound { return } memberId := "" if member != nil { memberId = member.Id.String() } s := c.Pack().New(c.Match()[0]) s.Query = s.DB().Query().Where(kol.Equals{"GameId", base64DecodedId}) s.Call = func(i interface{}, op string) (err error) { messages := i.([]*Message) result := Messages{} for _, message := range messages { if message.Public { game := &Game{Id: message.GameId} if err = c.DB().Get(game); err != nil { return } var members Members if members, err = game.Members(c.DB()); err != nil { return } message.RecipientIds = map[string]bool{} for _, memb := range members { message.RecipientIds[memb.Id.String()] = true } } if message.Public || message.RecipientIds[memberId] { result = append(result, *message) } } if op == gosubs.FetchType || len(result) > 0 { sort.Sort(result) return s.Send(result, op) } return } return s.Subscribe(&Message{}) }
func Create(c common.WSContext) error { var state GameState c.Data().Overwrite(&state) game := &Game{ Variant: state.Game.Variant, EndYear: state.Game.EndYear, Private: state.Game.Private, SecretEmail: state.Game.SecretEmail, SecretNickname: state.Game.SecretNickname, SecretNation: state.Game.SecretNation, Deadlines: state.Game.Deadlines, ChatFlags: state.Game.ChatFlags, AllocationMethod: state.Game.AllocationMethod, NonCommitConsequences: state.Game.NonCommitConsequences, NMRConsequences: state.Game.NMRConsequences, Ranking: state.Game.Ranking, } if _, found := common.VariantMap[game.Variant]; !found { return fmt.Errorf("Unknown variant for %+v", game) } if _, found := common.AllocationMethodMap[game.AllocationMethod]; !found { return fmt.Errorf("Unknown allocation method for %+v", game) } member := &Member{ UserId: kol.Id(c.Principal()), PreferredNations: state.Members[0].PreferredNations, } return c.Transact(func(c common.WSContext) error { if err := c.DB().Set(game); err != nil { return err } member.GameId = game.Id return c.DB().Set(member) }) }
func SubscribeMine(c common.WSContext) error { if c.Principal() == "" { return websocket.JSON.Send(c.Conn(), gosubs.Message{ Type: gosubs.FetchType, Object: &gosubs.Object{ URI: c.Match()[0], }, }) } s := c.Pack().New(c.Match()[0]) s.Query = s.DB().Query().Where(kol.Equals{"UserId", kol.Id(c.Principal())}) s.Call = func(i interface{}, op string) (err error) { members := i.([]*Member) var ep time.Duration ep, err = epoch.Get(c.DB()) if err != nil { return } states := GameStates{} for _, member := range members { if op == gosubs.DeleteType { states = append(states, GameState{ Game: &Game{Id: member.GameId}, Members: []MemberState{MemberState{Member: member}}, }) } else { game := &Game{Id: member.GameId} if err = s.DB().Get(game); err != nil { return } var gameMembers Members if gameMembers, err = game.Members(c.DB()); err != nil { return } var state GameState if state, err = game.ToState(c.DB(), gameMembers, member); err != nil { return } states = append(states, state) } } if op == gosubs.FetchType || len(states) > 0 { states = states.SortAndLimit(func(a, b GameState) bool { urgencyA := time.Hour * 24 * 365 urgencyB := time.Hour * 24 * 365 switch a.State { case common.GameStateStarted: _, phase, err := a.Game.Phase(c.DB(), 0) if err == nil { urgencyA = phase.Deadline - ep } case common.GameStateCreated: urgencyA -= 1 } switch b.State { case common.GameStateStarted: _, phase, err := b.Game.Phase(c.DB(), 0) if err == nil { urgencyB = phase.Deadline - ep } case common.GameStateCreated: urgencyB -= 1 } if urgencyA != urgencyB { return urgencyA < urgencyB } return a.CreatedAt.Before(b.CreatedAt) }, 1024*16) return s.Send(states, op) } return nil } return s.Subscribe(&Member{}) }
func AddMember(c common.WSContext) error { var state GameState c.Data().Overwrite(&state) return c.Transact(func(c common.WSContext) error { game := Game{Id: state.Game.Id} if err := c.DB().Get(&game); err != nil { return fmt.Errorf("Game not found") } if game.State != common.GameStateCreated { return fmt.Errorf("%+v already started") } variant, found := common.VariantMap[game.Variant] if !found { return fmt.Errorf("Unknown variant %v", game.Variant) } if alreadyMember, err := game.Member(c.DB(), c.Principal()); err != nil { return err } else if alreadyMember != nil { return fmt.Errorf("%+v is already member of %v", alreadyMember, game.Id) } me := &user.User{Id: kol.Id(c.Principal())} if err := c.DB().Get(me); err != nil { return err } if game.Disallows(me) { return fmt.Errorf("Is not allowed to join this game due to game settings") } already, err := game.Members(c.DB()) if err != nil { return err } if disallows, err := already.Disallows(c.DB(), me); err != nil { return err } else if disallows { return fmt.Errorf("Is not allowed to join this game due to blacklistings") } if len(already) < len(variant.Nations) { member := Member{ GameId: state.Game.Id, UserId: kol.Id(c.Principal()), PreferredNations: state.Members[0].PreferredNations, } if err := c.DB().Set(&member); err != nil { return err } if len(already) == len(variant.Nations)-1 { if err := game.start(c.Diet()); err != nil { return err } c.Infof("Started %v", game.Id) } } return nil }) }