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); }