Feature merge

Essentials/AutoCommand.cs

@@ -1,66 +1,195 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Collections.ObjectModel;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
+using NLog;
 using Torch;
 using Torch.API;
-using Torch.Commands;
 using Torch.API.Managers;
+using Torch.Commands;
 using Torch.Server;
+using Torch.Views;
 
 namespace Essentials
 {
-    public class AutoCommand : ViewModel, IDisposable
+    public class AutoCommand : ViewModel
     {
-        private Timer _timer;
-
+        private TimeSpan _scheduledTime = TimeSpan.Zero;
+        private static readonly Logger Log = LogManager.GetLogger("Essentials");
+        private TimeSpan _interval = TimeSpan.Zero;
+        private DateTime _nextRun = DateTime.MinValue;
+        private DayOfWeek _day = DayOfWeek.All;
+        private int _currentStep;
+        private string _name;
         private bool _enabled;
-        public bool Enabled { get => _enabled; set { _enabled = value; OnTimerChanged(); OnPropertyChanged(); } }
-        private string _command;
-        public string Command { get => _command; set { _command = value; OnTimerChanged(); OnPropertyChanged(); } }
-        private int _dueTime;
-        public int DueTime { get => _dueTime / 1000; set { _dueTime = value * 1000; OnTimerChanged(); OnPropertyChanged(); } }
-        private int _period;
-        public int Period { get => _period / 1000; set { _period = value * 1000; OnTimerChanged(); OnPropertyChanged(); } }
-
-        private void OnTimerChanged()
+
+        [Display(Description = "Enables or disables this command. NOTE: !admin runauto does NOT respect this setting!")]
+        public bool Enabled
+        {
+            get => _enabled;
+            set => SetValue(ref _enabled, value);
+        }
+
+        [Display(Description = "Sets the name of this command. Use this name in conjunction with !admin runauto to trigger the command from ingame or from other auto commands.")]
+        public string Name
         {
-            _timer?.Dispose();
-            if (Enabled && Period > 0)
-                _timer = new Timer(RunCommand, this, _dueTime, _period);
+            get => _name;
+            set => SetValue(ref _name, value);
         }
 
-        private void RunCommand(object state)
+        [Display(Name = "Scheduled Time", GroupName = "Schedule", Description = "Sets a time of day for this command to be run. Format is HH:MM:SS. MUST use 24 hour format! Will be reset to zero if Interval is set.")]
+        public string ScheduledTime
         {
-            if (((TorchServer)TorchBase.Instance).State != ServerState.Running)
+            get => _scheduledTime.ToString();
+            set
+            {
+                _scheduledTime = TimeSpan.Parse(value);
+                OnPropertyChanged();
+                if (_scheduledTime != TimeSpan.Zero)
+                {
+                    Interval = TimeSpan.Zero.ToString();
+                    _nextRun = DateTime.Now.Date + _scheduledTime;
+                    if (_nextRun < DateTime.Now)
+                        _nextRun += TimeSpan.FromDays(1);
+                }
+            }
+        }
+
+        [Display(Description = "Sets an interval for this command to be repeated. Format is HH:MM:SS. Will be reset to zero if Scheduled Time is set!")]
+        public string Interval
+        {
+            get => _interval.ToString();
+            set
+            {
+                _interval = TimeSpan.Parse(value);
+                OnPropertyChanged();
+                if (_interval != TimeSpan.Zero)
+                {
+                    ScheduledTime = TimeSpan.Zero.ToString(); //I hate myself for this
+                    _nextRun = DateTime.Now + _interval;
+                }
+            }
+        }
+
+        [Display(Name = "Day of week", GroupName = "Schedule", Description = "Combined with Scheduled Time, will run the command on the given day of the week at the set time.")]
+        public DayOfWeek DayOfWeek
+        {
+            get => _day;
+            set => SetValue(ref _day, value);
+        }
+
+        [Display(Description = "Sub-command steps that will be iterated through once the Interval or Scheduled time is reached.")]
+        public ObservableCollection<CommandStep> Steps { get; } = new ObservableCollection<CommandStep>();
+
+        public AutoCommand()
+        {
+            Steps.CollectionChanged += (sender, args) => OnPropertyChanged();
+        }
+
+        public void Update()
+        {
+            if (DateTime.Now < _nextRun)
+                return;
+
+            //double cast here as I'm unsure how casting directly between enum types will work
+            if (DayOfWeek != DayOfWeek.All && DateTime.Now.DayOfWeek != (System.DayOfWeek)(int)DayOfWeek)
+            {
+                //adding one day because I can't be bothered to calculate exact interval
+                _nextRun += TimeSpan.FromDays(1);
                 return;
+            }
+
+            if (Steps.Count <= 0)
+                return;
+
+            var step = Steps[_currentStep];
+
+            step.RunStep();
+            _currentStep++;
+            _nextRun += step.DelaySpan;
 
-            var autoCommand = (AutoCommand)state;
-            TorchBase.Instance.Invoke(() =>
+            if (_currentStep >= Steps.Count)
             {
-                var manager = TorchBase.Instance.CurrentSession.Managers.GetManager<CommandManager>();
-                manager?.HandleCommandFromServer(autoCommand.Command);
-            });
+                _currentStep = 0;
+                if (_scheduledTime != TimeSpan.Zero)
+                    _nextRun = DateTime.Now.Date + _scheduledTime + TimeSpan.FromDays(1);
+                else
+                    _nextRun = DateTime.Now + _interval;
+            }
         }
 
-        ~AutoCommand()
+        public class CommandStep : ViewModel
         {
-            try
+            internal TimeSpan DelaySpan;
+            private string _command;
+
+            [Display(Description = "Delay AFTER this step and BEFORE the next step. Format is HH:MM:SS.")]
+            public string Delay
             {
-                Dispose();
+                get => DelaySpan.ToString();
+                set => SetValue(ref DelaySpan, TimeSpan.Parse(value));
             }
-            catch
+
+            [Display(Description = "Command to be run as the server.")]
+            public string Command
             {
-                // ignored
+                get => _command;
+                set => SetValue(ref _command, value);
             }
+
+            public void RunStep()
+            {
+                if (((TorchServer)EssentialsPlugin.Instance.Torch).State != ServerState.Running)
+                    return;
+
+                if (string.IsNullOrEmpty(Command))
+                    return;
+
+                EssentialsPlugin.Instance.Torch.Invoke(() =>
+                                                       {
+                                                           var manager = EssentialsPlugin.Instance.Torch.CurrentSession.Managers.GetManager<CommandManager>();
+                                                           manager?.HandleCommandFromServer(Command);
+                                                       });
+            }
+
+            public override string ToString()
+            {
+                return Command;
+            }
+        }
+
+
+        /// <summary>
+        /// Runs the command and all steps immediately, in a new thread
+        /// </summary>
+        internal void RunNow()
+        {
+            Task.Run(() =>
+                     {
+                         foreach (var step in Steps)
+                         {
+                             step.RunStep();
+                             Thread.Sleep(step.DelaySpan);
+                         }
+                     });
         }
 
-        /// <inheritdoc />
-        public void Dispose()
+        public override string ToString()
         {
-            _timer?.Dispose();
+            return $"{Name} : {(Enabled ? "Enabled" : "Disabled")} : {Steps.Count}";
         }
     }
