public ActionResult DeleteXml()
{
try
{
string fileName = Request.Form["FileName"];
if (string.IsNullOrEmpty(fileName))
{
throw new Exception("Invalid file name.");
}
string path = RssFeedHelper.GetFilePath(fileName);
FileInfo info = new FileInfo(path);
if (!info.Exists)
{
throw new HttpException(404, string.Format(@"The file ""{0}"" does not exists.", fileName));
}
info.Delete();
SuccessNotification(string.Format(@"The file ""{0}"" has been deleted successfully.", fileName));
}
catch (Exception e)
{
ErrorNotification(e);
}
return(RedirectToConfiguration());
}
public static void Create()
{
BaseScrapping bloomberght = new Bloomberght();
try
{
while (true)
{
Thread.Sleep(3000);
string latestNews = bloomberght.GetLatestUpdate();
if (RssFeedHelper.IsContentExists(latestNews) && !string.IsNullOrEmpty(latestNews))
{
RssFeedHelper.Save("ty-scrap-news", latestNews);
}
GC.Collect();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Create();
}
}
public ActionResult Configure(ConfigurationModel model)
{
DirectoryInfo info = new DirectoryInfo(RssFeedHelper.GetFilePath(""));
Directory.CreateDirectory(info.FullName);
model.Files = info.GetFiles("*.xml").OrderByDescending(p => p.CreationTime).ToArray();
if (!ModelState.IsValid)
{
return(View("~/Plugins/AF.Nop.Plugins.RssFeed/Views/Configure.cshtml", model));
}
try
{
_rssFeedSettings.EnabledSchedule = model.EnabledSchedule;
_rssFeedSettings.Locales.Clear();
foreach (var m in model.Locales)
{
_rssFeedSettings.Locales.Add(new RssFeedSettingLocale()
{
Title = m.Title,
Link = m.Link,
FileName = m.FileName,
Description = m.Description,
LanguageId = m.LanguageId
});
}
_rssFeedSettings.RebuildJson();
_rssFeedSettings.EnabledSchedule = model.EnabledSchedule;
_rssFeedSettings.TaskRunTime = model.TaskRunTime;
_rssFeedSettings.TaskCheckTime = model.TaskCheckTime;
var task = _scheduleTaskService.GetTaskById(_rssFeedSettings.TaskId);
if (task == null)
{
ErrorNotification("The schedualTaskId is corrupted. So, the plugin cannot be run in a schedule till this value is retrieved correctly.");
}
else
{
task.Enabled = model.EnabledSchedule;
task.Seconds = model.TaskCheckTime;
_scheduleTaskService.UpdateTask(task);
_rssFeedSettings.TaskName = task.Name;
}
SuccessNotification(_localizationService.GetResource("Admin.Configuration.Updated"));
_settingService.SaveSetting(_rssFeedSettings);
_settingService.ClearCache();
return(Configure());
}
catch (Exception ex)
{
ErrorNotification(ex);
return(View("~/Plugins/AF.Nop.Plugins.RssFeed/Views/Configure.cshtml", model));
}
}
public void GeneratRssFeedFiles(IList <ProductVariant> products)
{
try
{
var rssFeeds = CreateRssFeeds(products);
var path = RssFeedHelper.GetFilePath("");
Directory.CreateDirectory(path);
var xmlSettings = new XmlWriterSettings();
xmlSettings.Indent = true;
xmlSettings.Encoding = Encoding.UTF8;
foreach (var local in _rssFeedSettings.Locales)
{
var fileName = Path.Combine(path, local.FileName);
string fileNameAll = Path.Combine(path, Path.GetFileNameWithoutExtension(local.FileName) + "-all." + Path.GetExtension(local.FileName));
var tt1 = DateTime.Now.Ticks;
var feedsAll = rssFeeds[local.LanguageId];
var feedsWithoutCallForPrice = new Rss20()
{
Version = feedsAll.Version,
Channel = new Rss20Channel()
{
Title = feedsAll.Channel.Title,
Link = feedsAll.Channel.Link,
Description = feedsAll.Channel.Description,
Items = feedsAll.Channel.Items.Where(x => x.CallForPrice == false).ToList(),
},
};
XmlSerializer serializer = new XmlSerializer(typeof(Rss20));
var ns = new XmlSerializerNamespaces();
ns.Add("g", RssFeedHelper.GoogleNamespce);
using (var stream = XmlWriter.Create(fileNameAll, xmlSettings))
{
serializer.Serialize(stream, feedsAll, ns);
stream.Close();
_logger.Information($"RssFeed: the file {fileNameAll} has been saved");
}
using (var stream = XmlWriter.Create(fileName, xmlSettings))
{
serializer.Serialize(stream, feedsWithoutCallForPrice, ns);
stream.Close();
_logger.Information($"RssFeed: the file {fileName} has been saved");
}
}
}
catch (Exception ex)
{
_logger.Error("RssFeed: error occured in generating XML files", ex);
throw;
}
}
public void Execute()
{
Session session = SessionHelper.GetSession(_messageEventArgs.Message.From.Id);
if (session.InstructionId.Equals(NextInstruction.None))
{
return;
}
if (session.InstructionId.Equals(NextInstruction.AddRss))
{
if (RssHelper.IsRss(_messageEventArgs.Message.Text.Trim()))
{
Response <RssEntity> Validation = _queryRssService.Get(_messageEventArgs.Message.From.Id, _messageEventArgs.Message.Text.Trim());
if (Validation.ResponseData == null)
{
session.InstructionId = NextInstruction.AddAlias;
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, $"enter alias name for the rss.").GetAwaiter();
session.Payload = _messageEventArgs.Message.Text.Trim();
}
else
{
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, "rss is already exist in list.").GetAwaiter();
}
}
else
{
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, "rss is not found. please enter valid url.").GetAwaiter();
}
}
else if (session.InstructionId.Equals(NextInstruction.AddAlias))
{
Response <int> response = _commandRssService.Add(new RssEntity()
{
Url = session.Payload, AliasName = _messageEventArgs.Message.Text.Trim(), UserId = _messageEventArgs.Message.From.Id
});
if (response.Type.Equals(ResponseType.Success))
{
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, "rss added to list").GetAwaiter();
session.InstructionId = NextInstruction.None;
}
else if (response.Type.Equals(ResponseType.AlreadyExist))
{
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, "alias name is already exist. please enter unique name").GetAwaiter();
}
}
else if (session.InstructionId.Equals(NextInstruction.BugReport))
{
RssFeedHelper.SaveBugReport($"bug from {_messageEventArgs.Message.Chat.Id}", _messageEventArgs.Message.Text);
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, "thank you for your report.").GetAwaiter();
session.InstructionId = NextInstruction.None;
}
}
public async Task <FeedItem> RefreshFeedItem(FeedItem feedItem)
{
try
{
if (feedItem != null)
{
//get new episodes from saved URI in feedItem
var doc = await RssFeedHelper.GetXDocFromLinkAsync(feedItem.Link);
//update ImageLink and ImageFileName for FeedItem
var feedItemFromXDoc = FeedItemManager.GetFeedItemFromXDoc(doc, feedItem.Link);
feedItem.ImageLink = feedItemFromXDoc.ImageLink; //new image on FeedItem for new episode
feedItem.ImageFileName = feedItemFromXDoc.ImageFileName;
feedItem.LastCheck = DateTime.Now; //save LastCheck
var result = await DataStore.SaveFeedItemAsync(feedItem);
if (result == 0)
{
Debug.WriteLine("Could Not update FeedItem with new LastCheck date");
}
//get new episodes from saved URI in feedItem
var episodes = RssEpisodeManager.GetRssEpisodesFromXDoc(doc, feedItem.Id.Value);
//save new episodes to database
result = await DataStore.AddEpisodesToFeed(episodes); //returns the number of items added
if (result == 0)
{
Debug.WriteLine("FeedItemManager.RefreshFeedItem Result from AddEpisodesToFeed was 0 ");
}
//check existing episodes for undownloaded images
var existingEpisodes = await DataStore.GetAllEpisodeItemsByFeedIdAsync((int)feedItem.Id);
foreach (var episode in existingEpisodes)
{
if (DownloadService.CanDownloadImage(episode)) //check if image is already downloaded
{
await DownloadService.Instance.DownloadImageAsync(episode); //queue to download
}
}
}
}
catch (Exception ex)
{
//could not refresh item
Debug.WriteLine("FeedItemManager.RefreshFeedItem Error " + ex.Message);
}
return(feedItem);
}
public ActionResult AddRss(string rssUrl)
{
try
{
if (ModelState.IsValid && rssUrl != null)
{
Response.Cookies["rssUrl"].Value = rssUrl;
List <News> newsLIst = RssFeedHelper.ReadRssToNews(rssUrl, 1);
db.Newses.AddRange(newsLIst);
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch
{
return(RedirectToAction("Index"));
}
}
public ActionResult DownloadXml(string fileName)
{
try
{
string path = RssFeedHelper.GetFilePath(fileName);
FileInfo info = new FileInfo(path);
if (!info.Exists)
{
throw new HttpException(404, string.Format(@"The file ""{0}"" does not exists.", fileName));
}
return(File(path, "text/xml", fileName));
}
catch (Exception xp)
{
ErrorNotification(xp);
return(RedirectToConfiguration());
}
}
//******************************** Static Functions **************************************
public static List <RssEpisode> GetRssEpisodesFromXDoc(XDocument doc, int feedItemId)
{ //used in AddFeedItem and RefreshEpisodes
var episodes = new List <RssEpisode>();
try
{
foreach (var channel in doc.Descendants("channel"))
{
foreach (var item in channel.Descendants("item"))
{
var imageLink = RssFeedHelper.GetITunesImageUriFromXElement(item);
var imageFileName = Path.GetFileName(imageLink);
var podcastLink = RssFeedHelper.GetEnclosureUriFromXElement(item.Element("enclosure"));
var podcastFileName = Path.GetFileName(podcastLink);
var episode = new RssEpisode
{
FeedItemId = feedItemId,
Author = RssFeedHelper.ConvertXElementToString(item.Element("author")),
Description = RssFeedHelper.ConvertXElementToString(item.Element("description")),
PubDate = RssFeedHelper.ConvertXElementToDateTime(item.Element("pubDate")),
Title = RssFeedHelper.ConvertXElementToString(item.Element("title")),
LinkUrl = RssFeedHelper.ConvertXElementToString(item.Element("link")),
ImageLink = imageLink,
ImageFileName = imageFileName,
EnclosureLink = podcastLink,
PodcastFileName = podcastFileName,
IsDownloaded = IsDownloadedEnum.NotDownloaded,
CurrentPosition = 0,
Duration = 0, //reset to correct size when downloaded
PodcastFileSize = 0, //reset to correct size when downloaded
IsPlaying = IsPlayingEnum.NotStarted,
PlayPauseDownloadIcon = IconFont.FileDownload
};
episodes.Add(episode);
}
}
}
catch (Exception ex)
{
Debug.WriteLine("GetRssEpisodesFromXDoc Error " + ex.Message);
}
return(episodes);
}
public static FeedItem GetFeedItemFromXDoc(XDocument doc, string uri)
{
var feedItem = new FeedItem();
//populate feedItem
foreach (var channel in doc.Descendants("channel"))
{
if (channel != null)
{
var imageLink = RssFeedHelper.GetImageUriFromXElement(channel.Element("image"));
var imageFileName = Path.GetFileName(imageLink);
feedItem.Text = RssFeedHelper.ConvertXElementToString(channel.Element("title"));
feedItem.Description = RssFeedHelper.ConvertXElementToString(channel.Element("description"));
feedItem.Link = uri;
feedItem.ImageLink = imageLink;
feedItem.ImageFileName = imageFileName;
feedItem.LastCheck = DateTime.Now; //save LastCheck
}
}
return(feedItem);
}
public ActionResult Configure()
{
ConfigurationModel model = new ConfigurationModel();
var defaultLanguage = _languageService.GetAllLanguages().FirstOrDefault();
model.TaskId = _rssFeedSettings.TaskId;
model.TaskName = _rssFeedSettings.TaskName;
model.TaskRunTime = _rssFeedSettings.TaskRunTime;
model.TaskCheckTime = _rssFeedSettings.TaskCheckTime;
model.LastRunTime = _rssFeedSettings.LastRunTime;
model.EnabledSchedule = _rssFeedSettings.EnabledSchedule;
DirectoryInfo info = new DirectoryInfo(RssFeedHelper.GetFilePath(""));
Directory.CreateDirectory(info.FullName);
model.Files = info.GetFiles("*.xml").OrderByDescending(p => p.CreationTime).ToArray();
_rssFeedSettings.RebuildList();
AddLocales(_languageService, model.Locales);
foreach (var m in model.Locales)
{
foreach (var s in _rssFeedSettings.Locales)
{
if (m.LanguageId == s.LanguageId)
{
m.Link = s.Link;
m.Title = s.Title;
m.Description = s.Description;
m.FileName = s.FileName;
break;
}
}
}
return(View("~/Plugins/AF.Nop.Plugins.RssFeed/Views/Configure.cshtml", model));
}
protected Dictionary <int, Rss20Item> CreateProductRssItems(ProductVariant productVariant, IList <RssFeedSettingLocale> locales)
{
decimal price, salePrice;
string imageUrl = null;
var product = productVariant.Product;
var dic = new Dictionary <int, Rss20Item>();
var categories = _categoryService.GetProductCategoriesByProductId(product.Id).Select(x => x.Category).ToList();
CalculateProductPrices(productVariant, StoreCurrency, out price, out salePrice);
var brand = product.ProductManufacturers.OrderBy(x => x.DisplayOrder).FirstOrDefault();
var picture = product.GetDefaultProductPicture(_pictureService);
if (picture != null)
{
imageUrl = _pictureService.GetPictureUrl(picture, _rssFeedSettings.ImageSize).Replace("https://", "http://");
}
foreach (var L in locales)
{
var lang = _languageService.GetLanguageById(L.LanguageId);;
var item = new Rss20Item()
{
ProductId = product.Id,
Title = product.GetLocalized(x => x.Name, lang.Id),
Description = product.GetLocalized(x => x.FullDescription, lang.Id),
Price = FormatPrice(price, StoreCurrency),
SalePrice = FormatPrice(salePrice, StoreCurrency),
Link = GetProductUrl(productVariant, lang, L.Link),
MPN = productVariant.Sku,
Gtin = productVariant.Sku,
Condition = "new",
Image = imageUrl,
Availability = productVariant.StockQuantity > 0 ? "in stock" : "out of stock",
ExpirationDate = DateTime.Now.AddDays(29).ToString("yyyy-MM-dd"),
CallForPrice = productVariant.CallForPrice,
};
item.ProductType.AddRange(GetCategorieBreadCrumbs(categories, lang));
if (!string.IsNullOrEmpty(item.Description))
{
item.Description = RssFeedHelper.HtmlToPlainText(item.Description);
}
if (brand != null)
{
item.Brand = brand.Manufacturer.GetLocalized(x => x.Name, lang.Id);
}
dic[L.LanguageId] = item;
}
//CleanInvalidXmlChars(item.Title);
//CleanInvalidXmlChars(item.MPN);
//CleanInvalidXmlChars(item.Gtin);
//CleanInvalidXmlChars(item.Brand);
//CleanInvalidXmlChars(item.Description);
return(dic);
}
public async Task ExecuteNewFeedItemCommand()
{
IsBusy = true;
try
{
var doc = await RssFeedHelper.GetXDocFromLinkAsync(Link);
if (doc != null)
{
var newFeedItem = FeedItemManager.GetFeedItemFromXDoc(doc, Link);
if (newFeedItem != null)
{
var successFeedImage = await FileHelper.DownloadImageFile(newFeedItem.ImageLink);
if (!successFeedImage)
{
Debug.WriteLine("Could not download feed image file " + newFeedItem.ImageLink);
}
var result = await DataStore.SaveFeedItemAsync(newFeedItem);
if (newFeedItem.Id != null)
{
//defensive programming, delete any existing records for this new FeedItem.Id
//this is because Ids get reused and not all the episodes in and Id might get deleted
try
{
result = await DataStore.DeleteAllEpisodesByFeedIdAsync(newFeedItem.Id); //don't care about the result
}
catch (Exception ex)
{
Debug.WriteLine("Info Error Deleting Episodes before adding new Feed Item " + ex.Message);
}
var episodeList = RssEpisodeManager.GetRssEpisodesFromXDoc(doc, newFeedItem.Id.Value); //get the episodes
result = await DataStore.SaveEpisodeListAsync(episodeList); //save the episodes
//get the images
var count = 0;
var lastImageLink = "";
foreach (var episode in episodeList)
{
if (lastImageLink != episode.ImageLink)
{ //don't try to download when the image is the same from episode to episode
lastImageLink = episode.ImageLink;
await DownloadService.Instance.DownloadImageAsync(episode);
}
count++;
//if (count > 20) break; //only get 20, not like 1000
}
MessagingCenter.Send(newFeedItem, "AddFeedItem");
}
else
{
//newFeedItem.Id was null
Debug.WriteLine("newFeedItem.Id was null");
}
}
else
{
//newFeedItem was null
Debug.WriteLine("newFeedItem was null");
}
}
else
{
//problem getting feed
await Application.Current.MainPage.DisplayAlert("Alert", "Could not get RSS Feed from Link", "OK");
}
}
catch (Exception ex)
{
//could not delete item
Debug.WriteLine("Could not Add Podcast Feed Item " + ex.Message);
}
finally
{
IsBusy = false;
}
}
