Example #1
0
        public override async Task Action(MessageResult message)
        {
            await message.ConfirmAction();

            if (message.Handled)
            {
                return;
            }

            switch (message.RawData)
            {
            case "contact":

                await this.Device.RequestContact();

                break;

            case "location":

                await this.Device.RequestLocation();

                break;

            case "back":

                message.Handled = true;

                var start = new Menu();

                await this.NavigateTo(start);

                break;
            }
        }
Example #2
0
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData> ();

            await message.ConfirmAction();

            if (call == null)
            {
                return;
            }

            message.Handled = true;

            switch (call.Value)
            {
            case "AccListForm":
                var alf = new AccListForm();
                await this.NavigateTo(alf);

                break;

            default:
                message.Handled = false;
                break;
            }
        }
Example #3
0
        public async override Task Action(MessageResult result, string value = null)
        {
            if (result.Handled)
            {
                return;
            }

            if (!result.IsFirstHandler)
            {
                return;
            }

            await result.ConfirmAction(this.ConfirmationText ?? "");

            //Find clicked button depending on Text or Value (depending on markup type)
            if (this.KeyboardType != eKeyboardType.InlineKeyBoard)
            {
                return;
            }


            var button = HeadLayoutButtonRow?.FirstOrDefault(a => a.Value == result.RawData)
                         ?? SubHeadLayoutButtonRow?.FirstOrDefault(a => a.Value == result.RawData)
                         ?? ButtonsForm.ToList().FirstOrDefault(a => a.Value == result.RawData);

            var index = ButtonsForm.FindRowByButton(button);

            if (button != null)
            {
                await OnButtonClicked(new ButtonClickedEventArgs(button, index));

                result.Handled = true;
                return;
            }

            switch (result.RawData)
            {
            case "$previous$":

                if (this.CurrentPageIndex > 0)
                {
                    this.CurrentPageIndex--;
                }

                this.Updated();

                break;

            case "$next$":

                if (this.CurrentPageIndex < this.PageCount - 1)
                {
                    this.CurrentPageIndex++;
                }

                this.Updated();

                break;
            }
        }
Example #4
0
        public async override Task Action(MessageResult result, string value = null)
        {
            if (result.Handled)
            {
                return;
            }

            if (!result.IsFirstHandler)
            {
                return;
            }

            await result.ConfirmAction(this.ConfirmationText ?? "");

            //Find clicked button depending on Text or Value (depending on markup type)
            switch (this.KeyboardType)
            {
            case eKeyboardType.InlineKeyBoard:

                var button = ButtonsForm.ToList().FirstOrDefault(a => a.Value == result.RawData);

                if (button == null)
                {
                    return;
                }

                OnButtonClicked(new ButtonClickedEventArgs(button));

                result.Handled = true;

                break;
            }
        }
Example #5
0
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData> ();

            await message.ConfirmAction();

            if (call == null)
            {
                return;
            }

            message.Handled = true;

            var api = await ModelScoutAPI.ModelScoutAPIPooler.GetOrCreateApi(message.DeviceId);

            switch (call.Method)
            {
            case "GoToCfgAccForm":
                var caf = new CfgAccForm(Convert.ToInt64(call.Value));
                await this.NavigateTo(caf);

                break;

            case "GoToAddAccForm":
                PromptDialog pd = new PromptDialog(
                    "Введите токен аккаунта\n" +
                    "(Можно получить тут https://vkhost.github.io/)");

                pd.Closed += async(s, en) => {
                    ModelScoutAPI.Models.VkAcc vkAcc;
                    vkAcc = await api.CreateVkAcc(pd.Value);

                    if (vkAcc == null)
                    {
                        this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
                        await this.Device.Send("Аккаунт не был добавлен. Проверьте токен");
                    }
                    else
                    {
                        this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
                        await this.Device.Send($"Был добавлен аккаунт {vkAcc.FirstName} {vkAcc.LastName}");
                    }
                };

                await this.OpenModal(pd);

                break;

            case "GoToStartForm":
                var alf = new StartForm();
                await this.NavigateTo(alf);

                break;

            default:
                message.Handled = false;
                break;
            }
        }
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData>();

            await message.ConfirmAction();


            if (call == null)
            {
                return;
            }

            message.Handled = true;

            switch (call.Value)
            {
            case "button1":

                await this.Device.Send("Button 1 pressed");

                break;

            case "button2":

                await this.Device.Send("Button 2 pressed");

                break;

            case "button3":

                await this.Device.Send("Button 3 pressed");

                break;

            case "button4":

                await this.Device.Send("Button 4 pressed");

                break;

            case "back":

                var st = new Menu();

                await this.NavigateTo(st);

                break;

            default:

                message.Handled = false;

                break;
            }
        }
