Example #1
0
        private bool OverrideVersion(ItemVersion v, ItemVersion over)
        {
            bool changed = false;

            foreach (var versioner in Versioners)
            {
                if (over.ContainsKey(versioner.VersionKey))
                {
                    IUser u         = LyniconSecurityManager.Current.User;
                    var   legalVals = versioner.GetAllowedVersions(u);
                    var   overVal   = over[versioner.VersionKey];
                    if (legalVals.Any(lVal => lVal.Equals(overVal)))
                    {
                        if (!v.ContainsKey(versioner.VersionKey) ||
                            (v[versioner.VersionKey] == null && overVal != null) ||
                            !v[versioner.VersionKey].Equals(overVal))
                        {
                            v[versioner.VersionKey] = overVal;
                            changed = true;
                        }
                    }
                }
            }

            return(changed);
        }
Example #2
0
        /// <summary>
        /// Get a list of VersionSelectionViewModels to create a version selector for a given user and a given current version
        /// </summary>
        /// <param name="u">The user</param>
        /// <param name="currVersion">The current version</param>
        /// <param name="abbreviated">Whether the display is abbreviated (not implemented)</param>
        /// <returns>List of VersionSelectionViewModels</returns>
        public List <VersionSelectionViewModel> SelectionViewModel(IUser u, ItemVersion currVersion, bool abbreviated)
        {
            var vm = new List <VersionSelectionViewModel>();

            foreach (var v in Versioners.Where(v => currVersion.ContainsKey(v.VersionKey) && currVersion[v.VersionKey] != null).OrderBy(v => v.VersionKey))
            {
                var    versions   = v.GetAllowedVersions(u);
                var    selectList = new List <SelectListItem>();
                string cssClass   = null;
                foreach (object o in versions)
                {
                    var iv = new ItemVersion {
                        { v.VersionKey, o }
                    };
                    var dv = v.DisplayItemVersion(iv);
                    cssClass = dv.CssClass;
                    var sli = new SelectListItem();
                    sli.Text     = (abbreviated ? dv.Text + "|" : "") + dv.ListItem;
                    sli.Value    = JsonConvert.SerializeObject(o);
                    sli.Selected = currVersion[v.VersionKey] != null && currVersion[v.VersionKey].Equals(o);
                    selectList.Add(sli);
                }
                vm.Add(new VersionSelectionViewModel
                {
                    Title      = v.VersionKey,
                    SelectList = selectList,
                    VersionKey = v.VersionKey,
                    CssClass   = cssClass
                });
            }

            return(vm);
        }
Example #3
0
        /// <summary>
        /// Make the ItemVersion applicable to a given type by removing any inapplicable keys
        /// </summary>
        /// <param name="version">The original ItemVersion</param>
        /// <param name="t">The type to which to make it applicable</param>
        /// <returns>The modified, applicable ItemVersion</returns>
        public ItemVersion GetApplicableVersion(ItemVersion version, Type t)
        {
            ItemVersion res = new ItemVersion(Versioners
                                              .Where(vnr => version.ContainsKey(vnr.VersionKey) && vnr.Versionable(t))
                                              .ToDictionary(vnr => vnr.VersionKey, vnr => version[vnr.VersionKey]));

            return(res);
        }
Example #4
0
 /// <summary>
 /// Get all the displays for all the keys in an ItemVersion
 /// </summary>
 /// <param name="version">The ItemVersion to display</param>
 /// <returns>The VersionDisplays for all the keys of the ItemVersion</returns>
 public List <VersionDisplay> DisplayVersion(ItemVersion version)
 {
     return(Versioners
            .OrderBy(v => v.VersionKey)
            .Where(v => version.ContainsKey(v.VersionKey))
            .Select(v => v.DisplayItemVersion(version))
            .Where(vi => vi != null && !string.IsNullOrEmpty(vi.Text))
            .ToList());
 }
Example #5
0
 /// <summary>
 /// Set the container to have the ItemVersion supplied
 /// </summary>
 /// <param name="version">ItemVersion to set on the container</param>
 /// <param name="container">The container to set the ItemVersion for</param>
 public void SetVersion(ItemVersion version, object container)
 {
     foreach (var versioner in Versioners)
     {
         if (version.ContainsKey(versioner.VersionKey) && versioner.Versionable(container))
         {
             versioner.SetItemVersion(version, container);
         }
     }
 }
Example #6
0
        /// <summary>
        /// There is a specific ItemVersion which is contained by both this ItemVersion and the argument
        /// </summary>
        /// <param name="other">The other ItemVersion</param>
        /// <returns>Whether an common specific ItemVersion exists</returns>
        public bool Overlaps(ItemVersion other)
        {
            foreach (var key in this.Keys)
            {
                if (other.ContainsKey(key) && other[key] != null && this[key] != null && !other[key].Equals(this[key]))
                {
                    return(false);
                }
            }

            return(true);
        }
