예제 #1
0
 public static string GetContentMediaUrlLocal(ContentMedia contentMedia)
 {
     return String.Format("{0}/Media/Stream/{1}?version={2}",
         "", //SystemConfig.BaseUrl,
         contentMedia.ContentId.ToString(),
         (MediaVersion)contentMedia.MediaVersion);
 }
예제 #2
0
 public static string GetContentMediaPathLocal(ContentMedia contentMedia)
 {
     var assetPath = (MediaVersion)contentMedia.MediaVersion == MediaVersion.Full ?
         SystemConfig.MediaPathFull :
         SystemConfig.MediaPathPreview;
     return Path.Combine(assetPath, GetContentMediaFileName(contentMedia.ContentId));
 }
예제 #3
0
        public static byte[] GetContentMedia(ContentMedia contentMedia, User user)
        {
            //try {

                return GetContentMedia(contentMedia);

            //}
            //catch (Exception ex) {
            //    Log.Error(ex);
            //    throw ex;
            //}
        }
예제 #4
0
 /// <summary>
 /// Create a new ContentMedia object.
 /// </summary>
 /// <param name="contentId">Initial value of the ContentId property.</param>
 /// <param name="mediaVersion">Initial value of the MediaVersion property.</param>
 /// <param name="mediaDate">Initial value of the MediaDate property.</param>
 /// <param name="isRemote">Initial value of the IsRemote property.</param>
 public static ContentMedia CreateContentMedia(global::System.Int32 contentId, global::System.Int32 mediaVersion, global::System.DateTime mediaDate, global::System.Boolean isRemote)
 {
     ContentMedia contentMedia = new ContentMedia();
     contentMedia.ContentId = contentId;
     contentMedia.MediaVersion = mediaVersion;
     contentMedia.MediaDate = mediaDate;
     contentMedia.IsRemote = isRemote;
     return contentMedia;
 }
예제 #5
0
        // **************************************
        // GetContentMedia
        // **************************************
        public static void GetContentMedia(string target, ContentMedia contentMedia)
        {
            using (var awsclient = Amazon.AWSClientFactory.CreateAmazonS3Client(
                RemoteMediaConfiguration.AccessKeyID,
                RemoteMediaConfiguration.SecretAccessKeyID)) {

                var key = GetContentMediaKey(contentMedia);

                var request = new GetObjectRequest()
                    .WithBucketName(RemoteMediaConfiguration.BucketName)
                    .WithKey(key);

                try {
                    using (S3Response response = awsclient.GetObject(request)) {
                        using (Stream s = response.ResponseStream) {

                            using (var fs = File.OpenWrite(target)) {
                                byte[] data = new byte[262144];//[32768];
                                int bytesRead = 0;
                                do {
                                    bytesRead = s.Read(data, 0, data.Length);
                                    fs.Write(data, 0, bytesRead);
                                }
                                while (bytesRead > 0);

                                fs.Flush();
                                fs.Close();
                            }
                        }
                    }
                }
                catch (AmazonS3Exception amazonS3Exception) {
                    Log.Error(amazonS3Exception);
                }

            }
        }
예제 #6
0
 //: IMediaCloudService {
 // **************************************
 // GetContentKey
 // **************************************
 public static string GetContentKey(ContentMedia contentMedia)
 {
     return String.Concat(GetContentPrefix((MediaVersion)contentMedia.MediaVersion),
         contentMedia.ContentId, SystemConfig.MediaDefaultExtension);
 }
예제 #7
0
        // **************************************
        // GetContentMediaKey
        // **************************************
        private static string GetContentMediaKey(ContentMedia contentMedia)
        {
            var key = String.Format(RemoteMediaConfiguration.MediaUrlFormat, (MediaVersion)contentMedia.MediaVersion, contentMedia.ContentId);

            return key;
        }
예제 #8
0
        // **************************************
        // PutContentMedia
        // **************************************
        public static void PutContentMedia(string source, ContentMedia contentMedia)
        {
            using (var awsclient = Amazon.AWSClientFactory.CreateAmazonS3Client(RemoteMediaConfiguration.AccessKeyID,
                RemoteMediaConfiguration.SecretAccessKeyID)) {

                var key = GetContentMediaKey(contentMedia);

                // simple object put
                PutObjectRequest request = new PutObjectRequest();
                request.WithBucketName(RemoteMediaConfiguration.BucketName)
                    .WithFilePath(source)
                    .WithKey(key)
                    .WithStorageClass(S3StorageClass.ReducedRedundancy);

                awsclient.PutObject(request);

            }
        }