Example #7
0
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData>();

            await message.ConfirmAction();

            await message.DeleteMessage();

            message.Handled = true;

            if (call.Value == "testform1")
            {
                var tf = new TestForm();

                await this.NavigateTo(tf);
            }
            else if (call.Value == "alert")
            {
                AlertDialog ad = new AlertDialog("This is a message", "Ok");

                ad.ButtonClicked += async(s, en) =>
                {
                    var fto = new TestForm2();
                    await this.NavigateTo(fto);
                };

                await this.NavigateTo(ad);
            }
            else if (call.Value == "confirm")
            {
                ConfirmDialog pd = new ConfirmDialog("Please confirm", new ButtonBase("Ok", "ok"), new ButtonBase("Cancel", "cancel"));

                pd.ButtonClicked += async(s, en) =>
                {
                    var tf = new TestForm2();

                    await pd.NavigateTo(tf);
                };

                await this.NavigateTo(pd);
            }
            else if (call.Value == "prompt")
            {
                PromptDialog pd = new PromptDialog("Please tell me your name ?");

                pd.Completed += async(s, en) =>
                {
                    await this.Device.Send("Hello " + pd.Value);
                };

                await this.OpenModal(pd);
            }
        }
Example #8
0
        public override async Task Action(MessageResult message)
        {
            await message.ConfirmAction("");

            switch (message.RawData ?? "")
            {
            case "back":

                var st = new Start();
                await NavigateTo(st);

                break;
            }
        }
Example #9
0
        public override async Task Action(MessageResult result, String value = null)
        {
            if (result.Handled)
            {
                return;
            }

            await result.ConfirmAction(this.ChangedString);

            switch (value ?? "unknown")
            {
            case "on":

                if (this.Checked)
                {
                    return;
                }

                RenderNecessary = true;

                this.Checked = true;

                OnToggled(new EventArgs());

                break;

            case "off":

                if (!this.Checked)
                {
                    return;
                }

                RenderNecessary = true;

                this.Checked = false;

                OnToggled(new EventArgs());

                break;

            default:

                RenderNecessary = false;

                break;
            }

            result.Handled = true;
        }
Example #10
0
        public async override Task Action(MessageResult message)
        {
            await message.ConfirmAction();

            switch (message.RawData)
            {
            case "back":

                var start = new Start();

                await this.NavigateTo(start);

                break;
            }
        }
Example #11
0
        public override async Task Action(MessageResult result, String value = null)
        {
            if (result.Handled)
            {
                return;
            }

            await result.ConfirmAction(this.ChangedString);

            switch (value ?? "unknown")
            {
            default:

                var s = value.Split('$');

                if (s[0] == "check" && s.Length > 1)
                {
                    int index = 0;
                    if (!int.TryParse(s[1], out index))
                    {
                        return;
                    }

                    if (SelectedOption == null || SelectedOption != this.Options[index])
                    {
                        this.SelectedOption = this.Options[index];
                        OnToggled(new EventArgs());
                    }
                    else if (this.AllowEmptySelection)
                    {
                        this.SelectedOption = null;
                        OnToggled(new EventArgs());
                    }

                    RenderNecessary = true;

                    return;
                }


                RenderNecessary = false;

                break;
            }

            result.Handled = true;
        }
