public override Task Handle(HandlerContext <Command> context)
    {
        Roster      roster      = CompositionRoot.DocumentSession.Load <Roster>(context.Payload.RosterId);
        MatchResult matchResult = new(
            roster,
            context.Payload.Result.TeamScore,
            context.Payload.Result.OpponentScore,
            roster.BitsMatchId);

        Player[] players = CompositionRoot.DocumentSession.Load <Player>(roster.Players);

        MatchSerie[] matchSeries = context.Payload.Result.CreateMatchSeries();

        Dictionary <string, ResultForPlayerIndex.Result> resultsForPlayer =
            CompositionRoot.DocumentSession.Query <ResultForPlayerIndex.Result, ResultForPlayerIndex>()
            .Where(x => x.Season == roster.Season)
            .ToArray()
            .ToDictionary(x => x.PlayerId);

        matchResult.RegisterSeries(
            task => context.PublishMessage(task),
            matchSeries,
            context.Payload.Result.OpponentSeries,
            players,
            resultsForPlayer);
        CompositionRoot.EventStoreSession.Store(matchResult);

        return(Task.CompletedTask);
    }
    public override Task Handle(HandlerContext <Command> context)
    {
        int season = CompositionRoot.DocumentSession.LatestSeasonOrDefault(SystemTime.UtcNow.Year);

        Roster[] rosters = CompositionRoot.DocumentSession.Query <Roster, RosterSearchTerms>()
                           .Where(x => x.Season == season)
                           .ToArray();
        List <VerifyMatchTask> toVerify = new();

        foreach (Roster roster in rosters)
        {
            if (roster.BitsMatchId == 0)
            {
                continue;
            }

            if (roster.Date.ToUniversalTime() > SystemTime.UtcNow)
            {
                Logger.InfoFormat(
                    "Too early to verify {bitsMatchId}",
                    roster.BitsMatchId);
                continue;
            }

            if (roster.IsVerified && context.Payload.Force == false)
            {
                Logger.InfoFormat(
                    "Skipping {bitsMatchId} because it is already verified",
                    roster.BitsMatchId);
            }
            else
            {
                VerifyMatchTask verifyTask = new(
                    roster.BitsMatchId,
                    roster.Id !,
                    context.Payload.Force);
                toVerify.Add(verifyTask);
            }
        }

        foreach (VerifyMatchTask verifyMatchMessage in toVerify)
        {
            Logger.InfoFormat(
                "Scheduling verification of {bitsMatchId}",
                verifyMatchMessage.BitsMatchId);
            context.PublishMessage(verifyMatchMessage);
        }

        return(Task.CompletedTask);
    }
Exemplo n.º 3
0
    public override Task Handle(HandlerContext <Command> context)
    {
        SendEmailTask task = SendEmailTask.Create(
            context.Payload.Recipient,
            context.Payload.ReplyTo,
            context.Payload.Subject,
            context.Payload.Content,
            context.Payload.Rate,
            context.Payload.PerSeconds,
            context.Payload.Key);

        context.PublishMessage(task);
        return(Task.CompletedTask);
    }
    public override Task Handle(HandlerContext <Command> context)
    {
        Roster       roster      = CompositionRoot.DocumentSession.Load <Roster>(context.Payload.RosterId);
        MatchResult4 matchResult = new(
            roster,
            context.Payload.Result.TeamScore,
            context.Payload.Result.OpponentScore,
            roster.BitsMatchId);

        Player[] players = CompositionRoot.DocumentSession.Load <Player>(roster.Players);

        MatchSerie4[] matchSeries = context.Payload.Result.CreateMatchSeries();
        matchResult.RegisterSeries(
            task => context.PublishMessage(task),
            matchSeries,
            players,
            context.Payload.SummaryText ?? string.Empty,
            context.Payload.SummaryHtml ?? string.Empty);
        CompositionRoot.EventStoreSession.Store(matchResult);

        return(Task.CompletedTask);
    }
    public override Task Handle(HandlerContext <Command> context)
    {
        IndexCreator.CreateIndexes(CompositionRoot.DocumentStore);
        User admin = CompositionRoot.DocumentSession.Load <User>(User.AdminId);

        if (admin == null)
        {
            admin = new("", "", context.Payload.Email, context.Payload.Password)
            {
                Id = User.AdminId
            };
            admin.Initialize(t => context.PublishMessage(t));
            admin.Activate();
            CompositionRoot.DocumentSession.Store(admin);
        }
        else
        {
            admin.SetEmail(context.Payload.Email);
            admin.SetPassword(context.Payload.Password);
            admin.Activate();
        }

        return(Task.CompletedTask);
    }
