public List <ManualImportItem> GetMediaFiles(int seriesId, int?seasonNumber)
{
var series = _seriesService.GetSeries(seriesId);
var directoryInfo = new DirectoryInfo(series.Path);
var seriesFiles = seasonNumber.HasValue ? _mediaFileService.GetFilesBySeason(seriesId, seasonNumber.Value) : _mediaFileService.GetFilesBySeries(seriesId);
var items = seriesFiles.Select(episodeFile => MapItem(episodeFile, series, directoryInfo.Name)).ToList();
if (!seasonNumber.HasValue)
{
var mediaFiles = _diskScanService.FilterPaths(series.Path, _diskScanService.GetVideoFiles(series.Path)).ToList();
var unmappedFiles = MediaFileService.FilterExistingFiles(mediaFiles, seriesFiles, series);
items.AddRange(unmappedFiles.Select(file =>
new ManualImportItem
{
Path = Path.Combine(series.Path, file),
FolderName = directoryInfo.Name,
RelativePath = series.Path.GetRelativePath(file),
Name = Path.GetFileNameWithoutExtension(file),
Series = series,
SeasonNumber = null,
Episodes = new List <Episode>(),
ReleaseGroup = string.Empty,
Quality = new QualityModel(Quality.Unknown),
Language = Language.Unknown,
Size = _diskProvider.GetFileSize(file),
Rejections = Enumerable.Empty <Rejection>()
}
));
}
return(items);
}
public MediaFile Execute(UploadFileRequest request)
{
var maxLength = CmsConfiguration.Storage.MaximumFileNameLength > 0 ? CmsConfiguration.Storage.MaximumFileNameLength : 100;
var fileName = request.FileName;
if (fileName.Length > maxLength)
{
fileName = string.Concat(Path.GetFileNameWithoutExtension(fileName.Substring(0, maxLength)), Path.GetExtension(fileName));
}
if (request.Type == MediaType.File || request.Type == MediaType.Audio || request.Type == MediaType.Video)
{
var media = MediaFileService.UploadFile(request.Type, request.RootFolderId, fileName, request.FileLength, request.FileStream);
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(media);
return(media);
}
if (request.Type == MediaType.Image)
{
var media = MediaImageService.UploadImage(request.RootFolderId, fileName, request.FileLength, request.FileStream, request.ReuploadMediaId);
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(media);
return(media);
}
throw new CmsException(string.Format("A given media type {0} is not supported to upload.", request.Type));
}
public RemoteMediaWorker(ILogger <RemoteMediaWorker> logger, IConfiguration config, MediaFileService mediaFileService, MediaInformationService mediaInformationService)
{
_logger = logger;
_config = config;
_mediaFileService = mediaFileService;
_mediaInformationService = mediaInformationService;
_http = new HttpClient();
var authBytes = Encoding.ASCII.GetBytes(_config["RemoteHttp:HttpAuth"]);
var authHeader = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(authBytes));
_http.DefaultRequestHeaders.Authorization = authHeader;
}
public HttpResponseMessage Post(string MediaType)
{
HttpResponseMessage result = null;
var httpRequest = HttpContext.Current.Request;
if (httpRequest.Files.Count > 0)
{
var docfiles = new List <string>();
bool amazonCall = false;
string keyName = "";
foreach (string file in httpRequest.Files)
{
var postedFile = httpRequest.Files[file];
var localFilePath = HttpContext.Current.Server.MapPath("~/" + postedFile.FileName);
var extentionType = Path.GetExtension(postedFile.FileName);
int themeId = 196;
keyName = Guid.NewGuid().ToString() + extentionType;//.Substring(0, 12);
postedFile.SaveAs(localFilePath);
amazonCall = MediaFileService.sendMyFileToS3(localFilePath, keyName);
//creating thumbnail of image and sending to database
var thumbPath = HttpContext.Current.Server.MapPath("~/thumbnail" + postedFile.FileName);
ThumbnailService.ResizeImage(localFilePath, thumbPath, 400, 400, ImageFormat.Jpeg);
amazonCall = MediaFileService.sendMyFileToS3(thumbPath, "thumbnail/" + keyName);
MediaProfileRequest request = new MediaProfileRequest();
request.MediaType = MediaType;
request.ContentType = MimeMapping.GetMimeMapping(postedFile.FileName);
request.UserId = UserService.GetCurrentUserId();
request.FilePath = ConfigService.uploadFileS3Prefix + "/" + keyName;
request.MediaThemeId = themeId++;
int MediaId = this._mediaService.Post(request);
ItemResponse <int> response = new ItemResponse <int>();
response.Item = MediaId;
docfiles.Add(localFilePath);
result = Request.CreateResponse(HttpStatusCode.OK, response);
return(result);
}
result = Request.CreateResponse(HttpStatusCode.Created, keyName);
}
else
{
result = Request.CreateResponse(HttpStatusCode.BadRequest);
}
return(result);
}
/// <summary>
/// Executes the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns><c>true</c> on success, otherwise <c>false</c></returns>
/// <exception cref="CmsException">if media format is not supported.</exception>
public bool Execute(UndoUploadRequest request)
{
if (request.Type == MediaType.File || request.Type == MediaType.Audio || request.Type == MediaType.Video)
{
MediaFileService.RemoveFile(request.FileId, request.Version, doNotCheckVersion: true);
}
else if (request.Type == MediaType.Image)
{
MediaImageService.RemoveImageWithFiles(request.FileId, request.Version, doNotCheckVersion: true);
}
else
{
throw new CmsException(string.Format("A given media type {0} is not supported to upload.", request.Type));
}
return(true);
}
private void SearchMediaItems(RequestPagingItemsEventArgs e)
{
if (_currentPreviewItem != null)
{
_currentPreviewItem.ClosePreview();
_currentPreviewItem = null;
}
_mediaItemCollection.Clear();
var result = MediaFileService.GetMediaFiles(this.SearchOptions, e.PagingInfo);
foreach (var item in result.Items)
{
_mediaItemCollection.Add(new BindableFileMediaItem(item, this.ResolvePath(item.FileName)));
}
e.Result = result;
}
public MediaFile Execute(UploadFileRequest request)
{
if (request.Type == MediaType.File || request.Type == MediaType.Audio || request.Type == MediaType.Video)
{
var media = MediaFileService.UploadFile(request.Type, request.RootFolderId, request.FileName, request.FileLength, request.FileStream);
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(media);
return(media);
}
if (request.Type == MediaType.Image)
{
var media = MediaImageService.UploadImage(request.RootFolderId, request.FileName, request.FileLength, request.FileStream);
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(media);
return(media);
}
throw new CmsException(string.Format("A given media type {0} is not supported to upload.", request.Type));
}
public MediaInformationController(ILogger <MediaInformationController> logger, MediaFileService mediaFileService, MediaInformationService mediaInformationService)
{
_logger = logger;
_mediaFileService = mediaFileService;
_mediaInformationService = mediaInformationService;
}
public MediaFilesController(MediaFileService mediaFileServices)
{
_mediaFileServices = mediaFileServices;
}
public MediaFileController()
{
_mediaFileService = new MediaFileService();
}
public void Setup()
{
_sut = new MediaFileService();
}