Example #12
0
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData> ();

            await message.ConfirmAction();

            if (call == null)
            {
                return;
            }

            message.Handled = true;
            var api = await ModelScoutAPI.ModelScoutAPIPooler.GetOrCreateApi(message.DeviceId);

            int id;

            switch (call.Method)
            {
            case "AcceptClient":
                if (Int32.TryParse(call.Value, out id))
                {
                    await api.SetClientAccepted(id);
                }
                break;

            case "DeclineClient":
                if (Int32.TryParse(call.Value, out id))
                {
                    await api.SetClientDeclined(id);
                }
                break;

            case "NextSample":
                message.Handled = false;
                break;

            case "GoToStartForm":
                var sf = new StartForm();
                await this.NavigateTo(sf);

                break;

            default:
                message.Handled = false;
                break;
            }
        }
Example #13
0
        public override async Task Action(MessageResult result, String value = null)
        {
            await result.ConfirmAction();

            if (result.Handled)
            {
                return;
            }

            var val = result.RawData;

            switch (val)
            {
            case "up":
            case "parent":

                this.VisibleNode = (this.VisibleNode?.ParentNode);

                result.Handled = true;

                break;

            default:

                var n = (this.VisibleNode != null ? this.VisibleNode.FindNodeByValue(val) : this.Nodes.FirstOrDefault(a => a.Value == val));

                if (n == null)
                {
                    return;
                }


                if (n.ChildNodes.Count > 0)
                {
                    this.VisibleNode = n;
                }
                else
                {
                    this.SelectedNode = (this.SelectedNode != n ? n : null);
                }

                result.Handled = true;


                break;
            }
        }
Example #14
0
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData>();
            await message.ConfirmAction();

            if (call.Method == "nav" && call.Value == "create")
            {
                await NavigateTo(new TaskCreationForm());
            }
            else if (call.Method == "nav" && call.Value == "list-assigned")
            {
                await NavigateTo(new TaskListForm(TaskListForm.DisplayMode.Assigned));
            }
            else if (call.Method == "nav" && call.Value == "list-created")
            {
                await NavigateTo(new TaskListForm(TaskListForm.DisplayMode.Created));
            }
        }
        public override async Task Action(MessageResult message)
        {
            if (message.Handled)
            {
                return;
            }

            if (!message.IsFirstHandler)
            {
                return;
            }

            var call = message.GetData <CallbackData>();

            if (call == null)
            {
                return;
            }

            message.Handled = true;

            await message.ConfirmAction();

            await message.DeleteMessage();

            ButtonBase button = this.Buttons.FirstOrDefault(a => a.Value == call.Value);

            if (button == null)
            {
                return;
            }

            OnButtonClicked(new ButtonClickedEventArgs(button)
            {
                Tag = this.Tag
            });

            if (AutoCloseOnClick)
            {
                await CloseForm();
            }
        }
Example #16
0
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData>();

            message.Handled = true;

            if (!message.IsAction)
            {
                return;
            }

            await message.ConfirmAction();

            await message.DeleteMessage();

            var buttons = this.Buttons.Aggregate((a, b) => a.Union(b).ToArray()).ToList();

            if (call == null)
            {
                return;
            }

            ButtonBase button = buttons.FirstOrDefault(a => a.Value == call.Value);

            if (button == null)
            {
                return;
            }

            OnButtonClicked(new ButtonClickedEventArgs(button)
            {
                Tag = this.Tag
            });

            FormBase fb = ButtonForms.ContainsKey(call.Value) ? ButtonForms[call.Value] : null;

            if (fb != null)
            {
                await this.NavigateTo(fb);
            }
        }
        public override async Task Action(MessageResult message)
        {
            if (message.Handled)
            {
                return;
            }


            var bn = message.RawData;

            await message.ConfirmAction();

            message.Handled = true;

            switch (bn)
            {
            case "groupchange":

                var gc = new GroupChange();

                await this.NavigateTo(gc);

                break;

            case "welcomeuser":

                var wu = new WelcomeUser();

                await this.NavigateTo(wu);

                break;

            case "linkreplace":

                var lr = new LinkReplaceTest();

                await this.NavigateTo(lr);

                break;
            }
        }
        public async override Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData>();

            await message.ConfirmAction();

            if (call == null)
            {
                return;
            }

            switch (call.Value)
            {
            case "back":

                var start = new Start();

                await this.NavigateTo(start);

                break;
            }
        }
