public async Task <IActionResult> Put(Guid id, EditVideoRequest request)
{
request.Id = id;
VideoResponse result = await VideoService.EditVideoAsync(request);
return(Ok(result));
}
public async Task AddVideo_should_return_the_expected_video(string kindId, string genreId)
{
//Arrange
string data = GenData.Create <string>();
AddVideoRequest expectedVideo = new AddVideoRequest()
{
AltTitle = data,
Description = data,
Duration = 123,
Episode = 7,
ReleaseYear = DateTime.Now,
Season = 1,
Title = data,
KindId = new Guid(kindId),
GenreId = new Guid(genreId)
};
VideoService sut = new VideoService(Repository, Mapper);
//Act
VideoResponse result = await sut.AddVideoAsync(expectedVideo);
//Assert
result.Should().BeEquivalentTo(expectedVideo);
}
/// <summary>
/// It Fetches Data from the Database
/// </summary>
/// <returns>If Data Found return Response Data else null or Exception</returns>
public List <VideoResponse> ListOfVideos()
{
try
{
List <VideoResponse> responseList = null;
using (SqlConnection conn = new SqlConnection(sqlConnectionString))
{
responseList = new List <VideoResponse>();
using (SqlCommand cmd = new SqlCommand("spGetAllVideos", conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
conn.Open();
SqlDataReader dataReader = cmd.ExecuteReader();
while (dataReader.Read())
{
VideoResponse response = new VideoResponse
{
VideoID = Convert.ToInt32(dataReader["ID"]),
VideoPath = dataReader["VideoPath"].ToString(),
CreatedDate = Convert.ToDateTime(dataReader["CreatedDate"]),
ModifiedDate = Convert.ToDateTime(dataReader["ModifiedDate"])
};
responseList.Add(response);
}
}
}
return(responseList);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task EditVideo_should_return_the_expected_video(string kindId, string genreId)
{
//Arrange
string data = GenData.Create <string>();
EditVideoRequest expectedVideo = new EditVideoRequest()
{
Id = new Guid("eaa0B9d4-4A2d-496e-8a68-a36cd0758abb"),
AltTitle = data,
Description = data,
IsInactive = false,
Duration = 123,
Episode = 7,
ReleaseYear = DateTime.Now,
Season = 1,
Title = data,
KindId = new Guid(kindId),
GenreId = new Guid(genreId)
};
VideoService sut = new VideoService(Repository, Mapper);
//Act
VideoResponse result = await sut.EditVideoAsync(expectedVideo);
//Assert
result.Should().BeEquivalentTo(expectedVideo, o => o.Excluding(x => x.IsInactive));
}
public async Task <List <Video> > GetVideos(int id)
{
string action = "/videos";
List <Video> movies = new List <Video>();
try
{
string url = baseURL + "movie/" + id.ToString() + action + "?api_key=" + apiKey + "&sort_by=popularity.des";
Log.Debug("MovieAPI", "url = " + url);
HttpResponseMessage responseMsg = await client.GetAsync(url);
string content = await responseMsg.Content.ReadAsStringAsync();
VideoResponse response = JsonConvert.DeserializeObject <VideoResponse>(content);
Log.Debug("MovieAPI", "Response " + response.ToString());
movies = response.results;
}
catch (Exception ex)
{
Log.Debug("MovieAPI", "Exception " + ex.Message);
}
return(movies);
}
public async Task <bool> GetVideos()
{
var service = Locator.Get <IApiService>();
videos = await service.GetVideos(Item.Id).ConfigureAwait(false);
return(true);
}
public async Task <IActionResult> GetById(Guid id)
{
VideoResponse result = await VideoService.GetVideoAsync(new GetVideoRequest()
{
Id = id
});
return(Ok(result));
}
private static async Task VideosGetApi(HttpContext context)
{
var args = context.Request.Query;
string author = args["author"].ToString().ToLowerInvariant().Trim();
int? userid = null;
DateTime?uploadDate;
if (!Int32.TryParse(args["offset"].ToString(), out int offset) || offset < 0)
{
offset = 0;
}
if (!Int32.TryParse(args["count"].ToString(), out int count) || count > 100 || count < 0)
{
count = indexCountDefault;
}
using var connection = Database.OpenNewConnection();
//TODO(Simon): Fuzzy search for username
if (!String.IsNullOrEmpty(author))
{
userid = await UserController.UserIdFromUsername(author, connection);
}
if (!Int32.TryParse(args["agedays"].ToString(), out int daysOld) || daysOld < 0)
{
uploadDate = null;
}
else
{
uploadDate = DateTime.UtcNow.AddDays(-daysOld);
}
var videos = new VideoResponse();
try
{
//TODO(Simon): There might be a faster way to get the count, while also executing just 1 query: add "count(*) OVER() AS total_count" to query
videos.totalcount = await connection.QuerySingleAsync <int>(@"select count(*) from videos v
inner join users u on v.userid = u.userid
where (@userid::int is NULL or v.userid=@userid)
and (@uploadDate::timestamp is NULL or v.timestamp>=@uploadDate)" , new { userid, uploadDate });
videos.videos = await GetIndexVideos(IndexTab.MostWatched, count, offset, connection);
videos.count = videos.videos.AsList().Count;
videos.page = videos.totalcount > 0 ? offset / videos.totalcount + 1 : 1;
await context.Response.Body.WriteAsync(Utf8Json.JsonSerializer.SerializeUnsafe(videos));
}
catch (Exception e)
{
await CommonController.WriteError(context, "Something went wrong while processing this request", StatusCodes.Status500InternalServerError, e);
}
}
public async Task GetVideo()
{
string id = "7lCDEYXw3mM";
string result = await VideosProvider.GetVideo(id, ChannelPartParams.Statistics);
VideoResponse videoResponse = VideoResponse.FromString(result);
LoggingManager.CreateFile("GetVideo.txt", videoResponse);
Debugger.Break();
}
// public static IEnumerable<RemoteImageInfo> ToRemoteImageInfos(this IEnumerable<Images_posters> src, ImageType imageType)
// {
// return src.Select(s => s.ToRemoteImageInfo(imageType))
// .Where(s => s != null);
// }
// public static RemoteImageInfo ToRemoteImageInfo(this Images_posters src, ImageType imageType)
// {
// if (src is null)
// return null;
// return new RemoteImageInfo(){
// Type = imageType,
// Url = src.Url,
// Language = src.Language,
// Height = src.Height,
// Width = src.Width,
// ProviderName = Constants.ProviderName
// };
// }
public static IReadOnlyList <MediaUrl> ToMediaUrls(this VideoResponse src)
{
if (src is null || src.Items is null || src.Items.Count < 1)
{
return(null);
}
return(src.Items.Select(t => t.ToMediaUrl())
.Where(mu => mu != null)
.ToList());
}
public async Task GetVideo_should_return_video_with_specified_id(string guid)
{
//Arrange
VideoService sut = new VideoService(Repository, Mapper);
//Act
VideoResponse result = await sut.GetVideoAsync(new GetVideoRequest()
{
Id = new Guid(guid)
});
//Assert
result.Id.Should().Be(new Guid(guid));
Assert.NotNull(result.AltTitle);
}
private void PlayVideo(object sender, MouseButtonEventArgs e)
{
try
{
VideoResponse selected = (VideoResponse)Videos.SelectedItem;
if (selected != null)
{
var VideoPlayer = new VideoPlayer();
VideoPlayer.Show();
VideoPlayer.PlayerBrowser.Navigate(String.Format(selected.VideoPlayer));
VideoPlayer.Title = String.Format(selected.VideoTitle);
}
}
catch (Exception) { }
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
if (!(context.ActionArguments["id"] is Guid id))
{
context.Result = new BadRequestResult();
return;
}
VideoResponse result = await VidService.GetVideoAsync(new GetVideoRequest { Id = id });
if (result == null)
{
context.Result = new NotFoundObjectResult(new JsonErrorPayload
{
DetailedMessage = $"Video with id {id} not exist."
});
return;
}
await next();
}
public StopRequest(VideoResponse video)
{
Video = video;
}
public async Task <IActionResult> Post(AddVideoRequest request)
{
VideoResponse result = await VideoService.AddVideoAsync(request);
return(CreatedAtAction(nameof(GetById), new { id = result.Id }, null));
}
public PlayRequest(VideoResponse video, int startTimeMilliseconds)
{
Video = video;
StartTimeMilliseconds = startTimeMilliseconds;
}
private PlexResponse Parts(PlexRequest request)
{
if (request.PathSegments.Length < 3)
{
return XmlResponse.NotFound();
}
else
{
int PartId = Convert.ToInt32(request.PathSegments[2]);
VideoFileInfo vidFile = DataAccess.GetVideoFile(PartId);
VideoResponse resp = new VideoResponse();
resp.FilePath = vidFile.Path;
if (request.Headers["Range"] != null)
{
string[] range = request.Headers["Range"].Substring(6).Split('-');
resp.Start = Convert.ToInt64(range[0]);
if (range[1] != "")
{
resp.End = Convert.ToInt64(range[1]);
}
}
return resp;
}
}
public ActionResult DisplaySubmitedVideo(VideoResponse vr)
{
return(RedirectToAction("Experiment", new { expId = vr.ExpId, studentPhone = vr.PhoneNumber, studentRoom = vr.RoomId, currActivityIndex = vr.CurrActivityIndex + 1 }));
}
public AddFrameRequest(VideoResponse video, int milliseconds, List <Pixel> pixels)
{
Video = video;
Milliseconds = milliseconds;
Pixels = pixels;
}
