public void Equals_Claus_With_Two_Entity_Values()
{
var dataType = new DataTypeDefinition(-1, "Test")
{
Id = 12345
};
Expression <Func <PropertyType, bool> > predicate = p => p.DataTypeDefinitionId == dataType.Id;
var modelToSqlExpressionHelper = new ModelToSqlExpressionVisitor <PropertyType>();
var result = modelToSqlExpressionHelper.Visit(predicate);
Debug.Print("Model to Sql ExpressionHelper: \n" + result);
Assert.AreEqual("([cmsPropertyType].[dataTypeId] = @0)", result);
Assert.AreEqual(12345, modelToSqlExpressionHelper.GetSqlParameters()[0]);
}
public void TestIsParserForValidDataType()
{
// arrange
var dataTypeDefinition = new DataTypeDefinition(global::Umbraco.Core.Constants.PropertyEditors.GridAlias);
var gridConfigMock = new Mock <IGridConfig>();
var parser = new GridParser(gridConfigMock.Object);
// act
var result = parser.IsParserFor(dataTypeDefinition);
// verify
Assert.IsTrue(result);
}
public void TestIsParserForInValidDataType()
{
// arrange
var dataTypeDefinition = new DataTypeDefinition("foo");
var gridConfigMock = new Mock <IGridConfig>();
var parser = new GridParser(gridConfigMock.Object);
// act
var result = parser.IsParserFor(dataTypeDefinition);
// verify
Assert.IsFalse(result);
}
private ProductDefinitionField CreateProductDefinitionField(string name, DataTypeDefinition definition)
{
var productDefinitionField = new ProductDefinitionField()
{
DataType = _dataTypeRepository.Select().FirstOrDefault(x => x.DefinitionName == definition.Name),
Name = name,
RenderInEditor = true,
};
var descriptions = CreateDefinitionFieldsDescriptions(name);
descriptions.ForEach(productDefinitionField.AddProductDefinitionFieldDescription);
return(productDefinitionField);
}
private int?CreateDocumentType(Item item, int parentId, int userId = 0)
{
ContentType contentType = new ContentType(parentId);
contentType.Name = item.Name;
contentType.Alias = item.Alias;
contentType.Icon = "icon-message";
var textstringDef = new DataTypeDefinition(-1, "Umbraco.Textbox");
var richtextEditorDef = new DataTypeDefinition(-1, "Umbraco.TinyMCEv3");
var textboxMultipleDef = new DataTypeDefinition(-1, "Umbraco.TextboxMultiple");
if (item.Tabs != null && item.Tabs.Any())
{
foreach (var tab in item.Tabs)
{
if (!string.IsNullOrEmpty(tab.Name))
{
contentType.AddPropertyGroup(tab.Name);
foreach (var property in tab.Properties)
{
contentType.AddPropertyType(
new PropertyType(textstringDef)
{
Alias = property.Alias,
Name = property.Name,
Description = "",
Mandatory = property.Mandatory,
SortOrder = 1
},
tab.Name);
}
}
}
}
_contentTypeService.Save(contentType);
if (contentType != null)
{
return(contentType.Id);
}
else
{
return(parentId);
}
}
public void PropertyType_Make_New()
{
var allDataTypes = DataTypeDefinition.GetAll().ToList(); //get all definitions
var contentTypes = DocumentType.GetAllAsList();
var name = "TEST" + Guid.NewGuid().ToString("N");
var pt = PropertyType.MakeNew(allDataTypes.First(), contentTypes.First(), name, name);
Assert.IsTrue(pt.Id > 0);
Assert.IsInstanceOfType(pt, typeof(PropertyType));
pt.delete();
//make sure it's gone
Assert.IsFalse(PropertyType.GetAll().Select(x => x.Id).Contains(pt.Id));
}
public static void CreateTrueFalseDataType(string name)
{
var dataTypeService = ApplicationContext.Current.Services.DataTypeService;
var dataType = dataTypeService.GetDataTypeDefinitionByName(name);
if (dataType == null)
{
dataType = new DataTypeDefinition("Umbraco.TrueFalse")
{
Name = name
};
dataTypeService.Save(dataType);
}
}
private void CreateLinksPickerDataType()
{
var dataTypeService = ApplicationContext.Current.Services.DataTypeService;
var folderTypeDataType = dataTypeService.GetDataTypeDefinitionByName(DataTypeNames.LinksPicker);
if (folderTypeDataType == null)
{
folderTypeDataType = new DataTypeDefinition(-1, DataTypePropertyEditors.LinksPicker)
{
Name = DataTypeNames.LinksPicker
};
dataTypeService.Save(folderTypeDataType);
}
}
private DataTypeItem BuildDataTypeItem(DataTypeDefinition dataTypeDefinition)
{
var dataTypeItem = new DataTypeItem();
dataTypeItem.Id = dataTypeDefinition.DataType.DataTypeDefinitionId;
dataTypeItem.ControlTypeName = dataTypeDefinition.DataType.GetType().FullName;
var node = new CMSNode(dataTypeItem.Id);
dataTypeItem.DataTypeName = node.Text;
dataTypeItem.PreValueItems = this.BuildPreValues(dataTypeDefinition);
dataTypeItem.Type = this.DetermineType(dataTypeItem);
dataTypeItem.ModelType = DetermineModelType(dataTypeItem);
return(dataTypeItem);
}
/// <summary>
/// Adding a PropertyType to the ContentType, will add a new datafield/Property on all Documents of this Type.
/// </summary>
/// <param Name="dt">The DataTypeDefinition of the PropertyType</param>
/// <param Name="Alias">The Alias of the PropertyType</param>
/// <param Name="Name">The userfriendly Name</param>
public void AddPropertyType(DataTypeDefinition dt, string Alias, string Name)
{
PropertyType pt = PropertyType.MakeNew(dt, this, Name, Alias);
// Optimized call
Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQuery(GlobalSettings.DbDSN, CommandType.Text,
"insert into cmsPropertyData (contentNodeId, versionId, propertyTypeId) select contentId, versionId, @propertyTypeId from cmsContent inner join cmsContentVersion on cmsContent.nodeId = cmsContentVersion.contentId where contentType = @contentTypeId",
new SqlParameter("@propertyTypeId", pt.Id),
new SqlParameter("@contentTypeId", Id));
// foreach (Content c in Content.getContentOfContentType(this))
// c.addProperty(pt,c.Version);
// Remove from cache
FlushFromCache(Id);
}
protected void Page_Load(object sender, EventArgs e)
{
//get the settings for item usage datatype from datatype settings in developer section
var dataTypeDefinitions = DataTypeDefinition.GetAll().Where(dataTypeDef => dataTypeDef.Text == "Item Usage Datatype");
if (!dataTypeDefinitions.Any())
{
usageControl.Visible = false;
litMessage.Text = "There is no page usage data available - create a datatype called \"Item Usage Datatype\" and configure it to activate.";
}
else
{
var s = GetDataTypeSettingsForItemDataUsage(dataTypeDefinitions);
PassSettingsToItemUsageUserControl(s);
}
}
public void Can_Get_Pre_Value_Collection_With_Cache()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
var cache = new CacheHelper(new ObjectCacheRuntimeCacheProvider(), new StaticCacheProvider(), new StaticCacheProvider());
Func <DataTypeDefinitionRepository> creator = () => new DataTypeDefinitionRepository(
unitOfWork, CacheHelper.CreateDisabledCacheHelper(),
cache,
Mock.Of <ILogger>(), SqlSyntax,
new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax,
new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax, Mock.Of <IFileSystem>(), Mock.Of <IFileSystem>(), Mock.Of <ITemplatesSection>())));
DataTypeDefinition dtd;
using (var repository = creator())
{
dtd = new DataTypeDefinition(-1, new Guid(Constants.PropertyEditors.RadioButtonList))
{
Name = "test"
};
repository.AddOrUpdate(dtd);
unitOfWork.Commit();
}
DatabaseContext.Database.Insert(new DataTypePreValueDto()
{
DataTypeNodeId = dtd.Id, SortOrder = 0, Value = "test1"
});
DatabaseContext.Database.Insert(new DataTypePreValueDto()
{
DataTypeNodeId = dtd.Id, SortOrder = 1, Value = "test2"
});
//this will cache the result
using (var repository = creator())
{
var collection = repository.GetPreValuesCollectionByDataTypeId(dtd.Id);
}
var cached = cache.RuntimeCache.GetCacheItemsByKeySearch <PreValueCollection>(CacheKeys.DataTypePreValuesCacheKey + dtd.Id + "-");
Assert.IsNotNull(cached);
Assert.AreEqual(1, cached.Count());
Assert.AreEqual(2, cached.Single().FormatAsDictionary().Count);
}
private void OverrideYouTrack()
{
var migrationName = MethodBase.GetCurrentMethod().Name;
try
{
var path = HostingEnvironment.MapPath(MigrationMarkersPath + migrationName + ".txt");
if (File.Exists(path))
{
return;
}
var contentTypeService = UmbracoContext.Current.Application.Services.ContentTypeService;
var releaseContentType = contentTypeService.GetContentType("Release");
var propertyTypeAlias = "overrideYouTrackDescription";
if (releaseContentType.PropertyTypeExists(propertyTypeAlias) == false)
{
var checkbox = new DataTypeDefinition("Umbraco.TrueFalse");
var checkboxPropertyType = new PropertyType(checkbox, propertyTypeAlias)
{
Name = "Override YouTrack Description?"
};
releaseContentType.AddPropertyType(checkboxPropertyType, "Content");
contentTypeService.Save(releaseContentType);
}
propertyTypeAlias = "overrideYouTrackReleaseDate";
if (releaseContentType.PropertyTypeExists(propertyTypeAlias) == false)
{
var textbox = new DataTypeDefinition("Umbraco.Textbox");
var textboxPropertyType = new PropertyType(textbox, propertyTypeAlias)
{
Name = "Override YouTrack release date"
};
releaseContentType.AddPropertyType(textboxPropertyType, "Content");
contentTypeService.Save(releaseContentType);
}
string[] lines = { "" };
File.WriteAllLines(path, lines);
}
catch (Exception ex)
{
LogHelper.Error <MigrationsHandler>(string.Format("Migration: '{0}' failed", migrationName), ex);
}
}
private List <string> GetFields(Guid dataTypeId)
{
var fields = new List <string>();
IEnumerable <DataTypeDefinition> dataTypeDefinitions = DataTypeDefinition.GetAll().Where(d => d.DataType != null && d.DataType.Id == dataTypeId);
foreach (var dtd in dataTypeDefinitions)
{
fields.AddRange(from pt in PropertyType.GetByDataTypeDefinition(dtd.Id) select pt.Alias);
}
if (dataTypeId == new Guid("5e9b75ae-face-41c8-b47e-5f4b0fd82f83"))
{
fields = fields.Select(field => "rteLink" + field).ToList();
}
return(fields.Distinct().ToList());
}
public void DataTypeService_Can_Persist_New_DataTypeDefinition()
{
// Arrange
var dataTypeService = ServiceContext.DataTypeService;
// Act
var dataTypeDefinition = new DataTypeDefinition(-1, "Test.TestEditor")
{
Name = "Testing Textfield", DatabaseType = DataTypeDatabaseType.Ntext
};
dataTypeService.Save(dataTypeDefinition);
// Assert
Assert.That(dataTypeDefinition, Is.Not.Null);
Assert.That(dataTypeDefinition.HasIdentity, Is.True);
}
public IDataTypeDefinition Create(string name, string propertyEditorAlias, int parentId,
DataTypeDatabaseType databaseType, IDictionary <string, string> preValues)
{
if (Exists(name))
{
return(null);
}
var dataType = new DataTypeDefinition(propertyEditorAlias)
{
Name = name,
DatabaseType = databaseType,
};
if (parentId > 0)
{
dataType.ParentId = parentId;
}
_dataTypeService.Save(dataType);
var itemPreValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(dataType.Id)
.FormatAsDictionary();
foreach (var preValue in preValues)
{
LogHelper.Info <DataTypeBuilder>("PreValue: {0} [{1}]", () => preValue.Key, () => preValue.Value);
if (itemPreValues.ContainsKey(preValue.Key))
{
LogHelper.Info <DataTypeBuilder>("Update");
itemPreValues[preValue.Key].Value = preValue.Value;
}
else
{
LogHelper.Info <DataTypeBuilder>("Add");
itemPreValues.Add(preValue.Key, new PreValue(preValue.Value));
}
}
_dataTypeService.SavePreValues(dataType, itemPreValues);
_dataTypeService.Save(dataType);
return(dataType);
}
public void DataTypeService_Can_Persist_New_DataTypeDefinition()
{
// Arrange
var dataTypeService = ServiceContext.DataTypeService;
var textfieldId = new Guid("ec15c1e5-9d90-422a-aa52-4f7622c63bea");
// Act
var dataTypeDefinition = new DataTypeDefinition(-1, textfieldId)
{
Name = "Testing Textfield", DatabaseType = DataTypeDatabaseType.Ntext
};
dataTypeService.Save(dataTypeDefinition);
// Assert
Assert.That(dataTypeDefinition, Is.Not.Null);
Assert.That(dataTypeDefinition.HasIdentity, Is.True);
}
public DataType Create(string name, string propertyEditor, DataTypeDatabaseType databaseType = DataTypeDatabaseType.Ntext)
{
var allDataTypeDefinitions = UmbracoUtils.DataTypeService.GetAllDataTypeDefinitions();
if (allDataTypeDefinitions.Any(x => x.Name == name))
{
throw new FluentException(string.Format("Cannot create Data Type Definition `{0}` as it already exists.", name));
}
var newDataTypeDefinition = new DataTypeDefinition(-1, propertyEditor)
{
Name = name, DatabaseType = databaseType
};
UmbracoUtils.DataTypeService.Save(newDataTypeDefinition);
return(new DataType(newDataTypeDefinition, UmbracoUtils.UmbracoDatabase, UmbracoUtils.DataTypeService));
}
private void CreatePagePromotionDataType()
{
var dataTypeService = ApplicationContext.Current.Services.DataTypeService;
var dataType = dataTypeService.GetDataTypeDefinitionByName(PagePromotionInstallationConstants.DataTypeNames.PagePromotion);
if (dataType != null)
{
return;
}
dataType = new DataTypeDefinition(-1, "custom.PagePromotion")
{
Name = PagePromotionInstallationConstants.DataTypeNames.PagePromotion
};
dataTypeService.Save(dataType);
}
/// <summary>
/// Gets the insert data types.
/// </summary>
/// <returns>
/// </returns>
private List <StoredValue> GetInsertDataTypes()
{
var list = new List <StoredValue>();
foreach (var config in this.ColumnConfigurations)
{
var dtd = DataTypeDefinition.GetDataTypeDefinition(config.DataTypeId);
var dt = dtd.DataType;
var s = new StoredValue {
Name = config.Name, Alias = config.Alias, Value = dt
};
list.Add(s);
}
return(list);
}
private void CreateMemberChangesWatcherDataType()
{
var dataTypeService = ApplicationContext.Current.Services.DataTypeService;
var dataType = dataTypeService.GetDataTypeDefinitionByName(DataTypeNames.MemberChangesWatcher);
if (dataType != null)
{
return;
}
dataType = new DataTypeDefinition(DataTypePropertyEditors.MemberChangesWatcher)
{
Name = DataTypeNames.MemberChangesWatcher,
DatabaseType = DataTypeDatabaseType.Nvarchar
};
dataTypeService.Save(dataType);
}
public bool Execute(string packageName, XmlNode xmlData)
{
Initialize(xmlData);
IEnumerable <IDataTypeDefinition> dataTypeDefinitions = ApplicationContext.Current.Services.DataTypeService.GetDataTypeDefinitionByPropertyEditorAlias(_alias);
if (!dataTypeDefinitions.Any())
{
DataTypeDefinition dataTypeDefinition = new DataTypeDefinition(-1, _alias)
{
Name = _name,
DatabaseType = _alias != "TeaCommerce.StockManagement" ? DataTypeDatabaseType.Integer : DataTypeDatabaseType.Nvarchar
};
ApplicationContext.Current.Services.DataTypeService.Save(dataTypeDefinition);
}
return(true);
}
private void AddContentPagePicker()
{
var services = ApplicationContext.Current.Services;
var dtdService = services.DataTypeService;
var contentPagePickerDtd = dtdService.GetDataTypeDefinitionByName(dataTypeName);
if (contentPagePickerDtd == null)
{
contentPagePickerDtd = new DataTypeDefinition(-1, "Umbraco.MultiNodeTreePicker2")
{
Name = dataTypeName
};
var preValues = new Dictionary <string, PreValue>
{
{ "startNode", new PreValue(new { type = "content", query = $"$root/{CoreInstallationConstants.DocumentTypeAliases.HomePage}" }.ToJson()) },
{ "filter", new PreValue(CoreInstallationConstants.DocumentTypeAliases.ContentPage) },
{ "minNumber", new PreValue("0") },
{ "maxNumber", new PreValue("1") },
{ "showOpenButton", new PreValue("0") }
};
dtdService.SaveDataTypeAndPreValues(contentPagePickerDtd, preValues);
}
var contentTypeService = services.ContentTypeService;
var page = contentTypeService.GetContentType(CoreInstallationConstants.DocumentTypeAliases.HomePage);
if (page == null)
{
return;
}
if (page.PropertyTypeExists(propertyAlias))
{
return;
}
var property = new PropertyType(contentPagePickerDtd)
{
Name = propertyName,
Alias = propertyAlias
};
page.AddPropertyGroup(NavigationInstallationConstants.DocumentTypeTabNames.Navigation);
page.AddPropertyType(property, NavigationInstallationConstants.DocumentTypeTabNames.Navigation);
contentTypeService.Save(page);
}
public void DataTypeService_Can_Get_All()
{
var dataTypeService = ServiceContext.DataTypeService;
IDataTypeDefinition dataTypeDefinition = new DataTypeDefinition(-1, "Test.TestEditor")
{
Name = "Testing Textfield", DatabaseType = DataTypeDatabaseType.Ntext
};
dataTypeService.Save(dataTypeDefinition);
//Get all the first time (no cache)
var all = dataTypeService.GetAllDataTypeDefinitions();
//Get all a second time (with cache)
all = dataTypeService.GetAllDataTypeDefinitions();
Assert.Pass();
}
private static PropertyType CreateAndAddPropertyTypeToDocumentType(string propertyAlias, ContentType documentType, DocumentTypePropertyAttribute propertyAttribute)
{
var dataTypeDefinition = DataTypeDefinition.GetDataTypeDefinition(propertyAttribute.DataTypeId);
if (dataTypeDefinition == null)
{
throw new DataTypeDefinitionUnknownException(propertyAttribute.DataTypeId);
}
var propertyType = documentType.AddPropertyType(dataTypeDefinition, propertyAlias, propertyAttribute.Name);
SetPropertyTypeMandatoryIfDifferent(propertyType, propertyAttribute.Mandatory);
SetPropertyTypeValidationExpressionIfDifferent(propertyType, propertyAttribute.ValidationExpression);
SetPropertyTypeSortOrderIfDifferent(propertyType, propertyAttribute.SortOrder);
SetPropertyTypeDescriptionIfDifferent(propertyType, propertyAttribute.Description);
SetPropertyTypeTabIfDifferent(documentType, propertyType, propertyAttribute.Tab);
return(propertyType);
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
var parent = this.Parent;
while (parent != null && !(parent is TabPage))
{
parent = parent.Parent;
}
if (parent != null)
{
((TabPage)parent).Menu.NewElement("div", "tinyMCEMenu1", "tinymceMenuBar", 0);
DataTypeDefinition dataTypeDefinition1 = DataTypeDefinition.GetDataTypeDefinition(Configuration.TinyMceDataTypeId);
tinyMce = (umbraco.editorControls.tinyMCE3.TinyMCE)dataTypeDefinition1.DataType.DataEditor;
tinyMce.config.Add("umbraco_toolbar_id", "tinyMCEMenu1");
tinyMce.ID = "HtmlBodyTextBox";
}
}
public override void Render(ref XmlTree tree)
{
foreach (DataTypeDefinition dt in DataTypeDefinition.GetAll())
{
XmlTreeNode xNode = XmlTreeNode.Create(this);
xNode.NodeID = dt.Id.ToString();
xNode.Text = dt.Text;
xNode.Action = "javascript:openDataType(" + dt.Id + ");";
xNode.Icon = "developerDatatype.gif";
xNode.OpenIcon = "developerDatatype.gif";
OnBeforeNodeRender(ref tree, ref xNode, EventArgs.Empty);
if (xNode != null)
{
tree.Add(xNode);
OnAfterNodeRender(ref tree, ref xNode, EventArgs.Empty);
}
}
}
protected object ConvertDbToString_Fake(string propEditorAlias, string propAlias, object value)
{
// Create a fake DTD
var fakeDtd = new DataTypeDefinition(-1, propEditorAlias);
// Create a fake property type
var fakePropType = new PropertyType(fakeDtd)
{
Alias = propAlias
};
// Create a fake property
var fakeProp = new Property(fakePropType, value);
// Lookup the property editor
var fakePropEditor = PropertyEditorResolver.Current.GetByAlias(propEditorAlias);
return(fakePropEditor.ValueEditor.ConvertDbToString(fakeProp, fakePropType, ApplicationContext.Current.Services.DataTypeService));
}
/// <summary>
/// Fix for incompatible Umbraco versions
/// </summary>
/// <param name="contentType">Type of the content.</param>
/// <param name="dt">The dt.</param>
/// <param name="alias">The alias.</param>
/// <param name="name">The name.</param>
/// <param name="tabName">Name of the tab.</param>
public static void AddPropertyType(IContentTypeBase contentType, DataTypeDefinition dt, string alias, string name, string tabName)
{
IDataTypeDefinition idt = DataTypeService.GetDataTypeDefinitionById(dt.Id);
Umbraco.Core.Models.PropertyType pt = new Umbraco.Core.Models.PropertyType(idt)
{
Alias = alias,
Name = name
};
if (String.IsNullOrEmpty(tabName))
{
contentType.AddPropertyType(pt);
}
else
{
contentType.AddPropertyType(pt, tabName);
}
}
private void CreateMemberTypesIfRequired(ApplicationContext context)
{
var memberType = context.Services.MemberTypeService.Get("member");
var textBoxDefinition = new DataTypeDefinition(-1, "text");
const int textStringId = -88;
const int numericId = -51;
var numericDefinition = new DataTypeDefinition(-1, "numeric");
var updated = false;
if (!memberType.PropertyTypeExists("firstName"))
{
var propertyType = new PropertyType(textBoxDefinition)
{
Alias = "firstName", DataTypeDefinitionId = textStringId, Name = "First Name", Description = "", Mandatory = false, SortOrder = 1
};
memberType.AddPropertyType(propertyType, "Membership");
updated = true;
}
if (!memberType.PropertyTypeExists("lastName"))
{
memberType.AddPropertyType(new PropertyType(textBoxDefinition)
{
Alias = "lastName", DataTypeDefinitionId = textStringId, Name = "Last Name", Description = "", Mandatory = false, SortOrder = 1
}, "Membership");
updated = true;
}
if (!memberType.PropertyTypeExists("age"))
{
memberType.AddPropertyType(new PropertyType(numericDefinition)
{
Alias = "age", DataTypeDefinitionId = numericId, Name = "Age", Description = "", Mandatory = false, SortOrder = 1
}, "Membership");
updated = true;
}
if (updated)
{
context.Services.MemberTypeService.Save(memberType);
}
}
