private void RemoveSubscription(IrcMessage theMessage)
{
if (theMessage.CommandArgs.Count < 3)
{
theMessage.Answer("Die Funktion benötigt 3 Parameter: !subscribe remove <PluginName> <SubscriptionProvider>");
return;
}
PluginInfo plugin = PluginManager.Plugins.SingleOrDefault(x => x.IsNamed(theMessage.CommandArgs[1]));
if (plugin == null)
{
theMessage.Answer("Ein solches Plugin konnte ich nicht ausfindig machen");
return;
}
SubscriptionProvider provider = PluginManager.Plugins.SingleOrDefault(x => x.IsNamed(theMessage.CommandArgs[2])).As <SubscriptionProvider>();
if (provider == null)
{
theMessage.Answer("Es gibt keinen solchen SubscriptionProvider");
return;
}
using (var context = new BotContext())
{
Subscription sub = context.Subscriptions.FirstOrDefault(x => x.User == context.GetUser(theMessage.Nickname) && x.Provider == provider.PluginID && x.Plugin == plugin.ID);
if (sub != null)
{
context.Subscriptions.Remove(sub);
theMessage.Answer("Subscription entfernt");
}
else
{
theMessage.Answer("Ich konnte keine Zutreffende Subscription finden die ich hätte entfernen können");
}
}
}
public SelfConfigController()
{
_userProvider = new UserProvider(_httpClient);
_projectProvider = new ProjectProvider(_httpClient);
_subscriptionProvider = new SubscriptionProvider(_httpClient, _projectProvider);
_selfConfigManager = new SelfConfigManager(_subscriptionProvider, _projectProvider);
}
private void HelpSubscription(IrcMessage theMessage)
{
if (theMessage.CommandArgs.Count < 2)
{
theMessage.Answer("Die Funktion benötigt 2 Parameter: !subscribe help <SubscriptionProvider>");
return;
}
SubscriptionProvider provider = PluginManager.Plugins.SingleOrDefault(x => x.Names.Contains(theMessage.CommandArgs[1], StringComparer.OrdinalIgnoreCase)).As <SubscriptionProvider>();
if (provider == null)
{
theMessage.Answer("Es gibt keinen solchen SubscriptionProvider");
return;
}
HelpAttribute help = provider.GetType().GetCustomAttribute <HelpAttribute>();
if (help != null)
{
theMessage.Answer(help.Help);
}
else
{
theMessage.Answer("Der Subscription Provider bietet keine Hilfe an");
}
}
public bool IsSubscribed(ProjectEntity entity, Guid recipientID)
{
var recipient = RecipientProvider.GetRecipient(recipientID.ToString());
var objects = new List <String>(SubscriptionProvider.GetSubscriptions(NotifyAction, recipient));
return(!String.IsNullOrEmpty(objects.Find(item => String.Compare(item, entity.NotifyId, StringComparison.OrdinalIgnoreCase) == 0)));
}
public void Unsubscribe(string key)
{
var provider = new SubscriptionProvider(_subscriptionRepositoryFactory());
string email = provider.Unsubscribe(key);
var emailMessage = EmailComposer.GetUnsubscribenMail(email);
EmailSender.SendEmail(emailMessage);
}
public void ConfirmSubscription(string key)
{
var provider = new SubscriptionProvider(_subscriptionRepositoryFactory());
SubscriptionResponse response = provider.Confirm(key);
var mail = EmailComposer.GetSubscriptionConfirmedMail(response);
EmailSender.SendEmail(mail);
}
public void Subscribe(SubscriptionInfo subscription)
{
var provider = new SubscriptionProvider(_subscriptionRepositoryFactory());
SubscriptionResponse response = provider.Add(subscription);
var emailMessage = EmailComposer.GetConfirmSubscriptionMail(response);
EmailSender.SendEmail(emailMessage);
}
public bool IsSubscribed(ProjectEntity entity, Guid recipientID)
{
var recipient = RecipientProvider.GetRecipient(recipientID.ToString());
var objects = SubscriptionProvider.GetSubscriptions(NotifyAction, recipient);
return(objects.Any(item => string.Compare(item, entity.NotifyId, StringComparison.OrdinalIgnoreCase) == 0));
}
private bool IsEmptyNewCommentsSubscriptionType(Guid productID, Guid moduleOrGroupID, Guid typeID)
{
var currentAccount = SecurityContext.CurrentAccount;
var list = new List<string>(
SubscriptionProvider.GetSubscriptions(
BookmarkingBusinessConstants.NotifyActionNewComment,
new DirectRecipient(currentAccount.ID.ToString(), currentAccount.Name), false)
);
return list.Count == 0;
}
public void UnSubscribe(ProjectEntity entity, Guid recipientID)
{
var recipient = RecipientProvider.GetRecipient(recipientID.ToString());
if (recipient == null)
{
return;
}
SubscriptionProvider.UnSubscribe(NotifyAction, entity.NotifyId, recipient);
}
private bool IsEmptySubscriptionType(Guid productID, Guid moduleID, Guid typeID)
{
var type = GetSubscriptionTypes().Find(t => t.ID.Equals(typeID));
var objIDs = SubscriptionProvider.GetSubscriptions(type.NotifyAction, new DirectRecipient(SecurityContext.CurrentAccount.ID.ToString(), ""), false);
if (objIDs != null && objIDs.Length > 0)
{
return(false);
}
return(true);
}
private static void SetupSubscription(IrcMessage theMessage)
{
Contract.Requires(theMessage != null);
SubscriptionProvider provider = PluginManager.Plugins.FirstOrDefault(x => x.IsNamed(theMessage.CommandArgs[1])).As <SubscriptionProvider>();
if (provider == null)
{
theMessage.Answer("Es gibt keinen SubscriptionProvider namens " + theMessage.CommandArgs[1]);
return;
}
provider.ParseSubscriptionSetup(theMessage);
}
public void Subscribe(ProjectEntity entity, Guid recipientID)
{
var recipient = RecipientProvider.GetRecipient(recipientID.ToString());
if (recipient == null)
{
return;
}
if (!IsUnsubscribed(entity, recipientID) || entity.CanEdit())
{
SubscriptionProvider.Subscribe(NotifyAction, entity.NotifyId, recipient);
}
}
public void Follow(ProjectEntity entity, Guid recipientID)
{
var recipient = RecipientProvider.GetRecipient(recipientID.ToString());
if (recipient == null)
{
return;
}
if (!IsSubscribed(entity, recipientID))
{
SubscriptionProvider.Subscribe(NotifyAction, entity.NotifyId, recipient);
}
else
{
SubscriptionProvider.UnSubscribe(NotifyAction, entity.NotifyId, recipient);
}
}
public void SubscriptionAdd(IrcMessage theMessage)
{
if (theMessage.CommandArgs.Count < 3)
{
theMessage.Answer("Die Funktion benötigt mindestens 3 Parameter: !subscribe add <PluginName> <SubscriptionProvider> <Bedingung>(optional)");
return;
}
SubscriptionProvider provider = PluginManager.Get(theMessage.CommandArgs[2]).As <SubscriptionProvider>();
if (provider == null)
{
theMessage.Answer("Es gibt keinen solchen SubscriptionProvider");
return;
}
if (theMessage.CommandArgs[1] != "*")
{
PluginBase plugin = PluginManager.Get(theMessage.CommandArgs[1]).As <PluginBase>();
if (plugin == null)
{
theMessage.Answer("Ein solches Plugin konnte ich nicht ausfindig machen");
return;
}
if (plugin.GetType().GetCustomAttribute <SubscribeableAttribute>() == null)
{
theMessage.Answer("Dieses Plugin unterstützt keine Benachrichtigungen");
return;
}
provider.AddSubscription(theMessage, plugin);
}
else
{
List <PluginBase> availables = PluginManager.Plugins.Where(x => x.IsSubscribeable).Select(x => x.Plugin).ToList();
foreach (PluginBase plugin in availables)
{
provider.AddSubscription(theMessage, plugin);
}
}
}
public void NotifySubscribers()
{
var provider = new SubscriptionProvider(_subscriptionRepositoryFactory());
provider.DeleteExpiredSubscriptions();
List <SubscriptionInfo> subscriptions = provider.GetConfirmed();
DateRange dateRange = new DateRange {
From = DateTime.Now, To = DateTime.Now.AddDays(3)
};
var weatherProvider = new WeatherProvider(_sources);
foreach (SubscriptionInfo subscription in subscriptions)
{
List <DateTime> rainDates = new List <DateTime>();
Location coords = new Location {
Latitude = subscription.Latitude, Longitude = subscription.Longitude
};
List <Weather> weatherForecast = weatherProvider.GetWeather(dateRange, coords);
foreach (Weather weather in weatherForecast)
{
if (weather.Precipitation == Precipitation.Rain)
{
rainDates.Add(weather.Date);
}
}
if (rainDates.Count > 0)
{
var emailMessage = EmailComposer.GetNotificationMail(subscription, rainDates);
EmailSender.SendEmail(emailMessage);
provider.UpdateNotifyDate(subscription);
}
}
}
public SelfConfigManager(SubscriptionProvider subscriptionProvider, ProjectProvider projectProvider)
{
_subscriptionProvider = subscriptionProvider ?? throw new ArgumentNullException(nameof(subscriptionProvider));
_projectProvider = projectProvider ?? throw new ArgumentNullException(nameof(projectProvider));
}
private List<SubscriptionObject> GetSubscriptionObjects(bool includeBookmarks, bool includeComments)
{
List<SubscriptionObject> subscriptionObjects = new List<SubscriptionObject>();
IList<string> list = new List<string>();
var currentAccount = SecurityContext.CurrentAccount;
if (includeBookmarks)
{
list = new List<string>(
SubscriptionProvider.GetSubscriptions(
BookmarkingBusinessConstants.NotifyActionNewBookmark,
new DirectRecipient(currentAccount.ID.ToString(), currentAccount.Name), false)
);
if (list.Count > 0)
{
foreach (string id in list)
{
if (!string.IsNullOrEmpty(id))
{
subscriptionObjects.Add(new SubscriptionObject()
{
ID = id,
Name = BookmarkingBusinessResources.SubscriptionTypeNewBookmark,
URL = string.Empty,
SubscriptionType = GetSubscriptionTypes()[0]
});
}
}
}
}
if (includeComments)
{
list = new List<string>(
SubscriptionProvider.GetSubscriptions(
BookmarkingBusinessConstants.NotifyActionNewComment,
new DirectRecipient(currentAccount.ID.ToString(), currentAccount.Name), false)
);
if (list.Count > 0)
{
var service = BookmarkingService.GetCurrentInstanse();
foreach (string id in list)
{
if (!string.IsNullOrEmpty(id))
{
try
{
var bookmark = service.GetBookmarkByID(Int32.Parse(id));
subscriptionObjects.Add(new SubscriptionObject()
{
ID = id,
Name = bookmark.Name,
URL = VirtualPathUtility.ToAbsolute("~/Products/Community/Modules/Bookmarking/BookmarkInfo.aspx") + "?Url=" + HttpUtility.UrlEncode(bookmark.URL),
SubscriptionType = GetSubscriptionTypes()[1]
});
}
catch { }
}
}
}
}
return subscriptionObjects;
}
private IEnumerable <string> GetSubscriptions(INotifyAction action)
{
return(SubscriptionProvider.GetSubscriptions(action, NotifySource.Instance.GetRecipientsProvider().GetRecipient(SecurityContext.CurrentAccount.ID.ToString())));
}
protected virtual void DoNotification(Subscription subscription, string message)
{
SubscriptionProvider provider = PluginManager.Plugins.FirstOrDefault(x => x.Id == subscription.Provider).As <SubscriptionProvider>();
provider?.SendNotification(subscription.User, message);
}
public List <IRecipient> GetSubscribers(ProjectEntity entity)
{
return(SubscriptionProvider.GetRecipients(NotifyAction, entity.NotifyId).ToList());
}
public bool IsUnsubscribed(ProjectEntity entity, Guid recipientID)
{
var recipient = RecipientProvider.GetRecipient(recipientID.ToString());
return(recipient != null && SubscriptionProvider.IsUnsubscribe((IDirectRecipient)recipient, NotifyAction, entity.NotifyId));
}
public void UnSubscribeAll <T>(T entity) where T : ProjectEntity
{
SubscriptionProvider.UnSubscribe(NotifyAction, entity.NotifyId);
}
