public MetadataDefinitionCreatedEvent(Guid aggregateIdentity, MetadataDefinitionName name, IDataType datatype, string regex) : base(aggregateIdentity) { Name = name; DataType = datatype.Tag; Regex = regex; }
public void ReadMembers(object instance, INXmlElementReader nodeReader, IDataType type) { using (var membersNodeReader = nodeReader.GetNextChildNode("members")) { if (membersNodeReader == null) { throw new NXmlReaderFormatException("Missing class members node."); } ReadFields(instance, membersNodeReader, type); } var baseNodeReader = nodeReader.GetNextChildNode(); if (baseNodeReader != null) { if (baseNodeReader.Name != "base") { throw new NXmlReaderFormatException( string.Format("Found a {0} node when expecting a base node.", baseNodeReader.Name)); } using (var baseClassTypeNode = baseNodeReader.GetNextChildNode()) { baseClassMembersReader.ReadMembers(instance, baseClassTypeNode, type.BaseType); } baseNodeReader.Dispose(); } }
public MetadataDefinitionState(MetadataDefinitionName name, IDataType datatype, string regex) : this(name,datatype) { _regex = regex; CreatedUtcDate = DateTime.UtcNow; IsDeleted = false; }
public ElementConstant(int position, IDataType dataType) : base(position) { this.dataType = dataType; Selectable = true; ElementType = ELEMENT_TYPE.CONSTANTE; }
/// <summary> /// Creates a new evaluation value specifying the data type. /// </summary> /// <param name="value">The value to hold in the evaluation value.</param> /// <param name="dataType">The data type for the value.</param> public EvaluationValue(object value, IDataType dataType) { if (dataType == null) throw new ArgumentNullException("dataType"); var evaluationValue = value as EvaluationValue; if (evaluationValue != null) { _value = evaluationValue._value; _dataType = evaluationValue._dataType; } else if (value is BagValue) { _value = value; _dataType = dataType; } else { var parameter = value as IFunctionParameter; if (parameter != null) { _value = parameter.GetTypedValue(dataType, 0); _dataType = dataType; } else { _value = value; _dataType = dataType; } } }
public MetadataDefinitionState(MetadataDefinitionName name, IDataType datatype, IImmutableSet<AllowableValue> allowedValues, bool isDeleted) : this(name, datatype, allowedValues) { IsDeleted = isDeleted; CreatedUtcDate = DateTime.UtcNow; IsDeleted = false; }
public MetadataDefinitionState(MetadataDefinitionName name, IDataType datatype, string regex, IImmutableSet<AllowableValue> allowedValues) : this(name, datatype,regex) { _allowedValues = allowedValues; CreatedUtcDate = DateTime.UtcNow; IsDeleted = false; }
public MetadataDefinitionState(MetadataDefinitionName name, IDataType datatype, string regex, IImmutableSet<AllowableValue> allowedValues, MetadataDefinitionDescription desc, bool isDeleted) : this(name, datatype, regex, allowedValues) { _description = desc; CreatedUtcDate = DateTime.UtcNow; IsDeleted = isDeleted; }
private void ReadFields(object instance, INXmlElementReader membersNodeReader, IDataType type) { INXmlElementReader fieldReader; while ((fieldReader = membersNodeReader.GetNextChildNode("f")) != null) { if (fieldReader.Name != "f") { throw new NXmlReaderFormatException( string.Format("Invalid node '{0}' found when expecting a field node", fieldReader.Name)); } try { var members = memberReader.Read(fieldReader, type); members.SetValue(instance); } catch (Exception exception) { var memberName = fieldReader.Attributes.Get("name"); throw new NSerializerException( string.Format("Error reading member '{0}.{1}", type.FullName, memberName), exception); } fieldReader.Dispose(); } }
public DataTypeValidationTest() { str = new DataTypeString(); str.Value = "value"; num = new DataTypeNumeric(); num.Value = "4,12"; }
void IBaseTypeMembersReader.ReadMembers(object instance, INXmlElementReader nodeReader, IDataType type) { var dictionary = (IDictionary) instance; using (var itemNodesReader = nodeReader.GetNextChildNode("items")) { var numberOfItemPairs = itemNodesReader.Attributes.GetInteger("count"); for (var itemIndex = 0; itemIndex < numberOfItemPairs; itemIndex++) { object key; object value; using (var keyReader = itemNodesReader.GetNextChildNode()) { key = objectReader.Get(keyReader); } using (var valueReader = itemNodesReader.GetNextChildNode()) { value = objectReader.Get(valueReader); } dictionary.Add(key, value); } } }
/// <summary> /// Gets the value as a generic object. /// </summary> /// <param name="dataType">The expected data type of the value.</param> /// <param name="parNo">THe number of parameter used only for error notification.</param> /// <returns></returns> public object GetTypedValue(IDataType dataType, int parNo) { if (dataType != DataTypeDescriptor.Bag) { throw new EvaluationException("invalid datatype."); } return this; }
public EntityValueSetState(Guid metadataDefinitionIdentity, MetadataDefinitionName name, IDataType dataType, string regex, IValue supplied) { MetadataDefinitionIdentity = metadataDefinitionIdentity; Name = name; DataType = dataType; Regex = regex; Values = supplied; }
public EntityValueProvidedEvent(Guid aggregateIdentity, Guid metadataDefinitionIdentity, MetadataDefinitionName name, IDataType dataType, string regex, IValue value) : base(aggregateIdentity) { MetadataDefinitionIdentity = metadataDefinitionIdentity; Name = name; DataType = dataType; Regex = regex; Value = value; }
public MetadataDefinitionState(MetadataDefinitionName name, IDataType datatype) { _name = name; _datatype = datatype; _regex = String.Empty; _allowedValues = ImmutableHashSet.Create<AllowableValue>(); CreatedUtcDate = DateTime.UtcNow; IsDeleted = false; }
public static void ClearAll() { AssemblyInspector = null; Connection = null; DataPopulation = null; DataType = null; DataSave = null; ObjectProperties = null; ClassProperties = null; }
/// <summary> /// Configures for DTG. /// </summary> /// <param name="dataType">Type of the data.</param> /// <param name="container">The container.</param> public static void ConfigureForDtg(IDataType dataType, Control container) { dataType.DataEditor.Editor.Load += (sender, args) => { var wmd = dataType.DataEditor.Editor.Controls[0]; wmd.ID = dataType.DataEditor.Editor.ID + "_ctl0"; var txt = (TextBox)wmd.Controls[0]; txt.ID = wmd.ID + "_ctl0"; }; }
/// <summary> /// Retrieve a complete list of all registered IDataType's /// </summary> /// <returns>A list of IDataType's</returns> public IDataType[] GetAll() { IDataType[] retVal = new IDataType[_controls.Count]; int c = 0; foreach (Guid id in _controls.Keys) { retVal[c] = GetNewObject(id); c++; } return(retVal); }
public void Can_Perform_Get_On_DataTypeDefinitionRepository() { using (ScopeProvider.CreateScope()) { // Act IDataType dataTypeDefinition = DataTypeRepository.Get(Constants.DataTypes.DropDownSingle); // Assert Assert.That(dataTypeDefinition, Is.Not.Null); Assert.That(dataTypeDefinition.HasIdentity, Is.True); Assert.That(dataTypeDefinition.Name, Is.EqualTo("Dropdown")); } }
public static DataTypeDto BuildDto(IDataType entity) { var dataTypeDto = new DataTypeDto { EditorAlias = entity.EditorAlias, NodeId = entity.Id, DbType = entity.DatabaseType.ToString(), Configuration = ConfigurationEditor.ToDatabase(entity.Configuration), NodeDto = BuildNodeDto(entity) }; return(dataTypeDto); }
public ISchemaElementBuilder CreateElementWithValue(XName name, IDataType dataType, string description, Action <ISchemaElement> configurator = null) { var child = new SchemaElement(_schemaElement.Schema, name, description, _schemaElement) { UseContentAsValue = true, ValueType = dataType }; configurator?.Invoke(child); _schemaElement.AddChildElement(child); return(new SchemaElementBuilder(child)); }
public void Different_Data_Editors_Returns_Different_Value_Editors() { var sut = new ValueEditorCache(); var dataEditor1 = new FakeDataEditor("Editor1"); var dataEditor2 = new FakeDataEditor("Editor2"); IDataType dataType = CreateDataTypeMock(1).Object; IDataValueEditor firstEditor = sut.GetValueEditor(dataEditor1, dataType); IDataValueEditor secondEditor = sut.GetValueEditor(dataEditor2, dataType); Assert.AreNotSame(firstEditor, secondEditor); }
public IEnumerable <EntityContainer> GetContainers(IDataType dataType) { var ancestorIds = dataType.Path.Split(Constants.CharArrays.Comma, StringSplitOptions.RemoveEmptyEntries) .Select(x => { var asInt = x.TryConvertTo <int>(); return(asInt ? asInt.Result : int.MinValue); }) .Where(x => x != int.MinValue && x != dataType.Id) .ToArray(); return(GetContainers(ancestorIds)); }
protected bool TryResolveType(string typeName, out IDataType type) { if (typeName == null) { throw new ArgumentNullException("typeName"); } if (typeName != string.Empty) { return(this.services.Binder.TryResolveType(typeName, out type)); } type = null; return(false); }
internal DynamicReferenceInstance(IReferenceInstance refInstance) : base((IValueSymbol)refInstance) { this.normalizedDict = new Dictionary <string, ISymbol>(StringComparer.OrdinalIgnoreCase); IReferenceType dataType = (IReferenceType)refInstance.DataType; IResolvableType type2 = (IResolvableType)dataType; this.resolvedReferenceType = (type2 == null) ? dataType : type2.ResolveType(DataTypeResolveStrategy.AliasReference); if (this.resolvedReferenceType.Category == DataTypeCategory.Struct) { ReadOnlySymbolCollection subSymbols = ((IReferenceInstanceAccess)refInstance).SubSymbols; this.normalizedDict = DynamicStructInstance.createMemberDictionary(false, subSymbols); } }
/// <summary> /// Deletes an <see cref="IDataType"/> /// </summary> /// <remarks> /// Please note that deleting a <see cref="IDataType"/> will remove /// all the <see cref="IPropertyType"/> data that references this <see cref="IDataType"/>. /// </remarks> /// <param name="dataType"><see cref="IDataType"/> to delete</param> /// <param name="userId">Optional Id of the user issuing the deletion</param> public void Delete(IDataType dataType, int userId = Cms.Core.Constants.Security.SuperUserId) { var evtMsgs = EventMessagesFactory.Get(); using (var scope = ScopeProvider.CreateCoreScope()) { var deletingDataTypeNotification = new DataTypeDeletingNotification(dataType, evtMsgs); if (scope.Notifications.PublishCancelable(deletingDataTypeNotification)) { scope.Complete(); return; } // find ContentTypes using this IDataTypeDefinition on a PropertyType, and delete // TODO: media and members?! // TODO: non-group properties?! var query = Query<PropertyType>().Where(x => x.DataTypeId == dataType.Id); var contentTypes = _contentTypeRepository.GetByQuery(query); foreach (var contentType in contentTypes) { foreach (var propertyGroup in contentType.PropertyGroups) { var types = propertyGroup.PropertyTypes?.Where(x => x.DataTypeId == dataType.Id).ToList(); if (types is not null) { foreach (var propertyType in types) { propertyGroup.PropertyTypes?.Remove(propertyType); } } } // so... we are modifying content types here. the service will trigger Deleted event, // which will propagate to DataTypeCacheRefresher which will clear almost every cache // there is to clear... and in addition published snapshot caches will clear themselves too, so // this is probably safe although it looks... weird. // // what IS weird is that a content type is losing a property and we do NOT raise any // content type event... so ppl better listen on the data type events too. _contentTypeRepository.Save(contentType); } _dataTypeRepository.Delete(dataType); scope.Notifications.Publish(new DataTypeDeletedNotification(dataType, evtMsgs).WithStateFrom(deletingDataTypeNotification)); Audit(AuditType.Delete, userId, dataType.Id); scope.Complete(); } }
protected override ActionResult <TreeNodeCollection> GetTreeNodes(string id, FormCollection queryStrings) { if (!int.TryParse(id, NumberStyles.Integer, CultureInfo.InvariantCulture, out var intId)) { throw new InvalidOperationException("Id must be an integer"); } var nodes = new TreeNodeCollection(); //Folders first nodes.AddRange( _entityService.GetChildren(intId, UmbracoObjectTypes.DataTypeContainer) .OrderBy(entity => entity.Name) .Select(dt => { TreeNode node = CreateTreeNode(dt, Constants.ObjectTypes.DataType, id, queryStrings, Constants.Icons.Folder, dt.HasChildren); node.Path = dt.Path; node.NodeType = "container"; // TODO: This isn't the best way to ensure a no operation process for clicking a node but it works for now. node.AdditionalData["jsClickCallback"] = "javascript:void(0);"; return(node); })); //if the request is for folders only then just return if (queryStrings["foldersonly"].ToString().IsNullOrWhiteSpace() == false && queryStrings["foldersonly"] == "1") { return(nodes); } //System ListView nodes IEnumerable <int> systemListViewDataTypeIds = GetNonDeletableSystemListViewDataTypeIds(); IEntitySlim[] children = _entityService.GetChildren(intId, UmbracoObjectTypes.DataType).ToArray(); var dataTypes = _dataTypeService.GetAll(children.Select(c => c.Id).ToArray()).ToDictionary(dt => dt.Id); nodes.AddRange( children .OrderBy(entity => entity.Name) .Select(dt => { IDataType dataType = dataTypes[dt.Id]; TreeNode node = CreateTreeNode(dt.Id.ToInvariantString(), id, queryStrings, dt.Name, dataType.Editor?.Icon, false); node.Path = dt.Path; return(node); }) ); return(nodes); }
/// <summary> /// Get data type by type name /// </summary> /// <param name="configuration">database configuration instance</param> /// <param name="name">data type name</param> /// <param name="size">size of data</param> /// <returns>data type instance</returns> public static IDataType GetDataType(this IDatabaseConfiguration configuration, string name, int?size = null) { if (configuration == null) { throw new ArgumentNullException("configuration"); } if (string.IsNullOrEmpty(name)) { const string ErrorMessage = "parameter \"name\" should not be null or blank"; Trace.TraceError(ErrorMessage); throw new ArgumentException(ErrorMessage); } IDataType dataType = null; var supportedTypes = configuration.SupportedTypes; if (supportedTypes.IsReadOnlyNullOrEmpty()) { return(null); } if (!supportedTypes.TryGetValue(name, out dataType)) { var errorMessage = string.Format( CultureInfo.InvariantCulture, "Type \"{0}\" is not supported", name); Trace.TraceError(errorMessage); throw new ArgumentException(errorMessage); } var sizeType = dataType.DataSize.SizeType; if ((sizeType == DataSizeType.NotRequired) || ((sizeType == DataSizeType.Maximum) && !size.HasValue)) { return(dataType); } if (!size.HasValue) { var errorMessage = string.Format( CultureInfo.InvariantCulture, "Data size of type \"{0}\" is required", name); Trace.TraceError(errorMessage); throw new ArgumentException(errorMessage); } return(new DataType(dataType.TypeName, new DataSize(DataSizeType.Required, size))); }
public bool Implements(IDataType interfaceType) { var name = interfaceType.FullName; bool ret; if (!_implements.TryGetValue(name, out ret)) { _implements[name] = ret = _dataType.Implements( interfaceType is CachingDataType ? ((CachingDataType)interfaceType)._dataType : interfaceType); } return(ret); }
/// <summary> /// Returns the typed value for this string value. /// </summary> /// <param name="dataType">The expected data type of the value.</param> /// <param name="parNo">The parameter number used only for error reporing.</param> /// <returns>The typed value as an object.</returns> public object GetTypedValue(IDataType dataType, int parNo) { if (dataType == null) throw new ArgumentNullException("dataType"); if (IsBag) { return this; } if (DataTypeValue != dataType.DataTypeName) { throw new EvaluationException(string.Format(Properties.Resource.exc_invalid_datatype_in_stringvalue, parNo, DataTypeValue)); } return dataType.Parse(Value, parNo); }
public static IDataType RemoveDocTypeFromXPathFilter(this IDataType dataType, params string[] docTypes) { var preValues = dataType.GetMultiNodeTreePickerPreValues(); var docTypeListXPath = new DocTypeListXPath(preValues.AllowedDocTypes); docTypeListXPath.Remove(docTypes); preValues.AllowedDocTypes = docTypeListXPath.ToString(); dataType.SetMultiNodeTreePickerPreValues(preValues); return(dataType); }
internal static ISubRangeType Create(string name, IDataTypeResolver resolver) { string baseType = null; if (DataTypeStringParser.TryParseSubRange(name, out baseType)) { IDataType type = null; if (resolver.TryResolveType(baseType, out type)) { Create(name, type); } } return(null); }
public IMemberValue Read(INXmlElementReader nodeReader, IDataType type) { var memberValues = new List<IMemberValue>(); foreach (var typeMemberReader in memberReaders) { if (typeMemberReader.CanRead(nodeReader)) { memberValues.Add(typeMemberReader.Read(nodeReader, type)); break; } } return new MembersValue(memberValues.ToArray()); }
internal Symbol(AdsSymbolEntry entry, IDataType type, ISymbol parent, ISymbolFactoryServices factoryServices) : this(entry, parent, factoryServices) { base.category = type.Category; base.resolvedDataType = type; if ((base.attributes != null) && (base.attributes.Count >= 2)) { ISubRangeType subRange = null; if (TryParseSubRange(type, base.attributes, factoryServices.Binder, out subRange)) { base.category = subRange.Category; base.resolvedDataType = subRange; } } }
public EntityState AddOrUpdate(Guid metadataDefinitionIdentity, MetadataDefinitionName name, IDataType dataType, string regex, IValue supplied) { if (_values.All(x => x.MetadataDefinitionIdentity != metadataDefinitionIdentity)) return new EntityState(_group, _name, _values.Add(new EntityValueSetState(metadataDefinitionIdentity, name, dataType, regex, supplied))); var element = _values.First(x => x.MetadataDefinitionIdentity == metadataDefinitionIdentity); element.Name = name; element.DataType = dataType; element.Regex = regex; element.Values = supplied; return this; }
public int Unmarshal(IAttributedInstance symbol, byte[] data, int offset, out object value) { Encoding encoding = null; EncodingAttributeConverter.TryGetEncoding(symbol.Attributes, out encoding); IDataType dataType = symbol.DataType; IResolvableType type2 = symbol.DataType as IResolvableType; if (type2 != null) { dataType = type2.ResolveType(DataTypeResolveStrategy.AliasReference); } return(this._typeMarshaller.Unmarshal(dataType, encoding, data, offset, out value)); }
public static bool IsAssignableTo(this IDataType type, string parentType) { var currentType = type; while (currentType != null) { if (currentType.Name == parentType) { return(true); } currentType = type.BaseType; } return(false); }
public byte[] Marshal(IAttributedInstance symbol, object value) { Encoding encoding = null; this.TryGetEncoding(symbol, out encoding); IDataType dataType = symbol.DataType; IResolvableType type2 = symbol.DataType as IResolvableType; if (type2 != null) { dataType = type2.ResolveType(DataTypeResolveStrategy.AliasReference); } return(this._typeMarshaller.Marshal(dataType, encoding, value)); }
public IDataType ResolveType(DataTypeResolveStrategy type) { IDataType type2 = this; IDataType baseType = this; if (type == DataTypeResolveStrategy.Alias) { while (true) { if ((baseType == null) || (baseType.Category != DataTypeCategory.Alias)) { if ((baseType == null) && (this.Category == DataTypeCategory.Alias)) { object[] args = new object[] { type2.Name }; Module.Trace.TraceWarning("Could not resolve Alias '{0}'", args); } break; } type2 = baseType; baseType = ((IAliasType)baseType).BaseType; } } else if (type == DataTypeResolveStrategy.AliasReference) { while (true) { if ((baseType == null) || ((baseType.Category != DataTypeCategory.Alias) && (baseType.Category != DataTypeCategory.Reference))) { if ((baseType == null) && ((this.Category == DataTypeCategory.Alias) || (this.Category == DataTypeCategory.Reference))) { object[] args = new object[] { type2.Name }; Module.Trace.TraceWarning("Could not resolve Alias/Reference '{0}'", args); } break; } if (baseType.Category == DataTypeCategory.Alias) { type2 = baseType; baseType = ((IAliasType)baseType).BaseType; } else if (baseType.Category == DataTypeCategory.Reference) { type2 = baseType; baseType = ((IReferenceType)baseType).ReferencedType; } } } return(baseType); }
public void DefineMaps(IUmbracoMapper mapper) { mapper.Define <DocumentTypeSave, IContentType>( (source, context) => new ContentType(_shortStringHelper, source.ParentId), Map); mapper.Define <MediaTypeSave, IMediaType>( (source, context) => new MediaType(_shortStringHelper, source.ParentId), Map); mapper.Define <MemberTypeSave, IMemberType>( (source, context) => new MemberType(_shortStringHelper, source.ParentId), Map); mapper.Define <IContentType, DocumentTypeDisplay>((source, context) => new DocumentTypeDisplay(), Map); mapper.Define <IMediaType, MediaTypeDisplay>((source, context) => new MediaTypeDisplay(), Map); mapper.Define <IMemberType, MemberTypeDisplay>((source, context) => new MemberTypeDisplay(), Map); mapper.Define <PropertyTypeBasic, IPropertyType>( (source, context) => { IDataType dataType = _dataTypeService.GetDataType(source.DataTypeId); if (dataType == null) { throw new NullReferenceException("No data type found with id " + source.DataTypeId); } return(new PropertyType(_shortStringHelper, dataType, source.Alias)); }, Map); // TODO: isPublishing in ctor? mapper.Define <PropertyGroupBasic <PropertyTypeBasic>, PropertyGroup>( (source, context) => new PropertyGroup(false), Map); mapper.Define <PropertyGroupBasic <MemberPropertyTypeBasic>, PropertyGroup>( (source, context) => new PropertyGroup(false), Map); mapper.Define <IContentTypeComposition, ContentTypeBasic>((source, context) => new ContentTypeBasic(), Map); mapper.Define <IContentType, ContentTypeBasic>((source, context) => new ContentTypeBasic(), Map); mapper.Define <IMediaType, ContentTypeBasic>((source, context) => new ContentTypeBasic(), Map); mapper.Define <IMemberType, ContentTypeBasic>((source, context) => new ContentTypeBasic(), Map); mapper.Define <DocumentTypeSave, DocumentTypeDisplay>((source, context) => new DocumentTypeDisplay(), Map); mapper.Define <MediaTypeSave, MediaTypeDisplay>((source, context) => new MediaTypeDisplay(), Map); mapper.Define <MemberTypeSave, MemberTypeDisplay>((source, context) => new MemberTypeDisplay(), Map); mapper.Define <PropertyGroupBasic <PropertyTypeBasic>, PropertyGroupDisplay <PropertyTypeDisplay> >( (source, context) => new PropertyGroupDisplay <PropertyTypeDisplay>(), Map); mapper.Define <PropertyGroupBasic <MemberPropertyTypeBasic>, PropertyGroupDisplay <MemberPropertyTypeDisplay> >( (source, context) => new PropertyGroupDisplay <MemberPropertyTypeDisplay>(), Map); mapper.Define <PropertyTypeBasic, PropertyTypeDisplay>((source, context) => new PropertyTypeDisplay(), Map); mapper.Define <MemberPropertyTypeBasic, MemberPropertyTypeDisplay>( (source, context) => new MemberPropertyTypeDisplay(), Map); }
public IMemberValue Read(INXmlElementReader nodeReader, IDataType type) { var memberValues = new List <IMemberValue>(); foreach (var typeMemberReader in memberReaders) { if (typeMemberReader.CanRead(nodeReader)) { memberValues.Add(typeMemberReader.Read(nodeReader, type)); break; } } return(new MembersValue(memberValues.ToArray())); }
internal static ISubRangeType Create(AdsDataTypeEntry entry, IDataTypeResolver resolver) { ISubRangeType type = null; string baseType = null; if (DataTypeStringParser.TryParseSubRange(entry.entryName, out baseType)) { IDataType type2 = null; if (resolver.TryResolveType(baseType, out type2)) { type = Create(entry.entryName, type2); } } return(type); }
public static IDataType SetMultiNodeTreePickerPreValues(this IDataType dataType, MultiNodeTreePickerPreValues multiNodeTreePickerPreValues) { if (dataType.GetDataTypePreValues().Any()) { dataType.DeleteAllPreValues(); } dataType.AddPreValue(multiNodeTreePickerPreValues.StartNode.ToJsonString(), 1, "startNode") .AddPreValue(multiNodeTreePickerPreValues.AllowedDocTypes, 2, "filter") .AddPreValue(multiNodeTreePickerPreValues.MinSelectedNodes.ToString(), 3, "minNumber") .AddPreValue(multiNodeTreePickerPreValues.MaxSelectedNodes.ToString(), 4, "maxNumber") .AddPreValue(multiNodeTreePickerPreValues.ShowEditButton ? "1" : "0", 5, "showEditButton"); return(dataType); }
private void ProcessVariable(string fieldName, string typeInfo) { fieldName = Helper.CorrectHeadItemString(fieldName); string variableName = Helper.GetValidScriptVariableName(fieldName, true); if (variableName.Contains(CSVConstant.IDENTIFIER_OMIT_COLUMN)) { return; } IDataType dataType = dataTypeFactory.GetDataType(typeInfo, fieldName); classWriter.ProcessVariable(fieldName, variableName, dataType); }
public static string CreateDataTypesDefinition(IDataType[] vars) { string dt = ""; for (int i = 0; i < vars.Count(); i++) { IDataType dataType = vars[i]; dt = dt + dataType.AsString(); if (i < vars.Count() - 1) { dt = dt + ", "; } } return dt; }
/// <summary> /// adds a datatype to the repository by handle /// </summary> /// <param name="handle"></param> /// <param name="rule"></param> /// <returns></returns> public bool RemoveDataType(IDataType datatype) { Initialize(); if (this.HasDataType(datatype.Name)) { _datatypes.Remove(datatype.Name.ToUpper()); } if (this.HasDataTypeSignature(datatype.Signature)) { List <IDataType> aList = _datatypesSignature[datatype.Signature.ToUpper()]; // remove all existing aList.RemoveAll(x => x.Name.ToUpper() == datatype.Name.ToUpper()); } return(true); }
internal DynamicAliasInstance(IAliasInstance aliasInstance) : base((IValueSymbol)aliasInstance) { IAliasType dataType = (IAliasType)aliasInstance.DataType; IResolvableType type2 = dataType as IResolvableType; this.resolvedAlias = (type2 == null) ? dataType : type2.ResolveType(DataTypeResolveStrategy.AliasReference); if (this.resolvedAlias.Category == DataTypeCategory.Struct) { this.normalizedDict = new Dictionary <string, ISymbol>(StringComparer.OrdinalIgnoreCase); foreach (DynamicSymbol symbol in base.SubSymbols) { this.normalizedDict.Add(symbol.NormalizedName, symbol); } } }
private int tryReadValue(ISymbol symbol, int[] indices, out object result, out DateTime utcReadTime) { IDataType dataType = symbol.DataType; IResolvableType type2 = dataType as IResolvableType; IArrayType type3 = null; type3 = (type2 == null) ? ((IArrayType)dataType) : ((IArrayType)type2.ResolveType(DataTypeResolveStrategy.AliasReference)); IDataType elementType = type3.ElementType; byte[] buffer = null; int num = this.TryReadArrayElementValue(symbol, indices, out buffer, out utcReadTime); result = (num != 0) ? null : base.valueFactory.CreateValue(symbol, buffer, 0, utcReadTime); return(num); }
private XElement SerializePropertyType(IPropertyType propertyType, IDataType definition, PropertyGroup propertyGroup) => new XElement("GenericProperty", new XElement("Name", propertyType.Name), new XElement("Alias", propertyType.Alias), new XElement("Key", propertyType.Key), new XElement("Type", propertyType.PropertyEditorAlias), new XElement("Definition", definition.Key), propertyGroup != null ? new XElement("Tab", propertyGroup.Name, new XAttribute("Alias", propertyGroup.Alias)) : null, // TODO Replace with PropertyGroupAlias new XElement("SortOrder", propertyType.SortOrder), new XElement("Mandatory", propertyType.Mandatory.ToString()), new XElement("LabelOnTop", propertyType.LabelOnTop.ToString()), propertyType.MandatoryMessage != null ? new XElement("MandatoryMessage", propertyType.MandatoryMessage) : null, propertyType.ValidationRegExp != null ? new XElement("Validation", propertyType.ValidationRegExp) : null, propertyType.ValidationRegExpMessage != null ? new XElement("ValidationRegExpMessage", propertyType.ValidationRegExpMessage) : null, propertyType.Description != null ? new XElement("Description", new XCData(propertyType.Description)) : null);
public IActionResult Install() { var contentType = new ContentType(_shortStringHelper, -1) { Alias = ContentAlias, Name = "LoadTest Content", Description = "Content for LoadTest", Icon = "icon-document" }; IDataType def = _dataTypeService.GetDataType(TextboxDefinitionId); contentType.AddPropertyType(new PropertyType(_shortStringHelper, def) { Name = "Origin", Alias = "origin", Description = "The origin of the content.", }); _contentTypeService.Save(contentType); Template containerTemplate = ImportTemplate( "LoadTestContainer", "LoadTestContainer", s_containerTemplateText); var containerType = new ContentType(_shortStringHelper, -1) { Alias = ContainerAlias, Name = "LoadTest Container", Description = "Container for LoadTest content", Icon = "icon-document", AllowedAsRoot = true, IsContainer = true }; containerType.AllowedContentTypes = containerType.AllowedContentTypes.Union(new[] { new ContentTypeSort(new Lazy <int>(() => contentType.Id), 0, contentType.Alias), }); containerType.AllowedTemplates = containerType.AllowedTemplates.Union(new[] { containerTemplate }); containerType.SetDefaultTemplate(containerTemplate); _contentTypeService.Save(containerType); IContent content = _contentService.Create("LoadTestContainer", -1, ContainerAlias); _contentService.SaveAndPublish(content); return(ContentHtml("Installed.")); }
/// <summary> /// Deletes an <see cref="IDataType"/> /// </summary> /// <remarks> /// Please note that deleting a <see cref="IDataType"/> will remove /// all the <see cref="PropertyType"/> data that references this <see cref="IDataType"/>. /// </remarks> /// <param name="dataType"><see cref="IDataType"/> to delete</param> /// <param name="userId">Optional Id of the user issueing the deletion</param> public void Delete(IDataType dataType, int userId = 0) { using (var scope = ScopeProvider.CreateScope()) { var deleteEventArgs = new DeleteEventArgs <IDataType>(dataType); if (scope.Events.DispatchCancelable(Deleting, this, deleteEventArgs)) { scope.Complete(); return; } // find ContentTypes using this IDataTypeDefinition on a PropertyType, and delete // fixme - media and members?! // fixme - non-group properties?! var query = Query <PropertyType>().Where(x => x.DataTypeId == dataType.Id); var contentTypes = _contentTypeRepository.GetByQuery(query); foreach (var contentType in contentTypes) { foreach (var propertyGroup in contentType.PropertyGroups) { var types = propertyGroup.PropertyTypes.Where(x => x.DataTypeId == dataType.Id).ToList(); foreach (var propertyType in types) { propertyGroup.PropertyTypes.Remove(propertyType); } } // so... we are modifying content types here. the service will trigger Deleted event, // which will propagate to DataTypeCacheRefresher which will clear almost every cache // there is to clear... and in addition published snapshot caches will clear themselves too, so // this is probably safe alghough it looks... weird. // // what IS weird is that a content type is losing a property and we do NOT raise any // content type event... so ppl better listen on the data type events too. _contentTypeRepository.Save(contentType); } _dataTypeRepository.Delete(dataType); deleteEventArgs.CanCancel = false; scope.Events.Dispatch(Deleted, this, deleteEventArgs); Audit(AuditType.Delete, userId, dataType.Id); scope.Complete(); } }
/// <summary> /// Converts the datatype value to a DTG compatible string /// </summary> /// <param name="dataType">The DataType.</param> /// <returns></returns> public static string ToDtgString(IDataType dataType) { var value = dataType.Data.Value != null ? dataType.Data.Value.ToString() : string.Empty; try { var assembly = Assembly.GetAssembly(dataType.GetType()); var type = assembly.GetType("Our.Umbraco.DataType.Markdown.XsltExtensions"); return (string)type.InvokeMember("Transform", BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public, null, null, new object[] { value }); } catch // (Exception ex) { return value; // TODO: [LK->OA] Did you want to capture the exception? } }
void IBaseTypeMembersReader.ReadMembers(object instance, INXmlElementReader nodeReader, IDataType type) { var list = (IList) instance; using (var itemNodes = nodeReader.GetNextChildNode("items")) { var numberOfItems = itemNodes.Attributes.GetInteger("count"); while (numberOfItems-- > 0) { INXmlElementReader itemNode; using (itemNode = itemNodes.GetNextChildNode()) { list.Add(objectReader.Get(itemNode)); } } } }
public IMemberValue Read(INXmlElementReader nodeReader, IDataType type) { var fieldName = nodeReader.Attributes.Get("name"); var field = type.GetField(fieldName); if (field == null) { throw new UnableToReadXMLTextException( string.Format("Unable to find field '{0}'.", fieldName)); } IMemberValue value; using (var valueNode = nodeReader.GetNextChildNode()) { value = new FieldValue(field, objectReader.Get(valueNode)); } return value; }
protected override System.Type MapDbType(string columnName, IDataType dataType) { switch (dataType.SqlType.ToLower()) { case "float": return typeof(Double); case "integer": switch (dataType.Length) { case 1: return typeof(Byte); case 2: return typeof(Int16); case 4: return typeof(Int32); case 8: return typeof(Int64); } return MapDbType(columnName, null); default: return base.MapDbType(columnName, dataType); } }
/// <summary> /// Maps a type to enum type, if possible. /// </summary> /// <param name="dataType">Type of the data.</param> /// <returns></returns> protected virtual EnumType MapEnumDbType(IDataType dataType) { var enumType = new EnumType(); // MySQL represents enums as follows: // enum('value1','value2') Match outerMatch = DefaultEnumDefinitionEx.Match(dataType.FullType); if (outerMatch.Success) { string values = outerMatch.Groups["values"].Value; var innerMatches = EnumValuesEx.Matches(values); int currentValue = 1; foreach (Match innerMatch in innerMatches) { var value = innerMatch.Groups["value"].Value; enumType.EnumValues[value] = currentValue++; } } return enumType; }
protected virtual Type MapDbType(string columnName, IDataType dataType) { if (dataType == null) throw new ArgumentNullException("dataType"); if (dataType.ManagedType != null) return Type.GetType(dataType.ManagedType, true); string dataTypeL = dataType.SqlType.ToLowerInvariant(); if (columnName != null && columnName.ToLower().Contains("guid")) { bool correctTypeAndLen = ((dataTypeL == "char" || dataTypeL == "varchar") && dataType.Length == 36) || ((dataTypeL == "binary") && dataType.Length == 16); if (correctTypeAndLen) { Console.WriteLine("experimental support for guid--"); return typeof(Guid); } } switch (dataTypeL) { // string case "c": case "char": case "character": case "character varying": case "inet": case "long": case "longtext": case "long varchar": case "mediumtext": case "nchar": case "ntext": case "nvarchar": case "nvarchar2": case "string": case "text": case "varchar": case "varchar2": case "clob": // oracle type case "nclob": // oracle type case "rowid": // oracle type case "urowid": // oracle type case "tinytext": // mysql type return typeof(String); // bool case "bit": case "bool": case "boolean": return typeof(Boolean); // int8 case "tinyint": if (dataType.Length == 1) return typeof(Boolean); // tinyint is supposed to be signed // but we can have explicit sign if (dataType.Unsigned ?? false) return typeof(Byte); // default case, unsigned return typeof(SByte); // int16 case "short": case "smallint": if (dataType.Unsigned ?? false) return typeof(UInt16); return typeof(Int16); // int32 case "int": case "integer": case "mediumint": if (dataType.Unsigned ?? false) return typeof(UInt32); return typeof(Int32); // int64 case "bigint": return typeof(Int64); // single case "float": case "float4": case "real": case "binary_float": // oracle type return typeof(Single); // double case "double": case "double precision": case "binary_double": // oracle type return typeof(Double); // decimal case "decimal": case "money": case "numeric": return typeof(Decimal); case "number": // special oracle type if (dataType.Precision.HasValue && (dataType.Scale ?? 0) == 0) { if (dataType.Precision.Value == 1) return typeof(Boolean); if (dataType.Precision.Value <= 4) return typeof(Int16); if (dataType.Precision.Value <= 9) return typeof(Int32); if (dataType.Precision.Value <= 19) return typeof(Int64); } return typeof(Decimal); // time interval case "interval": return typeof(TimeSpan); //enum case "enum": return MapEnumDbType(dataType); // date case "date": case "datetime": case "ingresdate": case "timestamp": case "timestamp without time zone": case "time": case "time without time zone": //reported by [email protected], case "time with time zone": return typeof(DateTime); // byte[] case "binary": case "blob": case "bytea": case "byte varying": case "image": case "longblob": case "long byte": case "oid": case "sytea": case "mediumblob": case "tinyblob": case "raw": // oracle type case "long raw": // oracle type case "varbinary": return typeof(Byte[]); // PostgreSQL, for example has an uuid type that can be mapped as a Guid case "uuid": return typeof(Guid); case "void": return null; // if we fall to this case, we must handle the type default: throw new ArgumentException( string.Format("Don't know how to convert the SQL type '{0}' into a managed type.", dataTypeL), "dataType"); } }
/// <summary> /// This is a hack while I figure out a way to produce Dialect 3 types. /// </summary> /// <param name="columnName"></param> /// <param name="dataType"></param> /// <returns></returns> protected override System.Type MapDbType(string columnName, IDataType dataType) { switch (dataType.SqlType) { // string case "CSTRING": case "TEXT": case "VARYING": return typeof(String); // int16 case "SHORT": if (dataType.Unsigned ?? false) return typeof(UInt16); return typeof(Int16); // int32 case "LONG": if (dataType.Unsigned ?? false) return typeof(UInt32); return typeof(Int32); // int64 case "INT64": return typeof(Int64); // single case "FLOAT": return typeof(Single); // double case "DOUBLE": return typeof(Double); // decimal case "QUAD": return typeof(Decimal); // time interval case "TIME": return typeof(TimeSpan); // date case "TIMESTAMP": case "DATE": return typeof(DateTime); // byte[] case "BLOB": case "BLOB_ID": return typeof(Byte[]); // if we fall to this case, we must handle the type default: return null; } }
public MinLengthConstraint(ref DataTypeString data, int min) { _dataType = data; _min = min; }
public MinLengthConstraint(ref DataTypeNumeric data, int min) { _dataType = data; _min = min; }