/// <exclude />
public static void AddNewMetaDataToExistingPage(this IPage page, string metaDataDefinitionName, Type metaDataType, IData newDataTemplate)
{
IData data = page.GetMetaData(metaDataDefinitionName, metaDataType);
if (data != null)
{
return;
}
IPublishControlled newData = DataFacade.BuildNew(metaDataType) as IPublishControlled;
newDataTemplate.FullCopyChangedTo(newData);
newData.PublicationStatus = GenericPublishProcessController.Draft;
PageMetaDataFacade.AssignMetaDataSpecificValues(newData, metaDataDefinitionName, page);
ILocalizedControlled localizedData = newData as ILocalizedControlled;
if (localizedData != null)
{
localizedData.SourceCultureName = page.SourceCultureName;
}
newData = (IPublishControlled)DataFacade.AddNew((IData)newData); // Cast is needed for the DataFacade to work correctly
if (newData.PublicationStatus != page.PublicationStatus)
{
newData.PublicationStatus = page.PublicationStatus;
DataFacade.Update(newData);
}
}
private static void AddNewMetaDataToExistingPages(IEnumerable <IPage> affectedPages, string metaDataDefinitionName, Type metaDataType, IData newDataTemplate)
{
foreach (IPage affectedPage in affectedPages)
{
IData data = affectedPage.GetMetaData(metaDataDefinitionName, metaDataType);
if (data != null)
{
continue;
}
IPublishControlled newData = DataFacade.BuildNew(metaDataType) as IPublishControlled;
newDataTemplate.FullCopyChangedTo(newData);
newData.PublicationStatus = GenericPublishProcessController.Draft;
PageMetaDataFacade.AssignMetaDataSpecificValues(newData, metaDataDefinitionName, affectedPage);
ILocalizedControlled localizedData = newData as ILocalizedControlled;
if (localizedData != null)
{
localizedData.SourceCultureName = UserSettings.ActiveLocaleCultureInfo.Name;
}
newData = DataFacade.AddNew((IData)newData) as IPublishControlled;
if (newData.PublicationStatus != affectedPage.PublicationStatus)
{
newData.PublicationStatus = affectedPage.PublicationStatus;
DataFacade.Update(newData);
}
}
}
/// <summary>
/// Checks whether the specified data item can be translated.
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static bool IsTranslatable(this IData data)
{
IPublishControlled publishControlled = data as IPublishControlled;
if (!GlobalSettingsFacade.OnlyTranslateWhenApproved || publishControlled == null)
{
return(true);
}
switch (publishControlled.PublicationStatus)
{
case GenericPublishProcessController.Draft:
case GenericPublishProcessController.AwaitingApproval:
using (new DataScope(data.DataSourceId.LocaleScope))
{
return(DataFacade.GetDataFromOtherScope(data, DataScopeIdentifier.Public).Any());
}
case GenericPublishProcessController.AwaitingPublication:
case GenericPublishProcessController.Published:
return(true);
default:
throw new InvalidOperationException("Unexpected publication status: " + (publishControlled.PublicationStatus ?? "(null)"));
}
}
private static void OnAfterDataUpdated(object sender, DataEventArgs dataEventArgs)
{
IPublishControlled publishControlled = dataEventArgs.Data as IPublishControlled;
if (publishControlled == null)
{
return;
}
IPage page = dataEventArgs.Data as IPage;
if (page == null)
{
return;
}
var metaDataToBeUpdated = page.GetMetaData().Evaluate();
foreach (IData data in metaDataToBeUpdated)
{
IPublishControlled pc = data as IPublishControlled;
if (pc.PublicationStatus != publishControlled.PublicationStatus)
{
pc.PublicationStatus = publishControlled.PublicationStatus;
// THIS UPDATE WAS ALWAYS EXECUTED - OUTSIDE THE versionControlled CHECK - WAS THIS NEEDED?
DataFacade.Update(data, false, false, false);
}
}
}
private void saveCodeActivity_UpdateData_ExecuteCode(object sender, EventArgs e)
{
UpdateTreeRefresher updateTreeRefresher = this.CreateUpdateTreeRefresher(this.EntityToken);
IData data = ((DataEntityToken)this.EntityToken).Data;
bool isValid = ValidateBindings();
if (!BindAndValidate(this.FormsHelper, data))
{
isValid = false;
}
var fieldsWithBrokenReferences = new List <string>();
if (!data.TryValidateForeignKeyIntegrity(fieldsWithBrokenReferences))
{
isValid = false;
foreach (string fieldName in fieldsWithBrokenReferences)
{
ShowFieldMessage(fieldName, LocalizationFiles.Composite_Management.Validation_BrokenReference);
}
}
if (isValid)
{
if (data is IPublishControlled)
{
IPublishControlled publishControlledData = (IPublishControlled)data;
if (publishControlledData.PublicationStatus == GenericPublishProcessController.Published)
{
publishControlledData.PublicationStatus = GenericPublishProcessController.Draft;
}
}
DataFacade.Update(data);
EntityTokenCacheFacade.ClearCache(EntityToken);
updateTreeRefresher.PostRefreshMesseges(this.EntityToken);
PublishControlledHelper.PublishIfNeeded(data, _doPublish, Bindings, ShowMessage);
}
SetSaveStatus(isValid);
}
/// <summary>
/// Returns the data item either from "Administrated" or from "Public" scope depending on, which has to be used as translation source.
/// If onlyTranslateWhenApproved="true" or publication status is not "awaiting publishion" - item from the public scope will be returned.
/// </summary>
/// <param name="dataFromAdministratedScope">The data item</param>
/// <returns></returns>
public static T GetTranslationSource <T>(this T dataFromAdministratedScope) where T : class, IData
{
IPublishControlled publishControlled = dataFromAdministratedScope as IPublishControlled;
if (!GlobalSettingsFacade.OnlyTranslateWhenApproved ||
publishControlled == null ||
publishControlled.PublicationStatus == GenericPublishProcessController.AwaitingPublication)
{
return(dataFromAdministratedScope);
}
using (new DataScope(dataFromAdministratedScope.DataSourceId.LocaleScope))
{
return((DataFacade.GetDataFromOtherScope(dataFromAdministratedScope as IData, DataScopeIdentifier.Public)
.FirstOrDefault()
?? dataFromAdministratedScope) as T);
}
}
private void editCodeActivity_DisplayForm_ExecuteCode(object sender, EventArgs e)
{
IData data = ((DataEntityToken)this.EntityToken).Data;
if (!PermissionsFacade.GetPermissionsForCurrentUser(EntityToken).Contains(PermissionType.Publish) ||
!(data is IPublishControlled))
{
FormData formData = WorkflowFacade.GetFormData(InstanceId, true);
if (formData.ExcludedEvents == null)
{
formData.ExcludedEvents = new List <string>();
}
formData.ExcludedEvents.Add("SaveAndPublish");
}
if (data is IPublishControlled)
{
IPublishControlled publishControlledData = (IPublishControlled)data;
if (publishControlledData.PublicationStatus == GenericPublishProcessController.Published)
{
publishControlledData.PublicationStatus = GenericPublishProcessController.Draft;
}
}
this.FormsHelper.UpdateWithBindings(data, this.Bindings);
this.FormsHelper.LayoutLabel = data.GetLabel(true);
this.DeliverFormData(
this.TypeName,
StandardUiContainerTypes.Document,
this.FormsHelper.GetForm(),
this.Bindings,
this.FormsHelper.GetBindingsValidationRules(data)
);
}
public static ResourceHandle GetIcon(this IData data)
{
IPublishControlled publishControlled = data as IPublishControlled;
if (publishControlled == null)
{
return(DataIcon);
}
switch (publishControlled.PublicationStatus)
{
case GenericPublishProcessController.Draft:
return(DataDraftIcon);
case GenericPublishProcessController.AwaitingApproval:
return(DataAwaitingApprovalIcon);
case GenericPublishProcessController.AwaitingPublication:
return(DataAwaitingPublicationIcon);
case GenericPublishProcessController.Published:
return(DataPublishedIcon);
default:
var allowedPublicationStatuses = new[] {
GenericPublishProcessController.Draft,
GenericPublishProcessController.AwaitingApproval,
GenericPublishProcessController.AwaitingPublication,
GenericPublishProcessController.Published
};
string allowedValues = string.Join(", ", allowedPublicationStatuses.Select(status => "'" + status + "'"));
throw new InvalidOperationException("Unexpected publication status '{0}'. Allowed values: {1}"
.FormatWith(publishControlled.PublicationStatus ?? "(null)", allowedValues));
}
}
public static bool SubmitForm(ParameterList parameters, string captchaText)
{
try
{
_compiler.SaveControlProperties();
}
catch (Exception)
{ }
webUiControl.InitializeViewState();
Dictionary <string, string> errorMessages = formHelper.BindingsToObject(bindings, newData);
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(newData.DataSourceId.InterfaceType);
foreach (var property in newData.DataSourceId.InterfaceType.GetProperties())
{
if (property.PropertyType == typeof(string) && (string)property.GetValue(newData, null) == string.Empty)
{
property.SetValue(newData, null, null);
}
}
ValidationResults validationResults = ValidationFacade.Validate(newData.DataSourceId.InterfaceType, newData);
var isValid = true;
var useCaptcha = parameters.GetParameter <bool>("UseCaptcha");
if (useCaptcha)
{
var Session = HttpContext.Current.Session;
if (Session["FormsRendererCaptcha"] == null || !Captcha.IsValid(captchaText, Session["FormsRendererCaptcha"].ToString()))
{
ErrorSummary.AddError(StringResourceSystemFacade.GetString("Composite.Forms.Renderer", "Composite.Forms.Captcha.CaptchaText.error"));
isValid = false;
}
}
if (validationResults.IsValid == false)
{
isValid = false;
Dictionary <string, string> errorSummary = new Dictionary <string, string>();
foreach (ValidationResult result in validationResults)
{
var label = result.Key;
var help = result.Message;
try
{
label = dataTypeDescriptor.Fields[result.Key].FormRenderingProfile.Label;
help = dataTypeDescriptor.Fields[result.Key].FormRenderingProfile.HelpText;
//if no HelpText specified - use standard C1 error
if (help == string.Empty)
{
help = result.Message;
}
string error = GetLocalized(label) + ": " + GetLocalized(help);
if (!errorSummary.ContainsValue(error))
{
errorSummary.Add(errorSummary.Count().ToString(), error);
}
}
catch { }
}
// add errors to ErrorSummary
foreach (var dict in errorSummary)
{
ErrorSummary.AddError(dict.Value);
}
}
//TODO: Looks like rudimentary code related to old C1 errros with binding?
if (errorMessages != null)
{
isValid = false;
foreach (var kvp in errorMessages)
{
var label = kvp.Key;
try
{
label = dataTypeDescriptor.Fields[kvp.Key].FormRenderingProfile.Label;
}
catch { }
ErrorSummary.AddError(GetLocalized(label) + ": " + GetLocalized(kvp.Value));
}
}
if (isValid)
{
using (new DataScope(DataScopeIdentifier.Administrated))
{
IPublishControlled publishControlled = newData as IPublishControlled;
if (publishControlled != null)
{
publishControlled.PublicationStatus = GenericPublishProcessController.Draft;
}
DataFacade.AddNew(newData);
using (var datascope = new FormsRendererDataScope(newData))
{
var formEmailHeaders = parameters.GetParameter("Email") as IEnumerable <FormEmail>;
if (formEmailHeaders != null)
{
foreach (var formEmail in formEmailHeaders)
{
ParameterFacade.ResolveProperties(formEmail);
var inputXml = GetXElement(newData);
var body = new XhtmlDocument();
body.AppendDocument(formEmail.Body);
if (formEmail.AppendFormData)
{
var formData = new XDocument();
var xslTransform = new XslCompiledTransform();
xslTransform.LoadFromPath(FormsRendererLocalPath + "Xslt/MailBody.xslt");
using (var writer = formData.CreateWriter())
{
xslTransform.Transform(inputXml.CreateReader(), writer);
}
body.AppendDocument(formData);
}
Reflection.CallStaticMethod <object>("Composite.Core.WebClient.Renderings.Page.PageRenderer", "NormalizeXhtmlDocument", body);
var mailMessage = new MailMessage();
try
{
mailMessage.From = new MailAddress(formEmail.From);
}
catch (Exception e)
{
LoggingService.LogError(string.Format("Mail sending(From: '{0}')", formEmail.From), e.Message);
continue;
}
try
{
mailMessage.To.Add(formEmail.To);
}
catch (Exception e)
{
LoggingService.LogError(string.Format("Mail sending(To: '{0}')", formEmail.To), e.Message);
continue;
}
if (!string.IsNullOrEmpty(formEmail.Cc))
{
try
{
mailMessage.CC.Add(formEmail.Cc);
}
catch (Exception e)
{
LoggingService.LogError(string.Format("Mail sending(Cc: '{0}')", formEmail.Cc), e.Message);
}
}
try
{
mailMessage.Subject = formEmail.Subject;
mailMessage.IsBodyHtml = true;
mailMessage.Body = body.ToString();
new SmtpClient().Send(mailMessage);
}
catch (Exception e)
{
throw new InvalidOperationException("Unable to send mail. Please ensure that web.config has correct /configuration/system.net/mailSettings: " + e.Message);
}
}
}
}
}
}
return(isValid);
}
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 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));
}
private void localizeDataCodeActivity_Localize_ExecuteCode(object sender, EventArgs e)
{
DataEntityToken dataEntityToken = (DataEntityToken)this.EntityToken;
ILocalizedControlled data = dataEntityToken.Data as ILocalizedControlled;
CultureInfo targetCultureInfo = UserSettings.ActiveLocaleCultureInfo;
if (ExistsInLocale(data, targetCultureInfo))
{
this.ShowMessage(
DialogType.Message,
StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "LocalizeData.ShowError.Layout.Label"),
StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "LocalizeData.ShowError.AlreadyTranslated")
);
return;
}
IEnumerable <ReferenceFailingPropertyInfo> referenceFailingPropertyInfos = DataLocalizationFacade.GetReferencingLocalizeFailingProperties(data).Evaluate();
IData newData;
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
data = data.GetTranslationSource();
using (new DataScope(targetCultureInfo))
{
newData = DataFacade.BuildNew(data.DataSourceId.InterfaceType);
data.ProjectedCopyTo(newData);
ILocalizedControlled localizedControlled = newData as ILocalizedControlled;
localizedControlled.SourceCultureName = targetCultureInfo.Name;
if (newData is IPublishControlled)
{
IPublishControlled publishControlled = newData as IPublishControlled;
publishControlled.PublicationStatus = GenericPublishProcessController.Draft;
}
foreach (ReferenceFailingPropertyInfo referenceFailingPropertyInfo in referenceFailingPropertyInfos)
{
PropertyInfo propertyInfo = data.DataSourceId.InterfaceType.GetPropertiesRecursively().Single(f => f.Name == referenceFailingPropertyInfo.DataFieldDescriptor.Name);
if (propertyInfo.PropertyType.IsGenericType &&
propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
propertyInfo.SetValue(newData, null, null);
}
else if (propertyInfo.PropertyType == typeof(string))
{
propertyInfo.SetValue(newData, null, null);
}
else
{
propertyInfo.SetValue(newData, referenceFailingPropertyInfo.DataFieldDescriptor.DefaultValue.Value, null);
}
}
newData = DataFacade.AddNew(newData);
}
EntityTokenCacheFacade.ClearCache(data.GetDataEntityToken());
EntityTokenCacheFacade.ClearCache(newData.GetDataEntityToken());
transactionScope.Complete();
}
ParentTreeRefresher parentTreeRefresher = this.CreateParentTreeRefresher();
parentTreeRefresher.PostRefreshMesseges(newData.GetDataEntityToken(), 2);
}
private void localizeCodeActivity_ExecuteCode(object sender, EventArgs e)
{
DataEntityToken dataEntityToken = (DataEntityToken)this.EntityToken;
ILocalizedControlled data = dataEntityToken.Data as ILocalizedControlled;
CultureInfo targetCultureInfo = UserSettings.ActiveLocaleCultureInfo;
if (ExistsInLocale(data, targetCultureInfo))
{
string title = Texts.LocalizeDataWorkflow_ShowError_LayoutLabel;
string description = Texts.LocalizeDataWorkflow_ShowError_AlreadyTranslated;
var messageBox = new MessageBoxMessageQueueItem
{
DialogType = DialogType.Message,
Message = description,
Title = title
};
ConsoleMessageQueueFacade.Enqueue(messageBox, GetCurrentConsoleId());
return;
}
IEnumerable <ReferenceFailingPropertyInfo> referenceFailingPropertyInfos = DataLocalizationFacade.GetReferencingLocalizeFailingProperties(data).Evaluate();
IData newData;
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
data = data.GetTranslationSource();
using (new DataScope(targetCultureInfo))
{
newData = DataFacade.BuildNew(data.DataSourceId.InterfaceType);
data.ProjectedCopyTo(newData);
ILocalizedControlled localizedControlled = newData as ILocalizedControlled;
localizedControlled.SourceCultureName = targetCultureInfo.Name;
if (newData is IPublishControlled)
{
IPublishControlled publishControlled = newData as IPublishControlled;
publishControlled.PublicationStatus = GenericPublishProcessController.Draft;
}
foreach (ReferenceFailingPropertyInfo referenceFailingPropertyInfo in referenceFailingPropertyInfos)
{
PropertyInfo propertyInfo = data.DataSourceId.InterfaceType.GetPropertiesRecursively().Single(f => f.Name == referenceFailingPropertyInfo.DataFieldDescriptor.Name);
if (propertyInfo.PropertyType.IsGenericType &&
propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
propertyInfo.SetValue(newData, null, null);
}
else if (propertyInfo.PropertyType == typeof(string))
{
propertyInfo.SetValue(newData, null, null);
}
else
{
propertyInfo.SetValue(newData, referenceFailingPropertyInfo.DataFieldDescriptor.DefaultValue.Value, null);
}
}
newData = DataFacade.AddNew(newData, false, false, true);
}
EntityTokenCacheFacade.ClearCache(data.GetDataEntityToken());
EntityTokenCacheFacade.ClearCache(newData.GetDataEntityToken());
transactionScope.Complete();
}
ParentTreeRefresher parentTreeRefresher = this.CreateParentTreeRefresher();
parentTreeRefresher.PostRefreshMesseges(newData.GetDataEntityToken());
if (this.Payload == "Global")
{
this.ExecuteWorklow(newData.GetDataEntityToken(), typeof(EditDataWorkflow));
}
else if (this.Payload == "Pagefolder")
{
this.ExecuteWorklow(newData.GetDataEntityToken(), WorkflowFacade.GetWorkflowType("Composite.C1Console.Elements.ElementProviderHelpers.AssociatedDataElementProviderHelper.EditAssociatedDataWorkflow"));
}
}
public static IPage TranslatePage(IPage sourcePage, CultureInfo sourceCultureInfo, CultureInfo targetCultureInfo)
{
IPage newPage;
using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
List <IPagePlaceholderContent> sourcePagePlaceholders;
List <IData> sourceMetaDataSet;
using (new DataScope(sourceCultureInfo))
{
using (new DataScope(DataScopeIdentifier.Administrated))
{
sourcePage = sourcePage.GetTranslationSource();
using (new DataScope(sourcePage.DataSourceId.DataScopeIdentifier))
{
sourcePagePlaceholders = DataFacade.GetData <IPagePlaceholderContent>(f => f.PageId == sourcePage.Id).ToList();
sourceMetaDataSet = sourcePage.GetMetaData().ToList();
}
}
}
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));
}
}
}
}
transactionScope.Complete();
}
return(newPage);
}