Example #19
0
        public async override Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData>();

            await message.ConfirmAction();


            if (call == null)
            {
                return;
            }

            switch (call.Value)
            {
            case "form":

                var form = new PerForm();

                await this.NavigateTo(form);

                break;

            case "step":

                var step = new PerStep();

                await this.NavigateTo(step);

                break;

            case "backtodashboard":

                var start = new Tests.Menu();

                await this.NavigateTo(start);

                break;
            }
        }
Example #20
0
        public override async Task Action(MessageResult message)
        {
            await message.ConfirmAction("");

            switch (message.RawData ?? "")
            {
            case "async":

                var afe = new AsyncFormEdit();
                await NavigateTo(afe);


                break;

            case "async_del":

                var afu = new AsyncFormUpdate();
                await NavigateTo(afu);


                break;
            }
        }
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData>();

            if (call == null)
            {
                return;
            }

            message.Handled = true;

            await message.ConfirmAction();

            await message.DeleteMessage();

            ButtonBase button = this.Buttons.FirstOrDefault(a => a.Value == call.Value);

            if (button == null)
            {
                return;
            }

            OnButtonClicked(new ButtonClickedEventArgs(button));
        }
Example #22
0
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData> ();

            await message.ConfirmAction();

            if (call == null)
            {
                return;
            }

            var api = await ModelScoutAPI.ModelScoutAPIPooler.GetOrCreateApi(message.DeviceId);

            var vkAcc = await api.GetVkAcc(_vkAccId);

            message.Handled = true;

            PromptDialog pd;

            switch (call.Method)
            {
            case "ChangeCity":
                pd         = new PromptDialog("Введите id города:");
                pd.Closed += async(s, en) => {
                    int result;
                    this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
                    if (Int32.TryParse(pd.Value, out result) && result >= 0)
                    {
                        vkAcc.City = result;
                        await this.Device.Send("Город изменен");

                        await api.SaveVkAcc(vkAcc);

                        await api.ClearUncheckedClients();
                    }
                    else
                    {
                        await this.Device.Send("Неверный ввод");
                    }
                };
                await this.OpenModal(pd);

                break;

            case "ChangeCountry":
                pd         = new PromptDialog("Введите id страны:");
                pd.Closed += async(s, en) => {
                    int result;
                    this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
                    if (Int32.TryParse(pd.Value, out result) && result >= 0)
                    {
                        vkAcc.Country = result;
                        await this.Device.Send("Страна изменена");

                        await api.SaveVkAcc(vkAcc);

                        await api.ClearUncheckedClients();
                    }
                    else
                    {
                        await this.Device.Send("Неверный ввод");
                    }
                };
                await this.OpenModal(pd);

                break;

            case "ChangeBirthDay":
                pd         = new PromptDialog("Введите день рождения (0 - любой):");
                pd.Closed += async(s, en) => {
                    int result;
                    this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
                    if (Int32.TryParse(pd.Value, out result) && result >= 0 && result <= 31)
                    {
                        vkAcc.BirthDay = result;
                        await api.SaveVkAcc(vkAcc);

                        await this.Device.Send("День рождения изменен");

                        await api.ClearUncheckedClients();
                    }
                    else
                    {
                        await this.Device.Send("Неверный ввод");
                    }
                };
                await this.OpenModal(pd);

                break;

            case "ChangeBirthMonth":
                pd         = new PromptDialog("Введите месяц рождения (0 - любой)::");
                pd.Closed += async(s, en) => {
                    int result;
                    this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
                    if (Int32.TryParse(pd.Value, out result) && result >= 0 && result <= 12)
                    {
                        vkAcc.BirthMonth = result;
                        await api.SaveVkAcc(vkAcc);

                        await this.Device.Send("Месяц рождения изменен");

                        await api.ClearUncheckedClients();
                    }
                    else
                    {
                        await this.Device.Send("Неверный ввод");
                    }
                };
                await this.OpenModal(pd);

                break;

            case "ChangeAgeFrom":
                pd         = new PromptDialog("Введите нижний предел возраста:");
                pd.Closed += async(s, en) => {
                    int result;
                    this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
                    if (Int32.TryParse(pd.Value, out result) && result >= 0)
                    {
                        vkAcc.AgeFrom = result;
                        await api.SaveVkAcc(vkAcc);

                        await this.Device.Send("Нижний предел возраста изменен");

                        await api.ClearUncheckedClients();
                    }
                    else
                    {
                        await this.Device.Send("Неверный ввод");
                    }
                };
                await this.OpenModal(pd);

                break;

            case "ChangeAgeTo":
                pd         = new PromptDialog("Введите верхний предел возраста:");
                pd.Closed += async(s, en) => {
                    int result;
                    this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
                    if (Int32.TryParse(pd.Value, out result) && result >= 0 && result <= 200)
                    {
                        vkAcc.AgeTo = result;
                        await api.SaveVkAcc(vkAcc);

                        await this.Device.Send("Верхний предел возраста изменен");

                        await api.ClearUncheckedClients();
                    }
                    else
                    {
                        await this.Device.Send("Неверный ввод");
                    }
                };
                await this.OpenModal(pd);

                break;

            case "ChangeSex":
                pd         = new PromptDialog("Введите пол (0 - любой, 1 - ж, 2 - м):");
                pd.Closed += async(s, en) => {
                    int result;
                    this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
                    if (Int32.TryParse(pd.Value, out result) && result >= 0 && result <= 2)
                    {
                        vkAcc.Sex = result;
                        await this.Device.Send("Пол изменен");

                        await api.SaveVkAcc(vkAcc);

                        await api.ClearUncheckedClients();
                    }
                    else
                    {
                        await this.Device.Send("Неверный ввод");
                    }
                };
                await this.OpenModal(pd);

                break;

            case "ChangeLimit":
                pd = new PromptDialog(
                    "Введите лимит на добавление друзей\n" +
                    "(Этот лимит ограничивает кол-во заявок в друзья в день):");
                pd.Closed += async(s, en) => {
                    int result;
                    this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
                    if (Int32.TryParse(pd.Value, out result) && result >= 0)
                    {
                        vkAcc.FriendsLimit = result;
                        await this.Device.Send("Лимит изменен");

                        await api.SaveVkAcc(vkAcc);

                        await api.ClearUncheckedClients();
                    }
                    else
                    {
                        await this.Device.Send("Неверный ввод");
                    }
                };
                await this.OpenModal(pd);

                break;

            case "GoToCfgAccForm":
                var ccaf = new CfgAccForm(_vkAccId);
                await this.NavigateTo(ccaf);

                break;

            default:
                message.Handled = false;
                break;
            }
        }