예제 #9
0
        // **************************************
        // GetContentMediaUrl
        // **************************************
        public static string GetContentMediaUrl(ContentMedia contentMedia)
        {
            using (var awsclient = Amazon.AWSClientFactory.CreateAmazonS3Client(
                RemoteMediaConfiguration.AccessKeyID,
                RemoteMediaConfiguration.SecretAccessKeyID)) {

                var key = GetContentMediaKey(contentMedia);

                var request = new GetPreSignedUrlRequest()
                    .WithProtocol(Amazon.S3.Model.Protocol.HTTP)
                    .WithBucketName(RemoteMediaConfiguration.BucketName)
                    .WithKey(key)
                    .WithExpires(DateTime.Now.Date.AddDays(1));

                return awsclient.GetPreSignedURL(request);
            }
        }
예제 #10
0
 //: BaseService, IMediaService {
 // **************************************
 // GetContentMedia
 // **************************************
 public static byte[] GetContentMedia(ContentMedia contentMedia)
 {
     return SystemConfig.UseRemoteMedia && contentMedia.IsRemote ?
         AmazonCloudService.GetContentMedia(contentMedia)
         : GetContentMediaLocal(contentMedia);
 }
예제 #11
0
        private static ContentMedia UpdateMediaId3info(ContentMedia media, FileInfo file)
        {
            var id3tag = ID3Reader.GetID3Metadata(file.FullName);
            media.MediaSize = file.Length;
            media.MediaLength = id3tag.MediaLength;
            media.MediaBitRate = id3tag.GetBitRate(file.Length);

            return media;
        }
예제 #12
0
        // **************************************
        // RepushMedia
        // **************************************
        private static void RepushMedia(Content content, ContentMedia media, string filePath, FileInfo file)
        {
            AmazonCloudService.GetContentMedia(filePath, media);
            var tempFile = new FileInfo(filePath);

            Log.Debug(String.Format("Remote file for {0} downloaded", content.ContentId));

            UpdateContentId3Tag(content, tempFile);
            UpdateMediaId3info(media, tempFile);

            AmazonCloudService.PutContentMedia(tempFile.FullName, media);

            Log.Debug(String.Format("Re-uploaded remote file  {0}", file.FullName));

            //File.Delete(tempFile.FullName);
        }
예제 #13
0
 // **************************************
 // SaveContentMedia
 // **************************************
 public static void SaveContentMedia(string filePath, ContentMedia contentMedia)
 {
     //ID3Writer.NormalizeTag(filePath, content);
     var mediaPath = GetContentMediaPathLocal(contentMedia);
     FileSystem.SafeMove(filePath, mediaPath, true);
 }
예제 #14
0
 public static string GetContentMediaUrl(ContentMedia contentMedia)
 {
     return SystemConfig.UseRemoteMedia && contentMedia.IsRemote ?
             AmazonCloudService.GetContentMediaUrl(contentMedia)
             : GetContentMediaUrlLocal(contentMedia);
 }
예제 #15
0
 /// <summary>
 /// Deprecated Method for adding a new object to the ContentMedia EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead.
 /// </summary>
 public void AddToContentMedia(ContentMedia contentMedia)
 {
     base.AddObject("ContentMedia", contentMedia);
 }
예제 #16
0
        // **************************************
        // GetContentMedia
        // **************************************
        public static byte[] GetContentMedia(ContentMedia contentMedia)
        {
            byte[] mediaBytes = null;

            using (var awsclient = Amazon.AWSClientFactory.CreateAmazonS3Client(
                RemoteMediaConfiguration.AccessKeyID,
                RemoteMediaConfiguration.SecretAccessKeyID)) {

                var key = GetContentMediaKey(contentMedia);

                var request = new GetObjectRequest()
                    .WithBucketName(RemoteMediaConfiguration.BucketName)
                    .WithKey(key);

                try {
                    using (S3Response response = awsclient.GetObject(request)) {
                        using (Stream s = response.ResponseStream) {
                            using (var fs = new MemoryStream()) {
                                byte[] data = new byte[contentMedia.MediaSize.GetValueOrDefault(262144)];
                                int bytesRead = 0;
                                do {
                                    bytesRead = s.Read(data, 0, data.Length);
                                    fs.Write(data, 0, bytesRead);
                                }
                                while (bytesRead > 0);

                                mediaBytes = fs.ToArray();
                                return mediaBytes;
                            }
                        }
                    }
                }
                catch (AmazonS3Exception amazonS3Exception) {
                    Log.Error(amazonS3Exception);
                    return mediaBytes;
                }

            }
        }
