public static void Run(
[QueueTrigger("new-podcast", Connection = "AzureWebJobsStorage")] PodCast newPodCast,
[Queue("podcast-to-be-tweeted", Connection = "AzureWebJobsStorage")] ICollector <PodCast> toBeTweeted,
[Queue("podcast-to-be-added-to-weekly-activity", Connection = "AzureWebJobsStorage")] ICollector <PodCast> toBeAddedToWeeklyActivity,
ILogger log)
{
var podCastAge = (DateTime.Now - newPodCast.Created).TotalHours;
// Disable tweeting of Podcast listens
//if (podCastAge < 3)
//{
// toBeTweeted.Add(newPodCast);
//}
toBeAddedToWeeklyActivity.Add(newPodCast);
try
{
BroadcastToActivityBot(newPodCast);
}
catch (Exception ex)
{
log.LogError("Failed to Broadcast to ActivityBot", ex);
}
}
public async Task <IActionResult> Create(PodCastCreateViewModel model)
{
if (ModelState.IsValid)
{
PodCast toBeAddedPodCast = new PodCast
{
Guest = model.Guest,
ReleaseDate = model.ReleaseDate,
Host = model.Host,
Title = model.Title,
Url = model.Url
};
var user = await _userManager.GetUserAsync(HttpContext.User);
_mediaDbContext.PodCasts.Add(toBeAddedPodCast);
await _mediaDbContext.SaveChangesAsync();
UserPodCast newConnection = new UserPodCast
{
User = user,
UserId = user.Id,
PodCast = toBeAddedPodCast,
PodCastId = toBeAddedPodCast.Id
};
_mediaDbContext.UserPodCasts.Add(newConnection);
await _mediaDbContext.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(model));
}
public void AddEpisodeToDownloadList_1_OK()
{
// Arrange:
var podCast = new PodCast(
null,
"x",
new Uri("http://ww.ee"),
"x",
"x");
this.PodCastRepository.SavePodCast(podCast);
var episode = Episode.ConstructEpisode(
Guid.NewGuid().ToString(),
DateTime.Now,
"x",
"x",
new Uri("http://uu.qq"),
podCast,
false);
var episodes = new List <Episode>();
episodes.Add(episode);
this.EpisodeRepository.UpdateEpisodeList(
podCast.Id.Value,
episodes);
// Act:
this.EpisodeRepository.AddEpisodeToDownloadList(
podCast.Id.Value,
episode.Id);
// Assert:
}
public void GetEpisodesToDownload_All_OK()
{
// Arrange:
var podCast = new PodCast(
null,
"x",
new Uri("http://xx.dd"),
"x",
"x");
this.PodCastRepository.SavePodCast(podCast);
var episodes = new List <Episode>();
episodes.Add(Episode.ConstructEpisode(
Guid.NewGuid().ToString(),
DateTime.Now,
"x",
"x",
new Uri("http://xxx.ddd"),
podCast,
true));
this.EpisodeRepository.UpdateEpisodeList(
podCast.Id.Value,
episodes);
// Act:
this.EpisodeRepository.GetEpisodesToDownload();
// Assert:
}
public async Task <IActionResult> PodcastReview(int id, ReviewCreateViewModel reviewCreate)
{
PodCast podcastFromDb = _mediaWebDbContext.PodCasts.Find(id);
Review newReview = new Review()
{
Title = reviewCreate.Title,
Content = reviewCreate.Content,
IsChecked = false
};
var user = _userManager.GetUserAsync(HttpContext.User).Result;
var podcastReviews = new List <PodcastReview>();
user.Reviews.Add(newReview);
podcastReviews.Add(new PodcastReview()
{
Review = newReview
});
podcastFromDb.PodcastReviews = podcastReviews;
_mediaWebDbContext.Reviews.Add(newReview);
await _mediaWebDbContext.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public List <Data.Model.PodCast> getAll()
{
List <PodCast> resultset = new List <PodCast>();
SqlCommand comm = new SqlCommand();
comm.Connection = conn;
comm.CommandText = storedproc;
comm.CommandType = System.Data.CommandType.StoredProcedure;
SqlDataReader dr = comm.ExecuteReader();
if (dr != null)
{
if (dr.HasRows)
{
while (dr.Read())
{
PodCast a = new PodCast(dr["XMLUrl"].ToString(), dr["Name"].ToString(), dr["PodCastRoot"].ToString(), false, null, bool.Parse(dr["DownloadAll"].ToString()), logger);
a.fk_genre = dr["FK_Genre"].ToString();
a.useDefault = bool.Parse(dr["useDefault"].ToString());
a.DefaultArtistName = dr["DefaultArtistName"].ToString();
a.id = Guid.Parse(dr[0].ToString());
resultset.Add(a);
}
}
if (!dr.IsClosed)
{
dr.Close();
dr.Dispose();
}
}
podcasts = resultset;
return(resultset);
}
/// <summary>
/// Saves the pod cast.
/// </summary>
/// <param name="podCast">The pod cast.</param>
/// <exception cref="Uncas.PodCastPlayer.Repository.RepositoryException"></exception>
public void SavePodCast(
PodCast podCast)
{
if (podCast == null ||
podCast.Url == null)
{
return;
}
DBPodCast pc = new DBPodCast
{
Author = podCast.Author,
Description = podCast.Description,
Name = podCast.Name,
Url = podCast.Url.ToString()
};
try
{
this.DB.Add <DBPodCast>(pc);
}
catch (Exception ex)
{
// TODO: EXCEPTION: Unknown SubSonic exceptions
throw new RepositoryException(
"Error trying to add pod cast to database",
ex);
}
podCast.Id = (int)pc.PodCastId;
}
public static async System.Threading.Tasks.Task RunAsync(
[QueueTrigger("podcast-to-be-added-to-weekly-activity", Connection = "AzureWebJobsStorage")] PodCast podCast,
Binder binder,
ILogger log)
{
var week = Week.FromDate(podCast.Created);
var blobName = $"activity-weekly/{week.Year.ToString("0000")}/{week.WeekNumber.ToString("00")}.json";
log.LogInformation($"To save to {blobName}");
var attributes = new Attribute[]
{
new BlobAttribute(blobName),
new StorageAccountAttribute("AzureWebJobsStorage")
};
var blob = await binder.BindAsync <CloudBlockBlob>(attributes);
using (var locker = new CloudBlockBlobLocker <Models.WeekActivity>(blob))
{
var activity = locker.IsNew ?
new Models.WeekActivity(week.Year, week.WeekNumber) :
await locker.Download();
activity.AddPodCast(podCast);
await locker.Upload(activity);
}
}
/// <summary>
/// Saves the pod cast.
/// </summary>
/// <param name="podCast">The pod cast.</param>
public void SavePodCast(PodCastDetailsViewModel podCast)
{
if (podCast.Id.HasValue)
{
var existingPodCast =
PodCasts.Where(pc =>
pc.Id.Value == podCast.Id.Value)
.SingleOrDefault();
if (existingPodCast != null)
{
existingPodCast.Name = podCast.Name;
existingPodCast.Url = podCast.Url;
return;
}
}
int newId =
(PodCasts.Max(pc => pc.Id) ?? 0)
+ 1;
var newPodCast =
new PodCast(
newId,
podCast.Name,
podCast.Url);
PodCasts.Add(newPodCast);
}
public async Task <IActionResult> Detail(int id)
{
PodCast podcastFromDb =
await _mediaWebDbContext.PodCasts
.Include(podcast => podcast.PodCastHosts)
.ThenInclude(podcastHost => podcastHost.Host)
.Include(podcast => podcast.PodCastGuests)
.ThenInclude(podcastGuest => podcastGuest.Guest)
.Include(podcast => podcast.PodcastReviews)
.ThenInclude(podcastReview => podcastReview.Review)
.ThenInclude(review => review.MediaWebUser)
.FirstOrDefaultAsync(m => m.Id == id);
PodcastDetailViewModel detailModel = new PodcastDetailViewModel()
{
Id = podcastFromDb.Id,
Title = podcastFromDb.Title,
ReleaseDate = podcastFromDb.ReleaseDate,
Description = podcastFromDb.Description,
File = podcastFromDb.File,
PodcastHosts = podcastFromDb.PodCastHosts,
PodcastGuests = podcastFromDb.PodCastGuests,
PodcastReviews = podcastFromDb.PodcastReviews.Where(pr => pr.Review.IsChecked == true),
IsHidden = podcastFromDb.IsHidden
};
return(View(detailModel));
}
//Lägger till en pod om den inte redan finns i listan
public override bool Add(PodCast pod)
{
if (!Contains(pod))
{
return(base.Add(pod));
}
return(false);
}
//Genomför en uppdatering av en podcast med en uppdaterad feed
private PodCast PerformPodUpdate(PodCast p, SyndicationFeed updatedFeed)
{
p.Name = updatedFeed.Title.Text;
p.LastUpdated = updatedFeed.LastUpdatedTime;
p.Episodes = EpisodeList <Episode> .FromSyndicationItems(updatedFeed.Items);
return(p);
}
/// <summary>
/// Gets the episode.
/// </summary>
/// <param name="id">The id of the episode.</param>
/// <param name="podCast">The pod cast.</param>
/// <returns>The episode.</returns>
private static Episode GetEpisode(
string id,
PodCast podCast)
{
return(GetEpisode(
id,
podCast,
false));
}
//Uppdaterar en podcast om det finns ett nytt avsnitt
private async Task CheckForPodUpdates(PodCast pod)
{
bool updated = await RSSManager.UpdatePodIfNeeded(pod);
if (updated)
{
FirePodUpdated();
}
}
public async Task <IActionResult> ConfirmDelete(int id)
{
PodCast podCastToDelete = await _mediaDbContext.PodCasts.FindAsync(id);
_mediaDbContext.PodCasts.Remove(podCastToDelete);
await _mediaDbContext.SaveChangesAsync();
return(RedirectToAction("Index"));
}
private static void RunForXMLv2(string path, string dnbpath, bool islocalxml = true, string Show = "", string Genre = "")
{
Genre g = DBContext.getGenreByName(Genre);
PodCast p = new PodCast(path, Show, dnbpath, islocalxml, g, false, logger);
RSSListener.SQL.Inserts.InsertPodcast podcast = new RSSListener.SQL.Inserts.InsertPodcast(connection, p);
//List<Artist> artists = checkallartists(p.shows);
//Console.Read();
}
public async Task <IActionResult> Delete(int id)
{
PodCast podCastFromDb = await _mediaDbContext.PodCasts.FindAsync(id);
return(View(new PodCast()
{
Id = podCastFromDb.Id
}));
}
public async Task <IActionResult> HidePodcast(int id)
{
PodCast podcastFromDb = await _mediaWebDbContext.PodCasts.FirstOrDefaultAsync(m => m.Id == id);
podcastFromDb.IsHidden = true;
await _mediaWebDbContext.SaveChangesAsync();
return(RedirectToAction("Index"));
}
/// <summary>
/// Downloads the episode list.
/// </summary>
/// <param name="podCast">The pod cast.</param>
/// <returns>A list of episodes.</returns>
/// <exception cref="Uncas.PodCastPlayer.Utility.UtilityException"></exception>
public IList <Episode> DownloadEpisodeList(
PodCast podCast)
{
if (podCast == null)
{
return(null);
}
return(FetchEpisodeList(
podCast));
}
public Media GetInstance(IDbContext ctx
, string name
, string description
, int authorId
, string imagepath
, decimal price
, bool isAvailable
, int categoryId
, TimeSpan?duration = null
, string urlFeed = ""
, int quality = 0
, int pages = 0)
{
Media media = null;
if (duration.HasValue && string.IsNullOrWhiteSpace(urlFeed))
{
media = new Music {
Duration = duration.Value
};
}
else if (duration.HasValue && !string.IsNullOrWhiteSpace(urlFeed))
{
media = new PodCast {
Duration = duration.Value, UrlFeed = urlFeed
};
}
else if (pages != 0)
{
media = new Book {
Pages = pages
};
}
else if (quality != 0)
{
media = new Video {
Quality = quality
};
}
else
{
throw new Exception("Invalid media type.");
}
media.Name = name;
media.Description = description;
media.ImagePath = imagepath;
media.Price = price;
media.IsAvailable = isAvailable;
media.Category = ctx.Categories.Find(categoryId);
media.Author.Add(ctx.Users.Find(authorId));
return(media);
}
/// <summary>
/// Gets the pod cast.
/// </summary>
/// <returns>The pod cast.</returns>
private static PodCast GetPodCast()
{
var podCast = new PodCast(
1,
"x",
new Uri("http://sss.dd"),
"x",
"x");
return(podCast);
}
/// <summary>
/// Downloads the episode list.
/// </summary>
/// <param name="podCast">The pod cast.</param>
/// <returns>A list of episodes.</returns>
/// <exception cref="Uncas.PodCastPlayer.Utility.UtilityException"></exception>
public IList<Episode> DownloadEpisodeList(
PodCast podCast)
{
if (podCast == null)
{
return null;
}
return FetchEpisodeList(
podCast);
}
//Uppdaterar listan med podcastavsnitt
private void UpdateEpisodeList(PodCast feed)
{
EpisodeList <Episode> epList = feed.Episodes;
lvPodCastEpisodes.Items.Clear();
lvPodCastEpisodes.Items.AddRange(epList.ToListViewItems());
if (epList != null && epList.Count > 0)
{
UpdateEpisodeDetails(epList.Get(0));
}
}
public async Task <IActionResult> Delete(int id)
{
PodCast podcastFromDb = await _mediaWebDbContext.PodCasts.FirstOrDefaultAsync(m => m.Id == id);
PodcastDeleteViewModel deleteModel = new PodcastDeleteViewModel()
{
Id = podcastFromDb.Id,
Title = podcastFromDb.Title
};
return(View(deleteModel));
}
public void DownloadPodCastInfo_Hanselminutes_OK()
{
// Arrange:
// Act:
PodCast podCast =
this.downloader.DownloadPodCastInfo(
GetUri());
// Assert:
Trace.WriteLine(podCast);
}
public void downloadXMLData(PodCast p)
{
//Download XML Data
string pathtolocal = @"c:\temp\myxml.xml";
//Ensure there is no file
try
{
if (System.IO.File.Exists(pathtolocal))
{
System.IO.File.Delete(pathtolocal);
}
}
catch (System.IO.IOException ioex)
{
if (logger != null)
{
logger.addEvent(new cEvent(Severity.Warning, "There was an error attempting to delete the file: " + pathtolocal, ioex));
}
return;
}
//Download from URL in 'path' variable
try
{
System.Net.WebClient wc = new System.Net.WebClient();
wc.DownloadFile(p.URL, pathtolocal);
if (logger != null)
{
logger.addEvent(new cEvent(Severity.Information, "File successfully downloaded from: " + p.URL));
}
}
catch (System.Net.WebException webex)
{
if (logger != null)
{
logger.addEvent(new cEvent(Severity.FATAL, "Could not download the RSS feed data from: " + p.URL, webex));
}
return;
}
string xml = System.IO.File.ReadAllText(pathtolocal);
fetchPodCastsFromXML(p, pathtolocal);
if (p.AutomaticDownload)
{
foreach (Show s in p.shows)
{
if (!s.fileExists)
{
s.downloadFile(s.url);
}
}
}
}
private void GetEpisodes()
{
PodCast pod = _podcastController.GetPodCast(lblPodcast.Text);
var podId = pod.Id;
var episodes = _episodeController.GetAllEpisodes(podId).ToList();
episodes.Reverse();
foreach (var episode in episodes)
{
lstBoxEpisodes.Items.Add(episode.Title);
}
lblPodCastDescription.Text = "Avsnittsbeskrivning";
}
/// <summary>
/// Gets the episode.
/// </summary>
/// <param name="podCast">The pod cast.</param>
/// <returns>The episode.</returns>
private static Episode GetEpisode(PodCast podCast)
{
var one = Episode.ConstructEpisode(
"x",
DateTime.Now,
"x",
"x",
new Uri("http://www.xxx.dk"),
podCast,
false);
return(one);
}
//Uppdaterar en podcast om poden har en uppdatering
public async Task <bool> UpdatePodIfNeeded(PodCast p)
{
var updatedFeed = await ReadRSSAsync(p.Url);
bool updated = false;
if (updatedFeed.LastUpdatedTime > p.LastUpdated)
{
PerformPodUpdate(p, updatedFeed);
updated = true;
}
return(updated);
}
public async Task <IActionResult> Edit(int id)
{
PodCast podcastFromDb = await _mediaWebDbContext.PodCasts.FirstOrDefaultAsync(m => m.Id == id);
PodcastEditViewModel editModel = new PodcastEditViewModel()
{
Title = podcastFromDb.Title,
ReleaseDate = podcastFromDb.ReleaseDate,
Description = podcastFromDb.Description,
PodcastLink = podcastFromDb.File
};
return(View(editModel));
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
PodCast podcastFromDb = await _mediaWebDbContext.PodCasts.FirstOrDefaultAsync(m => m.Id == id);
if (!string.IsNullOrEmpty(podcastFromDb.File))
{
_uploadUtility.DeleteFile(_hostingEnvironment.WebRootPath, podcastFromDb.File);
}
_mediaWebDbContext.PodCasts.Remove(podcastFromDb);
await _mediaWebDbContext.SaveChangesAsync();
return(RedirectToAction("Index"));
}
/// <summary>
/// Reads the pod cast.
/// </summary>
/// <param name="podCast">The pod cast.</param>
/// <returns>A list of episodes.</returns>
/// <exception cref="Uncas.PodCastPlayer.Utility.UtilityException"></exception>
private static IList<Episode> FetchEpisodeList(
PodCast podCast)
{
var result = new List<Episode>();
// Loads the pod cast:
var feed = GetFeed(podCast.Url);
foreach (var item in feed.Items)
{
// Gets enclosure info:
var enclosure =
item.Links.Where(
l => l.RelationshipType == "enclosure")
.SingleOrDefault();
if (enclosure == null)
{
continue;
}
// Gets episode info:
var episode =
Episode.ConstructEpisode(
item.Id,
item.PublishDate.Date,
item.Title.Text,
item.Summary.Text,
enclosure.Uri,
podCast,
false);
episode.MediaInfo =
new EpisodeMediaInfo
{
FileSizeInBytes = enclosure.Length
};
result.Add(episode);
}
return result;
}
