public override void Process(MediaGenerateMarkupArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            Assert.ArgumentNotNull(args.MediaItem, "args.PlayerProperties");
            Assert.ArgumentNotNull(args.AccountItem, "args.PlayerProperties");

            if (!this.CheckState(args))
            {
                return;
            }

            Field eventsField = AccountManager.GetSettingsField(args.AccountItem, FieldIDs.AccountSettings.PlaybackEventsRules);

            if (eventsField != null)
            {
                var ruleList = RuleFactory.GetRules <PlaybackRuleContext>(eventsField);

                var context = new PlaybackRuleContext {
                    Item = args.MediaItem
                };

                ruleList.Run(context);

                args.PlaybackEvents = context.PlaybackEvents;
            }
        }
        public override void Process(MediaGenerateMarkupArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            Assert.ArgumentNotNull(args.Generator, "args.Generator");

            if (args.PlayerItem == null)
            {
                args.PlayerItem = args.Database.GetItem(args.Properties.PlayerId);

                if (args.PlayerItem == null)
                {
                    LogHelper.Warn("Selected player item could not be found. Default player will be used.", this);

                    args.PlayerItem = args.Generator.GetDefaultPlayer(args);
                }
            }

            if (args.PlayerItem != null)
            {
                args.Properties.PlayerId = args.PlayerItem.ID;
            }
            else
            {
                LogHelper.Warn("Player item could not be found. Player markup generation will be stopped.", this);

                args.AbortPipeline();
            }
        }
        public override void Process(MediaGenerateMarkupArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            Assert.ArgumentNotNull(args.Database, "args.Database");
            Assert.ArgumentNotNull(args.Properties, "args.PlayerProperties");

            if (args.MediaItem == null)
            {
                args.MediaItem = args.Database.GetItem(args.Properties.ItemId);
            }

            if (args.MediaItem != null)
            {
                args.Properties.ItemId = args.MediaItem.ID;

                if (args.MarkupType == MarkupType.Html)
                {
                    args.Properties.Template = args.MediaItem.TemplateID;
                }
            }
            else
            {
                LogHelper.Warn("Media item could not be found. Player markup generation will be stopped.", this);

                args.AbortPipeline();
            }
        }
        public override void Process(MediaGenerateMarkupArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            Assert.ArgumentNotNull(args.MediaItem, "args.MediaItem");

            if (args.AccountItem == null)
            {
                args.AccountItem = AccountManager.GetAccountItemForDescendant(args.MediaItem);

                if (args.AccountItem == null)
                {
                    LogHelper.Warn("Account item could not be found. Player markup generation will be stopped.", this);

                    args.AbortPipeline();
                }
            }
        }
示例#5
0
        public override void Process(MediaGenerateMarkupArgs args)
        {
            Assert.ArgumentNotNull(args, "args");

            if (args.MediaItem != null)
            {
                args.Database = args.MediaItem.Database;
            }
            else if (args.Database == null)
            {
                args.Database = Context.ContentDatabase ?? Context.Database;

                if (args.Database == null)
                {
                    LogHelper.Warn("Database is null. Player markup generation will be stopped.", this);
                    args.AbortPipeline();
                }
            }
        }
示例#6
0
        public override void Process(MediaGenerateMarkupArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            Assert.ArgumentNotNull(args.MediaItem, "args.PlayerProperties");
            Assert.ArgumentNotNull(args.PlaybackEvents, "args.PlaybackEvents");

            if (args.PlaybackEvents.Count > 0)
            {
                string mediaId = args.Properties.MediaId;

                if (!string.IsNullOrEmpty(mediaId))
                {
                    string json = JsonConvert.SerializeObject(args.PlaybackEvents);

                    string script = string.Format("PlayerEventsListener.prototype.playbackEvents['{0}'] = {1};", mediaId, json);

                    args.Result.BottomScripts.Add("mf_pe_" + args.MediaItem.ID, script);
                }
            }
        }
        /// <summary>
        /// Processes determining the markup generator.
        /// </summary>
        /// <param name="args">
        /// The args.
        /// </param>
        public override void Process(MediaGenerateMarkupArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            Assert.ArgumentNotNull(args.MediaItem, "args.MediaItem");

            IPlayerMarkupGenerator generator = MediaFrameworkContext.GetPlayerMarkupGenerator(args.MediaItem.TemplateID);

            if (generator != null)
            {
                args.Generator = generator;

                if (args.MarkupType == MarkupType.Html)
                {
                    args.Properties.MediaId = args.Generator.GetMediaId(args.MediaItem);
                }
            }
            else
            {
                LogHelper.Warn("Player markup generator couldn't be determine for player. Player markup generation will be stopped.", this);

                args.AbortPipeline();
            }
        }
示例#8
0
        /// <summary>
        /// Processes generating of a markup.
        /// </summary>
        /// <param name="args">
        /// The args.
        /// </param>
        public override void Process(MediaGenerateMarkupArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            Assert.ArgumentNotNull(args.Generator, "args.Generator");

            switch (args.MarkupType)
            {
            case MarkupType.Frame:
                args.Result.Html = args.Generator.GetFrame(args);
                break;

            case MarkupType.FrameUrl:
                args.Result.Html = args.Generator.GenerateFrameUrl(args);
                break;

            case MarkupType.Link:
                if (string.IsNullOrEmpty(args.LinkTitle))
                {
                    args.LinkTitle = Translate.Text("Media Link");
                }

                args.Result.Html = args.Generator.GenerateLinkHtml(args);
                break;

            case MarkupType.Html:
                if (!args.Properties.ForceRender && Context.PageMode.IsPageEditorEditing)
                {
                    args.Result.Html = args.Generator.GetPreviewImage(args);
                }
                else
                {
                    args.Result = args.Generator.Generate(args);
                }
                break;
            }
        }
 /// <summary>
 /// Runs the pipeline.
 /// </summary>
 /// <param name="args">
 /// The args.
 /// </param>
 public static void Run(MediaGenerateMarkupArgs args)
 {
     Assert.ArgumentNotNull(args, "args");
     CorePipeline.Run("mediaFramework.mediaGenerateMarkup", args);
 }
 protected virtual bool CheckState(MediaGenerateMarkupArgs args)
 {
     return(args.MarkupType == MarkupType.Html && Sitecore.Configuration.Settings.GetBoolSetting("Xdb.Enabled", false) && !Context.PageMode.IsExperienceEditorEditing);
 }
 protected virtual bool CheckState(MediaGenerateMarkupArgs args)
 {
     return(args.MarkupType == MarkupType.Html && Settings.Analytics.Enabled && !Context.PageMode.IsPageEditorEditing);
 }