public ActionResult EditPlacementPost(string id, EditPlacementViewModel viewModel)
{
if (!Services.Authorizer.Authorize(Permissions.EditContentTypes, T("Not allowed to edit a content type.")))
{
return(new HttpUnauthorizedResult());
}
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(id);
if (contentTypeDefinition == null)
{
return(HttpNotFound());
}
contentTypeDefinition.ResetPlacement(PlacementType.Editor);
foreach (var placement in viewModel.AllPlacements)
{
var placementSetting = placement.PlacementSettings;
contentTypeDefinition.Placement(PlacementType.Editor,
placementSetting.ShapeType,
placementSetting.Differentiator,
placementSetting.Zone,
placementSetting.Position);
}
// persist changes
_contentDefinitionManager.StoreTypeDefinition(contentTypeDefinition);
_settingsManagerEventHandlers.Value.Invoke(x => x.Saved(_settings), Logger);
return(RedirectToAction("EditPlacement", new { id }));
}
public void DeleteField(string typeName, string fieldName)
{
var typeDefinition = _contentDefinitionManager.GetTypeDefinition(typeName);
if (typeDefinition == null ||
!typeDefinition.Settings.ContainsKey("Layout"))
{
return;
}
var layout = GetLayoutElement(typeDefinition.Settings["Layout"]);
var field = layout.Descendants("fd-field").FirstOrDefault(x => x.Attribute("field-name").Value == fieldName);
if (field == null)
{
return;
}
var row = field.Parent.Parent;
field.Remove();
if (!row.Descendants("fd-field").Any())
{
row.Remove();
}
typeDefinition.Settings["Layout"] = GetLayoutString(layout);
_contentDefinitionManager.StoreTypeDefinition(typeDefinition);
}
public int Create()
{
foreach (var typeDefinition in _contentDefinitionManager.ListTypeDefinitions())
{
if (typeDefinition.Settings.ContainsKey("ContentTypeSettings.Creatable") && Convert.ToBoolean(typeDefinition.Settings["ContentTypeSettings.Creatable"], CultureInfo.InvariantCulture))
{
typeDefinition.Settings["ContentTypeSettings.Listable"] = "True";
_contentDefinitionManager.StoreTypeDefinition(typeDefinition);
}
}
return(1);
}
public ContentTypeDefinition AddType(string name, string displayName)
{
if (String.IsNullOrWhiteSpace(displayName))
{
throw new ArgumentException(nameof(displayName));
}
if (String.IsNullOrWhiteSpace(name))
{
name = GenerateContentTypeNameFromDisplayName(displayName);
}
else
{
if (!name[0].IsLetter())
{
throw new ArgumentException("Content type name must start with a letter", "name");
}
}
while (_contentDefinitionManager.GetTypeDefinition(name) != null)
{
name = VersionName(name);
}
var contentTypeDefinition = new ContentTypeDefinition(name, displayName);
_contentDefinitionManager.StoreTypeDefinition(contentTypeDefinition);
_contentDefinitionManager.AlterTypeDefinition(name, cfg => cfg.Creatable().Draftable().Listable().Securable());
_eventBus.Notify <IContentDefinitionEventHandler>(x => x.ContentTypeCreated(new ContentTypeCreatedContext {
ContentTypeDefinition = contentTypeDefinition
}));
return(contentTypeDefinition);
}
// POST api/metadata/field
public virtual HttpResponseMessage Post(string id, ICollection <Section> data)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.MethodNotAllowed));
}
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(id);
if (contentTypeDefinition == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
var layout = GetLayout(contentTypeDefinition, data);
if (string.IsNullOrEmpty(layout))
{
return(Request.CreateResponse(HttpStatusCode.ExpectationFailed));
}
if (contentTypeDefinition.Settings.ContainsKey("Layout"))
{
contentTypeDefinition.Settings["Layout"] = layout;
}
else
{
contentTypeDefinition.Settings.Add("Layout", layout);
}
_contentDefinitionManager.StoreTypeDefinition(contentTypeDefinition);
return(Request.CreateResponse(HttpStatusCode.OK));
}
public int UpdateFrom6()
{
SchemaBuilder.AlterTable("DynamicButtonToWorkflowsRecord", table => table
.AddColumn <string>("GlobalIdentifier")
);
var buttonsWithoutGuid = _dynamicButtonToWorkflowsService.GetButtons().Where(w => String.IsNullOrWhiteSpace(w.GlobalIdentifier));
if (buttonsWithoutGuid.Count() > 0)
{
List <DynamicButtonToWorkflowsEdit> buttonList = new List <DynamicButtonToWorkflowsEdit>();
var activities = _activityRepository.Table.Where(w => w.Name.Equals("DynamicButtonEvent"));
var typesWithButtons = _contentDefinitionManager.ListTypeDefinitions().Where(w => w.Parts.Any(p => p.PartDefinition.Name == "DynamicButtonToWorkflowsPart")).ToList();
foreach (var button in buttonsWithoutGuid)
{
// Associo un Guid a tutti i bottoni già esistenti che non ne hanno uno
DynamicButtonToWorkflowsEdit buttonData = new DynamicButtonToWorkflowsEdit();
buttonData.Id = button.Id;
buttonData.ButtonText = button.ButtonText;
buttonData.ButtonAsync = button.ButtonAsync;
buttonData.ButtonDescription = button.ButtonDescription;
buttonData.ButtonMessage = button.ButtonMessage;
buttonData.ButtonName = button.ButtonName;
buttonData.GlobalIdentifier = Guid.NewGuid().ToString();
buttonData.Delete = false;
buttonList.Add(buttonData);
// Correggo i riferimenti ai bottoni nelle parti
string partSettingToEdit = string.Format("{{{0}}}", button.Id);
foreach (var type in typesWithButtons)
{
var part = type.Parts.Where(w => w.PartDefinition.Name == "DynamicButtonToWorkflowsPart").FirstOrDefault();
if (part != null)
{
part.Settings["DynamicButtonsSetting.Buttons"] = part.Settings["DynamicButtonsSetting.Buttons"].Replace(partSettingToEdit, string.Format("{{{0}}}", buttonData.GlobalIdentifier));
_contentDefinitionManager.StoreTypeDefinition(type);
}
}
// Correggo i riferimenti ai bottoni nelle activities dei workflows
string activitySettingToEdit = string.Format("\"DynamicButton\":\"{0}\"", button.Id);
var activitiesWithButton = activities.Where(w => w.State.Contains(activitySettingToEdit));
foreach (var activity in activitiesWithButton)
{
activity.State = activity.State.Replace(activitySettingToEdit, string.Format("\"DynamicButton\":\"{0}\"", buttonData.GlobalIdentifier));
_activityRepository.Update(activity);
}
}
_dynamicButtonToWorkflowsService.UpdateButtons(buttonList);
_activityRepository.Flush();
}
return(7);
}
public static void AlterTypeDefinition(this IContentDefinitionManager manager, string name, Action <ContentTypeDefinitionBuilder> alteration)
{
var typeDefinition = manager.LoadTypeDefinition(name) ?? new ContentTypeDefinition(name, name.CamelFriendly());
var builder = new ContentTypeDefinitionBuilder(typeDefinition);
alteration(builder);
manager.StoreTypeDefinition(builder.Build());
}
public ActionResult EditPlacementPost(string id, EditPlacementViewModel viewModel)
{
if (!Services.Authorizer.Authorize(Permissions.EditContentTypes, T("Not allowed to edit a content type.")))
{
return(new HttpUnauthorizedResult());
}
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(id);
if (contentTypeDefinition == null)
{
return(HttpNotFound());
}
var allPlacements = _placementService.GetEditorPlacement(id).ToList();
var result = new List <PlacementSettings>(contentTypeDefinition.GetPlacement(PlacementType.Editor));
contentTypeDefinition.ResetPlacement(PlacementType.Editor);
foreach (var driverPlacement in viewModel.AllPlacements)
{
// if the placement has changed, persist it
if (!allPlacements.Any(x => x.PlacementSettings.Equals(driverPlacement.PlacementSettings)))
{
result = result.Where(x => !x.IsSameAs(driverPlacement.PlacementSettings)).ToList();
result.Add(driverPlacement.PlacementSettings);
}
}
foreach (var placementSetting in result)
{
contentTypeDefinition.Placement(PlacementType.Editor,
placementSetting.ShapeType,
placementSetting.Differentiator,
placementSetting.Zone,
placementSetting.Position);
}
// persist changes
_contentDefinitionManager.StoreTypeDefinition(contentTypeDefinition);
_settingsManagerEventHandlers.Value.Invoke(x => x.Saved(_settings), Logger);
return(RedirectToAction("EditPlacement", new { id }));
}
public static async Task AlterTypeDefinitionAsync(this IContentDefinitionManager manager, string name, Func <ContentTypeDefinitionBuilder, Task> alterationAsync)
{
var typeDefinition = manager.LoadTypeDefinition(name) ?? new ContentTypeDefinition(name, name.CamelFriendly());
var builder = new ContentTypeDefinitionBuilder(typeDefinition);
await alterationAsync(builder);
manager.StoreTypeDefinition(builder.Build());
}
public int UpdateFrom1()
{
foreach (var typeDefinition in _contentDefinitionManager.ListTypeDefinitions())
{
if (typeDefinition.Settings.ContainsKey("TypeIndexing.Included") && Convert.ToBoolean(typeDefinition.Settings["TypeIndexing.Included"], CultureInfo.InvariantCulture))
{
typeDefinition.Settings.Remove("TypeIndexing.Included");
typeDefinition.Settings["TypeIndexing.Indexes"] = "Search";
_contentDefinitionManager.StoreTypeDefinition(typeDefinition);
}
}
return(2);
}
public int UpdateFrom1()
{
foreach (var typeDefinition in _contentDefinitionManager.ListTypeDefinitions())
{
if (typeDefinition.Settings.ContainsKey("TypeIndexing.Included") && Convert.ToBoolean(typeDefinition.Settings["TypeIndexing.Included"], CultureInfo.InvariantCulture))
{
typeDefinition.Settings.Remove("TypeIndexing.Included");
typeDefinition.Settings["TypeIndexing.Indexes"] = "Search";
_contentDefinitionManager.StoreTypeDefinition(typeDefinition);
}
}
return(4); // Returns 4 instead of 2 due to the modified/deleted migrations in UpdateFrom2-3.
}
public ContentTypeDefinition AddType(string name, string displayName)
{
if (String.IsNullOrWhiteSpace(displayName))
{
throw new ArgumentException(nameof(displayName));
}
if (String.IsNullOrWhiteSpace(name))
{
name = GenerateContentTypeNameFromDisplayName(displayName);
}
else
{
if (!name[0].IsLetter())
{
throw new ArgumentException("Content type name must start with a letter", "name");
}
if (!String.Equals(name, name.ToSafeName(), StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentException("Content type name contains invalid characters", "name");
}
}
while (_contentDefinitionManager.LoadTypeDefinition(name) != null)
{
name = VersionName(name);
}
var contentTypeDefinition = new ContentTypeDefinition(name, displayName);
_contentDefinitionManager.StoreTypeDefinition(contentTypeDefinition);
// Ensure it has its own part
_contentDefinitionManager.AlterTypeDefinition(name, builder => builder.WithPart(name));
_contentDefinitionManager.AlterTypeDefinition(name, cfg => cfg.Creatable().Draftable().Versionable().Listable().Securable().Enabled());
_contentDefinitionEventHandlers.Invoke((handler, context) => handler.ContentTypeCreated(context), new ContentTypeCreatedContext {
ContentTypeDefinition = contentTypeDefinition
}, _logger);
return(contentTypeDefinition);
}
private PlacementSettings[] SetCurrentPlacement(
ContentTypeDefinition contentTypeDefinition, IEnumerable <PlacementSettings> newPlacements)
{
var placementsArray = newPlacements.ToArray();
if (_currentPlacement == null)
{
_currentPlacement = new Dictionary <string, PlacementSettings[]>();
}
if (_currentPlacement.ContainsKey(contentTypeDefinition.Name))
{
_currentPlacement.Remove(contentTypeDefinition.Name);
}
_currentPlacement.Add(contentTypeDefinition.Name, placementsArray);
// write the placement settings as a setting for the type, by serializing them all
var serializer = new JavaScriptSerializer();
if (_typeBuilder.Current.Name == contentTypeDefinition.Name)
{
_typeBuilder.WithSetting("ContentTypeSettings.Placement.ProfileFrontEndEditor",
serializer.Serialize(placementsArray));
}
else
{
contentTypeDefinition.Settings["ContentTypeSettings.Placement.ProfileFrontEndEditor"] =
serializer.Serialize(placementsArray);
// persist changes: The type definition is persisted already after these events are processed
_contentDefinitionManager.StoreTypeDefinition(contentTypeDefinition);
// schedules a re-evaluation of the shell
_settingsManagerEventHandlers.Value.Invoke(x => x.Saved(_shellSettings), Logger);
}
return(placementsArray);
}
private PlacementSettings[] SetCurrentPlacement(
ContentTypeDefinition contentTypeDefinition, IEnumerable <PlacementSettings> newPlacements)
{
// create the dictioanry if it does not exist (i.e. the first time this method
// is ever called in a request)
if (_currentPlacement == null)
{
_currentPlacement = new Dictionary <string, Dictionary <string, Dictionary <string, PlacementSettings> > >();
}
// add a Dictionary for the ContentType we are processing
if (!_currentPlacement.ContainsKey(contentTypeDefinition.Name))
{
_currentPlacement.Add(contentTypeDefinition.Name,
new Dictionary <string, Dictionary <string, PlacementSettings> >());
}
// dictionary of placements for this type
var placementsForType = _currentPlacement[contentTypeDefinition.Name];
// update placements for this type
foreach (var placement in newPlacements)
{
// If we already had some information for this ShapeType
if (placementsForType.ContainsKey(placement.ShapeType))
{
// update setting: we need to further drill things down on the differentiation
// this will generally not matter for parts, but it is required to correctly
// manage ContentFields, that generally share a single ShapeType.
var differentPlacements = placementsForType[placement.ShapeType];
if (differentPlacements.ContainsKey(placement.Differentiator))
{
// update
differentPlacements[placement.Differentiator] = placement;
}
else
{
// add
differentPlacements.Add(placement.Differentiator, placement);
}
}
else
{
// add settings for this ShapeType
placementsForType.Add(placement.ShapeType,
new Dictionary <string, PlacementSettings>());
placementsForType[placement.ShapeType].Add(placement.Differentiator, placement);
}
}
// pull the settings from the dictionary: for each shapeType we have a dictionary
// of settings
var placementsArray = placementsForType // Dictionary<string, Dictionary<string, PlacementSettings>>
.SelectMany(kvp => kvp.Value.Values)
.ToArray();
// write the placement settings as a setting for the type, by serializing them all
var serializer = new JavaScriptSerializer();
if (_typeBuilder.Current.Name == contentTypeDefinition.Name)
{
_typeBuilder.WithSetting("ContentTypeSettings.Placement.ProfileFrontEndEditor",
serializer.Serialize(placementsArray));
}
else
{
contentTypeDefinition.Settings["ContentTypeSettings.Placement.ProfileFrontEndEditor"] =
serializer.Serialize(placementsArray);
// persist changes: The type definition is persisted already after these events are processed
_contentDefinitionManager.StoreTypeDefinition(contentTypeDefinition);
// schedules a re-evaluation of the shell
_settingsManagerEventHandlers.Value.Invoke(x => x.Saved(_shellSettings), Logger);
}
return(placementsArray);
}
