Beispiel #1
0
#pragma warning disable CS0612 // Type or member is obsolete
        internal ModerationActionModel(MixItUp.Base.Actions.ModerationAction action)
            : base(ActionTypeEnum.Moderation)
        {
            if (action.ModerationType != Base.Actions.ModerationActionTypeEnum.VIPUser && action.ModerationType != Base.Actions.ModerationActionTypeEnum.UnVIPUser)
            {
                switch (action.ModerationType)
                {
                case Base.Actions.ModerationActionTypeEnum.ChatTimeout: this.ActionType = ModerationActionTypeEnum.TimeoutUser; break;

                case Base.Actions.ModerationActionTypeEnum.PurgeUser: this.ActionType = ModerationActionTypeEnum.PurgeUser; break;

                case Base.Actions.ModerationActionTypeEnum.ClearChat: this.ActionType = ModerationActionTypeEnum.ClearChat; break;

                case Base.Actions.ModerationActionTypeEnum.BanUser: this.ActionType = ModerationActionTypeEnum.BanUser; break;

                case Base.Actions.ModerationActionTypeEnum.UnbanUser: this.ActionType = ModerationActionTypeEnum.UnbanUser; break;

                case Base.Actions.ModerationActionTypeEnum.ModUser: this.ActionType = ModerationActionTypeEnum.ModUser; break;

                case Base.Actions.ModerationActionTypeEnum.UnmodUser: this.ActionType = ModerationActionTypeEnum.UnmodUser; break;

                case Base.Actions.ModerationActionTypeEnum.AddModerationStrike: this.ActionType = ModerationActionTypeEnum.AddModerationStrike; break;

                case Base.Actions.ModerationActionTypeEnum.RemoveModerationStrike: this.ActionType = ModerationActionTypeEnum.RemoveModerationStrike; break;
                }
                this.TargetUsername   = action.UserName;
                this.TimeoutAmount    = action.TimeAmount;
                this.ModerationReason = action.ModerationReason;
            }
        }
Beispiel #2
0
 internal TwitchActionModel(MixItUp.Base.Actions.ModerationAction action)
     : base(ActionTypeEnum.Twitch)
 {
     if (action.ModerationType == Base.Actions.ModerationActionTypeEnum.VIPUser)
     {
         this.ActionType = TwitchActionType.VIPUser;
         this.Username   = action.UserName;
     }
     else if (action.ModerationType == Base.Actions.ModerationActionTypeEnum.UnVIPUser)
     {
         this.ActionType = TwitchActionType.UnVIPUser;
         this.Username   = action.UserName;
     }
 }
