internal static GSettingsKey ExtractFromField(SchemaSet schemaSet, FieldInfo field)
{
if (field == null)
{
throw new ArgumentNullException("field");
}
object schema = field.GetValue(null);
if (schema == null)
{
throw new InvalidSchemaException(String.Format(
"Schema could not be retrieved from field {0} in type {1}",
field.Name, field.DeclaringType.FullName));
}
var default_value_field = schema.GetType().GetField("DefaultValue");
var default_value = default_value_field.GetValue(schema);
var default_value_type = default_value_field.FieldType;
var namespce = GetStringValueOfFieldNamed(schema, "Namespace");
var key = GetStringValueOfFieldNamed(schema, "Key");
var short_description = GetStringValueOfFieldNamed(schema, "ShortDescription");
var long_description = GetStringValueOfFieldNamed(schema, "LongDescription");
return(new GSettingsKey(schemaSet, default_value, default_value_type, namespce, key, short_description, long_description));
}
public StreamMetadataResource(IStreamStore streamStore)
{
if (streamStore == null)
{
throw new ArgumentNullException(nameof(streamStore));
}
_streamStore = streamStore;
Schema = new SchemaSet <StreamMetadataResource>();
}
public StreamResource(IStreamStore streamStore)
{
if (streamStore == null)
{
throw new ArgumentNullException(nameof(streamStore));
}
_streamStore = streamStore;
_relativePathToRoot = "../";
Schema = new SchemaSet <StreamResource>();
}
private GSettingsKey(SchemaSet schemaSet, object defaultValue, Type defaultValueType,
string namespce, string key,
string short_desc, string long_desc) : this()
{
ParentSchema = schemaSet.RetrieveOrCreate(namespce);
Default = GetDefault(defaultValue, defaultValueType);
KeyName = key.Replace("_", "-");
KeyType = GetTypeAttrib(defaultValue, defaultValueType);
Summary = short_desc;
Description = long_desc;
ParentSchema.Keys.Add(this);
}
/// <include file='doc\XmlSchemas.uex' path='docs/doc[@for="XmlSchemas.this1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlSchema this[string ns] {
get {
IList values = (IList)SchemaSet.Schemas(ns);
if (values.Count == 0)
{
return(null);
}
if (values.Count == 1)
{
return((XmlSchema)values[0]);
}
throw new InvalidOperationException(Res.GetString(Res.XmlSchemaDuplicateNamespace, ns));
}
}
public override bool Validate(Stream xmlStream)
{
bool valid = false;
try
{
string path = Globals.ApplicationMapPath;
string desktopFolder = Util.Utility.DesktopModuleFolderName.Replace("/", @"\");
string fullPath = path + desktopFolder + "Content.Publish.xsd";
SchemaSet.Add("", fullPath);
valid = base.Validate(xmlStream);
}
catch (Exception ex)
{
Errors.Add(ex.ToString());
}
return(valid);
}
internal static StringBuilder Extract(IEnumerable <Type> types)
{
Console.WriteLine("Generating schemas");
schema_count = 0;
schema_fields = new HashSet <FieldInfo> ();
foreach (Type type in types)
{
foreach (FieldInfo field in type.GetFields(BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Static))
{
if (CheckForValidEntry(type, field))
{
schema_fields.Add(field);
}
}
}
if (schema_fields.Count > 0)
{
var schemaSet = new SchemaSet();
foreach (FieldInfo field in schema_fields)
{
GSettingsKey.ExtractFromField(schemaSet, field);
}
StringBuilder final = new StringBuilder();
final.Append("<schemalist>\n");
foreach (GSettingsSchema schema in schemaSet.Schemas.Values)
{
final.Append(schema.ToString());
}
final.Append("</schemalist>\n");
return(final);
}
return(null);
}
public void Compile(ValidationEventHandler handler, bool fullCompile)
{
if (_isCompiled)
{
return;
}
foreach (XmlSchema s in delayedSchemas.Values)
{
Merge(s);
}
delayedSchemas.Clear();
if (fullCompile)
{
_schemaSet = new XmlSchemaSet();
_schemaSet.XmlResolver = null;
_schemaSet.ValidationEventHandler += handler;
foreach (XmlSchema s in References.Values)
{
_schemaSet.Add(s);
}
int schemaCount = _schemaSet.Count;
foreach (XmlSchema s in List)
{
if (!SchemaSet.Contains(s))
{
_schemaSet.Add(s);
schemaCount++;
}
}
if (!SchemaSet.Contains(XmlSchema.Namespace))
{
AddReference(XsdSchema);
_schemaSet.Add(XsdSchema);
schemaCount++;
}
if (!SchemaSet.Contains(XmlReservedNs.NsXml))
{
AddReference(XmlSchema);
_schemaSet.Add(XmlSchema);
schemaCount++;
}
_schemaSet.Compile();
_schemaSet.ValidationEventHandler -= handler;
_isCompiled = _schemaSet.IsCompiled && schemaCount == _schemaSet.Count;
}
else
{
try
{
XmlNameTable nameTable = new System.Xml.NameTable();
Preprocessor prep = new Preprocessor(nameTable, new SchemaNames(nameTable), null);
prep.XmlResolver = null;
prep.SchemaLocations = new Hashtable();
prep.ChameleonSchemas = new Hashtable();
foreach (XmlSchema schema in SchemaSet.Schemas())
{
prep.Execute(schema, schema.TargetNamespace, true);
}
}
catch (XmlSchemaException e)
{
throw CreateValidationException(e, e.Message);
}
}
}
public IList GetSchemas(string ns)
{
return((IList)SchemaSet.Schemas(ns));
}
public override bool Validate(Stream XmlStream)
{
SchemaSet.Add("", GetDnnSchemaPath(XmlStream));
return(base.Validate(XmlStream));
}
public StreamBrowserResource(IStreamStore streamStore)
{
_streamStore = streamStore;
Schema = new SchemaSet <StreamBrowserResource>();
}
public bool Validate(string xmlFilename, string schemaFileName)
{
SchemaSet.Add("", schemaFileName);
return(Validate(xmlFilename));
}
public bool Validate(Stream xmlStream, string schemaFile)
{
SchemaSet.Add("", schemaFile);
return(base.Validate(xmlStream));
}