+
+    public enum DayOfWeek
+    {
+        All = -1,
+        Sunday = System.DayOfWeek.Sunday,
+        Monday = System.DayOfWeek.Monday,
+        Tuesday = System.DayOfWeek.Tuesday,
+        Wednesday = System.DayOfWeek.Wednesday,
+        Thursday = System.DayOfWeek.Thursday,
+        Friday = System.DayOfWeek.Friday,
+        Saturday = System.DayOfWeek.Saturday
+    }
 }

Essentials/AutoCommands.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Timers;
+using NLog;
+
+namespace Essentials
+{
+    public class AutoCommands : IDisposable
+    {
+        private static AutoCommands _instance;
+        public static AutoCommands Instance => _instance ?? (_instance = new AutoCommands());
+        private static readonly Logger Log = LogManager.GetLogger("Essentials");
+
+        private Timer _timer;
+
+        public void Start()
+        {
+            _timer = new Timer(1000);
+            _timer.Elapsed += TimerElapsed;
+            _timer.AutoReset = true;
+            _timer.Start();
+        }
+
+        private void TimerElapsed(object sender, ElapsedEventArgs e)
+        {
+            foreach (var command in EssentialsPlugin.Instance.Config.AutoCommands)
+            {
+                if(!command.Enabled)
+                    continue;
+
+                try
+                {
+                    command.Update();
+                }
+                catch (Exception ex)
+                {
+                    Log.Error(ex, "Error encountered during autocommand update!");
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            _timer?.Dispose();
+        }
+    }
+}

Essentials/Commands/AdminModule.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Sandbox.Engine.Multiplayer;
+using Torch.Commands;
+using Torch.Commands.Permissions;
+using Torch.Mod;
+using Torch.Mod.Messages;
+using VRage.Game.ModAPI;
+using VRageRender.Utils;
+
+namespace Essentials.Commands
+{
+    [Category("admin")]
+    public class AdminModule : CommandModule
+    {
+        [Command("stats", "Get performance statistics of the server")]
+        [Permission(MyPromoteLevel.Admin)]
+        public void Statistics()
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("Generic:");
+            Stats.Generic.WriteTo(sb);
+            sb.AppendLine("Network:");
+            Stats.Network.WriteTo(sb);
+            sb.AppendLine("Timing:");
+            Stats.Timing.WriteTo(sb);
+
+            ModCommunication.SendMessageTo(new DialogMessage("Statistics", null, sb.ToString()) , Context.Player.SteamUserId);
+        }
+
+        [Command("playercount", "Gets or sets the max number of players on the server")]
+        [Permission(MyPromoteLevel.Admin)]
+        public void PlayerCount(int count = -1)
+        {
+            if (count == -1)
+            {
+                Context.Respond($"Nax player count: {MyMultiplayer.Static.MemberLimit}. Current online players: {MyMultiplayer.Static.MemberCount - 1}");
+                return;
+            }
+
+            MyMultiplayer.Static.MemberLimit = count;
+            Context.Respond($"Nax player count: {MyMultiplayer.Static.MemberLimit}. Current online players: {MyMultiplayer.Static.MemberCount - 1}");
+        }
+
+        [Command("runauto", "Runs the auto command with the given name immediately")]
+        [Permission(MyPromoteLevel.Admin)]
+        public void RunAuto(string name)
+        {
+            var command = EssentialsPlugin.Instance.Config.AutoCommands.FirstOrDefault(c => c.Name.Equals(name));
+            if (command == null)
+            {
+                Context.Respond($"Couldn't find an auto command with the name {name}");
+                return;
+            }
+
+            command.RunNow();
+        }
+    }
+}