Example #7
0
        /// <summary>
        /// Where the other version contains a key, and this version contains a key, set this version's key to the other's value
        /// </summary>
        /// <param name="other">The version to overlay on this one</param>
        /// <returns></returns>
        public ItemVersion Overlay(ItemVersion other)
        {
            var overlaid = new ItemVersion(this);

            other.Do(kvp =>
            {
                if (overlaid.ContainsKey(kvp.Key))
                {
                    overlaid[kvp.Key] = kvp.Value;
                }
            });
            return(overlaid);
        }
Example #8
0
        /// <summary>
        /// Expand the abstract version to a list of fully-specified versions
        /// with all the keys of all the registered versions
        /// </summary>
        /// <param name="iv">Abstract version to expand</param>
        /// <returns>List of fully-specified versions</returns>
        public List <ItemVersion> ContainingVersions(ItemVersion iv)
        {
            var expIv = new ItemVersion(iv);

            foreach (var versioner in Versioners)
            {
                if (!iv.ContainsKey(versioner.VersionKey))
                {
                    expIv.Add(versioner.VersionKey, null);
                }
            }
            return(expIv.Expand());
        }
Example #9
0
        private ItemVersion OverrideVersion(ItemVersion overridden, ItemVersion over)
        {
            bool changed = false;

            var v = overridden.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);

            // detected if we have recursed into this (on the current thread/request) and don't apply override if so
            bool blocked = RequestThreadCache.Current.ContainsKey(overrideBlockKey + UniqueId)
                ? ((bool?)RequestThreadCache.Current[overrideBlockKey + UniqueId] ?? false)
                : false;

            if (over.Count > 0 && !blocked)
            {
                IUser u = null;
                RequestThreadCache.Current[overrideBlockKey + UniqueId] = true;
                try
                {
                    u = SecurityManager.Current?.User;
                }
                finally
                {
                    RequestThreadCache.Current[overrideBlockKey + UniqueId] = false;
                }

                foreach (var versioner in Versioners)
                {
                    if (over.ContainsKey(versioner.VersionKey))
                    {
                        var legalVals = u == null
                            ? new List <object> {
                            versioner.PublicVersionValue
                        }
                            : versioner.GetAllowedVersions(u);
                        var overVal = over[versioner.VersionKey];
                        if (legalVals.Any(lVal => lVal == null || lVal.Equals(overVal)))
                        {
                            if (!v.ContainsKey(versioner.VersionKey) ||
                                (v[versioner.VersionKey] == null && overVal != null) ||
                                !v[versioner.VersionKey].Equals(overVal))
                            {
                                v[versioner.VersionKey] = overVal;
                                changed = true;
                            }
                        }
                    }
                }
            }

            return(changed ? new ItemVersion(v) : null);
        }
Example #10
0
        /// <summary>
        /// Make the ItemVersion applicable to a given type by removing any inapplicable keys
        /// </summary>
        /// <param name="version">The original ItemVersion</param>
        /// <param name="t">The type to which to make it applicable</param>
        /// <returns>The modified, applicable ItemVersion</returns>
        public ItemVersion GetApplicableVersion(ItemVersion version, Type t)
        {
            ItemVersion res = new ItemVersion();

            foreach (var versioner in Versioners)
            {
                if (!version.ContainsKey(versioner.VersionKey))
                {
                    continue;
                }
                if (versioner.Versionable(t))
                {
                    res.Add(versioner.VersionKey, version[versioner.VersionKey]);
                }
            }
            return(res);
        }
Example #11
0
        public bool Equals(ItemVersion other)
        {
            if (other == null || this.Values.Where(v => v != null).Count() != other.Values.Where(v => v != null).Count())
            {
                return(false);
            }

            foreach (var kvp in this)
            {
                if (kvp.Value == null)
                {
                    continue;
                }

                if (!other.ContainsKey(kvp.Key) || other[kvp.Key] == null || !other[kvp.Key].Equals(kvp.Value))
                {
                    return(false);
                }
            }
            return(true);
        }
Example #12
0
        /// <summary>
        /// Find all specific ItemVersions which are applicable to a type
        /// </summary>
        /// <param name="t">The type</param>
        /// <returns>All applicable ItemVersion</returns>
        public List <ItemVersion> MatchingVersions(Type t)
        {
            var vsn   = new ItemVersion(this);
            var other = VersionManager.Instance.VersionForType(t);

            foreach (var key in this.Keys)
            {
                if (!other.ContainsKey(key))
                {
                    vsn.Remove(key);
                }
            }
            foreach (var key in other.Keys)
            {
                if (!vsn.ContainsKey(key))
                {
                    vsn.Add(key, null);
                }
            }
            return(vsn.Expand());
        }