Esempio n. 1
0
        public async Task AddEventFake(string eventName, string path, string discription, bool isActive)
        {
            EmbedBuilder eb = new EmbedBuilder();

            //Loaded data
            BinaryEventArray entry = new BinaryEventArray(new BinaryEvent[0]);

            //Load
            EventArray.Load(path, ref entry);
            //Modify
            bool isValidEventName = false;

            for (int i = 0; i < entry.Events.Length; i++)
            {
                if (entry.Events[i].EventName == eventName)
                {
                    if (entry.Events[i].EventType == -1 || entry.Events[i].EventType == 0 || entry.Events[i].EventType == 1)
                    {
                        entry.Events[i].EventType = 0;
                        if (isActive)
                        {
                            entry.Events[i].EventType = 1;
                        }

                        List <BinaryEventSchedule> schedules          = entry.Events[i].Schedules.ToList();
                        BinaryEventSchedule        eventScheduleEntry = new BinaryEventSchedule(discription, "", new long[0], 0);
                        schedules.Add(eventScheduleEntry);

                        entry.Events[i].Schedules = schedules.ToArray();
                        //Save
                        EventArray.Save(path, entry);

                        eb.Title = "**πŸ“ A new schedule has been added to " + eventName + "!**";
                        eb.WithColor(Color.Green);
                    }
                    else
                    {
                        eb.Title = "**🚫 " + eventName + " is a different event type!**";
                        eb.WithColor(Color.Red);
                    }

                    isValidEventName = true;
                    break;
                }
            }

            if (!isValidEventName)
            {
                eb.Title = "**🚫 The event " + eventName + " doesn't exists!**";
                eb.WithColor(Color.Red);
            }

            await Context.Channel.SendMessageAsync("", false, eb.Build());
        }
