private static void SetReservationStatus(IContentBase apartment, string valueName) { var dts = new DataTypeService(); var statusEditor = dts.GetAllDataTypeDefinitions().First(x => x.Name == "Status Rezerwacji"); var preValueId = dts.GetPreValuesCollectionByDataTypeId(statusEditor.Id).PreValuesAsDictionary.Where(d => d.Value.Value == valueName).Select(f => f.Value.Id).First(); apartment.SetValue("status", preValueId); }
public override void Map(Property property, ContentPropertyDto dest, MapperContext context) { base.Map(property, dest, context); dest.IsRequired = property.PropertyType.Mandatory; dest.ValidationRegExp = property.PropertyType.ValidationRegExp; dest.Description = property.PropertyType.Description; dest.Label = property.PropertyType.Name; dest.DataType = DataTypeService.GetDataType(property.PropertyType.DataTypeId); }
public override ContentPropertyDto Convert(Property property, ContentPropertyDto dest, ResolutionContext context) { var propertyDto = base.Convert(property, dest, context); propertyDto.IsRequired = property.PropertyType.Mandatory; propertyDto.ValidationRegExp = property.PropertyType.ValidationRegExp; propertyDto.Description = property.PropertyType.Description; propertyDto.Label = property.PropertyType.Name; propertyDto.DataType = DataTypeService.GetDataType(property.PropertyType.DataTypeId); return(propertyDto); }
public override void Map(IProperty property, ContentPropertyDto dest, MapperContext context) { base.Map(property, dest, context); dest.IsRequired = property.PropertyType?.Mandatory; dest.IsRequiredMessage = property.PropertyType?.MandatoryMessage; dest.ValidationRegExp = property.PropertyType?.ValidationRegExp; dest.ValidationRegExpMessage = property.PropertyType?.ValidationRegExpMessage; dest.Description = property.PropertyType?.Description; dest.Label = property.PropertyType?.Name; dest.DataType = property.PropertyType is null ? null : DataTypeService.GetDataType(property.PropertyType.DataTypeId); dest.LabelOnTop = property.PropertyType?.LabelOnTop; }
public override void Up() { //Create a new Data Type called "Videolizer" DataTypeService dataTypeService = (DataTypeService)ApplicationContext.Current.Services.DataTypeService; if (dataTypeService.GetDataTypeDefinitionByName("Videolizer") == null) //check to see if it already exists //Create a new one { DataTypeDefinition VideolizerDataTypeDef = new DataTypeDefinition("DigitalMomentum.Videolizer"); VideolizerDataTypeDef.Name = "Videolizer"; dataTypeService.Save(VideolizerDataTypeDef); } }
public override void Map(IProperty originalProp, ContentPropertyDisplay dest, MapperContext context) { base.Map(originalProp, dest, context); var config = originalProp.PropertyType is null ? null : DataTypeService.GetDataType(originalProp.PropertyType.DataTypeId)?.Configuration; // TODO: IDataValueEditor configuration - general issue // GetValueEditor() returns a non-configured IDataValueEditor // - for richtext and nested, configuration determines HideLabel, so we need to configure the value editor // - could configuration also determines ValueType, everywhere? // - does it make any sense to use a IDataValueEditor without configuring it? // configure the editor for display with configuration IDataValueEditor?valEditor = dest.PropertyEditor?.GetValueEditor(config); // set the display properties after mapping dest.Alias = originalProp.Alias; dest.Description = originalProp.PropertyType?.Description; dest.Label = originalProp.PropertyType?.Name; dest.HideLabel = valEditor?.HideLabel ?? false; dest.LabelOnTop = originalProp.PropertyType?.LabelOnTop; // add the validation information dest.Validation.Mandatory = originalProp.PropertyType?.Mandatory ?? false; dest.Validation.MandatoryMessage = originalProp.PropertyType?.MandatoryMessage; dest.Validation.Pattern = originalProp.PropertyType?.ValidationRegExp; dest.Validation.PatternMessage = originalProp.PropertyType?.ValidationRegExpMessage; if (dest.PropertyEditor == null) { // display.Config = PreValueCollection.AsDictionary(preVals); // if there is no property editor it means that it is a legacy data type // we cannot support editing with that so we'll just render the readonly value view. dest.View = "views/propertyeditors/readonlyvalue/readonlyvalue.html"; } else { // let the property editor format the pre-values dest.Config = dest.PropertyEditor.GetConfigurationEditor().ToValueEditor(config); dest.View = valEditor?.View; } // Translate dest.Label = _textService.UmbracoDictionaryTranslate(_cultureDictionary, dest.Label); dest.Description = _textService.UmbracoDictionaryTranslate(_cultureDictionary, dest.Description); }
public override ContentPropertyDisplay Convert(Property originalProp, ContentPropertyDisplay dest, ResolutionContext context) { var display = base.Convert(originalProp, dest, context); var config = DataTypeService.GetDataType(originalProp.PropertyType.DataTypeId).Configuration; // fixme - IDataValueEditor configuration - general issue // GetValueEditor() returns a non-configured IDataValueEditor // - for richtext and nested, configuration determines HideLabel, so we need to configure the value editor // - could configuration also determines ValueType, everywhere? // - does it make any sense to use a IDataValueEditor without configuring it? // configure the editor for display with configuration var valEditor = display.PropertyEditor.GetValueEditor(config); //set the display properties after mapping display.Alias = originalProp.Alias; display.Description = originalProp.PropertyType.Description; display.Label = originalProp.PropertyType.Name; display.HideLabel = valEditor.HideLabel; //add the validation information display.Validation.Mandatory = originalProp.PropertyType.Mandatory; display.Validation.Pattern = originalProp.PropertyType.ValidationRegExp; if (display.PropertyEditor == null) { //display.Config = PreValueCollection.AsDictionary(preVals); //if there is no property editor it means that it is a legacy data type // we cannot support editing with that so we'll just render the readonly value view. display.View = "views/propertyeditors/readonlyvalue/readonlyvalue.html"; } else { //let the property editor format the pre-values display.Config = display.PropertyEditor.GetConfigurationEditor().ToValueEditor(config); display.View = valEditor.View; } //Translate display.Label = _textService.UmbracoDictionaryTranslate(display.Label); display.Description = _textService.UmbracoDictionaryTranslate(display.Description); return(display); }
public void Run() { Initialise("TypeSet3"); var dataTypes = DataTypeService.GetAllDataTypeDefinitions(); var expectedDataTypes = GetDataTypes(); AssertDataTypes(dataTypes, expectedDataTypes); var docTypes = ContentTypeService.GetAllContentTypes(); var expectedDocTypes = GetDocTypes(); AssertContentTypes(docTypes, expectedDocTypes); var mediaTypes = ContentTypeService.GetAllMediaTypes(); var expectedMediaTypes = GetMediaTypes(); AssertContentTypes(mediaTypes, expectedMediaTypes); }
public ActionResult submit(BookingInfo lunch) { //Check to see if the submission is valid if (!ModelState.IsValid) { return(CurrentUmbracoPage()); } //get the datatype for the Lunch Choices so we can work with it IDataTypeDefinition datatype = Services.DataTypeService.GetDataTypeDefinitionByName("Lunch Choices"); DataTypeService dts = (DataTypeService)Services.DataTypeService; //Get the parent ID of content you want to attach the submission to var categoryContentType = Services.ContentTypeService.GetContentType("Lunchformpage"); var parent = Services.ContentService.GetContentOfContentType(categoryContentType.Id).FirstOrDefault(x => x.Name == "Lunch Chooser"); //Create a new content item under a given parent var contentService = Services.ContentService; var LunchContent = contentService.CreateContent( lunch.FirstName + " " + lunch.LastName + DateTime.Now, //Name of the new Lunch Submission content parent.Id, //Content Parent ID, where these submissions will live under "Lunchchoicedata", // the alias of the Document Type we are adding 0); //the user adding the record, 0 is the admin //Get the preValue of selected lunch choice //The dropdown on our form only contained the text and not the true value (prevalue), //we need to find the prevalue id and enter the prevalue id into Umbraco var statusEditor = dts.GetAllDataTypeDefinitions().First(x => x.Name == "Lunch Choices"); int preValueId = dts.GetPreValuesCollectionByDataTypeId(statusEditor.Id).PreValuesAsDictionary.Where(d => d.Value.Value == lunch.LunchChoice).Select(f => f.Value.Id).First(); //Set the values of each property so that we can add the new item to Umbraco LunchContent.SetValue("firstName", lunch.FirstName); LunchContent.SetValue("lastName", lunch.LastName); LunchContent.SetValue("lunchChoice", preValueId); // publish and save the new content contentService.SaveAndPublishWithStatus(LunchContent); //Return to the same page return(CurrentUmbracoPage()); }
public void CreateStub() { string fieldValue = "test field value"; string name = "Target"; string contentTypeAlias = "TestType"; string contentTypeName = "Test Type"; var unitOfWork = Global.CreateUnitOfWork(); var repoFactory = new RepositoryFactory(); _contentService = new ContentService(unitOfWork, repoFactory); var contentTypeService = new ContentTypeService(unitOfWork, repoFactory, new ContentService(unitOfWork), new MediaService(unitOfWork, repoFactory)); var dataTypeService = new DataTypeService(unitOfWork, repoFactory); var contentType = new ContentType(-1); contentType.Name = contentTypeName; contentType.Alias = contentTypeAlias; contentType.Thumbnail = string.Empty; contentTypeService.Save(contentType); Assert.Greater(contentType.Id, 0); var definitions = dataTypeService.GetDataTypeDefinitionByControlId(new Guid("ec15c1e5-9d90-422a-aa52-4f7622c63bea")); dataTypeService.Save(definitions.FirstOrDefault()); var propertyType = new PropertyType(definitions.FirstOrDefault()); propertyType.Alias = "Property"; contentType.AddPropertyType(propertyType); contentTypeService.Save(contentType); Assert.Greater(contentType.Id, 0); var content = new Content(name, -1, contentType); content.Key = new Guid("{D2517065-2818-4AF7-B851-493E46EA79D5}"); content.SetPropertyValue("Property", fieldValue); _contentService.Save(content); }
public void CreateStub() { bool fieldValue = false; string name = "Target"; string contentTypeAlias = "TestType"; string contentTypeName = "Test Type"; var unitOfWork = Global.CreateUnitOfWork(); var repoFactory = new RepositoryFactory(); _contentService = new ContentService(unitOfWork, repoFactory); var contentTypeService = new ContentTypeService(unitOfWork, repoFactory, new ContentService(unitOfWork), new MediaService(unitOfWork, repoFactory)); var dataTypeService = new DataTypeService(unitOfWork, repoFactory); var contentType = new ContentType(-1); contentType.Name = contentTypeName; contentType.Alias = contentTypeAlias; contentType.Thumbnail = string.Empty; contentTypeService.Save(contentType); Assert.Greater(contentType.Id, 0); var definitions = dataTypeService.GetDataTypeDefinitionByControlId(new Guid("38b352c1-e9f8-4fd8-9324-9a2eab06d97a")); dataTypeService.Save(definitions.FirstOrDefault()); var propertyType = new PropertyType(definitions.FirstOrDefault()); propertyType.Alias = ContentTypeProperty; contentType.AddPropertyType(propertyType); contentTypeService.Save(contentType); Assert.Greater(contentType.Id, 0); var content = new Content(name, -1, contentType); content.Key = new Guid("{5928EFBB-6DF2-4BB6-A026-BF4938D7ED7A}"); content.SetPropertyValue(ContentTypeProperty, fieldValue); _contentService.Save(content); }
public override void Up() { //Create a new Data Type called "Videolizer" //Thanks to Sebastiaan Janssen for the code to detect UaaS / Umbraco Cloud - https://our.umbraco.com/forum/umbraco-7/developing-umbraco-7-packages/72572-detecting-if-you-are-running-on-umbraco-as-a-service var onUaaS = AppDomain.CurrentDomain.GetAssemblies() .Any(a => a.FullName.StartsWith("Umbraco.Deploy")); if (!onUaaS) { DataTypeService dataTypeService = (DataTypeService)ApplicationContext.Current.Services.DataTypeService; if (dataTypeService.GetDataTypeDefinitionByName("Videolizer") == null) { //check to see if it already exists //Create a new one DataTypeDefinition VideolizerDataTypeDef = new DataTypeDefinition("DigitalMomentum.Videolizer"); VideolizerDataTypeDef.Name = "Videolizer"; dataTypeService.Save(VideolizerDataTypeDef); } } }
public void CreateStub() { string name = "Target"; string contentTypeAlias = "TestType"; string contentTypeName = "Test Type"; var unitOfWork = Global.CreateUnitOfWork(); var repoFactory = new RepositoryFactory(); _contentService = new ContentService(unitOfWork, repoFactory); var contentTypeService = new ContentTypeService(unitOfWork, repoFactory, new ContentService(unitOfWork), new MediaService(unitOfWork, repoFactory)); var dataTypeService = new DataTypeService(unitOfWork, repoFactory); var contentType = new ContentType(-1); contentType.Name = contentTypeName; contentType.Alias = contentTypeAlias; contentType.Thumbnail = string.Empty; contentTypeService.Save(contentType); Assert.Greater(contentType.Id, 0); var definitions = dataTypeService.GetDataTypeDefinitionByControlId(new Guid("ec15c1e5-9d90-422a-aa52-4f7622c63bea")); dataTypeService.Save(definitions.FirstOrDefault()); var propertyType = new PropertyType(definitions.FirstOrDefault()); propertyType.Alias = "Property"; contentType.AddPropertyType(propertyType); contentTypeService.Save(contentType); Assert.Greater(contentType.Id, 0); var content = new Content(name, -1, contentType); content.Key = new Guid("{2867D837-B258-4DF1-90F1-D5E849FCAF84}"); _contentService.Save(content); }
public override void OnActionExecuting(HttpActionContext actionContext) { var dataType = (DataTypeSave)actionContext.ActionArguments["dataType"]; dataType.Name = dataType.Name.CleanForXss('[', ']', '(', ')', ':'); dataType.Alias = dataType.Alias == null ? dataType.Name : dataType.Alias.CleanForXss('[', ']', '(', ')', ':'); // get the property editor, ensuring that it exits if (!PropertyEditors.TryGet(dataType.EditorAlias, out var propertyEditor)) { var message = $"Property editor \"{dataType.EditorAlias}\" was not found."; actionContext.Response = actionContext.Request.CreateErrorResponse(HttpStatusCode.NotFound, message); return; } // assign dataType.PropertyEditor = propertyEditor; // validate that the data type exists, or create one if required IDataType persisted; switch (dataType.Action) { case ContentSaveAction.Save: persisted = DataTypeService.GetDataType(Convert.ToInt32(dataType.Id)); if (persisted == null) { var message = $"Data type with id {dataType.Id} was not found."; actionContext.Response = actionContext.Request.CreateErrorResponse(HttpStatusCode.NotFound, message); return; } // map the model to the persisted instance Current.Mapper.Map(dataType, persisted); break; case ContentSaveAction.SaveNew: // create the persisted model from mapping the saved model persisted = Current.Mapper.Map <IDataType>(dataType); ((DataType)persisted).ResetIdentity(); break; default: actionContext.Response = actionContext.Request.CreateErrorResponse(HttpStatusCode.NotFound, new ArgumentOutOfRangeException()); return; } // assign (so it's available in the action) dataType.PersistedDataType = persisted; // validate the configuration // which is posted as a set of fields with key (string) and value (object) var configurationEditor = propertyEditor.GetConfigurationEditor(); foreach (var field in dataType.ConfigurationFields) { var editorField = configurationEditor.Fields.SingleOrDefault(x => x.Key == field.Key); if (editorField == null) { continue; } // run each IValueValidator (with null valueType and dataTypeConfiguration: not relevant here) foreach (var validator in editorField.Validators) { foreach (var result in validator.Validate(field.Value, null, null)) { actionContext.ModelState.AddValidationError(result, "Properties", field.Key); } } } if (actionContext.ModelState.IsValid == false) { // if it is not valid, do not continue and return the model state actionContext.Response = actionContext.Request.CreateValidationErrorResponse(actionContext.ModelState); } }
public void General_RetrieveContentAndPropertiesFromUmbraco_ReturnPopulatedClass() { //Assign string fieldValue = "test field value"; string name = "Target"; string contentTypeAlias = "TestType"; string contentTypeName = "Test Type"; string contentTypeProperty = "TestProperty"; var unitOfWork = Global.CreateUnitOfWork(); var repoFactory = new RepositoryFactory(); var contentService = new ContentService(unitOfWork, repoFactory); var contentTypeService = new ContentTypeService(unitOfWork, repoFactory, new ContentService(unitOfWork), new MediaService(unitOfWork, repoFactory)); var dataTypeService = new DataTypeService(unitOfWork, repoFactory); var context = WindsorContainer.GetContext(); var loader = new UmbracoFluentConfigurationLoader(); var stubConfig = loader.Add <Stub>(); stubConfig.Configure(x => { x.Id(y => y.Id); x.Id(y => y.Key); x.Property(y => y.TestProperty); x.Info(y => y.Name).InfoType(UmbracoInfoType.Name); x.Info(y => y.ContentTypeName).InfoType(UmbracoInfoType.ContentTypeName); x.Info(y => y.ContentTypeAlias).InfoType(UmbracoInfoType.ContentTypeAlias); x.Info(y => y.Path).InfoType(UmbracoInfoType.Path); x.Info(y => y.Version).InfoType(UmbracoInfoType.Version); x.Info(y => y.CreateDate).InfoType(UmbracoInfoType.CreateDate); x.Info(y => y.UpdateDate).InfoType(UmbracoInfoType.UpdateDate); x.Info(y => y.Creator).InfoType(UmbracoInfoType.Creator); x.Delegate(y => y.Delegated).GetValue(GetDelegatedValue); }); context.Load(loader); IContentType contentType = new ContentType(-1); contentType.Name = contentTypeName; contentType.Alias = contentTypeAlias; contentType.Thumbnail = string.Empty; contentTypeService.Save(contentType); Assert.Greater(contentType.Id, 0); var definitions = dataTypeService.GetDataTypeDefinitionByControlId(new Guid("ec15c1e5-9d90-422a-aa52-4f7622c63bea")); dataTypeService.Save(definitions.FirstOrDefault()); var propertyType = new PropertyType(definitions.FirstOrDefault()); propertyType.Alias = contentTypeProperty; contentType.AddPropertyType(propertyType); contentTypeService.Save(contentType); Assert.Greater(contentType.Id, 0); var content = new Content(name, -1, contentType); content.SetPropertyValue(contentTypeProperty, fieldValue); contentService.Save(content); var umbracoService = new UmbracoService(contentService, context); //Act var result = umbracoService.GetItem <Stub>(content.Id); //Assert Assert.IsNotNull(result); Assert.AreEqual(fieldValue, result.TestProperty); Assert.AreEqual(content.Id, result.Id); Assert.AreEqual(content.Key, result.Key); Assert.AreEqual(name, result.Name); Assert.AreEqual(contentTypeName, result.ContentTypeName); Assert.AreEqual(content.ParentId + "," + content.Id, result.Path); Assert.AreEqual(contentTypeAlias, result.ContentTypeAlias); Assert.AreEqual(content.Version, result.Version); Assert.AreEqual(content.CreateDate, result.CreateDate); Assert.AreEqual(content.UpdateDate, result.UpdateDate); Assert.AreEqual("admin", result.Creator); Assert.AreEqual("happy", result.Delegated); }
public void Process(IEnumerable <DocumentTypeMetadata> types) { var contentTypes = new List <IContentType>(); var dataTypeDefinitions = DataTypeService.GetAllDataTypeDefinitions().ToArray(); foreach (var type in types) { var ct = ContentTypeService.GetContentType(type.Alias) ?? new ContentType(-1); ct.Name = type.Name; ct.Alias = type.Alias; ct.AllowedAsRoot = type.AllowAsRoot; ct.Description = type.Description; ct.Icon = type.Icon; ct.Thumbnail = type.Thumbnail; var properties = ct.PropertyTypes.ToArray(); var newProperties = type.Properties.Where(p => !properties.Any(x => x.Alias == p.Alias)); foreach (var property in newProperties) { var p = new PropertyType(dataTypeDefinitions.First(dtd => dtd.Name == property.DataType)) { Name = property.Name, Alias = property.Alias, Description = property.Description }; if (property.Tab == null) { ct.AddPropertyType(p); } else { ct.AddPropertyType(p, property.Tab.ToString()); } } var modifiedProperties = type.Properties.Join(properties, p => p.Alias, p => p.Alias, (meta, p) => new { Metadata = meta, PropertyType = p }); foreach (var property in modifiedProperties) { var p = property.PropertyType; var meta = property.Metadata; p.Name = meta.Name; p.DataTypeDefinitionId = dataTypeDefinitions.First(dtd => dtd.Name == meta.DataType).Id; p.Description = meta.Description; //the following hack is brought to you be the letter F var fn = p.GetType().GetProperty("PropertyGroupId", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(p) as System.Lazy <int>; if (fn != null) { var tabId = fn.Value; var tab = ct.PropertyGroups.FirstOrDefault(t => t.Id == tabId); var newTabName = meta.Tab.ToString(); var newTab = ct.PropertyGroups.FirstOrDefault(t => t.Name == newTabName); if (tab != null && tab.Name != newTabName) { if (newTab == null) { ct.AddPropertyGroup(newTabName); } ct.MovePropertyType(p.Alias, newTabName); } } } contentTypes.Add(ct); } ContentTypeService.Save(contentTypes); var preprocessedData = contentTypes .Join(types, x => x.Alias, x => x.Alias, (ct, m) => new { ct, m }) .ToDictionary(x => x.ct, x => x.m); SetupAllowedChildren(preprocessedData); SetupTemplates(preprocessedData); ContentTypeService.Save(contentTypes); }
public static void AddSocialMediaChannelMediaType() { MediaType mediaType = new MediaType(-1); mediaType.AllowedAsRoot = true; mediaType.Name = SOCIAL_MEDIA_THEME_NAME; mediaType.Description = "Container for the Social Media Channel Theme Images"; mediaType.IsContainer = true; mediaType.Icon = "icon-picture"; mediaType.Alias = SOCIAL_MEDIA_THEME_ALIAS; //Allowed child nodes var children = new List <ContentTypeSort> { new ContentTypeSort(FOLDER_ID, 0), new ContentTypeSort(IMAGE_ID, 1) }; mediaType.AllowedContentTypes = children; //Add properties DataTypeService dataTypeService = (DataTypeService)ApplicationContext.Current.Services.DataTypeService; var name = new PropertyType(dataTypeService.GetDataTypeDefinitionById(TEXT_ID), "themeName"); name.Name = "Theme Name"; name.Description = "Name for the theme"; name.SortOrder = 0; var url = new PropertyType(dataTypeService.GetDataTypeDefinitionById(TEXT_ID), "themeUrl"); url.Name = "Theme Url"; url.Description = "Url for the original theme"; url.SortOrder = 1; var createdBy = new PropertyType(dataTypeService.GetDataTypeDefinitionById(TEXT_ID), "createdBy"); createdBy.Name = "Created By"; createdBy.Description = "Theme Author"; createdBy.SortOrder = 2; var createdDate = new PropertyType(dataTypeService.GetDataTypeDefinitionById(DATE_ID), "createdDate"); createdDate.Name = "Created Date"; createdDate.Description = "Date the Theme was created"; createdDate.SortOrder = 3; var upload = new PropertyType(dataTypeService.GetDataTypeDefinitionById(UPLOAD_ID), "umbracoFile"); upload.Name = "Upload Image"; upload.Description = "Theme Thumbnail"; upload.SortOrder = 4; var width = new PropertyType(dataTypeService.GetDataTypeDefinitionById(LABEL_ID), "umbracoWidth"); width.Name = "Image Width"; width.SortOrder = 5; var height = new PropertyType(dataTypeService.GetDataTypeDefinitionById(LABEL_ID), "umbracoHeight"); height.Name = "Image Height"; height.SortOrder = 5; var size = new PropertyType(dataTypeService.GetDataTypeDefinitionById(LABEL_ID), "umbracoBytes"); size.Name = "Image Size"; size.SortOrder = 5; var extension = new PropertyType(dataTypeService.GetDataTypeDefinitionById(LABEL_ID), "umbracoExtension"); extension.Name = "Image Extension"; extension.SortOrder = 5; mediaType.AddPropertyType(name, "Theme"); mediaType.AddPropertyType(url, "Theme"); mediaType.AddPropertyType(createdBy, "Theme"); mediaType.AddPropertyType(createdDate, "Theme"); mediaType.AddPropertyType(upload, "Theme"); mediaType.AddPropertyType(width, "Theme"); mediaType.AddPropertyType(height, "Theme"); mediaType.AddPropertyType(size, "Theme"); mediaType.AddPropertyType(extension, "Theme"); //Save new media type ContentTypeService contentTypeService = (ContentTypeService)ApplicationContext.Current.Services.ContentTypeService; contentTypeService.Save(mediaType); }