727 lines
22 KiB
C#
727 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using Telegram.Bot;
|
|
using TelegramBotBase.Args;
|
|
using TelegramBotBase.Attributes;
|
|
using TelegramBotBase.Base;
|
|
using TelegramBotBase.Form;
|
|
using TelegramBotBase.Interfaces;
|
|
using TelegramBotBase.Sessions;
|
|
|
|
namespace TelegramBotBase
|
|
{
|
|
/// <summary>
|
|
/// Bot base class for full Device/Context and Messagehandling
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
public class BotBase<T>
|
|
where T : FormBase
|
|
{
|
|
public MessageClient Client { get; set; }
|
|
|
|
/// <summary>
|
|
/// Your TelegramBot APIKey
|
|
/// </summary>
|
|
public String APIKey { get; set; } = "";
|
|
|
|
/// <summary>
|
|
/// List of all running/active sessions
|
|
/// </summary>
|
|
public SessionBase Sessions { get; set; }
|
|
|
|
/// <summary>
|
|
/// Contains System commands which will be available at everytime and didnt get passed to forms, i.e. /start
|
|
/// </summary>
|
|
public List<String> SystemCalls { get; set; }
|
|
|
|
private EventHandlerList __Events = new EventHandlerList();
|
|
|
|
private static object __evSessionBegins = new object();
|
|
|
|
private static object __evMessage = new object();
|
|
|
|
private static object __evSystemCall = new object();
|
|
|
|
public delegate Task SystemCallEventHandler(object sender, SystemCallEventArgs e);
|
|
|
|
private static object __evException = new object();
|
|
|
|
private static object __evUnhandledCall = new object();
|
|
|
|
|
|
/// <summary>
|
|
/// Skips all messages during running (good for big delay updates)
|
|
/// </summary>
|
|
public bool SkipAllMessages { get; set; } = false;
|
|
|
|
/// <summary>
|
|
/// Loggs all messages and sent them to the event handler
|
|
/// </summary>
|
|
public bool LogAllMessages { get; set; } = false;
|
|
|
|
/// <summary>
|
|
/// Enable the SessionState (you need to implement on call forms the IStateForm interface)
|
|
/// </summary>
|
|
public IStateMachine StateMachine { get; set; }
|
|
|
|
/// <summary>
|
|
/// How often could a form navigate to another (within one user action/call/message)
|
|
/// </summary>
|
|
private const int NavigationMaximum = 10;
|
|
|
|
/// <summary>
|
|
/// Simple start of your Bot with the APIKey
|
|
/// </summary>
|
|
/// <param name="apiKey"></param>
|
|
public BotBase(String apiKey)
|
|
{
|
|
this.APIKey = apiKey;
|
|
|
|
this.Client = new Base.MessageClient(this.APIKey);
|
|
this.Client.TelegramClient.Timeout = new TimeSpan(0, 1, 0);
|
|
|
|
this.SystemCalls = new List<string>();
|
|
|
|
this.Sessions = new SessionBase();
|
|
this.Sessions.Client = this.Client;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Simple start of your Bot with the APIKey and a proxyAdress
|
|
/// </summary>
|
|
/// <param name="apiKey"></param>
|
|
/// <param name="proxyBaseAddress">i.e. https://127.0.0.1:10000</param>
|
|
public BotBase(String apiKey, System.Net.Http.HttpClient proxy)
|
|
{
|
|
this.APIKey = apiKey;
|
|
|
|
this.Client = new Base.MessageClient(this.APIKey, proxy);
|
|
|
|
this.SystemCalls = new List<string>();
|
|
|
|
this.Sessions = new SessionBase();
|
|
this.Sessions.Client = this.Client;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Simple start of your Bot with the APIKey and a TelegramBotClient instance.
|
|
/// </summary>
|
|
/// <param name="apiKey"></param>
|
|
/// <param name="client"></param>
|
|
public BotBase(String apiKey, TelegramBotClient client)
|
|
{
|
|
this.APIKey = apiKey;
|
|
|
|
this.Client = new Base.MessageClient(this.APIKey, client);
|
|
|
|
this.SystemCalls = new List<string>();
|
|
|
|
this.Sessions = new SessionBase();
|
|
this.Sessions.Client = this.Client;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Simple start of your Bot with the APIKey and a proxyAdress
|
|
/// </summary>
|
|
/// <param name="apiKey"></param>
|
|
/// <param name="proxyBaseAddress">i.e. https://127.0.0.1:10000</param>
|
|
public BotBase(String apiKey, String proxyBaseAddress)
|
|
{
|
|
this.APIKey = apiKey;
|
|
|
|
var url = new Uri(proxyBaseAddress);
|
|
|
|
this.Client = new Base.MessageClient(this.APIKey, url);
|
|
|
|
this.SystemCalls = new List<string>();
|
|
|
|
this.Sessions = new SessionBase();
|
|
this.Sessions.Client = this.Client;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Simple start of your Bot with the APIKey and a proxyAdress
|
|
/// </summary>
|
|
/// <param name="apiKey"></param>
|
|
/// <param name="proxyHost">i.e. 127.0.0.1</param>
|
|
/// <param name="proxyPort">i.e. 10000</param>
|
|
public BotBase(String apiKey, String proxyHost, int proxyPort)
|
|
{
|
|
this.APIKey = apiKey;
|
|
|
|
this.Client = new Base.MessageClient(this.APIKey, proxyHost, proxyPort);
|
|
|
|
this.SystemCalls = new List<string>();
|
|
|
|
this.Sessions = new SessionBase();
|
|
this.Sessions.Client = this.Client;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start your Bot
|
|
/// </summary>
|
|
public void Start()
|
|
{
|
|
if (this.Client == null)
|
|
return;
|
|
|
|
this.Client.Message += Client_Message;
|
|
this.Client.MessageEdit += Client_MessageEdit;
|
|
this.Client.Action += Client_Action;
|
|
|
|
if (this.StateMachine != null)
|
|
{
|
|
LoadSessionStates();
|
|
}
|
|
|
|
this.Client.TelegramClient.StartReceiving();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Stop your Bot
|
|
/// </summary>
|
|
public void Stop()
|
|
{
|
|
if (this.Client == null)
|
|
return;
|
|
|
|
this.Client.Message -= Client_Message;
|
|
this.Client.Action -= Client_Action;
|
|
|
|
this.Client.TelegramClient.StopReceiving();
|
|
|
|
if (this.StateMachine != null)
|
|
{
|
|
SaveSessionStates();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send a message to all active Sessions.
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
/// <returns></returns>
|
|
public async Task SentToAll(String message)
|
|
{
|
|
if (this.Client == null)
|
|
return;
|
|
|
|
foreach (var s in this.Sessions.SessionList)
|
|
{
|
|
await this.Client.TelegramClient.SendTextMessageAsync(s.Key, message);
|
|
}
|
|
}
|
|
|
|
private async void Client_Message(object sender, MessageResult e)
|
|
{
|
|
if (this.SkipAllMessages)
|
|
return;
|
|
|
|
try
|
|
{
|
|
DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
|
|
e.Device = ds;
|
|
|
|
if (LogAllMessages)
|
|
{
|
|
OnMessage(new MessageIncomeEventArgs(e.DeviceId, ds, e));
|
|
}
|
|
|
|
ds?.OnMessageReceived(new MessageReceivedEventArgs(e.Message));
|
|
|
|
await Client_TryMessage(sender, e);
|
|
}
|
|
catch (Telegram.Bot.Exceptions.ApiRequestException ex)
|
|
{
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
|
|
OnException(new SystemExceptionEventArgs(e.Message.Text, ds?.DeviceId ?? -1, ds, ex));
|
|
}
|
|
}
|
|
|
|
private async Task Client_TryMessage(object sender, MessageResult e)
|
|
{
|
|
DeviceSession ds = e.Device;
|
|
if (ds == null)
|
|
{
|
|
ds = await this.Sessions.StartSession<T>(e.DeviceId);
|
|
e.Device = ds;
|
|
|
|
ds.LastMessage = e.Message;
|
|
|
|
OnSessionBegins(new SessionBeginEventArgs(e.DeviceId, ds));
|
|
}
|
|
|
|
ds.ChatTitle = e.Message.Chat.Username ?? e.Message.Chat.Title;
|
|
ds.LastAction = DateTime.Now;
|
|
ds.LastMessage = e.Message;
|
|
|
|
//Is this a systemcall ?
|
|
if (e.IsSystemCall && this.SystemCalls.Contains(e.SystemCommand))
|
|
{
|
|
var sce = new SystemCallEventArgs(e.SystemCommand, e.SystemCallParameters, e.Message, ds.DeviceId, ds);
|
|
await OnSystemCall(sce);
|
|
|
|
if (sce.Handled)
|
|
return;
|
|
}
|
|
|
|
FormBase activeForm = null;
|
|
|
|
int i = 0;
|
|
|
|
//Should formulars get navigated (allow maximum of 10, to dont get loops)
|
|
do
|
|
{
|
|
i++;
|
|
|
|
//Reset navigation
|
|
ds.FormSwitched = false;
|
|
|
|
activeForm = ds.ActiveForm;
|
|
|
|
//Pre Loading Event
|
|
await activeForm.PreLoad(e);
|
|
|
|
//Send Load event to controls
|
|
await activeForm.LoadControls(e);
|
|
|
|
//Loading Event
|
|
await activeForm.Load(e);
|
|
|
|
//Is Attachment ? (Photo, Audio, Video, Contact, Location, Document)
|
|
if (e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Contact | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Document | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Location |
|
|
e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Photo | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Video | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Audio)
|
|
{
|
|
await activeForm.SentData(new DataResult(e));
|
|
}
|
|
|
|
//Render Event
|
|
if (!ds.FormSwitched)
|
|
{
|
|
await activeForm.RenderControls(e);
|
|
|
|
await activeForm.Render(e);
|
|
}
|
|
|
|
e.IsFirstHandler = false;
|
|
|
|
} while (ds.FormSwitched && i < NavigationMaximum);
|
|
|
|
|
|
}
|
|
|
|
private async void Client_MessageEdit(object sender, MessageResult e)
|
|
{
|
|
if (this.SkipAllMessages)
|
|
return;
|
|
|
|
try
|
|
{
|
|
DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
|
|
e.Device = ds;
|
|
|
|
if (LogAllMessages)
|
|
{
|
|
OnMessage(new MessageIncomeEventArgs(e.DeviceId, ds, e));
|
|
}
|
|
|
|
//Call same, to handle received liked edited
|
|
ds?.OnMessageReceived(new MessageReceivedEventArgs(e.Message));
|
|
|
|
await Client_TryMessageEdit(sender, e);
|
|
}
|
|
catch (Telegram.Bot.Exceptions.ApiRequestException ex)
|
|
{
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
|
|
OnException(new SystemExceptionEventArgs(e.Message.Text, ds?.DeviceId ?? -1, ds, ex));
|
|
}
|
|
}
|
|
|
|
private async Task Client_TryMessageEdit(object sender, MessageResult e)
|
|
{
|
|
DeviceSession ds = e.Device;
|
|
if (ds == null)
|
|
{
|
|
ds = await this.Sessions.StartSession<T>(e.DeviceId);
|
|
e.Device = ds;
|
|
}
|
|
|
|
ds.ChatTitle = e.Message.Chat.Username ?? e.Message.Chat.Title;
|
|
ds.LastAction = DateTime.Now;
|
|
ds.LastMessage = e.Message;
|
|
|
|
//Pre Loading Event
|
|
await ds.ActiveForm.Edited(e);
|
|
|
|
//When form has been switched due navigation within the edit method, reopen Client_Message
|
|
if (ds.FormSwitched)
|
|
{
|
|
await Client_TryMessage(sender, e);
|
|
}
|
|
|
|
}
|
|
|
|
private void Client_Action(object sender, MessageResult e)
|
|
{
|
|
try
|
|
{
|
|
DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
|
|
e.Device = ds;
|
|
|
|
if (LogAllMessages)
|
|
{
|
|
OnMessage(new MessageIncomeEventArgs(e.DeviceId, ds, e));
|
|
}
|
|
|
|
Client_TryAction(sender, e);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
|
|
OnException(new SystemExceptionEventArgs(e.Message.Text, ds?.DeviceId ?? -1, ds, ex));
|
|
}
|
|
}
|
|
|
|
private async void Client_TryAction(object sender, MessageResult e)
|
|
{
|
|
DeviceSession ds = e.Device;
|
|
if (ds == null)
|
|
{
|
|
ds = await this.Sessions.StartSession<T>(e.DeviceId);
|
|
e.Device = ds;
|
|
}
|
|
|
|
ds.ChatTitle = e.Message.Chat.Username ?? e.Message.Chat.Title;
|
|
ds.LastAction = DateTime.Now;
|
|
ds.LastMessage = e.Message;
|
|
|
|
FormBase activeForm = null;
|
|
|
|
int i = 0;
|
|
|
|
//Should formulars get navigated (allow maximum of 10, to dont get loops)
|
|
do
|
|
{
|
|
i++;
|
|
|
|
//Reset navigation
|
|
ds.FormSwitched = false;
|
|
|
|
activeForm = ds.ActiveForm;
|
|
|
|
//Pre Loading Event
|
|
await activeForm.PreLoad(e);
|
|
|
|
//Send Load event to controls
|
|
await activeForm.LoadControls(e);
|
|
|
|
//Loading Event
|
|
await activeForm.Load(e);
|
|
|
|
//Action Event
|
|
if (!ds.FormSwitched)
|
|
{
|
|
//Send Action event to controls
|
|
await activeForm.ActionControls(e);
|
|
|
|
//Send Action event to form itself
|
|
await activeForm.Action(e);
|
|
|
|
if (!e.Handled)
|
|
{
|
|
var uhc = new UnhandledCallEventArgs(e.Message.Text, e.RawData, ds.DeviceId, e.MessageId, e.Message, ds);
|
|
OnUnhandledCall(uhc);
|
|
|
|
if (uhc.Handled)
|
|
{
|
|
if (ds.FormSwitched)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//Render Event
|
|
if (!ds.FormSwitched)
|
|
{
|
|
await activeForm.RenderControls(e);
|
|
|
|
await activeForm.Render(e);
|
|
}
|
|
|
|
e.IsFirstHandler = false;
|
|
|
|
} while (ds.FormSwitched && i < NavigationMaximum);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loads the previously saved states from the machine.
|
|
/// </summary>
|
|
private async void LoadSessionStates()
|
|
{
|
|
if (this.StateMachine == null)
|
|
{
|
|
throw new ArgumentNullException("StateMachine", "No StateMachine defined. Please set one to property BotBase.StateMachine");
|
|
}
|
|
|
|
var container = this.StateMachine.LoadFormStates();
|
|
|
|
foreach (var s in container.States)
|
|
{
|
|
Type t = Type.GetType(s.QualifiedName);
|
|
if (t == null || !t.IsSubclassOf(typeof(FormBase)))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var form = t.GetConstructor(new Type[] { }).Invoke(new object[] { }) as FormBase;
|
|
|
|
if (s.Values != null && s.Values.Count > 0)
|
|
{
|
|
var properties = s.Values.Where(a => a.Key.StartsWith("$"));
|
|
var fields = form.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic).Where(a => a.GetCustomAttributes(typeof(SaveState), true).Length != 0).ToList();
|
|
|
|
foreach (var p in properties)
|
|
{
|
|
var f = fields.FirstOrDefault(a => a.Name == p.Key.Substring(1));
|
|
if (f == null)
|
|
continue;
|
|
|
|
try
|
|
{
|
|
f.SetValue(form, p.Value);
|
|
}
|
|
catch (ArgumentException ex)
|
|
{
|
|
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
//Is Subclass of IStateForm
|
|
var iform = form as IStateForm;
|
|
if (iform != null)
|
|
{
|
|
var ls = new LoadStateEventArgs();
|
|
ls.Values = s.Values;
|
|
iform.LoadState(ls);
|
|
}
|
|
|
|
|
|
form.Client = Client;
|
|
var device = new DeviceSession(s.DeviceId, form);
|
|
|
|
device.ChatTitle = s.ChatTitle;
|
|
|
|
this.Sessions.SessionList.Add(s.DeviceId, device);
|
|
|
|
try
|
|
{
|
|
await form.OnInit(new InitEventArgs());
|
|
|
|
await form.OnOpened(new EventArgs());
|
|
}
|
|
catch
|
|
{
|
|
//Skip on exception
|
|
this.Sessions.SessionList.Remove(s.DeviceId);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Saves all open states into the machine.
|
|
/// </summary>
|
|
private void SaveSessionStates()
|
|
{
|
|
if (this.StateMachine == null)
|
|
{
|
|
throw new ArgumentNullException("StateMachine", "No StateMachine defined. Please set one to property BotBase.StateMachine");
|
|
}
|
|
|
|
var states = new List<StateEntry>();
|
|
|
|
foreach (var s in Sessions.SessionList)
|
|
{
|
|
if (s.Value == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var form = s.Value.ActiveForm;
|
|
|
|
|
|
try
|
|
{
|
|
var se = new StateEntry();
|
|
se.DeviceId = s.Key;
|
|
se.ChatTitle = s.Value.ChatTitle;
|
|
se.FormUri = form.GetType().FullName;
|
|
se.QualifiedName = form.GetType().AssemblyQualifiedName;
|
|
|
|
if (form.GetType().GetCustomAttributes(typeof(IgnoreState), true).Length != 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//Is Subclass of IStateForm
|
|
var iform = form as IStateForm;
|
|
if (iform != null)
|
|
{
|
|
//Loading Session states
|
|
SaveStateEventArgs ssea = new SaveStateEventArgs();
|
|
iform.SaveState(ssea);
|
|
|
|
se.Values = ssea.Values;
|
|
}
|
|
|
|
//Search for public properties with SaveState attribute
|
|
var fields = form.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic).Where(a => a.GetCustomAttributes(typeof(SaveState), true).Length != 0).ToList();
|
|
|
|
foreach (var f in fields)
|
|
{
|
|
var val = f.GetValue(form);
|
|
|
|
se.Values.Add("$" + f.Name, val);
|
|
}
|
|
|
|
states.Add(se);
|
|
}
|
|
catch
|
|
{
|
|
//Continue on error (skip this form)
|
|
continue;
|
|
}
|
|
}
|
|
|
|
var sc = new StateContainer();
|
|
sc.States = states;
|
|
|
|
this.StateMachine.SaveFormStates(new SaveStatesEventArgs(sc));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Will be called if a session/context gets started
|
|
/// </summary>
|
|
|
|
public event EventHandler<SessionBeginEventArgs> SessionBegins
|
|
{
|
|
add
|
|
{
|
|
this.__Events.AddHandler(__evSessionBegins, value);
|
|
}
|
|
remove
|
|
{
|
|
this.__Events.RemoveHandler(__evSessionBegins, value);
|
|
}
|
|
}
|
|
|
|
public void OnSessionBegins(SessionBeginEventArgs e)
|
|
{
|
|
(this.__Events[__evSessionBegins] as EventHandler<SessionBeginEventArgs>)?.Invoke(this, e);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Will be called on incomming message
|
|
/// </summary>
|
|
public event EventHandler<MessageIncomeEventArgs> Message
|
|
{
|
|
add
|
|
{
|
|
this.__Events.AddHandler(__evMessage, value);
|
|
}
|
|
remove
|
|
{
|
|
this.__Events.RemoveHandler(__evMessage, value);
|
|
}
|
|
}
|
|
|
|
public void OnMessage(MessageIncomeEventArgs e)
|
|
{
|
|
(this.__Events[__evMessage] as EventHandler<MessageIncomeEventArgs>)?.Invoke(this, e);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Will be called if a system call gets raised
|
|
/// </summary>
|
|
public event SystemCallEventHandler SystemCall;
|
|
|
|
|
|
public async Task OnSystemCall(SystemCallEventArgs e)
|
|
{
|
|
if (this.SystemCall != null)
|
|
await SystemCall(this, e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Will be called on an inner exception
|
|
/// </summary>
|
|
public event EventHandler<SystemExceptionEventArgs> Exception
|
|
{
|
|
add
|
|
{
|
|
this.__Events.AddHandler(__evException, value);
|
|
}
|
|
remove
|
|
{
|
|
this.__Events.RemoveHandler(__evException, value);
|
|
}
|
|
}
|
|
|
|
public void OnException(SystemExceptionEventArgs e)
|
|
{
|
|
(this.__Events[__evException] as EventHandler<SystemExceptionEventArgs>)?.Invoke(this, e);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Will be called if no form handeled this call
|
|
/// </summary>
|
|
public event EventHandler<UnhandledCallEventArgs> UnhandledCall
|
|
{
|
|
add
|
|
{
|
|
this.__Events.AddHandler(__evUnhandledCall, value);
|
|
}
|
|
remove
|
|
{
|
|
this.__Events.RemoveHandler(__evUnhandledCall, value);
|
|
}
|
|
}
|
|
|
|
public void OnUnhandledCall(UnhandledCallEventArgs e)
|
|
{
|
|
(this.__Events[__evUnhandledCall] as EventHandler<UnhandledCallEventArgs>)?.Invoke(this, e);
|
|
|
|
}
|
|
}
|
|
}
|