Esempio n. 2
0
        public async Task AddEventDate(string eventName, string path, string startingDate, string endingDate, string duration, string[] startTimes)
        {
            EmbedBuilder eb = new EmbedBuilder();

            DateTime parsedStartingDate;
            DateTime parsedEndingDate;
            bool     isValidStartingDate = DateTime.TryParseExact(startingDate, "MM-dd-yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out parsedStartingDate);
            bool     isValidEndingDate   = DateTime.TryParseExact(endingDate, "MM-dd-yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out parsedEndingDate);

            if (parsedStartingDate <= parsedEndingDate)
            {
                if (isValidStartingDate && isValidEndingDate)
                {
                    TimeSpan parsedDuration;
                    bool     isValidDuration = TimeSpan.TryParseExact(duration, "hh':'mm", null, out parsedDuration);

                    if (isValidDuration)
                    {
                        List <TimeSpan> parsedStartTimes  = new List <TimeSpan>();
                        bool            isValidStartTimes = true;
                        for (int i = 0; i < startTimes.Length; i++)
                        {
                            TimeSpan parsedStartTime;
                            if (TimeSpan.TryParseExact(startTimes[i], "hh':'mm", null, out parsedStartTime))
                            {
                                parsedStartTimes.Add(parsedStartTime);
                            }
                            else
                            {
                                isValidStartTimes = false;
                                break;
                            }
                        }
                        parsedStartTimes.Sort();

                        if (isValidStartTimes)
                        {
                            //Loaded data
                            BinaryEventArray entry = new BinaryEventArray(new BinaryEvent[0]);
                            //Load
                            EventArray.Load(path, ref entry);
                            //Modify
                            bool isValidEventName = false;
                            for (int i = 0; i < entry.Events.Length; i++)
                            {
                                if (entry.Events[i].EventName == eventName)
                                {
                                    if (entry.Events[i].EventType == -1 || entry.Events[i].EventType == 3)
                                    {
                                        entry.Events[i].EventType = 3;

                                        List <long> StartTimeTicks = new List <long>();
                                        for (int j = 0; j < parsedStartTimes.Count; j++)
                                        {
                                            StartTimeTicks.Add(parsedStartTimes[j].Ticks);
                                        }

                                        List <BinaryEventSchedule> schedules          = entry.Events[i].Schedules.ToList();
                                        BinaryEventSchedule        eventScheduleEntry = new BinaryEventSchedule(startingDate, endingDate, StartTimeTicks.ToArray(), parsedDuration.Ticks);
                                        schedules.Add(eventScheduleEntry);

                                        entry.Events[i].Schedules = schedules.ToArray();
                                        //Save
                                        EventArray.Save(path, entry);

                                        eb.Title = "**πŸ“ A new schedule has been added to " + eventName + "!**";
                                        eb.WithColor(Color.Green);
                                    }
                                    else
                                    {
                                        eb.Title = "**🚫 " + eventName + " is a different event type!**";
                                        eb.WithColor(Color.Red);
                                    }

                                    isValidEventName = true;
                                    break;
                                }
                            }

                            if (!isValidEventName)
                            {
                                eb.Title = "**🚫 The event " + eventName + " doesn't exists!**";
                                eb.WithColor(Color.Red);
                            }
                        }
                        else
                        {
                            eb.Title = "**🚫 Invalid Start Times!**";
                            eb.WithColor(Color.Red);
                        }
                    }
                    else
                    {
                        eb.Title = "**🚫 Invalid duration!**";
                        eb.WithColor(Color.Red);
                    }
                }
                else
                {
                    eb.Title = "**🚫 Invalid date!**";
                    eb.WithColor(Color.Red);
                }
            }
            else
            {
                eb.Title = "**🚫 Starting date must be earlier or equal to ending date!**";
                eb.WithColor(Color.Red);
            }
            await Context.Channel.SendMessageAsync("", false, eb.Build());
        }
Esempio n. 3
0
        public async Task AddEventDaily(string eventName, string path, string startingDay, string endingDay, string duration, string[] startTimes)
        {
            EmbedBuilder eb = new EmbedBuilder();

            //Checks if the day string passed in is a valid value
            string[] dayNames           = Enum.GetNames(typeof(DayOfWeek));
            bool     isValidStartingDay = dayNames.Contains(startingDay, StringComparer.InvariantCultureIgnoreCase);
            bool     isValidEndingDay   = dayNames.Contains(endingDay, StringComparer.InvariantCultureIgnoreCase);

            if (isValidStartingDay && isValidEndingDay)
            {
                TimeSpan parsedDuration;
                bool     isValidDuration = TimeSpan.TryParseExact(duration, "hh':'mm", null, out parsedDuration);

                if (isValidDuration)
                {
                    List <TimeSpan> parsedStartTimes  = new List <TimeSpan>();
                    bool            isValidStartTimes = true;
                    for (int i = 0; i < startTimes.Length; i++)
                    {
                        TimeSpan parsedStartTime;
                        if (TimeSpan.TryParseExact(startTimes[i], "hh':'mm", null, out parsedStartTime))
                        {
                            parsedStartTimes.Add(parsedStartTime);
                        }
                        else
                        {
                            isValidStartTimes = false;
                            break;
                        }
                    }
                    parsedStartTimes.Sort();

                    if (isValidStartTimes)
                    {
                        //Loaded data
                        BinaryEventArray entry = new BinaryEventArray(new BinaryEvent[0]);
                        //Load
                        EventArray.Load(path, ref entry);
                        //Modify
                        bool isValidEventName = false;
                        for (int i = 0; i < entry.Events.Length; i++)
                        {
                            if (entry.Events[i].EventName == eventName)
                            {
                                if (entry.Events[i].EventType == -1 || entry.Events[i].EventType == 2)
                                {
                                    entry.Events[i].EventType = 2;

                                    List <long> StartTimeTicks = new List <long>();
                                    for (int j = 0; j < parsedStartTimes.Count; j++)
                                    {
                                        StartTimeTicks.Add(parsedStartTimes[j].Ticks);
                                    }

                                    List <BinaryEventSchedule> schedules          = entry.Events[i].Schedules.ToList();
                                    BinaryEventSchedule        eventScheduleEntry = new BinaryEventSchedule(startingDay, endingDay, StartTimeTicks.ToArray(), parsedDuration.Ticks);
                                    schedules.Add(eventScheduleEntry);

                                    entry.Events[i].Schedules = schedules.ToArray();
                                    //Save
                                    EventArray.Save(path, entry);

                                    eb.Title = "**πŸ“ A new schedule has been added to " + eventName + "!**";
                                    eb.WithColor(Color.Green);
                                }
                                else
                                {
                                    eb.Title = "**🚫 " + eventName + " is a different event type!**";
                                    eb.WithColor(Color.Red);
                                }

                                isValidEventName = true;
                                break;
                            }
                        }

                        if (!isValidEventName)
                        {
                            eb.Title = "**🚫 The event " + eventName + " doesn't exists!**";
                            eb.WithColor(Color.Red);
                        }
                    }
                    else
                    {
                        eb.Title = "**🚫 Invalid Start Times!**";
                        eb.WithColor(Color.Red);
                    }
                }
                else
                {
                    eb.Title = "**🚫 Invalid duration!**";
                    eb.WithColor(Color.Red);
                }
            }
            else
            {
                eb.Title = "**🚫 Invalid day!**";
                eb.WithColor(Color.Red);
            }

            await Context.Channel.SendMessageAsync("", false, eb.Build());
        }