private void finalizeCodeActivity_ExecuteCode(object sender, EventArgs e)
{
var justAdded = false;
var isValid = ValidateBindings();
var helper = GetDataTypeDescriptorFormsHelper();
var newData = GetBinding <IData>("NewData");
if (!BindAndValidate(helper, newData))
{
isValid = false;
}
if (isValid)
{
if (!BindingExist("DataAdded"))
{
newData = DataFacade.AddNew(newData);
justAdded = true;
AcquireLock(newData.GetDataEntityToken());
UpdateBinding("NewData", newData);
Bindings.Add("DataAdded", true);
PublishControlledHelper.PublishIfNeeded(newData, _doPublish, Bindings, ShowMessage);
var specificTreeRefresher = CreateParentTreeRefresher();
specificTreeRefresher.PostRefreshMesseges(EntityToken);
}
else
{
var updateTreeRefresher = CreateUpdateTreeRefresher(EntityToken);
DataFacade.Update(newData);
EntityTokenCacheFacade.ClearCache(newData.GetDataEntityToken());
var published = PublishControlledHelper.PublishIfNeeded(newData, _doPublish, Bindings, ShowMessage);
if (!published)
{
updateTreeRefresher.PostRefreshMesseges(EntityToken);
}
}
}
if (justAdded)
{
SetSaveStatus(true, newData);
}
else
{
SetSaveStatus(isValid);
}
}
private void saveCodeActivity_ExecuteCode(object sender, EventArgs e)
{
var isValid = ValidateBindings();
var updateTreeRefresher = CreateUpdateTreeRefresher(EntityToken);
var helper = GetDataTypeDescriptorFormsHelper();
var data = ((DataEntityToken)EntityToken).Data;
if (!BindAndValidate(helper, data))
{
isValid = false;
}
var fieldsWithBrokenReferences = new List <string>();
if (!data.TryValidateForeignKeyIntegrity(fieldsWithBrokenReferences))
{
isValid = false;
foreach (var fieldName in fieldsWithBrokenReferences)
{
ShowFieldMessage(fieldName, StringResourceSystemFacade.GetString("Composite.Management", "Validation.BrokenReference"));
}
}
if (isValid)
{
// published data stayed as published data - change to draft if status is published
if (data is IPublishControlled)
{
var publishControlledData = (IPublishControlled)data;
if (publishControlledData.PublicationStatus == GenericPublishProcessController.Published)
{
publishControlledData.PublicationStatus = GenericPublishProcessController.Draft;
}
}
DataFacade.Update(data);
EntityTokenCacheFacade.ClearCache(EntityToken);
updateTreeRefresher.PostRefreshMesseges(EntityToken);
PublishControlledHelper.PublishIfNeeded(data, _doPublish, Bindings, ShowMessage);
SetSaveStatus(true);
}
else
{
SetSaveStatus(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);
}
private void saveDataCodeActivity_ExecuteCode(object sender, EventArgs e)
{
var isValid = ValidateBindings();
var updateTreeRefresher = CreateUpdateTreeRefresher(EntityToken);
var helper = GetDataTypeDescriptorFormsHelper();
var data = ((DataEntityToken)EntityToken).Data;
if (!BindAndValidate(helper, data))
{
isValid = false;
}
if (isValid)
{
// published data stayed as published data - change to draft if status is published
if (data is IPublishControlled)
{
var publishControlledData = (IPublishControlled)data;
if (publishControlledData.PublicationStatus == GenericPublishProcessController.Published)
{
publishControlledData.PublicationStatus = GenericPublishProcessController.Draft;
}
}
DataFacade.Update(data);
EntityTokenCacheFacade.ClearCache(data.GetDataEntityToken());
var published = PublishControlledHelper.PublishIfNeeded(data, _doPublish, Bindings, ShowMessage);
if (!published)
{
updateTreeRefresher.PostRefreshMesseges(EntityToken);
}
SetSaveStatus(true);
}
else
{
SetSaveStatus(false);
}
}
private void saveCodeActivity_SaveData_ExecuteCode(object sender, EventArgs e)
{
Initialize();
bool isValid = ValidateBindings();
IData newData = this.GetBinding <IData>("NewData");
if (!BindAndValidate(FormsHelper, newData))
{
isValid = false;
}
if (!isValid)
{
SetSaveStatus(false);
return;
}
this.RefreshCurrentEntityToken();
if (!this.BindingExist("DataAdded"))
{
newData = DataFacade.AddNew(newData);
this.AcquireLock(newData.GetDataEntityToken());
this.UpdateBinding("NewData", newData);
this.Bindings.Add("DataAdded", true);
SetSaveStatus(true, newData);
}
else
{
DataFacade.Update(newData);
SetSaveStatus(true);
}
PublishControlledHelper.PublishIfNeeded(newData, _doPublish, Bindings, ShowMessage);
}
private void finalizeCodeActivity_ExecuteCode(object sender, EventArgs e)
{
var dataTypeDescriptor = GetBinding <DataTypeDescriptor>("DataTypeDescriptor");
var newData = GetBinding <IData>("NewData");
var helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor, true, newData.GetDataEntityToken());
var generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor);
helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames);
var isValid = ValidateBindings();
if (!BindAndValidate(helper, newData))
{
isValid = false;
}
var justAdded = false;
if (isValid)
{
var published = false;
if (!BindingExist("DataAdded"))
{
var dataScopeIdentifier = DataScopeIdentifier.Public;
if (dataTypeDescriptor.SuperInterfaces.Contains(typeof(IPublishControlled)))
{
dataScopeIdentifier = DataScopeIdentifier.Administrated;
}
using (new DataScope(dataScopeIdentifier))
{
newData = DataFacade.AddNew(newData);
justAdded = true;
}
PublishControlledHelper.PublishIfNeeded(newData, _doPublish, Bindings, ShowMessage);
AcquireLock(newData.GetDataEntityToken());
UpdateBinding("NewData", newData);
Bindings.Add("DataAdded", true);
}
else
{
var publishedControlled = newData as IPublishControlled;
if (publishedControlled != null)
{
var refreshedData = (IPublishControlled)DataFacade.GetDataFromDataSourceId(newData.DataSourceId);
if (refreshedData != null && refreshedData.PublicationStatus == GenericPublishProcessController.Published)
{
refreshedData.PublicationStatus = GenericPublishProcessController.Draft;
DataFacade.Update(refreshedData);
}
}
DataFacade.Update(newData);
published = PublishControlledHelper.PublishIfNeeded(newData, _doPublish, Bindings, ShowMessage);
EntityTokenCacheFacade.ClearCache(newData.GetDataEntityToken());
}
if (!published)
{
var specificTreeRefresher = CreateParentTreeRefresher();
specificTreeRefresher.PostRefreshMesseges(EntityToken);
}
if (justAdded)
{
SetSaveStatus(true, newData);
}
else
{
SetSaveStatus(true);
}
}
else
{
SetSaveStatus(false);
}
}
private void saveCodeActivity_ExecuteCode(object sender, EventArgs e)
{
var updateTreeRefresher = CreateUpdateTreeRefresher(EntityToken);
var selectedPage = GetBinding <IPage>("SelectedPage");
var originalPage = DataFacade.GetData <IPage>(f => f.Id == selectedPage.Id).SingleOrDefault();
var viewLabelUpdated = originalPage == null ||
selectedPage.MenuTitle != originalPage.MenuTitle ||
selectedPage.Title != originalPage.Title;
var treeviewRequiresRefreshing = false;
var dataToAdd = new Dictionary <string, IData>();
var dataToUpdate = new Dictionary <string, IData>();
var dataValidated = true;
WorkflowInstance publishWorkflowInstance = null;
WorkflowInstance unpublishWorkflowInstance = null;
try
{
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
dataValidated = PrepareAddUpdateMetaData(selectedPage, dataToAdd, dataToUpdate);
if (dataValidated)
{
PublishControlledHelper.HandlePublishUnpublishWorkflows(selectedPage, UserSettings.ActiveLocaleCultureInfo.Name, PublishDate, UnpublishDate, ref publishWorkflowInstance, ref unpublishWorkflowInstance);
if (selectedPage.PageTypeId != originalPage.PageTypeId)
{
// Adding metadata fields
var oldPageMetaDataDefinitions = originalPage.GetAllowedMetaDataDefinitions().Except(selectedPage.GetAllowedMetaDataDefinitions(), new PageMetaDataDefinitionEqualityComparer());
foreach (var pageMetaDataDefinition in oldPageMetaDataDefinitions)
{
var oldMetaData = selectedPage.GetMetaData(pageMetaDataDefinition.Name, pageMetaDataDefinition.MetaDataTypeId);
if (oldMetaData != null)
{
ProcessControllerFacade.FullDelete(oldMetaData);
}
}
// Adding page folders
var pageTypeDataFolderTypeLinks =
DataFacade.GetData <IPageTypeDataFolderTypeLink>().
Where(f => f.PageTypeId == selectedPage.PageTypeId).
Evaluate().
RemoveDeadLinks();
foreach (var pageTypeDataFolderTypeLink in pageTypeDataFolderTypeLinks)
{
if (selectedPage.GetFolderDefinitionId(pageTypeDataFolderTypeLink.DataTypeId) != Guid.Empty)
{
continue;
}
selectedPage.AddFolderDefinition(pageTypeDataFolderTypeLink.DataTypeId);
treeviewRequiresRefreshing = true;
}
// Adding applications
var pageTypeTreeLinks =
DataFacade.GetData <IPageTypeTreeLink>().
Where(f => f.PageTypeId == selectedPage.PageTypeId).
Evaluate().
RemoveDeadLinks();
foreach (var pageTypeTreeLink in pageTypeTreeLinks)
{
var tree = TreeFacade.GetTree(pageTypeTreeLink.TreeId);
if (tree.HasAttachmentPoints(selectedPage.GetDataEntityToken()))
{
continue;
}
TreeFacade.AddPersistedAttachmentPoint(pageTypeTreeLink.TreeId, typeof(IPage), selectedPage.Id);
treeviewRequiresRefreshing = true;
}
}
foreach (var data in dataToAdd.Values)
{
DataFacade.AddNew(data);
}
foreach (var data in dataToUpdate.Values)
{
var publishControlled = data as IPublishControlled;
publishControlled.PublicationStatus = GenericPublishProcessController.Draft;
DataFacade.Update(data);
}
treeviewRequiresRefreshing |= (originalPage.Title != selectedPage.Title) ||
(originalPage.Description != selectedPage.Description) ||
(originalPage.PublicationStatus != selectedPage.PublicationStatus);
// NOTE: updating originalPage object, in order to make XML & SQL provider work in the same way
originalPage.TemplateId = selectedPage.TemplateId;
originalPage.PageTypeId = selectedPage.PageTypeId;
originalPage.Title = selectedPage.Title;
originalPage.MenuTitle = selectedPage.MenuTitle;
originalPage.UrlTitle = selectedPage.UrlTitle;
originalPage.FriendlyUrl = selectedPage.FriendlyUrl;
originalPage.Description = selectedPage.Description;
originalPage.PublicationStatus = selectedPage.PublicationStatus;
originalPage.SourceCultureName = selectedPage.SourceCultureName;
DataFacade.Update(originalPage);
var contentDictionary = GetBinding <Dictionary <string, string> >("NamedXhtmlFragments");
var existingContents = DataFacade.GetData <IPagePlaceholderContent>(f => f.PageId == selectedPage.Id).ToList();
foreach (var existingContent in existingContents)
{
if (contentDictionary.ContainsKey(existingContent.PlaceHolderId))
{
existingContent.Content = contentDictionary[existingContent.PlaceHolderId];
existingContent.PublicationStatus = GenericPublishProcessController.Draft;
DataFacade.Update(existingContent);
}
else
{
DataFacade.Delete(existingContent);
}
}
foreach (var contentDictionaryElement in contentDictionary.Where(f => existingContents.Any(existing => existing.PlaceHolderId == f.Key) == false))
{
var newContent = DataFacade.BuildNew <IPagePlaceholderContent>();
newContent.PageId = selectedPage.Id;
newContent.PlaceHolderId = contentDictionaryElement.Key;
newContent.Content = contentDictionaryElement.Value;
newContent.SourceCultureName = UserSettings.ActiveLocaleCultureInfo.Name;
newContent.PublicationStatus = GenericPublishProcessController.Draft;
DataFacade.AddNew(newContent);
}
}
transactionScope.Complete();
}
if (publishWorkflowInstance != null)
{
publishWorkflowInstance.Start();
WorkflowFacade.RunWorkflow(publishWorkflowInstance);
}
if (unpublishWorkflowInstance != null)
{
unpublishWorkflowInstance.Start();
WorkflowFacade.RunWorkflow(unpublishWorkflowInstance);
}
if (_doPublish)
{
if (publishWorkflowInstance == null || PublishDate < DateTime.Now)
{
var actionToken = new GenericPublishProcessController.PublishActionToken();
var serviceContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
ActionExecutorFacade.Execute(EntityToken, actionToken, serviceContainer);
treeviewRequiresRefreshing = false;
}
else
{
var title = StringResourceSystemFacade.GetString("Composite.Management", "Website.Forms.Administrative.EditPage.PublishDatePreventPublishTitle");
var message = StringResourceSystemFacade.GetString("Composite.Management", "Website.Forms.Administrative.EditPage.PublishDatePreventPublish");
ShowMessage(DialogType.Warning, title, message);
}
}
if (treeviewRequiresRefreshing)
{
updateTreeRefresher.PostRefreshMesseges(selectedPage.GetDataEntityToken());
}
UpdateBinding("OldPublicationStatus", selectedPage.PublicationStatus);
if (viewLabelUpdated)
{
RerenderView();
}
}
catch (Exception ex)
{
var mostSpecificException = ex;
while (mostSpecificException.InnerException != null)
{
mostSpecificException = mostSpecificException.InnerException;
}
ShowMessage(DialogType.Error, "Save failed", string.Format("Save failed: {0}", mostSpecificException.Message));
Log.LogError("Page save", ex);
}
finally
{
SetSaveStatus(dataValidated);
}
}
internal static bool ConvertOldPublishingWorkflows(Guid pageId, string localeName)
{
lock (_conversionSyncRoot)
try
{
using (GlobalInitializerFacade.CoreIsInitializedScope)
using (ThreadDataManager.EnsureInitialize())
{
using (new DataScope(DataScopeIdentifier.Administrated, CultureInfo.CreateSpecificCulture(localeName)))
{
using (var transaction = TransactionsFacade.CreateNewScope())
{
var pagePublishSchedule =
(from ps in DataFacade.GetData <IPagePublishSchedule>()
where ps.PageId == pageId &&
ps.LocaleCultureName == localeName
select ps).SingleOrDefault();
var pageUnpublishSchedule =
(from ps in DataFacade.GetData <IPageUnpublishSchedule>()
where ps.PageId == pageId &&
ps.LocaleCultureName == localeName
select ps).SingleOrDefault();
if (pagePublishSchedule == null && pageUnpublishSchedule == null)
{
return(true);
}
if (pagePublishSchedule != null)
{
DataFacade.Delete(pagePublishSchedule);
}
if (pageUnpublishSchedule != null)
{
DataFacade.Delete(pageUnpublishSchedule);
}
DateTime?publishDate = pagePublishSchedule != null ? pagePublishSchedule.PublishDate : (DateTime?)null;
DateTime?unpublishDate = pageUnpublishSchedule != null ? pageUnpublishSchedule.UnpublishDate : (DateTime?)null;
IPage page = DataFacade.GetData <IPage>(p => p.Id == pageId).FirstOrDefault();
Verify.IsNotNull(page, "The page with the id {0} does not exist", pageId);
WorkflowInstance publishWorkflowInstance = null;
WorkflowInstance unpublishWorkflowInstance = null;
PublishControlledHelper.HandlePublishUnpublishWorkflows(page, localeName, publishDate, unpublishDate,
ref publishWorkflowInstance, ref unpublishWorkflowInstance);
transaction.Complete();
}
}
}
return(true);
}
catch (Exception ex)
{
Log.LogError(LogTitle, ex);
return(false);
}
}