Example #23
0
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData> ();

            await message.ConfirmAction();

            if (call == null)
            {
                return;
            }

            message.Handled = true;
            var api = await ModelScoutAPI.ModelScoutAPIPooler.GetOrCreateApi(message.DeviceId);

            switch (call.Method)
            {
            case "RemoveVkAcc":
                var vkAcc = await api.GetVkAcc(this._vkAccId);

                ConfirmDialog pd = new ConfirmDialog(
                    $"Подтвердите удаление аккаунта {vkAcc.FirstName} {vkAcc.LastName}",
                    new ButtonBase("Да, удалить", "ok"),
                    new ButtonBase("Нет, я случайно нажала", "cancel"));

                Boolean Confirmed = false;
                pd.ButtonClicked += (s, en) => {
                    if (en.Button.Value == "ok")
                    {
                        Confirmed = true;
                    }
                    else if (en.Button.Value == "cancel")
                    {
                        Confirmed = false;
                    }
                };
                pd.Closed += async(s, en) => {
                    this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
                    if (Confirmed)
                    {
                        await api.RemoveVkAcc(vkAcc);

                        await pd.Device.Send("Аккаунт был удален.");

                        var alf = new AccListForm();
                        await this.NavigateTo(alf);
                    }
                    else
                    {
                        await pd.Device.Send("Аккаунт не был удален.");
                    }
                };

                await this.OpenModal(pd);

                break;

            case "GoToChangeCfgAccForm":
                var ccaf = new ChangeCfgAccForm(_vkAccId);
                await this.NavigateTo(ccaf);

                break;

            case "GoToAccListForm":
                var alf = new AccListForm();
                await this.NavigateTo(alf);

                break;

            default:
                message.Handled = false;
                break;
            }
        }
