/// <summary>
/// Adds a locale to the system. Throws exception if the given locale has already been installed or
/// if the given url mapping name has already been used. If the given locale is the first, its set
/// to be the default locale.
/// </summary>
/// <param name="cultureInfo"></param>
/// <param name="urlMappingName"></param>
/// <param name="addAccessToAllUsers"></param>
/// <param name="makeFlush"></param>
/// <param name="isDefault"></param>
internal static void AddLocale(CultureInfo cultureInfo, string urlMappingName, bool addAccessToAllUsers, bool makeFlush, bool isDefault)
{
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
Verify.That(!IsLocaleInstalled(cultureInfo), "The locale '{0}' has already been added to the system", cultureInfo);
Verify.That(!IsUrlMappingNameInUse(urlMappingName), "The url mapping name '{0}' has already been used in the system", urlMappingName);
if (!DataLocalizationFacade.ActiveLocalizationCultures.Any())
{
addAccessToAllUsers = true;
}
var systemActiveLocale = DataFacade.BuildNew <ISystemActiveLocale>();
systemActiveLocale.Id = Guid.NewGuid();
systemActiveLocale.CultureName = cultureInfo.Name;
systemActiveLocale.UrlMappingName = urlMappingName;
systemActiveLocale.IsDefault = isDefault;
DataFacade.AddNew(systemActiveLocale);
if (addAccessToAllUsers)
{
List <string> usernames =
(from u in DataFacade.GetData <IUser>()
select u.Username).ToList();
foreach (string username in usernames)
{
UserSettings.AddActiveLocaleCultureInfo(username, cultureInfo);
if (UserSettings.GetCurrentActiveLocaleCultureInfo(username) == null)
{
UserSettings.SetCurrentActiveLocaleCultureInfo(username, cultureInfo);
UserSettings.SetForeignLocaleCultureInfo(username, cultureInfo);
}
}
}
if (DataLocalizationFacade.DefaultLocalizationCulture == null)
{
DataLocalizationFacade.DefaultLocalizationCulture = cultureInfo;
}
transactionScope.Complete();
}
DynamicTypeManager.AddLocale(cultureInfo);
}
/// <summary>
/// Removes the given locale, all data is lost
/// </summary>
/// <param name="cultureInfo"></param>
/// <param name="makeFlush"></param>
public static void RemoveLocale(CultureInfo cultureInfo, bool makeFlush = true)
{
Verify.That(!IsDefaultLocale(cultureInfo), "The locale '{0}' is the default locale and can not be removed", cultureInfo);
Verify.That(!IsOnlyActiveLocaleForSomeUsers(cultureInfo), "The locale '{0}' is the only locale for some user(s) and can not be removed", cultureInfo);
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
string cultureName = cultureInfo.Name;
var systemActiveLocale = DataFacade.GetData <ISystemActiveLocale>().SingleOrDefault(f => f.CultureName == cultureName);
Verify.IsNotNull(systemActiveLocale, "The locale '{0}' has not beed added and can not be removed", cultureInfo);
List <string> usernames =
(from u in DataFacade.GetData <IUser>()
select u.Username).ToList();
foreach (string username in usernames)
{
if (cultureInfo.Equals(UserSettings.GetCurrentActiveLocaleCultureInfo(username)))
{
CultureInfo fallbackCultureInfo = UserSettings.GetActiveLocaleCultureInfos(username).First(f => !f.Equals(cultureInfo));
UserSettings.SetCurrentActiveLocaleCultureInfo(username, fallbackCultureInfo);
}
if (cultureInfo.Equals(UserSettings.GetForeignLocaleCultureInfo(username)))
{
UserSettings.SetForeignLocaleCultureInfo(username, null);
}
UserSettings.RemoveActiveLocaleCultureInfo(username, cultureInfo);
}
DataFacade.Delete <ISystemActiveLocale>(systemActiveLocale);
transactionScope.Complete();
}
DynamicTypeManager.RemoveLocale(cultureInfo);
if (makeFlush)
{
C1Console.Events.GlobalEventSystemFacade.FlushTheSystem(false);
}
}
protected override void Execute()
{
Type type = TypeManager.GetType(DataType);
using (new DataScope(DataScopeIdentifier.Administrated, CultureInfo.CreateSpecificCulture(LocaleName)))
{
DataEntityToken dataEntityToken;
using (var transaction = TransactionsFacade.CreateNewScope())
{
var publishSchedule = PublishScheduleHelper.GetPublishSchedule(type, DataId, LocaleName);
DataFacade.Delete(publishSchedule);
var data = (IPublishControlled)DataFacade.TryGetDataByUniqueKey(type, DataId);
if (data == null)
{
Log.LogWarning(LogTitle, $"Failed to find data of type '{type}' by id '{DataId}'.");
transaction.Complete();
return;
}
dataEntityToken = data.GetDataEntityToken();
var transitions = ProcessControllerFacade.GetValidTransitions(data).Keys;
if (transitions.Contains(GenericPublishProcessController.Published))
{
data.PublicationStatus = GenericPublishProcessController.Published;
DataFacade.Update(data);
Log.LogVerbose(LogTitle, $"Scheduled publishing of data with label '{data.GetLabel()}' is complete");
}
else
{
Log.LogWarning(LogTitle, $"Scheduled publishing of data with label '{data.GetLabel()}' could not be done because the data is not in a publisheble state");
}
transaction.Complete();
}
EntityTokenCacheFacade.ClearCache(dataEntityToken);
PublishControlledHelper.ReloadDataElementInConsole(dataEntityToken);
}
}
public void DeleteType(string providerName, DataTypeDescriptor dataTypeDescriptor, bool makeAFlush)
{
Verify.ArgumentNotNullOrEmpty(providerName, "providerName");
Verify.ArgumentNotNull(dataTypeDescriptor, "dataTypeDescriptor");
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
DynamicTypeManager.DropStore(providerName, dataTypeDescriptor, makeAFlush);
transactionScope.Complete();
}
if (makeAFlush && dataTypeDescriptor.IsCodeGenerated)
{
CodeGenerationManager.GenerateCompositeGeneratedAssembly(true);
}
}
private static void AddFiles(string providerName, IEnumerable <IMediaFile> files, bool overwrite)
{
foreach (IMediaFile file in files)
{
using (var transactionScope = TransactionsFacade.CreateNewScope(ExtrationTimeout))
{
EnsureFolderExistence(file.FolderPath);
if (overwrite)
{
if (Exists(file))
{
IMediaFile currentFile = DataFacade.GetData <IMediaFile>()
.First(x => x.FolderPath == file.FolderPath && x.FileName == file.FileName);
using (Stream readStream = file.GetReadStream())
{
using (Stream writeStream = currentFile.GetNewWriteStream())
{
readStream.CopyTo(writeStream);
}
}
DataFacade.Update(currentFile);
}
else
{
DataFacade.AddNew <IMediaFile>(file, providerName);
}
}
else
{
int counter = 0;
string extension = Path.GetExtension(file.FileName);
string name = file.FileName.GetNameWithoutExtension();
while (Exists(file))
{
counter++;
file.FileName = name + counter.ToString() + extension;
}
DataFacade.AddNew <IMediaFile>(file, providerName);
}
transactionScope.Complete();
}
}
}
/// <exclude />
public void AlterStore(UpdateDataTypeDescriptor updateDataTypeDescriptor, bool forceCompile)
{
DataTypeChangeDescriptor dataTypeChangeDescriptor = updateDataTypeDescriptor.CreateDataTypeChangeDescriptor();
dataTypeChangeDescriptor.AlteredType.Validate();
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
DataMetaDataFacade.PersistMetaData(dataTypeChangeDescriptor.AlteredType);
if (dataTypeChangeDescriptor.AlteredTypeHasChanges)
{
DataProviderPluginFacade.AlterStore(updateDataTypeDescriptor, forceCompile);
}
transactionScope.Complete();
}
}
/// <exclude />
public void RemoveLocale(string providerName, CultureInfo cultureInfo)
{
if (string.IsNullOrEmpty(providerName))
{
throw new ArgumentNullException("providerName");
}
if (cultureInfo == null)
{
throw new ArgumentNullException("cultureInfo");
}
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
DataProviderPluginFacade.RemoveLocale(providerName, cultureInfo);
transactionScope.Complete();
}
CodeGenerationManager.GenerateCompositeGeneratedAssembly(true);
}
/// <exclude />
public void DropStore(string providerName, DataTypeDescriptor typeDescriptor, bool makeAFlush)
{
Verify.ArgumentNotNullOrEmpty(providerName, "providerName");
Verify.ArgumentNotNull(typeDescriptor, "typeDescriptor");
typeDescriptor.Validate();
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
DataProviderPluginFacade.DropStore(providerName, typeDescriptor);
DataMetaDataFacade.DeleteMetaData(typeDescriptor.DataTypeId);
transactionScope.Complete();
}
if (makeAFlush)
{
GlobalEventSystemFacade.FlushTheSystem();
}
}
/// <summary>
/// Delete the specific version of the page in the current localization scope.
/// </summary>
/// <param name="pageId"></param>
/// <param name="versionId"></param>
/// <param name="locale"></param>
public static void DeletePage(Guid pageId, Guid versionId, CultureInfo locale)
{
Verify.ArgumentNotNull(locale, nameof(locale));
using (var conn = new DataConnection(PublicationScope.Unpublished, locale))
{
var pages = conn.Get <IPage>().Where(p => p.Id == pageId).ToList();
if (pages.Count == 1 && pages[0].VersionId == versionId)
{
DeletePage(pages[0]);
return;
}
}
var publicationScopes = new[] { PublicationScope.Published, PublicationScope.Unpublished };
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
foreach (var publicationScope in publicationScopes)
{
using (var conn = new DataConnection(publicationScope, locale))
{
var pageToDelete = conn.Get <IPage>()
.SingleOrDefault(p => p.Id == pageId && p.VersionId == versionId);
var placeholders = conn.Get <IPagePlaceholderContent>()
.Where(p => p.PageId == pageId && p.VersionId == versionId).ToList();
if (placeholders.Any())
{
DataFacade.Delete(placeholders, false, false);
}
if (pageToDelete != null)
{
DataFacade.Delete(pageToDelete);
}
}
}
transactionScope.Complete();
}
}
/// <summary>
/// Removes a metadata definition and possibly deletes all data items that are defined by it
/// </summary>
/// <param name="definingItemId"></param>
/// <param name="definitionName"></param>
/// <param name="deleteExistingMetaData"></param>
public static void RemoveDefinition(Guid definingItemId, string definitionName, bool deleteExistingMetaData = true)
{
IPageMetaDataDefinition pageMetaDataDefinition = GetMetaDataDefinition(definingItemId, definitionName);
IEnumerable <IPageMetaDataDefinition> otherPageMetaDataDefinitions =
DataFacade.GetData <IPageMetaDataDefinition>().
Where(f => f.Name == definitionName && f.Id != pageMetaDataDefinition.Id).
Evaluate();
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(pageMetaDataDefinition.MetaDataTypeId);
Type metaDataType = TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName);
if (deleteExistingMetaData)
{
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
foreach (CultureInfo localeCultureInfo in DataLocalizationFacade.ActiveLocalizationCultures)
{
using (new DataScope(localeCultureInfo))
{
using (new DataScope(DataScopeIdentifier.Public))
{
RemoveDefinitionDeleteData(definitionName, metaDataType, otherPageMetaDataDefinitions);
}
using (new DataScope(DataScopeIdentifier.Administrated))
{
RemoveDefinitionDeleteData(definitionName, metaDataType, otherPageMetaDataDefinitions);
}
}
}
DataFacade.Delete(pageMetaDataDefinition);
transactionScope.Complete();
}
}
else
{
DataFacade.Delete(pageMetaDataDefinition);
}
}
public ImportResult Import()
{
_keysToAdd.Clear();
_valuesToAdd.Clear();
_valuesToUpdate.Clear();
var result = new ImportResult
{
Languages = _model.Languages.Keys.ToArray(),
ResourceSets = _model.Languages.Values.SelectMany(l => l.ResourceSets.Select(r => r.Name)).Distinct().ToArray()
};
using (var transaction = TransactionsFacade.CreateNewScope())
{
using (var data = new DataConnection())
{
var existingKeys = data.Get<IResourceKey>().ToDictionary(k => k.Key);
var existingValues = data.Get<IResourceValue>().ToDictionary(v => Tuple.Create(v.KeyId, v.Culture));
foreach (var language in _model.Languages.Values)
{
foreach (var resourceSet in language.ResourceSets)
{
EvaluateAddOrUpdates(language.Culture, resourceSet, data, result, existingKeys, existingValues);
}
}
result.KeysAdded = _keysToAdd.Count;
result.ValuesAdded = _valuesToAdd.Count;
result.ValuesUpdated = _valuesToUpdate.Count;
data.Add<IResourceKey>(_keysToAdd);
data.Add<IResourceValue>(_valuesToAdd);
data.Update<IResourceValue>(_valuesToUpdate);
}
transaction.Complete();
}
return result;
}
private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e)
{
Type selectedMetaDataType = this.GetBinding <Type>(SelectedTypeBindingName);
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(selectedMetaDataType.GetImmutableTypeId());
PageMetaDataDescription dataAssociationVisabilityRule = this.GetBinding <PageMetaDataDescription>(DataAssociationVisabilityDescriptionBindingName);
Guid metaDataContainerId = this.GetBinding <Guid>(SelectedContainerBindingName);
string metaDataDefinitionName = this.GetBinding <string>(FieldGroupNameBindingName);
string metaDataDefinitionLabel = this.GetBinding <string>(FieldGroupLabelBindingName);
IData newDataTemplate = null;
if (IsAnyPagesAffected())
{
DataTypeDescriptorFormsHelper helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor);
GeneratedTypesHelper generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor);
helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames);
newDataTemplate = DataFacade.BuildNew(selectedMetaDataType);
helper.BindingsToObject(this.Bindings, newDataTemplate);
}
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
IPage page = GetCurrentPage();
page.AddMetaDataDefinition(metaDataDefinitionName, metaDataDefinitionLabel, selectedMetaDataType.GetImmutableTypeId(), metaDataContainerId, dataAssociationVisabilityRule.StartLevel, dataAssociationVisabilityRule.Levels);
if (newDataTemplate != null)
{
page.AddNewMetaDataToExistingPages(metaDataDefinitionName, newDataTemplate);
}
transactionScope.Complete();
}
ParentTreeRefresher parentTreeRefresher = this.CreateParentTreeRefresher();
parentTreeRefresher.PostRefreshMesseges(this.EntityToken);
}
public static void DeleteNamespace(string ns, string resourceSet = null)
{
using (var transaction = TransactionsFacade.CreateNewScope())
{
using (var data = new DataConnection())
{
var keys = data.Get <IResourceKey>().Where(r => r.ResourceSet == null && r.Key.StartsWith(ns)).ToList();
foreach (var key in keys)
{
var values = data.Get <IResourceValue>().Where(v => v.KeyId == key.Id);
data.Delete <IResourceValue>(values);
}
data.Delete <IResourceKey>(keys);
}
transaction.Complete();
}
}
/// <summary>
/// Deletes the versions of the given page in its current localization scope.
/// </summary>
public static void DeletePage(IPage page)
{
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
using (var conn = new DataConnection())
{
conn.DisableServices();
var cultures = DataLocalizationFacade.ActiveLocalizationCultures.ToList();
cultures.Remove(page.DataSourceId.LocaleScope);
List <IPage> pagesToDelete = page.GetSubChildren().ToList();
foreach (IPage childPage in pagesToDelete)
{
if (!ExistInOtherLocale(cultures, childPage))
{
RemoveAllFolderAndMetaDataDefinitions(childPage);
}
childPage.DeletePageStructure(false);
ProcessControllerFacade.FullDelete(childPage);
}
if (!ExistInOtherLocale(cultures, page))
{
RemoveAllFolderAndMetaDataDefinitions(page);
}
page.DeletePageStructure();
Guid pageId = page.Id;
var pageVersions = DataFacade.GetData <IPage>(p => p.Id == pageId).ToList();
ProcessControllerFacade.FullDelete(pageVersions);
}
transactionScope.Complete();
}
}
/// <summary>
/// Update an existing metadata definition with possible new label and container id
/// </summary>
/// <param name="definingItemId"></param>
/// <param name="definitionName"></param>
/// <param name="newLabel"></param>
/// <param name="newMetaDataContainerId"></param>
public static void UpdateDefinition(Guid definingItemId, string definitionName, string newLabel, Guid newMetaDataContainerId)
{
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
IPageMetaDataDefinition pageMetaDataDefinition = GetMetaDataDefinition(definingItemId, definitionName);
pageMetaDataDefinition.Label = newLabel;
pageMetaDataDefinition.MetaDataContainerId = newMetaDataContainerId;
// Update all data
// PageDataAssociationVisabilityWrapper wrapper = new PageDataAssociationVisabilityWrapper(pageAssociationVisability);
// Make join expression tree with compositionType and IPage on compositionType ref to IPage
// and test those pages against the PageDataAssociationVisabilityWrapper (IsAllowed) and
// Change compositionType composition description name to new name
DataFacade.Update(pageMetaDataDefinition);
transactionScope.Complete();
}
}
/// <exclude />
public static void Save(Guid ownerId, IEnumerable <ManagedParameterDefinition> parameterDefinitions)
{
var dataParams = new List <IParameter>();
foreach (ManagedParameterDefinition paramDef in parameterDefinitions)
{
ValidateParameter(paramDef);
dataParams.Add(BuildIParameter(ownerId, paramDef));
}
using (TransactionScope transationScope = TransactionsFacade.CreateNewScope())
{
DataFacade.Delete <IParameter>(f => f.OwnerId == ownerId);
foreach (IParameter param in dataParams)
{
DataFacade.AddNew <IParameter>(param);
}
transationScope.Complete();
}
}
/// <summary>
/// This method will delete the data, and its if the exists its versions and publications
/// </summary>
/// <param name="data"></param>
public static void FullDelete(IData data)
{
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
using (new DataScope(DataScopeIdentifier.Administrated))
{
if (data is IPublishControlled)
{
using (new DataScope(DataScopeIdentifier.Public))
{
IEnumerable <IData> datasDelete = DataFacade.GetDataFromOtherScope(data, DataScopeIdentifier.Public).Evaluate();
DataFacade.Delete(datasDelete, CascadeDeleteType.Disable);
}
}
DataFacade.Delete(data);
}
transactionScope.Complete();
}
}
public void GenerateResources(IDictionary resourceList)
{
Verify.ArgumentNotNull(resourceList, nameof(resourceList));
using (var transaction = TransactionsFacade.CreateNewScope())
{
foreach (DictionaryEntry entry in resourceList)
{
var key = entry.Key.ToString();
if (entry.Value == null)
{
DeleteResource(key);
}
else
{
UpdateOrAddResource(key, entry.Value);
}
}
transaction.Complete();
}
}
public void SetUserPermissionDefinition(UserPermissionDefinition userPermissionDefinition)
{
string username = userPermissionDefinition.Username;
string serializedEntityToken = userPermissionDefinition.SerializedEntityToken;
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
IEnumerable <IUserPermissionDefinition> existingUserPermissionDefinitions =
DataFacade.GetData <IUserPermissionDefinition>()
.Where(d => d.Username == username)
.ToList()
.Where(d => userPermissionDefinition.EntityToken.EqualsWithVersionIgnore(DeserializeSilent(d.SerializedEntityToken)))
.ToList();
DataFacade.Delete(existingUserPermissionDefinitions);
IUserPermissionDefinition definition = DataFacade.BuildNew <IUserPermissionDefinition>();
definition.Id = Guid.NewGuid();
definition.Username = userPermissionDefinition.Username;
definition.SerializedEntityToken = serializedEntityToken;
DataFacade.AddNew(definition);
foreach (PermissionType permissionType in userPermissionDefinition.PermissionTypes)
{
IUserPermissionDefinitionPermissionType permission = DataFacade.BuildNew <IUserPermissionDefinitionPermissionType>();
permission.Id = Guid.NewGuid();
permission.PermissionTypeName = permissionType.ToString();
permission.UserPermissionDefinitionId = definition.Id;
DataFacade.AddNew(permission);
}
transactionScope.Complete();
}
}
/// <exclude />
public void CreateStores(string providerName, IReadOnlyCollection <DataTypeDescriptor> typeDescriptors, bool doFlush)
{
Verify.ArgumentNotNullOrEmpty(providerName, "providerName");
Verify.ArgumentNotNull(typeDescriptors, "typeDescriptors");
typeDescriptors.ForEach(d => d.Validate());
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
foreach (var typeDescriptor in typeDescriptors)
{
DataMetaDataFacade.PersistMetaData(typeDescriptor);
}
DataProviderPluginFacade.CreateStores(providerName, typeDescriptors);
transactionScope.Complete();
}
if (doFlush)
{
GlobalEventSystemFacade.FlushTheSystem();
}
}
protected override void Execute()
{
using (new DataScope(DataScopeIdentifier.Administrated, CultureInfo.CreateSpecificCulture(LocaleName)))
{
IPage page;
using (var transaction = TransactionsFacade.CreateNewScope())
{
var pagePublishSchedule = PublishScheduleHelper.GetPublishSchedule(typeof(IPage), PageId.ToString(), LocaleName);
DataFacade.Delete(pagePublishSchedule);
page = DataFacade.GetData <IPage>(p => p.Id == PageId).FirstOrDefault();
Verify.IsNotNull(page, "The page with the id {0} does not exist", PageId);
var transitions = ProcessControllerFacade.GetValidTransitions(page).Keys;
if (transitions.Contains(GenericPublishProcessController.Published))
{
page.PublicationStatus = GenericPublishProcessController.Published;
DataFacade.Update(page);
Log.LogVerbose(LogTitle, "Scheduled publishing of page with title '{0}' is complete", page.Title);
}
else
{
Log.LogWarning(LogTitle, "Scheduled publishing of page with title '{0}' could not be done because the page is not in a publisheble state", page.Title);
}
transaction.Complete();
}
PublishControlledHelper.ReloadPageElementInConsole(page);
}
}
private void finalizeCodeActivity_ExecuteCode(object sender, EventArgs e)
{
DeleteTreeRefresher deleteTreeRefresher = this.CreateDeleteTreeRefresher(this.EntityToken);
DataEntityToken dataEntityToken = (DataEntityToken)this.EntityToken;
ISqlConnection connection = (ISqlConnection)dataEntityToken.Data;
var queries = from item in DataFacade.GetData <ISqlFunctionInfo>()
where item.ConnectionId == connection.Id
select item;
using (TransactionScope transationScope = TransactionsFacade.CreateNewScope())
{
DataFacade.Delete(connection);
foreach (ISqlFunctionInfo query in queries)
{
DataFacade.Delete(query);
}
transationScope.Complete();
}
deleteTreeRefresher.PostRefreshMesseges();
}
/// <summary>
/// Removes a data folder type for the given page
/// </summary>
/// <param name="page"></param>
/// <param name="dataFolderType"></param>
/// <param name="deleteExistingFolderData"></param>
public static void RemoveFolderDefinition(this IPage page, Type dataFolderType, bool deleteExistingFolderData = true)
{
Guid dataFolderTypeId = dataFolderType.GetImmutableTypeId();
if (!deleteExistingFolderData)
{
RemoveFolderDefinitionInternal(page.Id, dataFolderTypeId);
return;
}
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
DataFacade.ForEachDataScope(dataFolderType, () =>
{
IEnumerable <IData> dataset = page.GetFolderData(dataFolderType);
DataFacade.Delete(dataset);
});
RemoveFolderDefinitionInternal(page.Id, dataFolderTypeId);
transactionScope.Complete();
}
}
public bool OnElementDraggedAndDropped(EntityToken draggedEntityToken, EntityToken newParentEntityToken, int dropIndex, DragAndDropType dragAndDropType, FlowControllerServicesContainer flowControllerServicesContainer)
{
IPage draggedPage = (IPage)((DataEntityToken)draggedEntityToken).Data;
Verify.IsNotNull(draggedPage, "Dragged page does not exist");
Guid newParentPageId;
if (newParentEntityToken is PageElementProviderEntityToken)
{
newParentPageId = Guid.Empty;
}
else if (newParentEntityToken is DataEntityToken)
{
IPage newParentPage = (IPage)((DataEntityToken)newParentEntityToken).Data;
newParentPageId = newParentPage.Id;
}
else
{
throw new NotImplementedException();
}
IPage oldParent = null;
Guid oldParentId = draggedPage.GetParentId();
if (oldParentId != Guid.Empty)
{
oldParent = DataFacade.GetData <IPage>(f => f.Id == oldParentId).Single();
}
if (dragAndDropType == DragAndDropType.Move)
{
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
string urlTitle = draggedPage.UrlTitle;
int counter = 1;
while (true)
{
bool urlTitleClash =
(from p in PageServices.GetChildren(newParentPageId).AsEnumerable()
where p.UrlTitle == urlTitle && p.Id != draggedPage.Id
select p).Any();
if (!urlTitleClash)
{
break;
}
urlTitle = string.Format("{0}{1}", draggedPage.UrlTitle, counter++);
}
draggedPage.UrlTitle = urlTitle;
// Real drop index takes into account pages from other locales
int realDropIndex = GetRealDropIndex(draggedPage, newParentPageId, dropIndex);
draggedPage.MoveTo(newParentPageId, realDropIndex, false);
DataFacade.Update(draggedPage);
EntityTokenCacheFacade.ClearCache(draggedPage.GetDataEntityToken());
transactionScope.Complete();
}
}
else
{
throw new NotImplementedException();
}
if (oldParent != null)
{
var oldParentParentTreeRefresher = new ParentTreeRefresher(flowControllerServicesContainer);
oldParentParentTreeRefresher.PostRefreshMesseges(oldParent.GetDataEntityToken());
}
else
{
var oldParentspecificTreeRefresher = new SpecificTreeRefresher(flowControllerServicesContainer);
oldParentspecificTreeRefresher.PostRefreshMesseges(new PageElementProviderEntityToken(_context.ProviderName));
}
var newParentParentTreeRefresher = new ParentTreeRefresher(flowControllerServicesContainer);
newParentParentTreeRefresher.PostRefreshMesseges(newParentEntityToken);
return(true);
}
private void saveCodeActivity_ExecuteCode(object sender, EventArgs e)
{
IUser user = this.GetBinding <IUser>(BindingNames.User);
var userFormLogin = GetBinding <IUserFormLogin>(BindingNames.UserFormLogin);
var userFormLoginFromDatabase = user.GetUserFormLogin();
bool userValidated = true;
ValidationResults validationResults = ValidationFacade.Validate(user);
foreach (ValidationResult result in validationResults)
{
this.ShowFieldMessage($"{BindingNames.User}.{result.Key}", result.Message);
userValidated = false;
}
List <CultureInfo> newActiveLocales = ActiveLocalesFormsHelper.GetSelectedLocalesTypes(this.Bindings).ToList();
List <CultureInfo> currentActiveLocales = null;
CultureInfo selectedActiveLocal = null;
if (newActiveLocales.Count > 0)
{
currentActiveLocales = UserSettings.GetActiveLocaleCultureInfos(user.Username).ToList();
string selectedActiveLocaleName = (user.Username != UserSettings.Username ?
this.GetBinding <string>("ActiveLocaleName") :
UserSettings.ActiveLocaleCultureInfo.ToString());
if (selectedActiveLocaleName != null)
{
selectedActiveLocal = CultureInfo.CreateSpecificCulture(selectedActiveLocaleName);
if (!newActiveLocales.Contains(selectedActiveLocal))
{
if (user.Username != UserSettings.Username)
{
this.ShowFieldMessage("ActiveLocaleName", GetText("Website.Forms.Administrative.EditUserStep1.ActiveLocaleNotChecked"));
}
else
{
this.ShowFieldMessage("ActiveLocalesFormsHelper_Selected", GetText("Website.Forms.Administrative.EditUserStep1.NoActiveLocaleSelected"));
}
userValidated = false;
}
}
}
else
{
this.ShowFieldMessage("ActiveLocalesFormsHelper_Selected", GetText("Website.Forms.Administrative.EditUserStep1.NoActiveLocaleSelected"));
userValidated = false;
}
string systemPerspectiveEntityToken = EntityTokenSerializer.Serialize(AttachingPoint.SystemPerspective.EntityToken);
List <Guid> newUserGroupIds = UserGroupsFormsHelper.GetSelectedUserGroupIds(this.Bindings);
List <string> newSerializedEnitityTokens = ActivePerspectiveFormsHelper.GetSelectedSerializedEntityTokens(this.Bindings).ToList();
if (string.Compare(user.Username, UserSettings.Username, StringComparison.InvariantCultureIgnoreCase) == 0)
{
// Current user shouldn't be able to lock itself
if (userFormLogin.IsLocked)
{
this.ShowMessage(DialogType.Message,
Texts.EditUserWorkflow_EditErrorTitle,
Texts.EditUserWorkflow_LockingOwnUserAccount);
userValidated = false;
}
// Current user shouldn't be able to remove its own access to "System" perspective
var groupsWithAccessToSystemPerspective = new HashSet <Guid>(GetGroupsThatHasAccessToPerspective(systemPerspectiveEntityToken));
if (!newSerializedEnitityTokens.Contains(systemPerspectiveEntityToken) &&
!newUserGroupIds.Any(groupsWithAccessToSystemPerspective.Contains))
{
this.ShowMessage(DialogType.Message,
Texts.EditUserWorkflow_EditErrorTitle,
Texts.EditUserWorkflow_EditOwnAccessToSystemPerspective);
userValidated = false;
}
}
string newPassword = this.GetBinding <string>(BindingNames.NewPassword);
if (newPassword == NotPassword || UserFormLoginManager.ValidatePassword(userFormLoginFromDatabase, newPassword))
{
newPassword = null;
}
else
{
IList <string> validationMessages;
if (!PasswordPolicyFacade.ValidatePassword(user, newPassword, out validationMessages))
{
foreach (var message in validationMessages)
{
this.ShowFieldMessage(BindingNames.NewPassword, message);
}
userValidated = false;
}
}
if (!userValidated)
{
return;
}
if (!userFormLogin.IsLocked)
{
userFormLogin.LockoutReason = (int)UserLockoutReason.Undefined;
}
else
{
bool wasLockedBefore = userFormLoginFromDatabase.IsLocked;
if (!wasLockedBefore)
{
userFormLoginFromDatabase.LockoutReason = (int)UserLockoutReason.LockedByAdministrator;
}
}
UpdateTreeRefresher updateTreeRefresher = this.CreateUpdateTreeRefresher(this.EntityToken);
bool reloadUsersConsoles = false;
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
DataFacade.Update(user);
userFormLoginFromDatabase.Folder = userFormLogin.Folder;
userFormLoginFromDatabase.IsLocked = userFormLogin.IsLocked;
DataFacade.Update(userFormLoginFromDatabase);
if (newPassword != null)
{
UserFormLoginManager.SetPassword(userFormLoginFromDatabase, newPassword);
}
string cultureName = this.GetBinding <string>("CultureName");
string c1ConsoleUiLanguageName = this.GetBinding <string>("C1ConsoleUiLanguageName");
UserSettings.SetUserCultureInfo(user.Username, CultureInfo.CreateSpecificCulture(cultureName));
UserSettings.SetUserC1ConsoleUiLanguage(user.Username, CultureInfo.CreateSpecificCulture(c1ConsoleUiLanguageName));
List <string> existingSerializedEntityTokens = UserPerspectiveFacade.GetSerializedEntityTokens(user.Username).ToList();
int intersectCount = existingSerializedEntityTokens.Intersect(newSerializedEnitityTokens).Count();
if ((intersectCount != newSerializedEnitityTokens.Count) ||
(intersectCount != existingSerializedEntityTokens.Count))
{
UserPerspectiveFacade.SetSerializedEntityTokens(user.Username, newSerializedEnitityTokens);
if (UserSettings.Username == user.Username)
{
reloadUsersConsoles = true;
}
}
if (DataLocalizationFacade.ActiveLocalizationCultures.Any())
{
foreach (CultureInfo cultureInfo in newActiveLocales)
{
if (!currentActiveLocales.Contains(cultureInfo))
{
UserSettings.AddActiveLocaleCultureInfo(user.Username, cultureInfo);
}
}
foreach (CultureInfo cultureInfo in currentActiveLocales)
{
if (!newActiveLocales.Contains(cultureInfo))
{
UserSettings.RemoveActiveLocaleCultureInfo(user.Username, cultureInfo);
}
}
if (selectedActiveLocal != null)
{
if (!UserSettings.GetCurrentActiveLocaleCultureInfo(user.Username).Equals(selectedActiveLocal))
{
reloadUsersConsoles = true;
}
UserSettings.SetCurrentActiveLocaleCultureInfo(user.Username, selectedActiveLocal);
}
else if (UserSettings.GetActiveLocaleCultureInfos(user.Username).Any())
{
UserSettings.SetCurrentActiveLocaleCultureInfo(user.Username, UserSettings.GetActiveLocaleCultureInfos(user.Username).First());
}
}
List <IUserUserGroupRelation> oldRelations = DataFacade.GetData <IUserUserGroupRelation>(f => f.UserId == user.Id).ToList();
IEnumerable <IUserUserGroupRelation> deleteRelations =
from r in oldRelations
where !newUserGroupIds.Contains(r.UserGroupId)
select r;
DataFacade.Delete(deleteRelations);
foreach (Guid newUserGroupId in newUserGroupIds)
{
Guid groupId = newUserGroupId;
if (oldRelations.Any(f => f.UserGroupId == groupId))
{
continue;
}
var userUserGroupRelation = DataFacade.BuildNew <IUserUserGroupRelation>();
userUserGroupRelation.UserId = user.Id;
userUserGroupRelation.UserGroupId = newUserGroupId;
DataFacade.AddNew(userUserGroupRelation);
}
LoggingService.LogEntry("UserManagement",
$"C1 Console user '{user.Username}' updated by '{UserValidationFacade.GetUsername()}'.",
LoggingService.Category.Audit,
TraceEventType.Information);
transactionScope.Complete();
}
if (reloadUsersConsoles)
{
foreach (string consoleId in GetConsoleIdsOpenedByCurrentUser())
{
ConsoleMessageQueueFacade.Enqueue(new RebootConsoleMessageQueueItem(), consoleId);
}
}
SetSaveStatus(true);
updateTreeRefresher.PostRefreshMesseges(user.GetDataEntityToken());
}
private void saveCodeActivity_Save_ExecuteCode(object sender, EventArgs e)
{
IInlineFunction function = this.GetBinding <IInlineFunction>("Function");
string code = this.GetBinding <string>("FunctionCode");
List <string> selectedAssemblies = this.GetBinding <List <string> >("SelectedAssemblies");
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
IEnumerable <IInlineFunctionAssemblyReference> assemblyReferences =
DataFacade.GetData <IInlineFunctionAssemblyReference>(f => f.Function == function.Id).Evaluate();
foreach (string selectedAssembly in selectedAssemblies)
{
string name = System.IO.Path.GetFileName(selectedAssembly).ToLowerInvariant();
string location = InlineFunctionHelper.GetAssemblyLocation(selectedAssembly).ToLowerInvariant();
if (assemblyReferences
.Any(f => (string.Compare(f.Name, name, StringComparison.InvariantCultureIgnoreCase) == 0) &&
(string.Compare(f.Location, location, StringComparison.InvariantCultureIgnoreCase) == 0)) == false)
{
IInlineFunctionAssemblyReference assemblyReference = DataFacade.BuildNew <IInlineFunctionAssemblyReference>();
assemblyReference.Id = Guid.NewGuid();
assemblyReference.Function = function.Id;
assemblyReference.Name = name;
assemblyReference.Location = location;
DataFacade.AddNew(assemblyReference);
}
}
foreach (IInlineFunctionAssemblyReference assemblyReference in assemblyReferences)
{
string fullPath = InlineFunctionHelper.GetAssemblyFullPath(assemblyReference.Name, assemblyReference.Location);
if (selectedAssemblies.Any(f => string.Compare(f, fullPath, StringComparison.InvariantCultureIgnoreCase) == 0) == false)
{
DataFacade.Delete(assemblyReference);
}
}
IInlineFunction oldFunction = DataFacade.GetData <IInlineFunction>(f => f.Id == function.Id).Single();
if ((oldFunction.Name != function.Name) || (oldFunction.Namespace != function.Namespace))
{
InlineFunctionHelper.FunctionRenamed(function, oldFunction);
}
List <ManagedParameterDefinition> parameters = this.GetBinding <List <ManagedParameterDefinition> >("Parameters");
ManagedParameterManager.Save(function.Id, parameters);
DataFacade.Update(function);
function.SetFunctionCode(code);
transactionScope.Complete();
}
SetSaveStatus(true);
UpdateTreeRefresher updateTreeRefresher = this.CreateUpdateTreeRefresher(this.EntityToken);
updateTreeRefresher.PostRefreshMesseges(function.GetDataEntityToken());
}
private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e)
{
IInlineFunction function = this.GetBinding <IInlineFunction>("NewFunction");
function.UpdateCodePath();
string selectedTemplate = this.GetBinding <string>("SelectedTemplate");
string codeTemplate;
switch (selectedTemplate)
{
case "clean":
codeTemplate = _cleanTemplate;
break;
case "parameter":
codeTemplate = _parameterTemplate;
List <ManagedParameterDefinition> parameters = new List <ManagedParameterDefinition>();
ManagedParameterDefinition parameter1 = new ManagedParameterDefinition();
parameter1.Id = Guid.NewGuid();
parameter1.Name = "myIntValue";
parameter1.Label = "myIntValue";
parameter1.HelpText = "myIntValue";
parameter1.Position = 0;
parameter1.Type = typeof(int);
parameter1.TestValueFunctionMarkup = "<f:function xmlns:f=\"http://www.composite.net/ns/function/1.0\" name=\"Composite.Constant.Integer\"><f:param name=\"Constant\" value=\"0\" /></f:function>";
parameter1.WidgetFunctionMarkup = "<f:widgetfunction xmlns:f=\"http://www.composite.net/ns/function/1.0\" name=\"Composite.Widgets.Integer.TextBox\" label=\"myIntValue\" bindingsourcename=\"\"><f:helpdefinition xmlns:f=\"http://www.composite.net/ns/function/1.0\" helptext=\"myIntValue\" /></f:widgetfunction>";
parameters.Add(parameter1);
ManagedParameterDefinition parameter2 = new ManagedParameterDefinition();
parameter2.Id = Guid.NewGuid();
parameter2.Name = "myStringValue";
parameter2.Label = "myStringValue";
parameter2.HelpText = "myStringValue";
parameter2.Position = 1;
parameter2.Type = typeof(string);
parameter2.TestValueFunctionMarkup = "<f:function xmlns:f=\"http://www.composite.net/ns/function/1.0\" name=\"Composite.Constant.String\"><f:param name=\"Constant\" value=\"Hello world!\" /></f:function>";
parameter2.WidgetFunctionMarkup = "<f:widgetfunction xmlns:f=\"http://www.composite.net/ns/function/1.0\" name=\"Composite.Widgets.String.TextBox\" label=\"myStringValue\" bindingsourcename=\"\"><f:helpdefinition xmlns:f=\"http://www.composite.net/ns/function/1.0\" helptext=\"myStringValue\" /></f:widgetfunction>";
parameters.Add(parameter2);
ManagedParameterManager.Save(function.Id, parameters);
break;
case "dataconnection":
codeTemplate = _dataConnectionTemplate;
break;
default:
throw new NotImplementedException();
}
string code = string.Format(codeTemplate, function.Namespace, InlineFunctionHelper.MethodClassContainerName, function.Name);
code = code.Replace('и', '\t');
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
foreach (string assemblyPath in InlineFunctionHelper.DefaultAssemblies)
{
IInlineFunctionAssemblyReference reference = DataFacade.BuildNew <IInlineFunctionAssemblyReference>();
reference.Id = Guid.NewGuid();
reference.Function = function.Id;
reference.Name = System.IO.Path.GetFileName(assemblyPath);
reference.Location = InlineFunctionHelper.GetAssemblyLocation(assemblyPath);
DataFacade.AddNew(reference);
}
function.SetFunctinoCode(code);
function = DataFacade.AddNew(function);
UserSettings.LastSpecifiedNamespace = function.Namespace;
transactionScope.Complete();
}
this.CloseCurrentView();
this.CreateAddNewTreeRefresher(this.EntityToken).PostRefreshMesseges(function.GetDataEntityToken());
this.ExecuteWorklow(function.GetDataEntityToken(), WorkflowFacade.GetWorkflowType("Composite.Workflows.Plugins.Elements.ElementProviders.MethodBasedFunctionProviderElementProvider.EditInlineFunctionWorkflow"));
}
public FlowToken Execute(EntityToken entityToken, ActionToken actionToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
DataEntityToken token = (DataEntityToken)entityToken;
IPublishControlled publishControlled = (IPublishControlled)DataFacade.GetDataFromDataSourceId(token.DataSourceId);
ValidationResults validationResults = ValidationFacade.Validate((IData)publishControlled);
if (validationResults.IsValid)
{
UpdateTreeRefresher treeRefresher = new UpdateTreeRefresher(token.Data.GetDataEntityToken(), flowControllerServicesContainer);
if (actionToken is PublishActionToken)
{
publishControlled.PublicationStatus = Published;
}
else if (actionToken is DraftActionToken)
{
publishControlled.PublicationStatus = Draft;
}
else if (actionToken is AwaitingApprovalActionToken)
{
publishControlled.PublicationStatus = AwaitingApproval;
}
else if (actionToken is AwaitingPublicationActionToken)
{
publishControlled.PublicationStatus = AwaitingPublication;
}
else if (actionToken is UnpublishActionToken)
{
publishControlled.PublicationStatus = Draft;
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
IData data = DataFacade.GetDataFromOtherScope(token.Data, DataScopeIdentifier.Public).SingleOrDefault();
if (data != null)
{
IPage page = data as IPage;
if (page != null)
{
IEnumerable <IData> referees;
using (new DataScope(DataScopeIdentifier.Public))
{
referees = page.GetMetaData();
}
DataFacade.Delete(referees, CascadeDeleteType.Disable);
}
DataFacade.Delete(data, CascadeDeleteType.Disable);
}
transactionScope.Complete();
}
}
else if (actionToken is UndoPublishedChangesActionToken)
{
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
using (ProcessControllerFacade.NoProcessControllers)
{
var administrativeData = (IPublishControlled)token.Data;
IData publishedData = DataFacade.GetDataFromOtherScope(token.Data, DataScopeIdentifier.Public).Single();
publishedData.FullCopyChangedTo(administrativeData);
administrativeData.PublicationStatus = Draft;
DataFacade.Update(administrativeData);
}
transactionScope.Complete();
}
}
else
{
throw new ArgumentException("Unknown action token", "actionToken");
}
DataFacade.Update(publishControlled);
treeRefresher.PostRefreshMesseges(publishControlled.GetDataEntityToken());
}
else
{
var managementConsoleMessageService = flowControllerServicesContainer.GetService <IManagementConsoleMessageService>();
StringBuilder sb = new System.Text.StringBuilder();
sb.AppendLine(StringResourceSystemFacade.GetString("Composite.Plugins.GenericPublishProcessController", "ValidationErrorMessage"));
foreach (ValidationResult result in validationResults)
{
sb.AppendLine(result.Message);
}
managementConsoleMessageService.ShowMessage(DialogType.Error, StringResourceSystemFacade.GetString("Composite.Plugins.GenericPublishProcessController", "ValidationErrorTitle"), sb.ToString());
}
return(null);
}
private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e)
{
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
List <Guid> oldPageIds = GetOldAffectedPageIds();
List <Guid> newPageIds = GetNewAffectedPageIds();
Pair <string, Type> metaDataPair = this.GetBinding <Pair <string, Type> >("SelectedMetaDataDefinition");
Guid newMetaDataContainerId = this.GetBinding <Guid>("SelectedMetaDataContainer");
string newLabel = this.GetBinding <string>("Label");
int startLevel = this.GetBinding <int>("SelectedStartDisplay");
int levels = this.GetBinding <int>("SelectedInheritDisplay");
PageMetaDataFacade.UpdateDefinition(GetCurrentPageId(), metaDataPair.First, newLabel, startLevel, levels, newMetaDataContainerId);
IEnumerable <Guid> oldPageIdsToRemove = oldPageIds.Except(newPageIds);
foreach (Guid id in oldPageIdsToRemove)
{
IPage page = Composite.Data.PageManager.GetPageById(id);
bool otherDefinitionExists = page.GetAllowedMetaDataDefinitions().Where(f => f.Name == metaDataPair.First).Any();
if (otherDefinitionExists)
{
continue;
}
using (new DataScope(DataScopeIdentifier.Public))
{
IData dataToDelete = page.GetMetaData(metaDataPair.First, metaDataPair.Second);
if (dataToDelete != null)
{
DataFacade.Delete(dataToDelete);
}
}
using (new DataScope(DataScopeIdentifier.Administrated))
{
IData dataToDelete = page.GetMetaData(metaDataPair.First, metaDataPair.Second);
if (dataToDelete != null)
{
DataFacade.Delete(dataToDelete);
}
}
}
IData newDataTemplate = null;
if (this.BindingExist("NewDataTemplate"))
{
newDataTemplate = this.GetBinding <IData>("NewDataTemplate");
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(metaDataPair.Second.GetImmutableTypeId());
DataTypeDescriptorFormsHelper helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor);
helper.BindingsToObject(this.Bindings, newDataTemplate);
}
IEnumerable <Guid> newPageIdsToAdd = newPageIds.Except(oldPageIds);
foreach (Guid id in newPageIdsToAdd)
{
IPage page = Composite.Data.PageManager.GetPageById(id);
page.AddNewMetaDataToExistingPage(metaDataPair.First, metaDataPair.Second, newDataTemplate);
}
transactionScope.Complete();
}
}
private void initializeCodeActivity_Copy_ExecuteCode(object sender, EventArgs e)
{
var castedEntityToken = (DataEntityToken)this.EntityToken;
IPage newPage;
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
CultureInfo sourceCultureInfo = UserSettings.ForeignLocaleCultureInfo;
IPage sourcePage;
List <IPagePlaceholderContent> sourcePagePlaceholders;
List <IData> sourceMetaDataSet;
using (new DataScope(sourceCultureInfo))
{
var pageFromEntityToken = (IPage)castedEntityToken.Data;
Guid sourcePageId = pageFromEntityToken.Id;
Guid sourcePageVersionId = pageFromEntityToken.VersionId;
using (new DataScope(DataScopeIdentifier.Administrated))
{
sourcePage = DataFacade.GetData <IPage>(f => f.Id == sourcePageId).Single();
sourcePage = sourcePage.GetTranslationSource();
using (new DataScope(sourcePage.DataSourceId.DataScopeIdentifier))
{
sourcePagePlaceholders = DataFacade
.GetData <IPagePlaceholderContent>(f => f.PageId == sourcePageId && f.VersionId == sourcePageVersionId)
.ToList();
sourceMetaDataSet = sourcePage.GetMetaData().ToList();
}
}
}
CultureInfo targetCultureInfo = UserSettings.ActiveLocaleCultureInfo;
using (new DataScope(targetCultureInfo))
{
newPage = DataFacade.BuildNew <IPage>();
sourcePage.ProjectedCopyTo(newPage);
newPage.SourceCultureName = targetCultureInfo.Name;
newPage.PublicationStatus = GenericPublishProcessController.Draft;
newPage = DataFacade.AddNew <IPage>(newPage);
foreach (IPagePlaceholderContent sourcePagePlaceholderContent in sourcePagePlaceholders)
{
IPagePlaceholderContent newPagePlaceholderContent = DataFacade.BuildNew <IPagePlaceholderContent>();
sourcePagePlaceholderContent.ProjectedCopyTo(newPagePlaceholderContent);
newPagePlaceholderContent.SourceCultureName = targetCultureInfo.Name;
newPagePlaceholderContent.PublicationStatus = GenericPublishProcessController.Draft;
DataFacade.AddNew <IPagePlaceholderContent>(newPagePlaceholderContent);
}
foreach (IData metaData in sourceMetaDataSet)
{
ILocalizedControlled localizedData = metaData as ILocalizedControlled;
if (localizedData == null)
{
continue;
}
IEnumerable <ReferenceFailingPropertyInfo> referenceFailingPropertyInfos = DataLocalizationFacade.GetReferencingLocalizeFailingProperties(localizedData).Evaluate();
if (!referenceFailingPropertyInfos.Any())
{
IData newMetaData = DataFacade.BuildNew(metaData.DataSourceId.InterfaceType);
metaData.ProjectedCopyTo(newMetaData);
ILocalizedControlled localizedControlled = newMetaData as ILocalizedControlled;
localizedControlled.SourceCultureName = targetCultureInfo.Name;
IPublishControlled publishControlled = newMetaData as IPublishControlled;
publishControlled.PublicationStatus = GenericPublishProcessController.Draft;
DataFacade.AddNew(newMetaData);
}
else
{
foreach (ReferenceFailingPropertyInfo referenceFailingPropertyInfo in referenceFailingPropertyInfos)
{
Log.LogVerbose("LocalizePageWorkflow",
"Meta data of type '{0}' is not localized because the field '{1}' is referring some not yet localzed data"
.FormatWith(metaData.DataSourceId.InterfaceType, referenceFailingPropertyInfo.DataFieldDescriptor.Name));
}
}
}
}
EntityTokenCacheFacade.ClearCache(sourcePage.GetDataEntityToken());
EntityTokenCacheFacade.ClearCache(newPage.GetDataEntityToken());
foreach (var folderType in PageFolderFacade.GetDefinedFolderTypes(newPage))
{
EntityTokenCacheFacade.ClearCache(new AssociatedDataElementProviderHelperEntityToken(
TypeManager.SerializeType(typeof(IPage)),
PageElementProvider.DefaultConfigurationName,
newPage.Id.ToString(),
TypeManager.SerializeType(folderType)));
}
transactionScope.Complete();
}
ParentTreeRefresher parentTreeRefresher = this.CreateParentTreeRefresher();
parentTreeRefresher.PostRefreshMesseges(newPage.GetDataEntityToken(), 2);
this.ExecuteWorklow(newPage.GetDataEntityToken(), typeof(EditPageWorkflow));
}
