public async Task StoreAsync <T>(string key, T value)
{
key.NullInspect(nameof(key));
var dbWorker = new GmailDbContextWorker();
var json = JsonConvert.SerializeObject(value);
int userId;
if (!int.TryParse(key, out userId))
{
throw new ArgumentException("Wrong key, it must be an User Id number.", key);
}
var userModel = await dbWorker.FindUserAsync(userId);
if (userModel == null)
{
throw new DbDataStoreException(
$"Can't store refreshed data in database. {nameof(UserModel)} record with id {userId} is absent in the database.");
}
JsonConvert.PopulateObject(json, userModel);
await dbWorker.UpdateUserRecordAsync(userModel);
LogMaker.Log(Logger, $"{nameof(UserModel)} record with userId={userId} updated with new access token.", false);
}
public async Task RestoreServicesFromRepositoryAsync()
{
var gmailDbContextWorker = new GmailDbContextWorker();
var users = await gmailDbContextWorker.GetAllUsersAsync();
if (users == null)
{
return;
}
await Task.Run(() =>
{
users.ForEach(userModel =>
{
var userSettingsModel = gmailDbContextWorker.FindUserSettings(userModel.UserId);
try
{
Instance_AuthorizationRegistredEvent(userModel, userSettingsModel);
}
catch (Exception ex)
{
gmailDbContextWorker.RemoveUserRecord(userModel);
LogMaker.Log(Logger, ex);
}
});
});
}
public void InitializePushNotificationWatchTimer(int updatePeriod)
{
if (UpdatesHandler == null)
{
throw new InvalidOperationException($"{nameof(ServiceFactory)} property must be initialized first.");
}
if (UpdatesHandler == null)
{
throw new InvalidOperationException($"{nameof(MessageHandler)} property must be initialized first.");
}
if (_gmailDbContextWorker == null)
{
_gmailDbContextWorker = new GmailDbContextWorker();
}
//start timer which would be update push notification watch for users which expiration time approaches the end
PushNotificationWatchTimer = new Timer(state =>
{
var userSettings = _gmailDbContextWorker.GetAllUsersSettings();
userSettings.ForEach(us =>
{
var difference = DateTime.UtcNow.Difference(us.Expiration);
if (difference.TotalHours >= 2)
{
return;
}
var service = ServiceFactory?.ServiceCollection.FirstOrDefault(s => s.From == us.UserId);
if (service == null)
{
return;
}
MessageHandler?.HandleStartWatchCommand(service);
});
}, null, updatePeriod, updatePeriod);
}
public async Task SendAuthorizeLink(ISender message, AuthorizeLinks links)
{
try
{
var gmailDbContextWorker = new GmailDbContextWorker();
LogMaker.Log(Logger, $"Start authorizing user with UserId={message.From.Id}.", false);
var userModel = await gmailDbContextWorker.FindUserAsync(message.From.Id) ??
await gmailDbContextWorker.AddNewUserAsync(message.From);
LogMaker.Log(Logger, $"The user with id:{userModel.UserId} has requested authorization", false);
var fullAccessState = Base64.Encode($"{userModel.UserId},{UserAccess.FULL}");
var notifyAccessState = Base64.Encode($"{userModel.UserId},{UserAccess.NOTIFY}");
var pendingUserModel = await gmailDbContextWorker.FindPendingUserAsync(userModel.UserId);
if (pendingUserModel != null)
{
await gmailDbContextWorker.UpdateRecordJoinTimeAsync(pendingUserModel.Id, DateTime.UtcNow);
}
else
{
await gmailDbContextWorker.QueueAsync(userModel.UserId);
}
Uri notifyAccessUri = null;
Uri fullAccessUri = null;
switch (links)
{
case AuthorizeLinks.Both:
notifyAccessUri = GetAuthenticationUri(notifyAccessState, UserAccessAttribute.GetScopesValue(UserAccess.NOTIFY));
fullAccessUri = GetAuthenticationUri(fullAccessState, UserAccessAttribute.GetScopesValue(UserAccess.FULL));
break;
case AuthorizeLinks.Full:
fullAccessUri = GetAuthenticationUri(fullAccessState, UserAccessAttribute.GetScopesValue(UserAccess.FULL));
break;
case AuthorizeLinks.Notify:
notifyAccessUri = GetAuthenticationUri(notifyAccessState, UserAccessAttribute.GetScopesValue(UserAccess.NOTIFY));
break;
default:
throw new ArgumentOutOfRangeException(nameof(links), links, null);
}
await _botActions.AuthorizeMessage(message.From.Id.ToString(), notifyAccessUri, fullAccessUri);
}
catch (Exception ex)
{
throw new AuthorizeException("An error occurred while trying to send the authentication link to the user", ex);
}
}
public ChosenInlineResultHandler()
{
try
{
_botActions = new BotActions(BotInitializer.Instance.BotSettings.Token);
InitRules();
_dbWorker = new GmailDbContextWorker();
BotInitializer.Instance.UpdatesHandler.TelegramChosenInlineEvent += HandleChosenInlineResult;
}
catch (Exception ex)
{
throw new TypeInitializationException(nameof(ChosenInlineResultHandler), ex);
}
}
public InlineQueryHandler()
{
try
{
_botSettings = BotInitializer.Instance.BotSettings;
_botActions = new BotActions(_botSettings.Token);
_dbWorker = new GmailDbContextWorker();
InitFullAccessRules();
InitNotifyAccessRules();
BotInitializer.Instance.UpdatesHandler.TelegramInlineQueryEvent += HandleInlineQuery;
}
catch (Exception ex)
{
throw new TypeInitializationException(nameof(InlineQueryHandler), ex);
}
}
public NotifyHandler()
{
try
{
_botSettings = BotInitializer.Instance.BotSettings;
_botActions = new BotActions(_botSettings.Token);
_messageHandler = BotInitializer.Instance.MessageHandler;
_dbWorker = new GmailDbContextWorker();
var authorizer = BotInitializer.Instance.Authorizer;
authorizer.AuthorizationRegistredEvent += Instance_AuthorizationRegistredEvent;
}
catch (Exception ex)
{
throw new TypeInitializationException(nameof(NotifyHandler), ex);
}
}
public void RestoreServicesFromRepository()
{
var gmailDbContextWorker = new GmailDbContextWorker();
var users = gmailDbContextWorker.GetAllUsers();
users?.ForEach(userModel =>
{
var userSettingsModel = gmailDbContextWorker.FindUserSettings(userModel.UserId);
try
{
Instance_AuthorizationRegistredEvent(userModel, userSettingsModel);
}
catch (Exception ex)
{
gmailDbContextWorker.RemoveUserRecord(userModel);
LogMaker.Log(Logger, ex);
}
});
}
public MessageHandler()
{
try
{
_authorizer = BotInitializer.Instance.Authorizer;
_dbWorker = new GmailDbContextWorker();
_botSettings = BotInitializer.Instance.BotSettings;
_botActions = new BotActions(_botSettings.Token);
InitFullAccessRules();
InitNotifyAccessRules();
InitFullForceReplyRules();
InitNotifyForceReplyRules();
BotInitializer.Instance.UpdatesHandler.TelegramTextMessageEvent += HandleTextMessage;
BotInitializer.Instance.UpdatesHandler.TelegramTextMessageEvent += HandleForceReplyMessage;
BotInitializer.Instance.UpdatesHandler.TelegramDocumentMessageEvent += HandleForceReplyMessage;
BotInitializer.Instance.UpdatesHandler.TelegramAudioMessageEvent += HandleForceReplyMessage;
BotInitializer.Instance.UpdatesHandler.TelegramVideoMessageEvent += HandleForceReplyMessage;
}
catch (Exception ex)
{
throw new TypeInitializationException(nameof(MessageHandler), ex);
}
}
public async Task DeleteAsync <T>(string key)
{
key.NullInspect(nameof(key));
var dbWorker = new GmailDbContextWorker();
int userId;
if (!int.TryParse(key, out userId))
{
throw new ArgumentException("Wrong key, it must be an User Id number.", key);
}
var service = ServiceFactory.Instance?.ServiceCollection.Find(s => s.From == userId);
if (service == null)
{
return;
}
var messageHandler = BotInitializer.Instance?.MessageHandler;
if (messageHandler != null)
{
try
{
await messageHandler.HandleStopWatchCommandAsync(service);
LogMaker.Log(Logger, $"Push notifications receiving has stopped for user with userId={userId}.", false);
}
catch (Exception ex)
{
LogMaker.Log(Logger, ex, $"exception throwed in attempt to stop push notifications. userId={userId}.");
}
}
var userModel = await dbWorker.FindUserAsync(userId);
if (userModel == null)
{
LogMaker.Log(Logger,
$"Error while removing {nameof(UserModel)} record from database. {nameof(UserModel)} record with id {userId} is absent in the database.",
false);
}
else
{
await dbWorker.RemoveUserRecordAsync(userModel);
LogMaker.Log(Logger, $"{nameof(UserModel)} record with userId={userId} deleted.", false);
}
var userSettingsModel = await dbWorker.FindUserSettingsAsync(userId);
if (userSettingsModel == null)
{
LogMaker.Log(Logger,
$"Error while removing {nameof(UserSettingsModel)} record from database. {nameof(UserSettingsModel)} record with id {userId} is absent in the database.",
false);
}
else
{
await dbWorker.RemoveUserSettingsRecordAsync(userSettingsModel);
LogMaker.Log(Logger, $"{nameof(UserSettingsModel)} record with userId={userId} deleted.", false);
}
var nmStoreModel = await dbWorker.FindNmStoreAsync(userId);
if (nmStoreModel != null)
{
await dbWorker.RemoveNmStoreAsync(nmStoreModel);
LogMaker.Log(Logger, $"{nameof(NmStoreModel)} record with userId={userId} deleted.", false);
}
var tempData = await dbWorker.FindTempDataAsync(userId);
if (tempData != null)
{
await dbWorker.RemoveTempDataAsync(tempData);
LogMaker.Log(Logger, $"{nameof(TempDataModel)} record with userId={userId} deleted.", false);
}
ServiceFactory.Instance?.ServiceCollection.Remove(service);
LogMaker.Log(Logger, $"Removed service from {nameof(ServiceFactory.ServiceCollection)} with userId={userId}.", false);
}
#pragma warning disable 4014
private void Authorizer_AuthorizeRequestEvent(string code, string state, string error)
{
int id;
string access;
if (!RestoreState(state, out id, out access))
{
return;
}
UserModel userModel = null;
PendingUserModel pendingUserModel = null;
var gmailDbContextWorker = new GmailDbContextWorker();
try
{
pendingUserModel = gmailDbContextWorker.FindPendingUser(id);
if (!string.IsNullOrEmpty(error))
{
_botActions.AuthorizationFailedMessage(id.ToString());
LogMaker.Log(Logger,
error == "access_denied"
? $"User with id:{id} user declined the authorization request."
: $"Authorization user with id:{id} has faulted with error={error}", false);
return;
}
if (pendingUserModel == null)
{
_botActions.AuthorizationTimeExpiredMessage(id.ToString());
return;
}
if (DateTime.Now.Subtract(pendingUserModel.JoinTimeUtc).Minutes > MaxPendingMinutes)
{
_botActions.AuthorizationTimeExpiredMessage(id.ToString());
LogMaker.Log(Logger,
$"Authorization attempt from user with id:{id} when authorization time has expired.", false);
return;
}
if (string.IsNullOrEmpty(code))
{
LogMaker.Log(Logger, $"Server returned empty authorization code for user with id:{id}.", false);
return;
}
userModel = gmailDbContextWorker.FindUser(id);
if (userModel == null)
{
return;
}
RevokeToken(userModel);
userModel.RefreshToken = null;
ExchangeCodeForToken(code, userModel);
GetTokenInfo(userModel);
var userSettings = gmailDbContextWorker.FindUserSettings(id) ??
gmailDbContextWorker.AddNewUserSettings(id);
userSettings.Access = access;
gmailDbContextWorker.UpdateUserSettingsRecord(userSettings);
AuthorizationRegistredEvent?.Invoke(userModel, userSettings);
_botActions.AuthorizationSuccessfulMessage(id.ToString());
}
catch (Exception ex)
{
gmailDbContextWorker.RemoveUserRecord(userModel);
_botActions.AuthorizationFailedMessage(id.ToString());
throw new AuthorizeException("An error occurred while attempting to authorize the user.", ex);
}
finally
{
if (pendingUserModel != null)
{
gmailDbContextWorker.RemoveFromQueue(pendingUserModel);
}
if (userModel != null)
{
gmailDbContextWorker.UpdateUserRecord(userModel);
}
}
}