Example #24
0
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData>();

            await message.ConfirmAction();


            if (call == null)
            {
                return;
            }

            switch (call.Value)
            {
            case "text":

                var sf = new SimpleForm();

                await this.NavigateTo(sf);

                break;

            case "buttons":

                var bf = new ButtonTestForm();

                await this.NavigateTo(bf);

                break;

            case "progress":

                var pf = new ProgressTest();

                await this.NavigateTo(pf);

                break;

            case "registration":

                var reg = new Register.Start();

                await this.NavigateTo(reg);

                break;

            case "form1":

                var form1 = new TestForm();

                await this.NavigateTo(form1);

                break;

            case "form2":

                var form2 = new TestForm2();

                await this.NavigateTo(form2);

                break;

            case "data":

                message.Handled = true;

                var data = new DataForm();

                await this.NavigateTo(data);

                break;

            case "calendar":

                message.Handled = true;

                var calendar = new Controls.CalendarPickerForm();

                await this.NavigateTo(calendar);

                break;

            case "month":

                message.Handled = true;

                var month = new Controls.MonthPickerForm();

                await this.NavigateTo(month);

                break;

            case "treeview":

                message.Handled = true;

                var tree = new Controls.TreeViewForms();

                await this.NavigateTo(tree);

                break;

            case "togglebuttons":

                message.Handled = true;

                var tb = new Controls.ToggleButtons();

                await this.NavigateTo(tb);

                break;

            case "buttongrid":

                message.Handled = true;

                var bg = new Controls.ButtonGridForm();

                await this.NavigateTo(bg);

                break;

            case "buttongridfilter":

                message.Handled = true;

                var bg2 = new Controls.ButtonGridPagingForm();

                await this.NavigateTo(bg2);

                break;

            case "buttongridtags":

                message.Handled = true;

                var bg3 = new Controls.ButtonGridTagForm();

                await this.NavigateTo(bg3);

                break;

            case "multiview":

                message.Handled = true;

                var mvf = new MultiViewForm();

                await NavigateTo(mvf);


                break;

            case "checkedbuttonlist":

                message.Handled = true;

                var cbl = new CheckedButtonListForm();

                await NavigateTo(cbl);


                break;
            }
        }
        public override async Task Action(MessageResult message)
        {
            var call = message.GetData <CallbackData>();

            await message.ConfirmAction();


            if (call == null)
            {
                return;
            }

            TelegramBotBase.Controls.ProgressBar Bar = null;

            switch (call.Value)
            {
            case "standard":

                Bar        = new TelegramBotBase.Controls.ProgressBar(0, 100, TelegramBotBase.Controls.ProgressBar.eProgressStyle.standard);
                Bar.Device = this.Device;

                break;

            case "squares":

                Bar        = new TelegramBotBase.Controls.ProgressBar(0, 100, TelegramBotBase.Controls.ProgressBar.eProgressStyle.squares);
                Bar.Device = this.Device;

                break;

            case "circles":

                Bar        = new TelegramBotBase.Controls.ProgressBar(0, 100, TelegramBotBase.Controls.ProgressBar.eProgressStyle.circles);
                Bar.Device = this.Device;

                break;

            case "lines":

                Bar        = new TelegramBotBase.Controls.ProgressBar(0, 100, TelegramBotBase.Controls.ProgressBar.eProgressStyle.lines);
                Bar.Device = this.Device;

                break;

            case "squaredlines":

                Bar        = new TelegramBotBase.Controls.ProgressBar(0, 100, TelegramBotBase.Controls.ProgressBar.eProgressStyle.squaredLines);
                Bar.Device = this.Device;

                break;

            case "start":

                var sf = new Menu();

                await this.NavigateTo(sf);

                return;

            default:

                return;
            }


            //Render Progress bar and show some "example" progress
            await Bar.Render(message);

            this.Controls.Add(Bar);

            for (int i = 0; i <= 100; i++)
            {
                Bar.Value++;
                await Bar.Render(message);

                Thread.Sleep(250);
            }
        }
        public override async Task Action(MessageResult message)
        {
            var btn = message.RawData;

            int id = -1;

            if (!int.TryParse(btn, out id))
            {
                return;
            }

            var cmd = Program.BotConfig.Commandos.Where(a => a.Enabled && a.ID == id).FirstOrDefault();

            if (cmd == null)
            {
                await this.Device.Send("Cmd nicht verfügbar.");

                return;
            }

            message.Handled = true;

            switch (cmd.Action)
            {
            case "start":

                FileInfo fi = new FileInfo(cmd.ShellCmd);

                if (cmd.MaxInstances != null && cmd.MaxInstances >= 0)
                {
                    if (Process.GetProcessesByName(cmd.ProcName).Count() >= cmd.MaxInstances)
                    {
                        await this.Device.Send("Anwendung läuft bereits.");

                        await message.ConfirmAction("Anwendung läuft bereits.");

                        return;
                    }
                }

                ProcessStartInfo psi = new ProcessStartInfo();
                psi.FileName         = cmd.ShellCmd;
                psi.WorkingDirectory = fi.DirectoryName;
                psi.UseShellExecute  = cmd.UseShell;

                Process.Start(psi);

                await this.Device.Send(fi.Name + " wurde gestarted.");

                await message.ConfirmAction(fi.Name + " wurde gestarted.");

                break;

            case "kill":

                FileInfo fi2 = new FileInfo(cmd.ShellCmd);

                String pros = fi2.Name.Replace(fi2.Extension, "");

                var proc = Process.GetProcessesByName(pros).ToList();

                foreach (var p in proc)
                {
                    try
                    {
                        p.Kill();
                    }
                    catch
                    {
                    }
                }

                await this.Device.Send(fi2.Name + " wurde beendet.");

                await message.ConfirmAction(fi2.Name + " wurde beendet.");

                break;

            case "restart":

                FileInfo fi3 = new FileInfo(cmd.ShellCmd);

                String pros2 = fi3.Name.Replace(fi3.Extension, "");

                var proc2 = Process.GetProcessesByName(pros2).ToList();

                foreach (var p in proc2)
                {
                    try
                    {
                        p.Kill();
                    }
                    catch
                    {
                    }
                }

                FileInfo fi4 = new FileInfo(cmd.ShellCmd);

                ProcessStartInfo psi2 = new ProcessStartInfo();
                psi2.FileName         = cmd.ShellCmd;
                psi2.WorkingDirectory = fi4.DirectoryName;
                psi2.FileName         = cmd.ShellCmd;
                psi2.UseShellExecute  = cmd.UseShell;

                Process.Start(psi2);

                await this.Device.Send(fi3.Name + " wurde neugestarted.");

                await message.ConfirmAction(fi3.Name + " wurde neugestarted.");


                break;

            default:

                await message.ConfirmAction();

                break;
            }
        }