#pragma warning disable CS0612 // Type or member is obsolete
        internal static IEnumerable <ActionModelBase> UpgradeAction(Base.Actions.ActionBase action)
        {
            List <ActionModelBase> actions = new List <ActionModelBase>();

            switch (action.Type)
            {
            case Base.Actions.ActionTypeEnum.Chat:
                actions.Add(new ChatActionModel((MixItUp.Base.Actions.ChatAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Clips:
                actions.Add(new TwitchActionModel((MixItUp.Base.Actions.ClipsAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Command:
                actions.Add(new CommandActionModel((MixItUp.Base.Actions.CommandAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Conditional:
                MixItUp.Base.Actions.ConditionalAction conAction = (MixItUp.Base.Actions.ConditionalAction)action;
                ActionModelBase subAction = null;
                if (conAction.CommandID != Guid.Empty)
                {
                    CommandActionModel cmdAction = new CommandActionModel(CommandActionTypeEnum.RunCommand, null);
                    cmdAction.CommandID = conAction.CommandID;
                    subAction           = cmdAction;
                }
                else
                {
                    IEnumerable <ActionModelBase> subActions = ActionModelBase.UpgradeAction(conAction.Action);
                    if (subActions != null && subActions.Count() > 0)
                    {
                        subAction = subActions.ElementAt(0);
                    }
                }
                actions.Add(new ConditionalActionModel(conAction, subAction));
                break;

            case Base.Actions.ActionTypeEnum.Counter:
                actions.Add(new CounterActionModel((MixItUp.Base.Actions.CounterAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Currency:
                actions.Add(new ConsumablesActionModel((MixItUp.Base.Actions.CurrencyAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Discord:
                actions.Add(new DiscordActionModel((MixItUp.Base.Actions.DiscordAction)action));
                break;

            case Base.Actions.ActionTypeEnum.ExternalProgram:
                actions.Add(new ExternalProgramActionModel((MixItUp.Base.Actions.ExternalProgramAction)action));
                break;

            case Base.Actions.ActionTypeEnum.File:
                actions.Add(new FileActionModel((MixItUp.Base.Actions.FileAction)action));
                break;

            case Base.Actions.ActionTypeEnum.GameQueue:
                actions.Add(new GameQueueActionModel((MixItUp.Base.Actions.GameQueueAction)action));
                break;

            case Base.Actions.ActionTypeEnum.IFTTT:
                actions.Add(new IFTTTActionModel((MixItUp.Base.Actions.IFTTTAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Input:
                actions.Add(new InputActionModel((MixItUp.Base.Actions.InputAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Moderation:
                MixItUp.Base.Actions.ModerationAction mAction = (MixItUp.Base.Actions.ModerationAction)action;
                if (mAction.ModerationType == Base.Actions.ModerationActionTypeEnum.VIPUser || mAction.ModerationType == Base.Actions.ModerationActionTypeEnum.UnVIPUser)
                {
                    actions.Add(new TwitchActionModel(mAction));
                }
                else
                {
                    actions.Add(new ModerationActionModel(mAction));
                }
                break;

            case Base.Actions.ActionTypeEnum.Overlay:
                actions.Add(new OverlayActionModel((MixItUp.Base.Actions.OverlayAction)action));
                break;

            case Base.Actions.ActionTypeEnum.OvrStream:
                actions.Add(new OvrStreamActionModel((MixItUp.Base.Actions.OvrStreamAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Serial:
                actions.Add(new SerialActionModel((MixItUp.Base.Actions.SerialAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Sound:
                actions.Add(new SoundActionModel((MixItUp.Base.Actions.SoundAction)action));
                break;

            case Base.Actions.ActionTypeEnum.SpecialIdentifier:
                actions.Add(new SpecialIdentifierActionModel((MixItUp.Base.Actions.SpecialIdentifierAction)action));
                break;

            case Base.Actions.ActionTypeEnum.StreamingPlatform:
                actions.Add(new TwitchActionModel((MixItUp.Base.Actions.StreamingPlatformAction)action));
                break;

            case Base.Actions.ActionTypeEnum.StreamingSoftware:
                actions.Add(new StreamingSoftwareActionModel((MixItUp.Base.Actions.StreamingSoftwareAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Streamlabs:
                actions.Add(new StreamlabsActionModel((MixItUp.Base.Actions.StreamlabsAction)action));
                break;

            case Base.Actions.ActionTypeEnum.TextToSpeech:
                actions.Add(new TextToSpeechActionModel((MixItUp.Base.Actions.TextToSpeechAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Translation:
                // Deprecated
                break;

            case Base.Actions.ActionTypeEnum.Twitter:
                actions.Add(new TwitterActionModel((MixItUp.Base.Actions.TwitterAction)action));
                break;

            case Base.Actions.ActionTypeEnum.Wait:
                actions.Add(new WaitActionModel((MixItUp.Base.Actions.WaitAction)action));
                break;

            case Base.Actions.ActionTypeEnum.WebRequest:
                MixItUp.Base.Actions.WebRequestAction wbAction = (MixItUp.Base.Actions.WebRequestAction)action;
                actions.Add(new WebRequestActionModel(wbAction));
                if (wbAction.ResponseAction == Base.Actions.WebRequestResponseActionTypeEnum.Chat)
                {
                    actions.Add(new ChatActionModel(wbAction.ResponseChatText));
                }
                else if (wbAction.ResponseAction == Base.Actions.WebRequestResponseActionTypeEnum.Command)
                {
                    CommandActionModel cmdAction = new CommandActionModel(CommandActionTypeEnum.RunCommand, null);
                    cmdAction.CommandID = wbAction.ResponseCommandID;
                    cmdAction.Arguments = wbAction.ResponseCommandArgumentsText;
                    actions.Add(cmdAction);
                }
                else if (wbAction.ResponseAction == Base.Actions.WebRequestResponseActionTypeEnum.SpecialIdentifier)
                {
                    actions.Add(new SpecialIdentifierActionModel(wbAction.SpecialIdentifierName, "$" + WebRequestActionModel.ResponseSpecialIdentifier, false, false));
                }
                break;
            }

            if (actions.Count > 0 && !string.Equals(action.Label, EnumLocalizationHelper.GetLocalizedName(action.Type)))
            {
                actions.First().Name = action.Label;
            }

            return(actions);
        }