예제 #17
0
        // **************************************
        // SaveCatalog
        // **************************************
        private CatalogUploadState SaveCatalog(CatalogUploadState state)
        {
            System.Diagnostics.Debug.Write("Step5");

            var user = Account.User();
            // Save/create Catalog
            if (user.IsAtLeastInRole(Roles.Admin) && !user.MyBalances().NumberOfSongs.IsAtTheLimit) {

                using (var ctx = new SongSearchContext()) {

                    var catalog = ctx.Catalogs.SingleOrDefault(c => c.CatalogName.ToUpper() == state.CatalogName) ??
                        new Catalog() {
                            CatalogName = state.CatalogName,
                            CreatedByUserId = user.UserId,
                            CreatedOn = DateTime.Now
                        };

                    if (catalog.CatalogId == 0) {

                        ctx.Catalogs.AddObject(catalog);
                        //DataSession.CommitChanges();

                        //Make current user an admin
                        var userCatalog = new UserCatalogRole() {
                            UserId = user.UserId,
                            CatalogId = catalog.CatalogId,
                            RoleId = (int)Roles.Admin
                        };
                        ctx.UserCatalogRoles.AddObject(userCatalog);

                        //Make parent user an admin
                        if (user.ParentUserId.HasValue) {
                            var parentUserCatalog =
                                //DataSession.Single<UserCatalogRole>(
                                //    x => x.UserId == user.ParentUserId.Value &&
                                //        x.CatalogId == catalog.CatalogId &&
                                //        x.RoleId == (int)Roles.Admin
                                //        ) ??
                                new UserCatalogRole() {
                                    UserId = user.ParentUserId.Value,
                                    CatalogId = catalog.CatalogId,
                                    RoleId = (int)Roles.Admin
                                };
                            ctx.UserCatalogRoles.AddObject(parentUserCatalog);
                        }

                        //Make plan user an admin
                        if (!user.IsPlanOwner && user.PlanUserId != user.ParentUserId.GetValueOrDefault()) {
                            var planUserCatalog =
                                //DataSession.Single<UserCatalogRole>(
                                //    x => x.UserId == user.PlanUserId &&
                                //        x.CatalogId == catalog.CatalogId &&
                                //        x.RoleId == (int)Roles.Admin
                                //        ) ??
                                new UserCatalogRole() {
                                    UserId = user.PlanUserId,
                                    CatalogId = catalog.CatalogId,
                                    RoleId = (int)Roles.Admin
                                };
                            ctx.UserCatalogRoles.AddObject(planUserCatalog);
                        }

                        // defer?
                        ctx.SaveChanges();
                    }

                    state.CatalogId = catalog.CatalogId;
                    state.CatalogName = catalog.CatalogName.ToUpper();

                    // Save Content
                    var content = App.IsLicensedVersion ?
                        state.Content.Take(user.MyBalances().NumberOfSongs.IsGoodFor(state.Content.Count())).ToList() :
                        state.Content;

                    foreach (var itm in content) {

                        itm.CatalogId = state.CatalogId;
                        itm.CreatedByUserId = user.UserId;
                        itm.CreatedOn = DateTime.Now;
                        itm.LastUpdatedByUserId = user.UserId;
                        itm.LastUpdatedOn = DateTime.Now;
                        //itm.IsMediaOnRemoteServer = false;

                        itm.Title = itm.Title.AsEmptyIfNull();//.CamelCase();//.ToUpper();
                        itm.Artist = itm.Artist.AsEmptyIfNull();//.CamelCase();//.ToUpper();
                        itm.RecordLabel = itm.RecordLabel.AsEmptyIfNull();//.CamelCase();//.ToUpper();
                        itm.ReleaseYear = itm.ReleaseYear.GetValueOrDefault().AsNullIfZero();
                        itm.Notes = itm.Notes;

                        var full = itm.UploadFiles.SingleOrDefault(f => f.FileMediaVersion == MediaVersion.Full);
                        foreach (var version in ModelEnums.MediaVersions()) {

                            var upl = itm.UploadFiles.SingleOrDefault(f => f.FileMediaVersion == version);
                            if (upl != null) {

                                var file = new FileInfo(upl.FilePath);
                                var id3 = ID3Writer.NormalizeTag(upl.FilePath, itm);

                                var media = new ContentMedia() {

                                    MediaVersion = (int)version,
                                    MediaType = "mp3",
                                    MediaSize = file.Length,
                                    MediaLength = id3.MediaLength,
                                    MediaDate = file.GetMediaDate(),
                                    MediaBitRate = id3.GetBitRate(file.Length)
                                };

                                media.IsRemote = false;

                                itm.ContentMedia.Add(media);
                            }

                        }
                        ctx.Contents.AddObject(itm);
                        ctx.AddToSongsBalance(user);
                        ctx.SaveChanges();

                        if (itm.ContentId > 0) {
                            foreach (var file in itm.UploadFiles) {
                                MediaService.SaveContentMedia(file.FilePath, itm.Media(file.FileMediaVersion));
                            }
                        }

                    }

                }
            }

            SessionService.Session().InitializeSession(true);
            CacheService.InitializeApp(true);

            return state;
        }
예제 #18
0
        private static byte[] GetContentMediaLocal(ContentMedia contentMedia)
        {
            var assetFile = new FileInfo(GetContentMediaPathLocal(contentMedia));

            if (assetFile.Exists)
            {
                var assetBytes = File.ReadAllBytes(assetFile.FullName);

                return assetBytes;
            }
            else
            {
                var ex = new ArgumentOutOfRangeException("Content media file is missing");
                Log.Error(ex);
                throw ex;
            }
        }