Exemplo n.º 6
0
    public override async Task Handle(HandlerContext <Command> context)
    {
        IQueryable <string> query =
            from rosterMail in CompositionRoot.Databases.Snittlistan.RosterMails
            where rosterMail.RosterKey == context.Payload.RosterKey &&
            rosterMail.PublishedDate == null
            select rosterMail.RosterKey;

        string[] rosterIds = await query.ToArrayAsync();

        Logger.InfoFormat("roster mails found: {@rosterIds}", rosterIds);
        if (rosterIds.Any() == false)
        {
            TenantFeatures features = await CompositionRoot.GetFeatures();

            _ = CompositionRoot.Databases.Snittlistan.RosterMails.Add(
                new(context.Payload.RosterKey));
            PublishRosterMailsTask task = new(
                context.Payload.RosterKey,
                context.Payload.RosterLink,
                context.Payload.UserProfileLink);
            context.PublishMessage(task, DateTime.Now.AddMinutes(features.RosterMailDelayMinutes));
        }
    }
    public override async Task Handle(HandlerContext <Command> context)
    {
        // TODO might be comma-separated values
        Roster        roster        = CompositionRoot.DocumentSession.LoadEx <Roster>(context.Payload.RosterKey);
        AuditLogEntry auditLogEntry =
            roster.AuditLogEntries.Single(x => x.CorrelationId == context.CorrelationId);
        RosterState      before          = (RosterState)auditLogEntry.Before;
        RosterState      after           = (RosterState)auditLogEntry.After;
        HashSet <string> affectedPlayers = new(before.Players.Concat(after.Players));

        // find user who did the last edit-players action
        AuditLogEntry?editPlayersAction = roster.AuditLogEntries.LastOrDefault(
            x => x.Action == Roster.ChangeType.EditPlayers.ToString());

        if (editPlayersAction == null)
        {
            throw new Exception($"No edit-players action found in roster {roster.Id}");
        }

        Dictionary <string, Player> playersDict =
            CompositionRoot.DocumentSession.Load <Player>(affectedPlayers)
            .ToDictionary(x => x.Id);
        Player?editPlayer   = CompositionRoot.DocumentSession.Load <Player>(editPlayersAction.UserId);
        User?  editUser     = CompositionRoot.DocumentSession.FindUserByEmail(editPlayersAction.UserId);
        string replyToEmail =
            editPlayer?.Email
            ?? editUser?.Email
            ?? throw new Exception($"Unable to find edit-players action user with id '{editPlayersAction.UserId}'");

        if (editPlayer is not null)
        {
            _ = affectedPlayers.Add(editPlayer.Id);
            playersDict[editPlayer.Id] = editPlayer;
        }

        // only send to players that have accepted email, or have not yet decided
        string[] propertyKeys = affectedPlayers.Select(UserSettings.GetKey).ToArray();
        Dictionary <string, UserSettings> properties =
            Enumerable.ToDictionary(
                await context.Databases.Snittlistan.KeyValueProperties.Where(
                    x => propertyKeys.Contains(x.Key))
                .ToArrayAsync(),
                x => x.Key,
                x => (UserSettings)x.Value);

        foreach (string playerId in affectedPlayers)
        {
            Player player = playersDict[playerId];
            do
            {
                if (properties.TryGetValue(
                        UserSettings.GetKey(playerId),
                        out UserSettings? settings))
                {
                    Logger.InfoFormat(
                        "found user settings for {playerId} {@settings}",
                        playerId,
                        settings);
                }
                else
                {
                    Logger.InfoFormat(
                        "no user settings found for {playerId}",
                        playerId);
                }

                if (string.IsNullOrEmpty(player.Email))
                {
                    Logger.InfoFormat("no email set for player {playerId}", playerId);
                    break;
                }

                if ((settings?.RosterMailEnabled ?? true) == false)
                {
                    Logger.InfoFormat("roster mail disabled for player {playerId}", playerId);
                    break;
                }

                PublishRosterMailTask message = new(
                    context.Payload.RosterKey,
                    player.Id,
                    player.Email,
                    player.Nickname ?? player.Name,
                    replyToEmail,
                    context.Payload.RosterLink,
                    context.Payload.UserProfileLink);
                context.PublishMessage(message);
            }while (false);
        }

        RosterMail rosterMail =
            await context.Databases.Snittlistan.RosterMails.SingleAsync(
                x => x.RosterKey == context.Payload.RosterKey && x.PublishedDate == null);

        rosterMail.MarkPublished(DateTime.Now);
    }
