public bool SaveItem([NotNull] ID itemID, [NotNull] ItemChanges changes)
{
Assert.ArgumentNotNull(itemID, "itemID");
Assert.ArgumentNotNull(changes, "changes");
var item = this.GetItem(itemID);
if (item == null)
{
return false;
}
lock (this.SyncRoot)
{
if (changes.HasPropertiesChanged)
{
var name = changes.GetPropertyValue("name") as string;
item.Name = name ?? item.Name;
var templateID = changes.GetPropertyValue("templateid") as ID;
item.TemplateID = templateID ?? item.TemplateID;
}
if (changes.HasFieldsChanged)
{
var saveAll = changes.Item.RuntimeSettings.SaveAll;
if (saveAll)
{
item.Fields.Shared.Clear();
item.Fields.Unversioned.Clear();
item.Fields.Versioned.Clear();
}
foreach (var fieldChange in changes.FieldChanges.OfType<FieldChange>())
{
var language = fieldChange.Language;
var number = fieldChange.Version.Number;
var fieldID = fieldChange.FieldID;
if (fieldID as object == null)
{
continue;
}
var definition = fieldChange.Definition;
if (definition == null)
{
continue;
}
var value = fieldChange.Value;
var shared = item.Fields.Shared;
var unversioned = item.Fields.Unversioned[language];
var versions = item.Fields.Versioned[language];
var versioned = versions[number];
if (fieldChange.RemoveField || value == null)
{
if (saveAll)
{
continue;
}
shared.Remove(fieldID);
unversioned.Remove(fieldID);
if (versioned != null)
{
versioned.Remove(fieldID);
}
}
else if (definition.IsShared)
{
shared[fieldID] = value;
}
else if (definition.IsUnversioned)
{
unversioned[fieldID] = value;
}
else if (definition.IsVersioned)
{
if (versioned == null)
{
versioned = new JsonFieldsCollection();
versions.Add(number, versioned);
}
versioned[fieldID] = value;
}
else
{
throw new NotSupportedException("This situation is not supported");
}
}
}
this.Commit();
}
return true;
}
public bool CopyItem([NotNull] ID sourceItemID, [NotNull] ID destinationItemID, [NotNull] ID copyID, [NotNull] string copyName)
{
Assert.ArgumentNotNull(sourceItemID, "sourceItemID");
Assert.ArgumentNotNull(destinationItemID, "destinationItemID");
Assert.ArgumentNotNull(copyID, "copyID");
Assert.ArgumentNotNull(copyName, "copyName");
var sourceItem = this.GetItem(sourceItemID);
if (sourceItem == null)
{
return false;
}
if (destinationItemID != this.RootID)
{
var destinationItem = this.GetItem(destinationItemID);
if (destinationItem == null)
{
return false;
}
}
if (!this.CreateItem(copyID, copyName, sourceItem.TemplateID, destinationItemID))
{
return false;
}
var copyItem = this.GetItem(copyID);
var copyFields = copyItem.Fields;
var copyShared = copyFields.Shared;
var copyUnversioned = copyFields.Unversioned;
var copyVersioned = copyFields.Versioned;
var sourceFields = sourceItem.Fields;
lock (this.SyncRoot)
{
// copy shared fields
copyShared.Clear();
foreach (var sourceField in sourceFields.Shared)
{
copyShared.Add(sourceField.Key, sourceField.Value);
}
// copy unversioned fields
foreach (var languageGroup in sourceFields.Unversioned)
{
var language = languageGroup.Key;
var fields = copyUnversioned[language];
foreach (var sourceField in languageGroup.Value)
{
fields.Add(sourceField.Key, sourceField.Value);
}
}
// copy versioned
foreach (var languageGroup in sourceFields.Versioned)
{
var language = languageGroup.Key;
var versions = copyVersioned[language];
foreach (var versionGroup in languageGroup.Value)
{
var number = versionGroup.Key;
var fields = new JsonFieldsCollection();
versions.Add(number, fields);
foreach (var sourceField in versionGroup.Value)
{
fields.Add(sourceField.Key, sourceField.Value);
}
}
}
this.Commit();
}
return true;
}
public int AddVersion([NotNull] ID itemID, [NotNull] VersionUri versionUri)
{
Assert.ArgumentNotNull(itemID, "itemID");
Assert.ArgumentNotNull(versionUri, "versionUri");
var item = this.GetItem(itemID);
if (item == null)
{
return -1;
}
var newNumber = -1;
var number = versionUri.Version.Number;
var language = versionUri.Language;
var versions = item.Fields.Versioned[language];
lock (this.SyncRoot)
{
if (number > 0)
{
// command to try to copy existing version
var version = versions[number];
if (version != null)
{
newNumber = versions.Max(x => x.Key) + 1;
var copiedVersion = new JsonFieldsCollection(version);
copiedVersion.Remove(FieldIDs.WorkflowState);
versions.Add(newNumber, copiedVersion);
}
}
if (newNumber != -1)
{
this.Commit();
return newNumber;
}
if (versions.Count == 0)
{
newNumber = 1;
}
else
{
newNumber = versions.Max(x => x.Key) + 1;
}
var newVersion = new JsonFieldsCollection();
newVersion[FieldIDs.Created] = DateUtil.IsoNowWithTicks;
versions.Add(newNumber, newVersion);
this.Commit();
return newNumber;
}
}
public int AddVersion([NotNull] ID itemID, [NotNull] VersionUri versionUri)
{
Assert.ArgumentNotNull(itemID, "itemID");
Assert.ArgumentNotNull(versionUri, "versionUri");
var item = this.GetItem(itemID);
if (item == null)
{
return(-1);
}
var newNumber = -1;
var number = versionUri.Version.Number;
var language = versionUri.Language;
var versions = item.Fields.Versioned[language];
lock (this.SyncRoot)
{
if (number > 0)
{
// command to try to copy existing version
var version = versions[number];
if (version != null)
{
newNumber = versions.Max(x => x.Key) + 1;
var copiedVersion = new JsonFieldsCollection(version);
copiedVersion.Remove(FieldIDs.WorkflowState);
versions.Add(newNumber, copiedVersion);
}
}
if (newNumber != -1)
{
this.Commit();
return(newNumber);
}
if (versions.Count == 0)
{
newNumber = 1;
}
else
{
newNumber = versions.Max(x => x.Key) + 1;
}
var newVersion = new JsonFieldsCollection();
newVersion[FieldIDs.Created] = DateUtil.IsoNowWithTicks;
versions.Add(newNumber, newVersion);
this.Commit();
return(newNumber);
}
}
public bool SaveItem([NotNull] ID itemID, [NotNull] ItemChanges changes)
{
Assert.ArgumentNotNull(itemID, "itemID");
Assert.ArgumentNotNull(changes, "changes");
var item = this.GetItem(itemID);
if (item == null)
{
return(false);
}
lock (this.SyncRoot)
{
if (changes.HasPropertiesChanged)
{
var name = changes.GetPropertyValue("name") as string;
item.Name = name ?? item.Name;
var templateID = changes.GetPropertyValue("templateid") as ID;
item.TemplateID = templateID ?? item.TemplateID;
}
if (changes.HasFieldsChanged)
{
var saveAll = changes.Item.RuntimeSettings.SaveAll;
if (saveAll)
{
item.Fields.Shared.Clear();
item.Fields.Unversioned.Clear();
item.Fields.Versioned.Clear();
}
foreach (var fieldChange in changes.FieldChanges.OfType <FieldChange>())
{
var language = fieldChange.Language;
var number = fieldChange.Version.Number;
var fieldID = fieldChange.FieldID;
if (fieldID as object == null)
{
continue;
}
var definition = fieldChange.Definition;
if (definition == null)
{
continue;
}
var value = fieldChange.Value;
var shared = item.Fields.Shared;
var unversioned = item.Fields.Unversioned[language];
var versions = item.Fields.Versioned[language];
var versioned = versions[number];
if (fieldChange.RemoveField || value == null)
{
if (saveAll)
{
continue;
}
shared.Remove(fieldID);
unversioned.Remove(fieldID);
if (versioned != null)
{
versioned.Remove(fieldID);
}
}
else if (definition.IsShared)
{
shared[fieldID] = value;
}
else if (definition.IsUnversioned)
{
unversioned[fieldID] = value;
}
else if (definition.IsVersioned)
{
if (versioned == null)
{
versioned = new JsonFieldsCollection();
versions.Add(number, versioned);
}
versioned[fieldID] = value;
}
else
{
throw new NotSupportedException("This situation is not supported");
}
}
}
this.Commit();
}
return(true);
}
public bool CopyItem([NotNull] ID sourceItemID, [NotNull] ID destinationItemID, [NotNull] ID copyID, [NotNull] string copyName)
{
Assert.ArgumentNotNull(sourceItemID, "sourceItemID");
Assert.ArgumentNotNull(destinationItemID, "destinationItemID");
Assert.ArgumentNotNull(copyID, "copyID");
Assert.ArgumentNotNull(copyName, "copyName");
var sourceItem = this.GetItem(sourceItemID);
if (sourceItem == null)
{
return(false);
}
if (destinationItemID != this.RootID)
{
var destinationItem = this.GetItem(destinationItemID);
if (destinationItem == null)
{
return(false);
}
}
if (!this.CreateItem(copyID, copyName, sourceItem.TemplateID, destinationItemID))
{
return(false);
}
var copyItem = this.GetItem(copyID);
var copyFields = copyItem.Fields;
var copyShared = copyFields.Shared;
var copyUnversioned = copyFields.Unversioned;
var copyVersioned = copyFields.Versioned;
var sourceFields = sourceItem.Fields;
lock (this.SyncRoot)
{
// copy shared fields
copyShared.Clear();
foreach (var sourceField in sourceFields.Shared)
{
copyShared.Add(sourceField.Key, sourceField.Value);
}
// copy unversioned fields
foreach (var languageGroup in sourceFields.Unversioned)
{
var language = languageGroup.Key;
var fields = copyUnversioned[language];
foreach (var sourceField in languageGroup.Value)
{
fields.Add(sourceField.Key, sourceField.Value);
}
}
// copy versioned
foreach (var languageGroup in sourceFields.Versioned)
{
var language = languageGroup.Key;
var versions = copyVersioned[language];
foreach (var versionGroup in languageGroup.Value)
{
var number = versionGroup.Key;
var fields = new JsonFieldsCollection();
versions.Add(number, fields);
foreach (var sourceField in versionGroup.Value)
{
fields.Add(sourceField.Key, sourceField.Value);
}
}
}
this.Commit();
}
return(true);
}
private void ChangeFieldSharingToVersioned([NotNull] JsonItem item, [NotNull] ID fieldID)
{
Assert.ArgumentNotNull(item, nameof(item));
Assert.ArgumentNotNull(fieldID, nameof(fieldID));
// find value among shared
var fields = item.Fields;
var fieldValue = fields.Shared[fieldID];
// if found among shared
if (fieldValue != null)
{
// set same "shared" value in all versions of all languages
foreach (var languageVersions in fields.Versioned.Values)
{
if (languageVersions == null)
{
continue;
}
foreach (var versionFields in languageVersions.Values)
{
if (versionFields != null)
{
versionFields[fieldID] = fieldValue;
}
}
}
}
else // find value among unversioned
{
var allLanguages = fields.GetAllLanguages();
foreach (var language in allLanguages)
{
if (fields.Unversioned.ContainsKey(language))
{
fieldValue = fields.Unversioned[language][fieldID];
}
// if value was found then
if (fieldValue != null)
{
// set unversioned value in all versions
var versions = fields.Versioned[language];
if (versions.Count == 0)
{
var fieldCollection = new JsonFieldsCollection
{
[FieldIDs.Created] = DateUtil.IsoNowWithTicks
};
versions.Add(1, fieldCollection);
}
foreach (var versionFields in versions.Values)
{
versionFields[fieldID] = fieldValue;
}
}
}
}
// remove invalid values
fields.Shared.Remove(fieldID);
fields.Unversioned.RemoveField(fieldID);
}
protected JsonItem DoCopy(ID sourceItemID, ID destinationItemID, ID copyID, string copyName, CallContext context)
{
var source = context.DataManager.Database.GetItem(sourceItemID);
var item = new JsonItem(copyID, destinationItemID)
{
Name = copyName,
TemplateID = source.TemplateID
};
var sharedIds = source.Template.Fields.Where(x => x.IsShared).Select(x => x.ID).ToArray();
foreach (var fieldId in sharedIds)
{
if (JsonDataProvider.IgnoreFields.Keys.Contains(fieldId))
{
continue;
}
var field = source.Fields[fieldId];
var value = field.GetValue(false, false, false, false);
if (value == null)
{
continue;
}
item.Fields.Shared[fieldId] = value;
}
var unversionedIds = source.Template.Fields.Where(x => x.IsUnversioned).Select(x => x.ID).ToArray();
foreach (var language in source.Languages)
{
var version = source.Versions.GetLatestVersion(language);
var json = item.Fields.Unversioned[language];
foreach (var fieldId in unversionedIds)
{
if (JsonDataProvider.IgnoreFields.Keys.Contains(fieldId))
{
continue;
}
var field = version.Fields[fieldId];
var value = field.GetValue(false, false, false, false);
if (value == null)
{
continue;
}
json[fieldId] = value;
}
}
var versionedIds = source.Template.Fields.Where(x => !x.IsShared && !x.IsUnversioned).Select(x => x.ID).ToArray();
foreach (var language in source.Languages)
{
var sourceVersion = source.Versions.GetLatestVersion(language);
var jsonVersions = item.Fields.Versioned[language];
foreach (var version in sourceVersion.Versions.GetVersions())
{
var json = new JsonFieldsCollection();
foreach (var fieldId in versionedIds)
{
if (JsonDataProvider.IgnoreFields.Keys.Contains(fieldId))
{
continue;
}
var field = version.Fields[fieldId];
var value = field.GetValue(false, false, false, false);
if (value == null)
{
continue;
}
json[fieldId] = value;
}
jsonVersions.Add(version.Version.Number, json);
}
}
return item;
}
public bool SaveItem(ID itemID, ItemChanges changes)
{
Assert.ArgumentNotNull(itemID, nameof(itemID));
Assert.ArgumentNotNull(changes, nameof(changes));
var item = this.GetItem(itemID);
if (item == null)
{
return false;
}
if (this.ReadOnly)
{
throw new InvalidOperationException($"The file mapping the {itemID} item belongs to is in read-only mode");
}
Lock.EnterWriteLock();
try
{
if (changes.HasPropertiesChanged)
{
var name = changes.GetPropertyValue("name") as string;
item.Name = name ?? item.Name;
var templateID = changes.GetPropertyValue("templateid") as ID;
item.TemplateID = templateID ?? item.TemplateID;
}
if (changes.HasFieldsChanged)
{
var saveAll = changes.Item.RuntimeSettings.SaveAll;
if (saveAll)
{
item.Fields.Shared.Clear();
item.Fields.Unversioned.Clear();
item.Fields.Versioned.Clear();
}
foreach (var fieldChange in changes.FieldChanges.OfType<FieldChange>())
{
var language = fieldChange.Language;
var number = fieldChange.Version.Number;
var fieldID = fieldChange.FieldID;
if (fieldID == Null.Object)
{
continue;
}
var definition = fieldChange.Definition;
if (definition == null)
{
continue;
}
var value = fieldChange.Value;
var shared = item.Fields.Shared;
var unversioned = item.Fields.Unversioned[language];
var versions = item.Fields.Versioned[language];
var versioned = versions[number];
if (fieldChange.RemoveField || value == null)
{
if (saveAll)
{
continue;
}
shared.Remove(fieldID);
unversioned.Remove(fieldID);
versioned?.Remove(fieldID);
}
else if (definition.IsShared)
{
shared[fieldID] = value;
}
else if (definition.IsUnversioned)
{
unversioned[fieldID] = value;
}
else if (definition.IsVersioned)
{
if (versioned == null)
{
versioned = new JsonFieldsCollection
{
[FieldIDs.Created] = DateUtil.IsoNowWithTicks
};
versions.Add(number, versioned);
}
versioned[fieldID] = value;
}
else
{
throw new NotSupportedException("This situation is not supported");
}
}
}
}
finally
{
Lock.ExitWriteLock();
}
this.Commit();
return true;
}
public int AddVersion(ID itemID, VersionUri versionUri)
{
Assert.ArgumentNotNull(itemID, nameof(itemID));
Assert.ArgumentNotNull(versionUri, nameof(versionUri));
JsonItem item;
item = this.GetItem(itemID);
if (item == null)
{
return -1;
}
if (this.ReadOnly)
{
throw new InvalidOperationException($"The file mapping the {itemID} item is in read-only mode");
}
var newNumber = -1;
var number = versionUri.Version.Number;
var language = versionUri.Language;
Lock.EnterWriteLock();
var locked = true;
try
{
var versions = item.Fields.Versioned[language];
if (number > 0)
{
// command to try to copy existing version
var version = versions[number];
if (version != null)
{
newNumber = versions.Max(x => x.Key) + 1;
var copiedVersion = new JsonFieldsCollection(version);
copiedVersion.Remove(FieldIDs.WorkflowState);
versions.Add(newNumber, copiedVersion);
}
}
if (newNumber != -1)
{
// unlock to commit
Lock.ExitWriteLock();
locked = false;
this.Commit();
return newNumber;
}
if (versions.Count == 0)
{
newNumber = 1;
}
else
{
newNumber = versions.Max(x => x.Key) + 1;
}
var newVersion = new JsonFieldsCollection
{
[FieldIDs.Created] = DateUtil.IsoNowWithTicks
};
versions.Add(newNumber, newVersion);
}
finally
{
if (locked)
{
Lock.ExitWriteLock();
}
}
this.Commit();
return newNumber;
}
