public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri version, CallContext context)
{
var args = new GetItemFieldsArgs(itemDefinition, context);
CorePipeline.Run("contactFacetDataProvider.getItemFields", args);
return(args.FieldList);
}
public override VersionUriList GetItemVersions(ItemDefinition itemDefinition, CallContext context)
{
// TODO: Move to provider!
// TODO: Use prefecthing like the old one?
var result = Provider.GetItem(itemDefinition.ID.ToGuid());
if (result != null && result.FieldValues != null)
{
var versions = new VersionUriList();
var versionsList = new List <VersionUri>();
foreach (var fieldKey in result.FieldValues.Where(field => field.Version.HasValue && field.Language != null))
{
if (versionsList.Any(ver => fieldKey.Matches(ver)))
{
continue;
}
var newVersionUri = new VersionUri(LanguageManager.GetLanguage(fieldKey.Language), new Version(fieldKey.Version.Value));
versionsList.Add(newVersionUri);
}
foreach (var version in versionsList)
{
versions.Add(version);
}
return(versions);
}
return(null);
}
public virtual void AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context)
{
if (DisableSerialization)
{
return;
}
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
var sourceItem = GetSourceFromIdIfIncluded(itemDefinition);
if (sourceItem == null)
{
return; // not an included item
}
// we make a clone of the item so that we can insert a new version on it
var versionAddProxy = new ProxyItem(sourceItem);
// determine what the next version number should be in the current language
// (highest number currently present + 1)
var newVersionNumber = 1 + versionAddProxy.Versions
.Where(v => v.Language.Equals(baseVersion.Language.CultureInfo))
.Select(v => v.VersionNumber)
.DefaultIfEmpty()
.Max();
IItemVersion newVersion;
// if the base version is 0 or less, that means add a blank version (per SC DP behavior). If 1 or more we should copy all fields on that version into the new version.
if (baseVersion.Version.Number > 0)
{
newVersion = versionAddProxy.Versions.FirstOrDefault(v => v.Language.Equals(baseVersion.Language.CultureInfo) && v.VersionNumber.Equals(baseVersion.Version.Number));
// the new version may not exist if we are using language fallback and adding a new version. If that's the case we should create a blank version, as that's what Sitecore does.
if (newVersion != null)
{
newVersion = new ProxyItemVersion(newVersion)
{
VersionNumber = newVersionNumber
}
}
; // creating a new proxyversion essentially clones the existing version
else
{
newVersion = new ProxyItemVersion(baseVersion.Language.CultureInfo, newVersionNumber);
}
}
else
{
newVersion = new ProxyItemVersion(baseVersion.Language.CultureInfo, newVersionNumber);
}
// inject the new version we created into the proxy item
var newVersions = versionAddProxy.Versions.Concat(new[] { newVersion }).ToArray();
versionAddProxy.Versions = newVersions;
// flush to serialization data store
SerializeItemIfIncluded(versionAddProxy, "Version Added");
}
public override int AddVersion([CanBeNull] ItemDefinition itemDefinition, [CanBeNull] VersionUri baseVersion, [CanBeNull] CallContext context)
{
if (itemDefinition == null || baseVersion == null || context == null)
{
return(base.AddVersion(itemDefinition, baseVersion, context));
}
var item = this.FindItem(itemDefinition.ID);
if (item == null)
{
return(base.AddVersion(itemDefinition, baseVersion, context));
}
var version = item.AddVersion(baseVersion.Language, baseVersion.Version.Number);
if (version == null)
{
return(-1);
}
item.File.Commit();
return(version.Number);
}
public virtual FieldList GetFieldList(VersionUri version)
{
var result = new FieldList();
result.SafeAdd(FieldIDs.DisplayName, DisplayName);
return(result);
}
public bool RemoveVersion([NotNull] ID itemID, [NotNull] VersionUri versionUri)
{
Assert.ArgumentNotNull(itemID, "itemID");
Assert.ArgumentNotNull(versionUri, "versionUri");
var item = this.GetItem(itemID);
if (item == null)
{
return(false);
}
var language = versionUri.Language;
Assert.IsNotNull(language, "language");
var version = versionUri.Version;
Assert.IsNotNull(version, "version");
var versions = item.Fields.Versioned[language];
lock (this.SyncRoot)
{
if (!versions.Remove(version.Number))
{
return(false);
}
this.Commit();
}
return(true);
}
public FieldList GetFieldList(VersionUri version)
{
return(new FieldList
{
{ FieldIDs.Revision, Guid.NewGuid().ToString() } // New revision ensures republish of this item everytime, when using Smart publish.
});
}
public void AddDataFromCategory(FieldList list, VersionUri version, Category category)
{
list.SafeAdd(FieldIds.Category.NameFieldId, category.Name);
list.SafeAdd(FieldIds.Category.CategoryIdFieldId, category.CategoryId.ToString());
list.SafeAdd(FieldIds.Category.ParentCatalogIdFieldId, category.ProductCatalog.ProductCatalogId.ToString());
list.SafeAdd(FieldIds.Category.DisplayOnSiteFieldId, category.DisplayOnSite.ToSitecoreFormat());
var description = category.GetDescription(version.Language.Name);
list.SafeAdd(FieldIds.Category.DisplayNameFieldId, description.DisplayName);
list.SafeAdd(FieldIds.Category.DescriptionFieldId, description.Description);
list.SafeAdd(FieldIds.Category.ImageFieldId,
string.IsNullOrEmpty(category.ImageMediaId)
? string.Empty
: string.Format("<image mediaid=\"{0}\" />", category.ImageMediaId));
list.SafeAdd(FieldIDs.Created, category.CreatedOn.ToSitecoreFormat());
list.SafeAdd(FieldIDs.CreatedBy, category.CreatedBy);
list.SafeAdd(FieldIDs.Updated, category.ModifiedOn.ToSitecoreFormat());
list.SafeAdd(FieldIDs.UpdatedBy, category.ModifiedBy);
list.SafeAdd(FieldIDs.Revision, category.Guid.Derived(category.ModifiedOn).ToString());
// Avoid adding product data to categories if the product data is not included.
var includeProductData = _dataProviderSettings.IncludeProductData;
if (includeProductData)
{
string productIdList = BuildListOfProductIds(category);
list.SafeAdd(FieldIds.Category.ProductsInCategory, productIdList);
}
_dynamicCategoryTemplate.AddDynamicFieldValuesForCategory(category, list, version);
}
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, Sitecore.Data.DataProviders.CallContext context)
{
if (!Templates.Contains(itemDefinition.TemplateID))
{
return(null);
}
var currentFields = context.CurrentResult as FieldList;
var productCode = currentFields != null ? currentFields[ActiveCommerce.TemplateFields.ProductCode] : null;
if (productCode.IsNullOrEmpty())
{
return(null);
}
var book = Data.Elements("book").SingleOrDefault(x => x.Attribute("id").Value == productCode);
if (book == null)
{
return(null);
}
var fields = new FieldList();
fields.Add(FieldIDs.Author, book.Element("author").Value);
fields.Add(FieldIDs.Genre, book.Element("genre").Value);
var dateValue = DateTime.ParseExact(book.Element("publish_date").Value, "yyyy-MM-dd", CultureInfo.InvariantCulture);
fields.Add(FieldIDs.PublishDate, Sitecore.DateUtil.ToIsoDate(dateValue));
return(fields);
}
private FieldList GetItemFieldsInternal(ItemDefinition item, VersionUri version, CallContext context)
{
var list = new FieldList();
ControllerType controllerType = null;
if (item.ID == FolderId || ControllerType.GetAllNamespaces().ContainsKey(item.ID.ToGuid()) || ((controllerType = ControllerType.GetControllerType(item.ID)) != null))
{
list.Add(FieldIDs.Icon, Themes.MapTheme("SoftwareV2/16x16/elements.png"));
if (controllerType != null)
{
list.Add(FieldIDs.DisplayName, controllerType.Description);
}
AddStandardFields(list);
}
else
{
var action = ControllerAction.GetControllerAction(item.ID);
if (action != null)
{
AddActionFields(list, action);
AddStandardFields(list);
}
}
return(list.Count == 0 ? base.GetItemFields(item, version, context) : list);
}
private FieldList GetFieldListForCategory(CategorySitecoreItem item, VersionUri version)
{
var fields = Cache.Lookup(item.Id, version);
if (fields != null)
{
if (UseVerboseLogging)
{
_log.Log <ContentNodeDataProvider>("cache hit");
}
Stats.Hit();
return(fields);
}
if (UseVerboseLogging)
{
_log.Log <ContentNodeDataProvider>("cache hit");
}
Stats.Miss();
PopulateCacheWithFieldListsForAllVersions(item);
fields = _cache.Lookup(item.Id, version);
if (fields != null)
{
return(fields);
}
return(item.GetFieldList(version));
}
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
if (itemDefinition.ID == FieldIds.SystemContent.UcommerceProductsMultilistWithSearch)
{
var fieldList = new FieldList
{
{ ID.Parse("{6BF5ED07-BC70-42F4-BB77-C017D340950E}"), "Ucommerce.Sitecore" },
{ ID.Parse("{9FE6154A-A16E-4827-99F6-F51533C34EC8}"), "Ucommerce.Sitecore.SitecoreDataProvider.Impl.ProductsMultilistWithSearch" }
};
return(fieldList);
}
if (itemDefinition.ID == FieldIds.SystemContent.UcommerceCategoriesTreeList)
{
var fieldList = new FieldList
{
{ ID.Parse("{6BF5ED07-BC70-42F4-BB77-C017D340950E}"), "Ucommerce.Sitecore" },
{ ID.Parse("{9FE6154A-A16E-4827-99F6-F51533C34EC8}"), "Ucommerce.Sitecore.SitecoreDataProvider.Impl.CategoriesTreelist" }
};
return(fieldList);
}
return(null);
}
// In this method we re-retrieve the item form the repository and populate the
// Sitecore item fields we care about from this item. By breaking this out from
// GetItemDefinition, we're able to keeps things flexible in terms of later updates.
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
if (this.canProcessItem(itemDefinition.ID))
{
Trace.WriteLine(String.Format("GetItemFields({0}, {1}, {2})", itemDefinition, versionUri, context), "ProductDataProvider");
var fields = new FieldList();
var template = TemplateManager.GetTemplate(this.productTemplateId, this.ContentDatabase);
if (template != null)
{
var originalId = this.getExternalId(itemDefinition.ID);
if (originalId != Guid.Empty)
{
if (context.DataManager.DataSource.ItemExists(itemDefinition.ID))
{
ReflectionUtil.CallMethod(typeof(ItemCache), "RemoveItem", true, true, new Object[] { itemDefinition.ID });
}
var product = this.productRepository.Find(originalId);
if (product != null)
{
foreach (var dataField in template.GetFields().Where(ItemUtil.IsDataField))
{
fields.Add(dataField.ID, this.getFieldValue(dataField, product));
}
}
}
}
return(fields);
}
return(base.GetItemFields(itemDefinition, versionUri, context));
}
private int CopyVersion([NotNull] ItemDefinition item, [NotNull] VersionUri baseVersion)
{
if (!VersionExists(item, baseVersion))
{
return(-1);
}
var newVersion = GetLatestVersion(item, baseVersion.Language) + 1;
VersionedFields[item.ID].AddRange(
VersionedFields[item.ID].Where(
r => (r.Language == baseVersion.Language.ToString()) && (r.Version == baseVersion.Version.ToInt32()))
.Select(
r =>
new FieldsRow
{
ItemID = item.ID,
Language = r.Language,
Version = newVersion,
FieldID = r.FieldID,
Value = r.Value
}));
return(newVersion);
}
/// <summary>
/// Get a list of all available versions in different languages.
/// </summary>
/// <param name="itemDefinition">Used to identify the particular item</param>
/// <param name="context"></param>
/// <returns></returns>
public override VersionUriList GetItemVersions(ItemDefinition itemDefinition, CallContext context)
{
Item result = Items.FindOneById(itemDefinition.ID.ToGuid());
if (result != null && result.FieldValues != null)
{
VersionUriList versions = new VersionUriList();
var versionsList = new List <VersionUri>();
foreach (FieldValueId fieldValueId in result.FieldValues.Keys.Where(fv => fv.Version.HasValue && fv.Language != null))
{
if (versionsList.Where(ver => fieldValueId.Matches(ver)).Count() == 0)
{
VersionUri newVersionUri = new VersionUri(
Sitecore.Data.Managers.LanguageManager.GetLanguage(fieldValueId.Language),
new Sitecore.Data.Version(fieldValueId.Version.Value));
versionsList.Add(newVersionUri);
}
}
foreach (var version in versionsList)
{
versions.Add(version);
}
return(versions);
}
return(null);
}
public FieldList GetFieldList(ID id, VersionUri version)
{
MakeSureWeAreReady();
if (ItemIsContainedInDictionary(id))
{
var item = _sitecoreItems[id];
if (UseVerboseLogging)
{
_log.Log <ProductsDataProvider>(string.Format("ContentNodeDataProvider: GetFieldList() : {0} - {1} - {2}", id.Guid, item.GetType().Name, item.ItemDefinition.Name));
}
if (item is CatalogSitecoreItem)
{
return(GetFieldListForCatalog(item as CatalogSitecoreItem, version));
}
if (item is CategorySitecoreItem)
{
return(GetFieldListForCategory(item as CategorySitecoreItem, version));
}
return(_sitecoreItems[id].GetFieldList(version));
}
return(new FieldList());
}
/// <summary>
/// Gets the fields of a specific item version.
/// </summary>
/// <param name="itemDefinition">The item.</param>
/// <param name="versionUri">The version URI.</param>
/// <param name="context">The context.</param>
/// <returns>Sitecore.Data.FieldList.</returns>
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
if (!_setupComplete)
{
return(base.GetItemFields(itemDefinition, versionUri, context));
}
var fields = new FieldList();
var sectionInfo = SectionTable.FirstOrDefault(x => x.SectionId == itemDefinition.ID);
if (sectionInfo != null)
{
GetStandardFields(fields,
sectionInfo.SectionSortOrder >= 0
? sectionInfo.SectionSortOrder
: (SectionTable.IndexOf(sectionInfo) + 100));
return(fields);
}
var fieldInfo = FieldTable.FirstOrDefault(x => x.FieldId == itemDefinition.ID);
if (fieldInfo != null)
{
GetStandardFields(fields,
fieldInfo.FieldSortOrder >= 0 ? fieldInfo.FieldSortOrder : (FieldTable.IndexOf(fieldInfo) + 100));
GetFieldFields(fieldInfo, fields);
return(fields);
}
return(base.GetItemFields(itemDefinition, versionUri, context));
}
/// <summary>
/// Gets the fields of a specific item version.
/// </summary>
/// <param name="itemDefinition">The item.</param>
/// <param name="versionUri">The version URI.</param>
/// <param name="context">The context.</param>
/// <returns>Sitecore.Data.FieldList.</returns>
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
if (!_setupComplete)
{
return(base.GetItemFields(itemDefinition, versionUri, context));
}
var fields = new FieldList();
var sectionTable = SectionTable.ToList();//prevent "Collection was modified"
var sectionInfo = sectionTable.FirstOrDefault(x => x.SectionId == itemDefinition.ID);
if (sectionInfo != null)
{
GetStandardFields(fields, sectionInfo.SectionSortOrder >= 0 ? sectionInfo.SectionSortOrder : 100);
return(fields);
}
var fieldtable = FieldTable.ToList();//prevent "Collection was modified"
var fieldInfo = fieldtable.FirstOrDefault(x => x.FieldId == itemDefinition.ID);
if (fieldInfo != null)
{
GetStandardFields(fields, fieldInfo.FieldSortOrder >= 0 ? fieldInfo.FieldSortOrder : 100);
GetFieldFields(fieldInfo, fields);
return(fields);
}
return(base.GetItemFields(itemDefinition, versionUri, context));
}
public override FieldList GetItemFields(ItemDefinition item, VersionUri version, CallContext context)
{
Assert.ArgumentNotNull(item, "item");
Assert.ArgumentNotNull(version, "version");
Assert.ArgumentNotNull(context, "context");
var list = new FieldList();
if (item.ID == FolderId || (ControllerType.GetControllerType(ParentId, item.ID) != null))
{
list.Add(FieldIDs.Icon, Themes.MapTheme("SoftwareV2/16x16/elements.png"));
}
else
{
var action = ControllerAction.GetControllerAction(ParentId, item.ID);
if (action != null && HttpContext.Current != null)
{
//VirtualPathData vpd;
//MvcActionHelper.GetRouteData(new HttpContextWrapper(HttpContext.Current), action.ActionName, action.ControllerType.ControllerName, null, false, out vpd);
//list.Add(LayoutFieldIDs.Path, vpd.VirtualPath);
list.Add(FieldIDs.Icon, Themes.MapTheme("SoftwareV2/16x16/element.png"));
}
}
if (list.Count == 0)
{
return(base.GetItemFields(item, version, context));
}
return(list);
}
public override int AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context)
{
var item = GetItem(itemDefinition.ID);
if (item == null)
{
return(base.AddVersion(itemDefinition, baseVersion, context));
}
var language = item.GetOrCreateLanguage(baseVersion.Language.ToString());
if (baseVersion.Version.Number > 0)
{
var current = language.GetOrCreateVersion(baseVersion.Version.Number);
var clone = current.Clone() as VersionModel;
clone.Number++;
language.Versions.Add(clone);
}
else
{
language.GetOrCreateVersion(1);
}
context.Abort();
return(_repository.WriteItem(item) ? 1 : -1);
}
internal void AddDataFromCatalog(ProductCatalog catalog, FieldList list, VersionUri version)
{
if (catalog == null)
{
return;
}
list.SafeAdd(FieldIDs.Security, GetSecurityPermisionsFor(catalog));
list.SafeAdd(FieldIds.Catalog.NameFieldId, catalog.Name);
list.SafeAdd(FieldIds.Catalog.CatalogIdFieldId, catalog.ProductCatalogId.ToString());
list.SafeAdd(FieldIds.Catalog.ShowPricesWithVatId, catalog.ShowPricesIncludingVAT.ToSitecoreFormat());
list.SafeAdd(FieldIds.Catalog.DefaultPriceGroupId, catalog.PriceGroup.SitecoreId().ToString());
list.SafeAdd(FieldIDs.Revision, catalog.Guid.Derived(catalog.ModifiedOn).ToString());
var description = catalog.GetDescription(version.Language.Name);
if (description != null)
{
list.SafeAdd(FieldIds.Catalog.DisplayNameFieldId, description.DisplayName);
}
var allowedPriceGroupIds = catalog.AllowedPriceGroups.ToList().Select(x => x.PriceGroupId).ToList();
foreach (var priceGroupId in _priceGroupIdToFieldIdMap.Keys)
{
list.SafeAdd(_priceGroupIdToFieldIdMap[priceGroupId],
allowedPriceGroupIds.Contains(priceGroupId) ? true.ToSitecoreFormat() : false.ToSitecoreFormat());
}
}
protected void AddDataFromCategory(int categoryId, FieldList list, VersionUri version)
{
var repository = ObjectFactory.Instance.Resolve <IRepository <Category> >();
var category = repository.Select(new SingleCategoryQuery(categoryId)).Single();
AddDataFromCategory(list, version, category);
}
private void AddCommonFieldsForProduct(Product product, FieldList list, VersionUri version)
{
// Bucketable
list.SafeAdd(new ID("{C9283D9E-7C29-4419-9C28-5A5C8FF53E84}"), true.ToSitecoreFormat());
// Common
list.SafeAdd(FieldIds.Product.SkuFieldId, product.Sku);
list.SafeAdd(FieldIds.Product.ProductIdFieldId, product.ProductId.ToString());
list.SafeAdd(FieldIds.Product.InternalNameFieldId, product.Name);
list.SafeAdd(FieldIds.Product.DisplayOnSiteFieldId, product.DisplayOnSite.ToSitecoreFormat());
list.SafeAdd(FieldIds.Product.AllowOrderingFieldId, product.AllowOrdering.ToSitecoreFormat());
// Multi-lingual
var description = product.ProductDescriptions.FirstOrDefault(x => x.CultureCode == version.Language.CultureInfo.Name);
if (description != null && !string.IsNullOrEmpty(description.DisplayName))
{
list.SafeAdd(FieldIds.Product.DisplayNameFieldId, description.DisplayName);
}
if (description != null && !string.IsNullOrEmpty(description.ShortDescription))
{
list.SafeAdd(FieldIds.Product.ShortDescriptionFieldId, description.ShortDescription);
}
if (description != null && !string.IsNullOrEmpty(description.LongDescription))
{
list.SafeAdd(FieldIds.Product.LongDescriptionFieldId, description.LongDescription);
}
}
public virtual FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
// return null if not present, should return all shared fields as well as all fields in the version
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
Assert.ArgumentNotNull(versionUri, "versionUri");
if (DisableSerialization || DisableTransparentSync || itemDefinition == ItemDefinition.Empty)
{
return(null);
}
var item = GetTargetFromId(itemDefinition.ID);
if (item == null)
{
return(null);
}
var fields = new FieldList();
foreach (var sharedField in item.SharedFields)
{
if (sharedField.BlobId.HasValue || sharedField.Value != null)
{
fields.Add(new ID(sharedField.FieldId), sharedField.BlobId?.ToString() ?? sharedField.Value);
}
}
var version = item.Versions.FirstOrDefault(v => v.VersionNumber == versionUri.Version.Number && v.Language.Name == versionUri.Language.Name);
if (version == null)
{
return(fields);
}
foreach (var versionedField in version.Fields)
{
if (versionedField.BlobId.HasValue || versionedField.Value != null)
{
fields.Add(new ID(versionedField.FieldId), versionedField.BlobId?.ToString() ?? versionedField.Value);
}
}
var unversionedFields = item.UnversionedFields.FirstOrDefault(language => language.Language.Name == versionUri.Language.Name);
if (unversionedFields != null)
{
foreach (var unversionedField in unversionedFields.Fields)
{
fields.Add(new ID(unversionedField.FieldId), unversionedField.BlobId?.ToString() ?? unversionedField.Value);
}
}
fields.Add(FieldIDs.UpdatedBy, TransparentSyncUpdatedByValue);
fields.Add(FieldIDs.Revision, Guid.NewGuid().ToString());
AddBlobsToCache(item);
return(fields);
}
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
if (Items.Contains(itemDefinition.ID))
{
Log.Info(string.Format("GetItemFields called with itemDefinition id = {0}, name = {1}, version = {2}, language = {3} (BasicDataProvider)", itemDefinition.ID, itemDefinition.Name, versionUri.Version, versionUri.Language.Name), this);
}
return(null);
}
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
if (Items.Contains(itemDefinition.ID))
{
Log.Info(string.Format("GetItemFields called with itemDefinition id = {0}, name = {1}, version = {2}, language = {3} (BasicDataProvider)", itemDefinition.ID, itemDefinition.Name, versionUri.Version, versionUri.Language.Name), this);
}
return null;
}
public void ShouldGetNullItemFieldsIfNoItemFound(
[Greedy] FakeDataProvider sut,
ItemDefinition def,
VersionUri versionUri,
CallContext context)
{
sut.GetItemFields(def, versionUri, context).Should().BeNull();
}
public void AddDynamicFieldValuesForProduct(Product product, FieldList list, VersionUri version)
{
var properties = product.GetProperties().ToList();
properties.Where(x => x.RenderForCulture(version.Language.CultureInfo.ToString()))
.ToList()
.ForEach(x => TemplateFieldHelper.AddDynamicFieldValuesForProduct(list, x, _productDefinitionFieldIdToFieldIdMap));
}
public void AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context)
{
if (DisableSerialization) return;
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
SerializeItemIfIncluded(itemDefinition, "Version Added");
}
private bool VersionExists([NotNull] ItemDefinition item, [NotNull] VersionUri versionUri)
{
return
(VersionedFields[item.ID].Any(
r =>
(r.ItemID == item.ID) && (r.Language == versionUri.Language.ToString()) &&
(r.Version == versionUri.Version.ToInt32())));
}
private void AddVersionedFieldValues(ID itemId, VersionUri version, FieldList fieldList)
{
if (_versionedFields.ContainsKey(itemId.Guid))
{
var values = _versionedFields[itemId.Guid];
var key = version.Language.CultureInfo.Name + ";" + version.Version.Number;
AddFieldValue(fieldList, values, key);
}
}
public void AddFieldValues(ITreeNodeContent node, FieldList list, VersionUri version)
{
var store = ProductCatalogGroup.Get(int.Parse(node.ItemId));
if (store != null)
{
_baseProductCatalogGroupTemplate.AddBaseFieldValues(store, list, version);
}
}
public bool Matches(VersionUri versionUri)
{
var versionUriLanguage = versionUri.Language != null ? versionUri.Language.Name : null;
var versionUriVersion = versionUri.Version != null ? versionUri.Version.Number : null as int?;
var matchesLanguage = string.IsNullOrWhiteSpace(Language) || Language.Equals(versionUriLanguage);
var matchesVersion = !Version.HasValue || Version.Equals(versionUriVersion);
return matchesLanguage && matchesVersion;
}
public static SyncVersion GetVersion(this SyncItem item, VersionUri uri)
{
string versionString = uri.Version.Number.ToString(CultureInfo.InvariantCulture);
var language = uri.Language;
if (language.Equals(Language.Invariant)) language = LanguageManager.DefaultLanguage;
return item.Versions.FirstOrDefault(x => x.Language.Equals(language.Name, StringComparison.OrdinalIgnoreCase) && x.Version == versionString);
}
public override int AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context)
{
var baseVersionResult = base.AddVersion(itemDefinition, baseVersion, context);
if (baseVersionResult < 1) return baseVersionResult; // no version created for some reason
foreach (var provider in _unicornDataProviders)
provider.AddVersion(itemDefinition, baseVersion, context);
return baseVersionResult;
}
public override FieldList GetItemFields(ItemDefinition item, VersionUri version, CallContext context)
{
Assert.ArgumentNotNull(item, "item");
Assert.ArgumentNotNull(version, "version");
Assert.ArgumentNotNull(context, "context");
var action = ControllerAction.GetControllerAction(ParentId, item.ID);
if (action == null)
{
return base.GetItemFields(item, version, context);
}
FieldList list = new FieldList();
var template = context.DataManager.Database.GetTemplate(BaseTemplateId);
list.Add(template.GetField("Namespace").ID, typeof(MvcActionLoader).Namespace);
list.Add(template.GetField("Tag").ID, typeof(MvcActionLoader).Name);
list.Add(template.GetField("TagPrefix").ID, "mvc");
list.Add(template.GetField("Assembly").ID, typeof(MvcActionLoader).Assembly.GetName().Name);
list.Add(FieldIDs.Icon, Themes.MapTheme("SoftwareV2/16x16/element_selection.png"));
return list;
}
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
var fields = new FieldList();
if (itemDefinition == ItemDefinition.Empty)
{
return fields;
}
var database = GetDatabase(context);
var syncItem = database.GetItem(itemDefinition.ID.ToString(), versionUri.Language.Name);
if (syncItem == null)
{
return fields;
}
foreach (var syncField in syncItem.SharedFields)
{
fields.Add(ID.Parse(syncField.FieldID), syncField.FieldValue);
}
var syncVersion = syncItem.GetLatestVersions().Where(v => v.Language.Equals(versionUri.Language.Name, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
if (syncVersion == null)
{
return fields;
}
foreach (var syncField in syncVersion.Fields)
{
fields.Add(ID.Parse(syncField.FieldID), syncField.FieldValue);
}
return fields;
}
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
if (Items.ContainsKey(itemDefinition.ID))
{
FieldList itemFields = new FieldList();
foreach (KeyValuePair<ID,string> field in Items[itemDefinition.ID].Fields)
{
itemFields.Add(field.Key, field.Value);
}
return itemFields;
}
return null;
}
/// <summary>
/// Save changes that were made to an item to the database.
/// </summary>
/// <param name="itemDefinition">Used to identify the particular item</param>
/// <param name="changes">A holder object that keeps track of the changes</param>
/// <param name="context"></param>
/// <returns></returns>
public override bool SaveItem(ItemDefinition itemDefinition, Sitecore.Data.Items.ItemChanges changes, CallContext context)
{
Item current = Items.FindOneById(itemDefinition.ID.ToGuid());
if (current == null)
{
return false;
}
if (changes.HasPropertiesChanged)
{
current.Name = StringUtil.GetString(changes.GetPropertyValue("name"), itemDefinition.Name);
ID templateId = MainUtil.GetObject(changes.GetPropertyValue("templateid"), itemDefinition.TemplateID) as ID;
current.TemplateID = templateId != ID.Null ? templateId.ToGuid() : Guid.Empty;
ID branchId = MainUtil.GetObject(changes.GetPropertyValue("branchid"), itemDefinition.BranchId) as ID;
current.BranchID = branchId != ID.Null ? branchId.ToGuid() : Guid.Empty;
}
if (changes.HasFieldsChanged)
{
foreach (Sitecore.Data.Items.FieldChange change in changes.FieldChanges)
{
VersionUri fieldVersionUri = new VersionUri(
change.Definition == null || change.Definition.IsShared ? null : change.Language,
change.Definition == null || change.Definition.IsUnversioned ? null : change.Version);
var matchingFields = current.FieldValues.Where(fv => fv.Key.Matches(fieldVersionUri) && fv.Key.FieldId.Equals(change.FieldID.ToGuid()));
if (change.RemoveField)
{
if(matchingFields.Count() > 0)
{
current.FieldValues.Remove(matchingFields.First().Key);
}
}
else
{
if (matchingFields.Count() > 0)
{
current.FieldValues[matchingFields.First().Key] = change.Value;
}
else
{
current.FieldValues.Add(new FieldValueId()
{
FieldId = change.FieldID.ToGuid(),
Language = fieldVersionUri.Language != null ? fieldVersionUri.Language.Name : null,
Version = fieldVersionUri.Version != null ? fieldVersionUri.Version.Number : null as int?
}, change.Value);
}
}
}
Items.Save(current, SafeMode);
}
return true;
}
/// <summary>
/// Gets the fields of a specific item version.
/// </summary>
/// <param name="itemDefinition">The item.</param>
/// <param name="versionUri">The version URI.</param>
/// <param name="context">The context.</param>
/// <returns>Sitecore.Data.FieldList.</returns>
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
if (!_setupComplete)
return base.GetItemFields(itemDefinition, versionUri, context);
var fields = new FieldList();
var sectionInfo = SectionTable.FirstOrDefault(x => x.SectionId == itemDefinition.ID);
if (sectionInfo != null)
{
GetStandardFields(fields,
sectionInfo.SectionSortOrder >= 0
? sectionInfo.SectionSortOrder
: (SectionTable.IndexOf(sectionInfo) + 100));
return fields;
}
var fieldInfo = FieldTable.FirstOrDefault(x => x.FieldId == itemDefinition.ID);
if (fieldInfo != null)
{
GetStandardFields(fields,
fieldInfo.FieldSortOrder >= 0 ? fieldInfo.FieldSortOrder : (FieldTable.IndexOf(fieldInfo) + 100));
GetFieldFields(fieldInfo, fields);
return fields;
}
return base.GetItemFields(itemDefinition, versionUri, context);
}
public void AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context)
{
if (DisableSerialization) return;
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
var sourceItem = GetSourceFromIdIfIncluded(itemDefinition);
if (sourceItem == null) return; // not an included item
// we make a clone of the item so that we can insert a new version on it
var versionAddProxy = new ProxyItem(sourceItem);
// determine what the next version number should be in the current language
// (highest number currently present + 1)
var newVersionNumber = 1 + versionAddProxy.Versions
.Where(v => v.Language.Equals(baseVersion.Language.CultureInfo))
.Select(v => v.VersionNumber)
.DefaultIfEmpty()
.Max();
IItemVersion newVersion;
// if the base version is 0 or less, that means add a blank version (per SC DP behavior). If 1 or more we should copy all fields on that version into the new version.
if (baseVersion.Version.Number > 0)
{
newVersion = versionAddProxy.Versions.First(v => v.Language.Equals(baseVersion.Language.CultureInfo) && v.VersionNumber.Equals(baseVersion.Version.Number));
newVersion = new ProxyItemVersion(newVersion) { VersionNumber = newVersionNumber }; // creating a new proxyversion essentially clones the existing version
}
else newVersion = new ProxyItemVersion(baseVersion.Language.CultureInfo, newVersionNumber);
// inject the new version we created into the proxy item
var newVersions = versionAddProxy.Versions.Concat(new[] { newVersion }).ToArray();
versionAddProxy.Versions = newVersions;
// flush to serialization data store
SerializeItemIfIncluded(versionAddProxy, "Version Added");
}
/// <summary>
/// Creates a new version for a content item in a particular language.
/// </summary>
/// <param name="itemDefinition">Used to identify the particular item</param>
/// <param name="baseVersion">The version to copy off of</param>
/// <param name="context"></param>
/// <returns></returns>
public override int AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context)
{
Item current = Items.FindOneById(itemDefinition.ID.ToGuid());
if (current == null)
{
return -1;
}
int num = -1;
if (baseVersion.Version != null && baseVersion.Version.Number > 0)
{
// copy version
var currentFieldValues = current.FieldValues.Where(fv => fv.Key.Matches(baseVersion)).ToList();
int? maxVersionNumber = currentFieldValues.Max(fv => fv.Key.Version);
num = maxVersionNumber.HasValue && maxVersionNumber > 0 ? maxVersionNumber.Value + 1 : -1;
if(num > 0)
{
foreach (KeyValuePair<FieldValueId, string> fieldValue in currentFieldValues)
{
current.FieldValues.Add(new FieldValueId()
{
FieldId = fieldValue.Key.FieldId,
Language = fieldValue.Key.Language,
Version = num
}, fieldValue.Value);
}
}
}
if (num == -1)
{
num = 1;
// add blank version
current.FieldValues.Add(new FieldValueId()
{
FieldId = FieldIDs.Created.ToGuid(),
Language = baseVersion.Language.Name,
Version = num
}, string.Empty);
}
Items.Save(current, SafeMode);
return num;
}
public void ShouldGetItemFields([Greedy] FakeDataProvider sut, DbTemplate template, DbItem item, DbField field, Language language, Version version,
CallContext context)
{
template.Fields.Add(field);
item.Fields.Add(field); // ?
item.TemplateID = template.ID;
sut.DataStorage.GetFakeTemplate(template.ID).Returns(template);
sut.DataStorage.GetFakeItem(item.ID).Returns(item);
var def = new ItemDefinition(item.ID, item.Name, item.TemplateID, item.BranchId);
var versionUri = new VersionUri(language, version);
sut.GetItemFields(def, versionUri, context).Should().HaveCount(1);
}
public override bool RemoveVersion(ItemDefinition itemDefinition, VersionUri version, CallContext context)
{
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
if (!ShouldExecuteProvider(itemDefinition.ID)) return false;
context.Abort();
base.RemoveVersion(itemDefinition, version, context);
return true;
}
public override int AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context)
{
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
if (!ShouldExecuteProvider(itemDefinition.ID)) return -1;
context.Abort();
return base.AddVersion(itemDefinition, baseVersion, context);
}
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
foreach (var provider in UnicornDataProviders)
{
var providerResult = provider.GetItemFields(itemDefinition, versionUri, context);
if (providerResult != null) return providerResult;
}
return base.GetItemFields(itemDefinition, versionUri, context);
}
public override bool RemoveVersion(ItemDefinition itemDefinition, VersionUri version, CallContext context)
{
if (!base.RemoveVersion(itemDefinition, version, context)) return false;
foreach (var provider in _unicornDataProviders)
provider.RemoveVersion(itemDefinition, version, context);
return true;
}
/// <summary>
/// Get a list of all available versions in different languages.
/// </summary>
/// <param name="itemDefinition">Used to identify the particular item</param>
/// <param name="context"></param>
/// <returns></returns>
public override VersionUriList GetItemVersions(ItemDefinition itemDefinition, CallContext context)
{
if (ItemsById.ContainsKey(itemDefinition.ID)
&& ItemsById[itemDefinition.ID].Versions != null)
{
List<VersionUri> versionsList = new List<VersionUri>();
foreach (SyncVersion version in ItemsById[itemDefinition.ID].Versions)
{
VersionUri newVersionUri = new VersionUri(
Sitecore.Data.Managers.LanguageManager.GetLanguage(version.Language),
new Sitecore.Data.Version(version.Version));
versionsList.Add(newVersionUri);
}
VersionUriList versions = new VersionUriList();
foreach (VersionUri version in versionsList)
{
versions.Add(version);
}
return versions;
}
return null;
}
public virtual FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
// return null if not present, should return all shared fields as well as all fields in the version
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
Assert.ArgumentNotNull(versionUri, "versionUri");
if (DisableSerialization || DisableTransparentSync || itemDefinition == ItemDefinition.Empty) return null;
var item = GetTargetFromId(itemDefinition.ID);
if (item == null) return null;
var fields = new FieldList();
foreach (var sharedField in item.SharedFields)
{
fields.Add(new ID(sharedField.FieldId), sharedField.BlobId.HasValue ? sharedField.BlobId.ToString() : sharedField.Value);
}
var version = item.Versions.FirstOrDefault(v => v.VersionNumber == versionUri.Version.Number && v.Language.Name == versionUri.Language.Name);
if (version == null) return fields;
foreach (var versionedField in version.Fields)
{
fields.Add(new ID(versionedField.FieldId), versionedField.BlobId.HasValue ? versionedField.BlobId.ToString() : versionedField.Value);
}
fields.Add(FieldIDs.UpdatedBy, TransparentSyncUpdatedByValue);
fields.Add(FieldIDs.Revision, Guid.NewGuid().ToString());
AddBlobsToCache(item);
return fields;
}
/// <summary>
/// Get a list of all the item's fields and their values.
/// </summary>
/// <param name="itemDefinition">Used to identify the particular item</param>
/// <param name="versionUri">The language and version of the item to get field values for</param>
/// <param name="context"></param>
/// <returns></returns>
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
Language language = versionUri.Language;
if (Language.Invariant.Equals(language))
{
language = Sitecore.Data.Managers.LanguageManager.DefaultLanguage;
}
if (ItemsById.ContainsKey(itemDefinition.ID))
{
FieldList fields = new FieldList();
foreach (SyncField sharedField in ItemsById[itemDefinition.ID].SharedFields)
{
fields.Add(ParseId(sharedField.FieldID), sharedField.FieldValue);
}
if (ItemsById[itemDefinition.ID].Versions != null)
{
foreach (SyncVersion version in ItemsById[itemDefinition.ID].Versions)
{
if (language.Name.Equals(version.Language)
&& versionUri.Version.Number.ToString().Equals(version.Version))
{
foreach (SyncField fieldValue in version.Fields)
{
fields.Add(ParseId(fieldValue.FieldID), fieldValue.FieldValue);
}
break;
}
}
}
return fields;
}
return null;
}
/// <summary>
/// Get a list of all available versions in different languages.
/// </summary>
/// <param name="itemDefinition">Used to identify the particular item</param>
/// <param name="context"></param>
/// <returns></returns>
public override VersionUriList GetItemVersions(ItemDefinition itemDefinition, CallContext context)
{
Item result = Items.FindOneById(itemDefinition.ID.ToGuid());
if (result != null && result.FieldValues != null)
{
VersionUriList versions = new VersionUriList();
var versionsList = new List<VersionUri>();
foreach (FieldValueId fieldValueId in result.FieldValues.Keys.Where(fv => fv.Version.HasValue && fv.Language != null))
{
if (versionsList.Where(ver => fieldValueId.Matches(ver)).Count() == 0)
{
VersionUri newVersionUri = new VersionUri(
Sitecore.Data.Managers.LanguageManager.GetLanguage(fieldValueId.Language),
new Sitecore.Data.Version(fieldValueId.Version.Value));
versionsList.Add(newVersionUri);
}
}
foreach (var version in versionsList)
{
versions.Add(version);
}
return versions;
}
return null;
}
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
Assert.ArgumentNotNull(versionUri, "versionUri");
if (itemDefinition == ItemDefinition.Empty) return null;
var syncItem = SerializedDatabase.GetItem(itemDefinition.ID);
if (syncItem == null) return null;
var fields = new FieldList();
foreach (var sharedField in syncItem.SharedFields)
{
fields.Add(sharedField.GetSitecoreId(), sharedField.FieldValue);
}
var syncVersion = syncItem.GetVersion(versionUri);
if (syncVersion == null) return fields;
foreach (var versionedField in syncVersion.Fields)
{
fields.Add(versionedField.GetSitecoreId(), versionedField.FieldValue);
}
return fields;
}
/// <summary>
/// Get a list of all the item's fields and their values.
/// </summary>
/// <param name="itemDefinition">Used to identify the particular item</param>
/// <param name="versionUri">The language and version of the item to get field values for</param>
/// <param name="context"></param>
/// <returns></returns>
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
Item result = Items.FindOneById(itemDefinition.ID.ToGuid());
if (result != null && result.FieldValues != null)
{
FieldList fields = new FieldList();
foreach (KeyValuePair<FieldValueId, string> fieldValue in result.FieldValues.Where(fv => fv.Key.Matches(versionUri)))
{
fields.Add(new ID(fieldValue.Key.FieldId), fieldValue.Value);
}
return fields;
}
return null;
}
public override int AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context)
{
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
Assert.ArgumentNotNull(baseVersion, "baseVersion");
var existingItem = SerializedDatabase.GetItem(itemDefinition.ID);
if (existingItem == null) return -1; // item may have been in another data provider, cede control
int newVersionNumber;
if (baseVersion.Version.Number > 0)
{
var baseSyncVersion = existingItem.GetVersion(baseVersion);
Assert.IsNotNull(baseSyncVersion, "Base version {0}#{1} did not exist on {2}!", baseVersion.Language.Name,
baseVersion.Version.Number, itemDefinition.ID);
var newSyncVersion = baseSyncVersion.Clone();
// the new version will be the max of the base version + 1, OR the highest existing version number in the current language + 1
newVersionNumber = Math.Max(baseVersion.Version.Number + 1, existingItem.Versions
.Where(x => x.Language == baseVersion.Language.Name)
.Max(x => int.Parse(x.Version)) + 1);
newSyncVersion.Version = newVersionNumber.ToString(CultureInfo.InvariantCulture);
existingItem.Versions.Add(newSyncVersion);
}
else
{
newVersionNumber = 1;
existingItem.AddVersion(baseVersion.Language.Name, newVersionNumber.ToString(CultureInfo.InvariantCulture), ID.NewID.ToString());
}
SerializedDatabase.SaveItem(existingItem);
return newVersionNumber;
}
public void ShouldGetNullItemFieldsIfNoItemFound([Greedy]FakeDataProvider sut, ItemDefinition def, VersionUri versionUri, CallContext context)
{
sut.GetItemFields(def, versionUri, context).Should().BeNull();
}
public override bool RemoveVersion(ItemDefinition itemDefinition, VersionUri version, CallContext context)
{
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
Assert.ArgumentNotNull(version, "version");
var existingItem = SerializedDatabase.GetItem(itemDefinition.ID);
Assert.IsNotNull(existingItem, "Existing item {0} did not exist in the serialization store!", itemDefinition.ID);
var syncVersion = existingItem.GetVersion(version);
Assert.IsNotNull(syncVersion, "Version to remove {0}#{1} did not exist on {2}!", version.Language.Name, version.Version.Number, itemDefinition.ID);
existingItem.Versions.Remove(syncVersion);
SerializedDatabase.SaveItem(existingItem);
return true;
}
public override FieldList GetItemFields(ItemDefinition item, VersionUri version, CallContext context)
{
Assert.ArgumentNotNull(item, "item");
Assert.ArgumentNotNull(version, "version");
Assert.ArgumentNotNull(context, "context");
var list = new FieldList();
if (item.ID == FolderId || (ControllerType.GetControllerType(ParentId, item.ID) != null))
{
list.Add(FieldIDs.Icon, Themes.MapTheme("SoftwareV2/16x16/elements.png"));
}
else
{
var action = ControllerAction.GetControllerAction(ParentId, item.ID);
if (action != null && HttpContext.Current != null)
{
//VirtualPathData vpd;
//MvcActionHelper.GetRouteData(new HttpContextWrapper(HttpContext.Current), action.ActionName, action.ControllerType.ControllerName, null, false, out vpd);
//list.Add(LayoutFieldIDs.Path, vpd.VirtualPath);
list.Add(FieldIDs.Icon, Themes.MapTheme("SoftwareV2/16x16/element.png"));
}
}
if (list.Count == 0)
return base.GetItemFields(item, version, context);
return list;
}
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
if (!ShouldExecuteProvider(itemDefinition.ID)) return null;
context.Abort();
return base.GetItemFields(itemDefinition, versionUri, context);
}
/// <summary>
/// Creates a new version for a content item in a particular language.
/// </summary>
/// <param name="itemDefinition">Used to identify the particular item</param>
/// <param name="baseVersion">The version to copy off of</param>
/// <param name="context"></param>
/// <returns></returns>
public override int AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context)
{
if (! ItemsById.ContainsKey(itemDefinition.ID))
{
return -1;
}
SyncItem current = ItemsById[itemDefinition.ID];
int num = -1;
Language baseVersionLanguage = baseVersion.Language;
if (Language.Invariant.Equals(baseVersionLanguage))
{
baseVersionLanguage = Sitecore.Data.Managers.LanguageManager.DefaultLanguage;
}
if (baseVersion.Version != null && baseVersion.Version.Number > 0)
{
// copy version
SyncVersion matchingVersion = (current.Versions ?? new List<SyncVersion>())
.OrderByDescending(vr => int.Parse(vr.Version))
.FirstOrDefault(vr => vr.Language.Equals(baseVersionLanguage.Name));
int? maxVersionNumber = matchingVersion != null ? int.Parse(matchingVersion.Version) : null as int?;
num = maxVersionNumber.HasValue && maxVersionNumber > 0 ? maxVersionNumber.Value + 1 : -1;
if (num > 0)
{
SyncVersion newVersion = current.AddVersion(matchingVersion.Language, num.ToString(), matchingVersion.Revision);
var currentFieldValues = matchingVersion.Fields;
foreach (var fieldValue in currentFieldValues)
{
newVersion.AddField(fieldValue.FieldID, fieldValue.FieldName, fieldValue.FieldKey, fieldValue.FieldValue, true);
}
}
}
if (num == -1)
{
num = 1;
// add blank version
current.AddVersion(baseVersionLanguage.Name, num.ToString(), Guid.NewGuid().ToString());
}
return num;
}
public void RemoveVersion(ItemDefinition itemDefinition, VersionUri version, CallContext context)
{
if (DisableSerialization) return;
Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
var sourceItem = GetSourceFromIdIfIncluded(itemDefinition);
if (sourceItem == null) return; // predicate excluded item
// create a clone of the item to remove the version from
var versionRemovingProxy = new ProxyItem(sourceItem);
// exclude the removed version
versionRemovingProxy.Versions = versionRemovingProxy.Versions.Where(v => !v.Language.Equals(version.Language.CultureInfo) || !v.VersionNumber.Equals(version.Version.Number));
SerializeItemIfIncluded(versionRemovingProxy, "Version Removed");
}