Exemplo n.º 8
0
    public override async Task Handle(HandlerContext <Command> context)
    {
        Roster roster = CompositionRoot.DocumentSession.Load <Roster>(context.Payload.RosterId);

        if (roster.IsVerified && context.Payload.Force == false)
        {
            return;
        }

        WebsiteConfig websiteConfig = CompositionRoot.DocumentSession.Load <WebsiteConfig>(WebsiteConfig.GlobalId);
        HeadInfo      result        = await CompositionRoot.BitsClient.GetHeadInfo(roster.BitsMatchId);

        ParseHeaderResult header = BitsParser.ParseHeader(result, websiteConfig.ClubId);

        // chance to update roster values
        Roster.Update update = new(
            Roster.ChangeType.VerifyMatchMessage,
            "system")
        {
            OilPattern = header.OilPattern,
            Date       = header.Date,
            Opponent   = header.Opponent,
            Location   = header.Location
        };
        if (roster.MatchResultId != null)
        {
            // update match result values
            BitsMatchResult bitsMatchResult = await CompositionRoot.BitsClient.GetBitsMatchResult(roster.BitsMatchId);

            Player[] players = CompositionRoot.DocumentSession.Query <Player, PlayerSearch>()
                               .ToArray()
                               .Where(x => x.PlayerItem?.LicNbr != null)
                               .ToArray();
            BitsParser parser = new(players);
            if (roster.IsFourPlayer)
            {
                MatchResult4?matchResult = CompositionRoot.EventStoreSession.Load <MatchResult4>(roster.MatchResultId);
                Parse4Result?parseResult = parser.Parse4(bitsMatchResult, websiteConfig.ClubId);
                update.Players = parseResult !.GetPlayerIds();
                bool isVerified = matchResult !.Update(
                    t => context.PublishMessage(t),
                    roster,
                    parseResult.TeamScore,
                    parseResult.OpponentScore,
                    roster.BitsMatchId,
                    parseResult.CreateMatchSeries(),
                    players);
                update.IsVerified = isVerified;
            }
            else
            {
                MatchResult?matchResult =
                    CompositionRoot.EventStoreSession.Load <MatchResult>(roster.MatchResultId);
                ParseResult?parseResult = parser.Parse(bitsMatchResult, websiteConfig.ClubId);
                update.Players = parseResult !.GetPlayerIds();
                Dictionary <string, ResultForPlayerIndex.Result> resultsForPlayer =
                    CompositionRoot.DocumentSession.Query <ResultForPlayerIndex.Result, ResultForPlayerIndex>()
                    .Where(x => x.Season == roster.Season)
                    .ToArray()
                    .ToDictionary(x => x.PlayerId);
                MatchSerie[] matchSeries = parseResult.CreateMatchSeries();
                bool         isVerified  = matchResult !.Update(
                    t => context.PublishMessage(t),
                    roster,
                    parseResult.TeamScore,
                    parseResult.OpponentScore,
                    matchSeries,
                    parseResult.OpponentSeries,
                    players,
                    resultsForPlayer);
                update.IsVerified = isVerified;
            }
        }

        _ = roster.UpdateWith(context.CorrelationId, update);
    }