Example #27
0
        public override async Task Action(MessageResult result, String value = null)
        {
            await result.ConfirmAction();

            switch (result.RawData)
            {
            case "next":

                switch (this.PickerMode)
                {
                case eMonthPickerMode.day:
                    this.VisibleMonth = this.VisibleMonth.AddMonths(1);
                    break;

                case eMonthPickerMode.month:
                    this.VisibleMonth = this.VisibleMonth.AddYears(1);
                    break;

                case eMonthPickerMode.year:
                    this.VisibleMonth = this.VisibleMonth.AddYears(10);
                    break;
                }


                break;

            case "prev":

                switch (this.PickerMode)
                {
                case eMonthPickerMode.day:
                    this.VisibleMonth = this.VisibleMonth.AddMonths(-1);
                    break;

                case eMonthPickerMode.month:
                    this.VisibleMonth = this.VisibleMonth.AddYears(-1);
                    break;

                case eMonthPickerMode.year:
                    this.VisibleMonth = this.VisibleMonth.AddYears(-10);
                    break;
                }

                break;

            case "monthtitle":

                if (this.EnableMonthView)
                {
                    this.PickerMode = eMonthPickerMode.month;
                }

                break;

            case "yeartitle":

                if (this.EnableYearView)
                {
                    this.PickerMode = eMonthPickerMode.year;
                }

                break;

            case "yearstitle":

                if (this.EnableMonthView)
                {
                    this.PickerMode = eMonthPickerMode.month;
                }

                this.VisibleMonth = this.SelectedDate;

                break;

            default:

                int day = 0;
                if (result.RawData.StartsWith("d-") && int.TryParse(result.RawData.Split('-')[1], out day))
                {
                    this.SelectedDate = new DateTime(this.VisibleMonth.Year, this.VisibleMonth.Month, day);
                }

                int month = 0;
                if (result.RawData.StartsWith("m-") && int.TryParse(result.RawData.Split('-')[1], out month))
                {
                    this.SelectedDate = new DateTime(this.VisibleMonth.Year, month, 1);
                    this.VisibleMonth = this.SelectedDate;

                    if (this.EnableDayView)
                    {
                        this.PickerMode = eMonthPickerMode.day;
                    }
                }

                int year = 0;
                if (result.RawData.StartsWith("y-") && int.TryParse(result.RawData.Split('-')[1], out year))
                {
                    this.SelectedDate = new DateTime(year, SelectedDate.Month, SelectedDate.Day);
                    this.VisibleMonth = this.SelectedDate;

                    if (this.EnableMonthView)
                    {
                        this.PickerMode = eMonthPickerMode.month;
                    }
                }

                break;
            }
        }
Example #28
0
        public async override Task Action(MessageResult result, string value = null)
        {
            if (result.Handled)
            {
                return;
            }

            if (!result.IsFirstHandler)
            {
                return;
            }

            //Find clicked button depending on Text or Value (depending on markup type)
            if (this.KeyboardType != eKeyboardType.InlineKeyBoard)
            {
                return;
            }

            await result.ConfirmAction(this.ConfirmationText ?? "");

            var button = HeadLayoutButtonRow?.FirstOrDefault(a => a.Value == result.RawData)
                         ?? SubHeadLayoutButtonRow?.FirstOrDefault(a => a.Value == result.RawData)
                         ?? ButtonsForm.ToList().FirstOrDefault(a => a.Value == result.RawData);

            var index = ButtonsForm.FindRowByButton(button);

            if (button != null)
            {
                await OnButtonClicked(new ButtonClickedEventArgs(button, index));

                result.Handled = true;
                return;
            }

            switch (result.RawData)
            {
            case "$previous$":

                if (this.CurrentPageIndex > 0)
                {
                    this.CurrentPageIndex--;
                }

                this.Updated();

                break;

            case "$next$":

                if (this.CurrentPageIndex < this.PageCount - 1)
                {
                    this.CurrentPageIndex++;
                }

                this.Updated();

                break;

            default:

                var s = result.RawData.Split('$');


                switch (s[0])
                {
                case "check":

                    index = int.Parse(s[1]);

                    if (!this.CheckedRows.Contains(index))
                    {
                        this.CheckedRows.Add(index);

                        this.Updated();

                        await OnCheckedChanged(new CheckedChangedEventArgs(ButtonsForm[index], index, true));
                    }

                    break;

                case "uncheck":

                    index = int.Parse(s[1]);

                    if (this.CheckedRows.Contains(index))
                    {
                        this.CheckedRows.Remove(index);

                        this.Updated();

                        await OnCheckedChanged(new CheckedChangedEventArgs(ButtonsForm[index], index, false));
                    }

                    break;
                }


                break;
            }
        }