public void AddResourceDirect( IResource resource )
{
if ( items.Contains( resource ) )
return;
items.Add( resource );
}
/// <summary>
/// Generates the URI template.
/// </summary>
/// <param name="resource">The resource.</param>
/// <param name="baseUri">The base URI.</param>
/// <param name="logger">The logger.</param>
/// <returns>A Uri template a client can expand to invoke a resource.</returns>
/// <exception cref="System.ArgumentNullException">Throws and exception if <paramref name="resource"/> or <paramref name="logger"/> is <c>null</c>.</exception>
public string GenerateUriTemplate(IResource resource, string baseUri, ILogger logger)
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
string result = null;
try
{
result = GenerateUriTemplate(resource.Name, baseUri, resource.Parameters, logger);
}
catch (Exception exception)
{
logger.Error(Resources.GenerateUriExecutionError, exception, GetType());
}
if (result != null)
{
return result;
}
return string.Empty;
}
/// <summary>
/// Converts the resource to the specified version
/// </summary>
/// <param name="resource">The resource.</param>
/// <param name="targetVersion">The target version.</param>
/// <returns></returns>
public IResource Convert(IResource resource, Version targetVersion)
{
//How does this work? If source and target versions are known, it means the classes
//that represent them are also known and we just serialize from the source type to xml
//and deserialize that xml to the target type, with any unsupported bits falling by the
//wayside in the process, and any new bits flubbed with default values as part of deserialization
var resVer = resource.GetResourceTypeDescriptor().Version;
var dstVer = string.Format("{0}.{1}.{2}", targetVersion.Major, targetVersion.Minor, targetVersion.Build); //NOXLATE
var dstXsd = resource.ValidatingSchema.Replace(resVer, dstVer);
using (var sr = ResourceTypeRegistry.Serialize(resource))
{
using (var str = new StreamReader(sr))
{
var xml = new StringBuilder(str.ReadToEnd());
xml.Replace(resource.ValidatingSchema, dstXsd);
xml.Replace("version=\"" + resVer, "version=\"" + dstVer); //NOXLATE
var convRes = ResourceTypeRegistry.Deserialize(xml.ToString());
convRes.CurrentConnection = resource.CurrentConnection;
convRes.ResourceID = resource.ResourceID;
return convRes;
}
}
}
/// <summary>
/// Initializes a new instance of the ProfilingDialog class
/// </summary>
/// <param name="item"></param>
/// <param name="resourceId"></param>
/// <param name="connection"></param>
public ProfilingDialog(IResource item, string resourceId, IServerConnection connection)
: this()
{
m_connection = connection;
m_item = item;
m_resourceId = resourceId;
}
/// <summary>
/// Create an encoded resource using the specified encoding.
/// </summary>
/// <param name="resource">the resource to read from. Must not be <c>null</c></param>
/// <param name="encoding">the encoding to use. If <c>null</c>, encoding will be autodetected.</param>
/// <param name="autoDetectEncoding">whether to autoDetect encoding from byte-order marks (<see cref="StreamReader(Stream, Encoding, bool)"/>)</param>
public EncodedResource(IResource resource, Encoding encoding, bool autoDetectEncoding)
{
AssertUtils.ArgumentNotNull(resource, "resource");
this.resource = resource;
this.encoding = encoding;
this.autoDetectEncoding = autoDetectEncoding;
}
public override void ProcessResource(IResource source, IConfigurationStore store)
{
XmlProcessor.XmlProcessor processor;
if (Kernel == null)
{
processor = new XmlProcessor.XmlProcessor(EnvironmentName);
}
else
{
var resourceSubSystem = Kernel.GetSubSystem(SubSystemConstants.ResourceKey) as IResourceSubSystem;
processor = new XmlProcessor.XmlProcessor(EnvironmentName, resourceSubSystem);
}
try
{
XmlNode element = processor.Process(source);
Deserialize(element, store);
}
catch(XmlProcessorException)
{
const string message = "Unable to process xml resource ";
throw new Exception(message);
}
}
/// <summary>
/// Initializes a new instance of the Location class.
/// </summary>
/// <param name="resource"></param>
/// <param name="source"></param>
public Location(IResource resource, object source)
{
//TODO: look into re-enabling this since resource *is* NULL when parsing config classes vs. acquiring IResources
//AssertUtils.ArgumentNotNull(resource, "resource");
this.resource = resource;
this.source = source;
}
public void DecorateClass(IResource resource,
string className,
CodeTypeDeclaration resourceClass,
ResourceClassGenerator generator,
string serviceClassName,
IEnumerable<IResourceDecorator> allDecorators)
{
foreach (IMethod method in resource.Methods.Values)
{
foreach (IParameter parameter in method.Parameters.Values)
{
if (parameter.EnumValues.IsNullOrEmpty())
{
continue; // Not an enumeration type.
}
// Check whether the type already exists.
if (DecoratorUtil.FindFittingEnumeration(
resourceClass, parameter.EnumValues, parameter.EnumValueDescriptions) != null)
{
continue;
}
// Create and add the enumeration.
resourceClass.Members.Add(GenerateEnum(
resourceClass, parameter.Name, parameter.Description, parameter.EnumValues,
parameter.EnumValueDescriptions));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AbstractInterpreter"/> class
/// from an The <see cref="IResource"/>.
/// </summary>
/// <param name="source">The <see cref="IResource"/>.</param>
public AbstractInterpreter(IResource source)
{
Contract.Require.That(source, Is.Not.Null).When("retrieving argument IResource in AbstractInterpreter constructor");
resource = source;
}
/// <summary>
/// Initializes a new instance of the ConfigurationClass class.
/// </summary>
/// <param name="objectName"></param>
/// <param name="type"></param>
public ConfigurationClass(string objectName, Type type)
{
_objectName = objectName;
_configurationClassType = type;
_resource = new ConfigurationClassAssemblyResource(type);
}
/// <summary>
/// Validats the specified resources for common issues associated with this
/// resource type
/// </summary>
/// <param name="context"></param>
/// <param name="resource"></param>
/// <param name="recurse"></param>
/// <returns></returns>
public virtual ValidationIssue[] Validate(ResourceValidationContext context, IResource resource, bool recurse)
{
if (!resource.GetResourceTypeDescriptor().Equals(this.SupportedResourceAndVersion))
return null;
return ValidateBase(context, resource, recurse);
}
public string Upload(IResource resource, string storeName)
{
// Authenticate the application (if not authenticated) and load the OAuth token
// if (!File.Exists(OAuthTokenFileName))
// {
// AuthorizeAppOAuth(dropboxServiceProvider);
// }
// OAuthToken oauthAccessToken = LoadOAuthToken();
// Login in Dropbox
IDropbox dropbox = this.dropboxServiceProvider
.GetApi(AuthorizationConstants.DropBoxOAuthAccessTokenValue, AuthorizationConstants.DropBoxOAuthAccessTokenSecret);
// Display user name (from his profile)
DropboxProfile profile = dropbox.GetUserProfileAsync().Result;
// Upload a file
Entry uploadFileEntry = dropbox.UploadFileAsync(resource, storeName).Result;
// Share a file
DropboxLink sharedUrl = dropbox.GetShareableLinkAsync(uploadFileEntry.Path).Result;
var link = dropbox.GetMediaLinkAsync(uploadFileEntry.Path).Result;
return link.Url;
}
public override void DecorateClass(IResource resource,
IMethod request,
CodeTypeDeclaration requestClass,
CodeTypeDeclaration resourceClass)
{
requestClass.Members.Add(CreateRequiredConstructor(resourceClass, request, false));
}
public string GetURL(IResource resource)
{
string url;
_lock.AcquireReaderLock(3000);
try
{
if (!_urlCache.TryGetValue(resource, out url))
{
var c = _lock.UpgradeToWriterLock(3000);
try
{
_urlCache.Add(resource, url = GetURLInternal(resource));
}
finally
{
_lock.DowngradeFromWriterLock(ref c);
}
}
}
finally
{
_lock.ReleaseReaderLock();
}
IProxyResource pr = resource as IProxyResource;
if (!(resource.Location is ExternalLocation) && pr != null && (pr.CultureSensitive || pr.CultureUISensitive))
{
url += "-";
if (pr.CultureSensitive)
url += CultureInfo.CurrentCulture.LCID.ToString("x");
url += "-";
if (pr.CultureUISensitive)
url += CultureInfo.CurrentCulture.LCID.ToString("x");
}
return url;
}
private string GetURLInternal(IResource resource)
{
IResourceLocation location = resource.Location;
string path;
if (location is TypeLocation)
{
TypeLocation tl = location as TypeLocation;
path = String.Format("{2}/{3}{0}/{1}{4}", HttpUtility.UrlPathEncode(tl.ProxyType.Assembly.GetName().Name), HttpUtility.UrlPathEncode(tl.ProxyType.FullName), AppPath, ResourceHttpHandler.AssemblyPath, ResourceHttpHandler.Extension);
}
else if (location is EmbeddedLocation)
{
EmbeddedLocation el = location as EmbeddedLocation;
path = String.Format("{2}/{3}{0}/{1}{4}", HttpUtility.UrlPathEncode(el.Assembly.GetName().Name), HttpUtility.UrlPathEncode(el.ResourceName), AppPath, ResourceHttpHandler.AssemblyPath, ResourceHttpHandler.Extension);
}
else if (location is VirtualPathLocation)
{
VirtualPathLocation vl = location as VirtualPathLocation;
path = HttpUtility.UrlPathEncode(vl.VirtualPath);
if (resource is IProxyResource) path += ResourceHttpHandler.Extension;
}
else if (location is ExternalLocation)
{
ExternalLocation el = location as ExternalLocation;
return el.Uri.ToString();
}
else
throw new Exception("Unknown IResourceLocationType");
return path + "?" + ToHex(resource.Version);
}
private string ParseReferenceElement(string serializedReferenceElement, IResource resource)
{
XElement referenceElement;
try
{
referenceElement = XElement.Parse(serializedReferenceElement);
}
catch (Exception)
{
return null;
}
var pathAttr = referenceElement.Attribute("path");
if (pathAttr != null)
{
string path = RemoveVsDocIfPresent(pathAttr.Value);
path = path.ToAppRelativePath(resource);
return path;
}
var nameAttr = referenceElement.Attribute("name");
if(nameAttr != null)
{
return CreateAssemblyVirtualPath(referenceElement, nameAttr.Value);
}
return null;
}
private static void ConvertRecursively(IResource currentResource, JObject node, JsonSerializer serializer)
{
if (currentResource == null)
{
return;
}
var currentResourceType = currentResource.GetType();
var readableProperties = GetReadablePropertyInfos(currentResourceType);
var nonResourceProperties = readableProperties.Where(IsNeitherResourceOrReservedProperty).ToList();
var resourceProperties = readableProperties.Where(IsResourceProperty).ToList();
node.Add(ReservedPropertyNames.Relations, JObject.FromObject(currentResource.Relations, serializer));
var embeddedResourceObject = new JObject();
node.Add(ReservedPropertyNames.EmbeddedResources, embeddedResourceObject);
foreach (var resourceProperty in resourceProperties)
{
var embeddedResourceNodeValue = new JObject();
ConvertRecursively((IResource)resourceProperty.GetValue(currentResource), embeddedResourceNodeValue, serializer);
embeddedResourceObject.Add(ToCamelCase(resourceProperty.Name), embeddedResourceNodeValue);
}
if (IsCollectionResourceType(currentResourceType))
{
var currentResourceDynamic = (dynamic) currentResource;
var jArray = new JArray();
string name = "";
foreach (IResource resourceItem in currentResourceDynamic.Items)
{
var embeddedResourceNodeValue = new JObject();
ConvertRecursively(resourceItem, embeddedResourceNodeValue, serializer);
jArray.Add(embeddedResourceNodeValue);
name = resourceItem.GetType().Name;
}
// Remove the "Resource" by convention.
if (name.EndsWith("Resource"))
{
name = name.Remove(name.LastIndexOf("Resource", StringComparison.Ordinal));
}
embeddedResourceObject.Add(ToCamelCase(name), jArray);
}
foreach (var nonResourceProperty in nonResourceProperties)
{
var value = nonResourceProperty.GetValue(currentResource);
if (value != null && value.GetType().GetTypeInfo().IsClass && value.GetType() != typeof(string))
{
node.Add(ToCamelCase(nonResourceProperty.Name), JToken.FromObject(value, serializer));
}
else
{
node.Add(ToCamelCase(nonResourceProperty.Name), new JValue(value));
}
}
}
public void DecorateClass(IResource resource,
string className,
CodeTypeDeclaration resourceClass,
ResourceClassGenerator generator,
string serviceClassName,
IEnumerable<IResourceDecorator> allDecorators)
{
resource.ThrowIfNull("resource");
className.ThrowIfNull("className");
resourceClass.ThrowIfNull("resourceClass");
generator.ThrowIfNull("generator");
serviceClassName.ThrowIfNull("serviceClassName");
allDecorators.ThrowIfNull("allDecorators");
if (!resource.IsServiceResource) // Only add subresources of normal resources, not the root resource.
{
// Add all subresources.
foreach (IResource subresource in resource.Resources.Values)
{
// Consider all members in the current class as invalid names.
var forbiddenWords = from CodeTypeMember m in resourceClass.Members select m.Name;
// Generate and add the subresource.
CodeTypeDeclaration decl = GenerateSubresource(
subresource, serviceClassName, allDecorators, generator.RequestGenerator,
generator.ContainerGenerator, forbiddenWords);
resourceClass.Members.Add(decl);
}
}
}
public async Task<Entry> UploadImageToCloud(IResource resource, string fileName, ITownsService towns, int townId)
{
string path = "/" + CreateFolder(towns, townId) + "/" + fileName;
Entry uploadFileEntry = await this.dropboxApi.UploadFileAsync(resource, path);
return uploadFileEntry;
}
public XmlNode Process(IResource resource)
{
try
{
using (resource)
{
var doc = new XmlDocument();
using (var stream = resource.GetStreamReader())
{
doc.Load(stream);
}
engine.PushResource(resource);
var element = Process(doc.DocumentElement);
engine.PopResource();
return element;
}
}
catch (ConfigurationProcessingException)
{
throw;
}
catch (Exception ex)
{
var message = String.Format("Error processing node resource {0}", resource);
throw new ConfigurationProcessingException(message, ex);
}
}
public virtual void Enlist(IResource resource)
{
logger.DebugFormat("Enlisting resource {0}", resource);
if (resource == null) throw new ArgumentNullException("resource");
// We can't add the resource more than once
if (resources.Contains(resource)) return;
if (Status == TransactionStatus.Active)
{
try
{
resource.Start();
}
catch(Exception ex)
{
state = TransactionStatus.Invalid;
logger.Error("Enlisting resource failed", ex);
throw;
}
}
resources.Add(resource);
logger.DebugFormat("Resource enlisted successfully {0}", resource);
}
public void Setup()
{
setupResource = new StaticContentResource(@"<?xml version=""1.0"" encoding=""utf-8"" ?>
<configuration>
<facilities>
<facility id=""startable"" type=""Castle.Facilities.Startable.StartableFacility, Castle.MicroKernel"" />
</facilities>
<components>
<!--if this line is uncommented (and the serviceB declared below commented), serviceA is resolved correctly -->
<!--<component id=""ServiceB"" type=""StartableFacilityTest.B, StartableFacilityTest"" service=""StartableFacilityTest.IB, StartableFacilityTest"" />-->
<component id=""ServiceA"" type=""Castle.Windsor.Tests.Bugs.FACILITIES_ISSUE_111.Components.A_Facilities_Issue_111, Castle.Windsor.Tests"" service=""Castle.Windsor.Tests.Bugs.FACILITIES_ISSUE_111.Components.IA_Facilities_Issue_111, Castle.Windsor.Tests"">
<parameters>
<ibs>
<array>
<item>${ServiceB}</item>
</array>
</ibs>
</parameters>
</component>
<component id=""ServiceB"" type=""Castle.Windsor.Tests.Bugs.FACILITIES_ISSUE_111.Components.B_Facilities_Issue_111, Castle.Windsor.Tests"" service=""Castle.Windsor.Tests.Bugs.FACILITIES_ISSUE_111.Components.IB_Facilities_Issue_111, Castle.Windsor.Tests"" />
</components>
</configuration>
");
}
private void listViewModels_SelectedIndexChanged(object sender, EventArgs e)
{
if (listViewModels.SelectedItems.Count > 0)
{
selectedItem = (IResource)listViewModels.SelectedItems[0].Tag;
}
}
public bool LoadMidi(IResource midiFile)
{
if (playing == true)
return false;
LoadMidiFile(new MidiFile(midiFile));
return true;
}
/// <summary>
/// Strips for ship.
/// </summary>
/// <param name="resource">The resource.</param>
/// <returns></returns>
public SerializableResource SerializeResourceForStudio(IResource resource)
{
// convert the fliping errors due to json issues in c# ;(
var errors = new List<ErrorInfo>();
var parseErrors = resource.Errors;
if(parseErrors != null)
{
errors.AddRange(parseErrors.Select(error => (error as ErrorInfo)));
}
var datalist = "<DataList></DataList>";
if(resource.DataList != null)
{
var replace = resource.DataList.Replace("\"", GlobalConstants.SerializableResourceQuote);
datalist = replace.Replace("'", GlobalConstants.SerializableResourceSingleQuote).ToString();
}
return new SerializableResource
{
Inputs = resource.Inputs,
Outputs = resource.Outputs,
ResourceCategory = resource.ResourcePath,
ResourceID = resource.ResourceID,
VersionInfo = resource.VersionInfo,
ResourceName = resource.ResourceName,
Permissions = AuthorizationService.GetResourcePermissions(resource.ResourceID),
ResourceType = resource.ResourceType,
IsValid = resource.IsValid,
DataList = datalist,
Errors = errors,
IsNewResource = resource.IsNewResource
};
}
public void LoadBank(IResource bankFile)
{
if (!bankFile.ReadAllowed())
throw new Exception("The bank file provided does not have read access.");
bank.Clear();
assets.PatchAssetList.Clear();
assets.SampleAssetList.Clear();
bankName = string.Empty;
comment = string.Empty;
switch (IOHelper.GetExtension(bankFile.GetName()).ToLower())
{
case ".bank":
bankName = IOHelper.GetFileNameWithoutExtension(bankFile.GetName());
LoadMyBank(bankFile.OpenResourceForRead());
break;
case ".sf2":
bankName = "SoundFont";
LoadSf2(bankFile.OpenResourceForRead());
break;
default:
throw new Exception("Invalid bank resource was provided. An extension must be included in the resource name.");
}
assets.PatchAssetList.TrimExcess();
assets.SampleAssetList.TrimExcess();
}
public Spec ThrowsSecurityExceptionIfUserIsNotLoggedOn(string input, IResource output)
{
return
new Spec()
.If(UserIsNotLoggedOn)
.Throws<SecurityException>();
}
/// <summary>
/// Parses a script from the specified resource.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="resource">The resource wcich to parse as script.</param>
/// <returns>Returns the parsed script.</returns>
/// <exception cref="ParseScriptException">Thrown when an exception occurres while parsing the script.</exception>
public IExpressionScript Parse(IMansionContext context, IResource resource)
{
// validate arguments
if (context == null)
throw new ArgumentNullException("context");
if (resource == null)
throw new ArgumentNullException("resource");
// open the script
var cacheKey = ResourceCacheKey.Create(resource);
return cachingService.GetOrAdd(
context,
cacheKey,
() =>
{
// get the phrase
string rawPhrase;
using (var resourceStream = resource.OpenForReading())
using (var reader = resourceStream.Reader)
rawPhrase = reader.ReadToEnd();
// let someone else do the heavy lifting
var phrase = ParsePhrase(context, rawPhrase);
// create the cache object
return new CachedPhrase(phrase);
});
}
public void DecorateClass(IResource resource,
string className,
CodeTypeDeclaration resourceClass,
ResourceClassGenerator generator,
string serviceClassName,
IEnumerable<IResourceDecorator> allDecorators)
{
var gen = new ResourceGenerator(className, objectTypeProvider, commentCreator);
foreach (var method in resource.Methods.Values)
{
logger.Debug("Adding RequestObject Method {0}.{1}", resource.Name, method.Name);
// Add the default request method to the class:
CodeTypeMember convenienceMethod = gen.CreateMethod(resourceClass, resource, method, false);
if (convenienceMethod != null)
{
resourceClass.Members.Add(convenienceMethod);
}
// Add the request method specifiying all parameters (also optional ones) to the class:
if (AddOptionalParameters && method.HasOptionalParameters())
{
convenienceMethod = gen.CreateMethod(resourceClass, resource, method, true);
if (convenienceMethod != null)
{
resourceClass.Members.Add(convenienceMethod);
}
}
}
}
public HtmlProxy(FileLocation location)
{
_includes = new IResource[0];
_references = _builds = _includes;
_location = location;
_version = ChecksumHelper.GetCombinedChecksum(location.Version, _includes, _builds);
}
public void ChangePropDataType()
{
IResource res = _storage.FindUniqueResource("PropType", "Name", "Name");
res.SetProp("DataType", (int)PropDataType.Int);
}
/* *
* Checks if a given INode is spin:query or a sub-property of it.
* @param predicate the INode to test
* @return true if predicate is a query property
*/
public static bool isQueryProperty(IResource predicate)
{
return(RDFUtil.sameTerm(SPIN.PropertyQuery, predicate) || predicate.hasProperty(RDFS.PropertySubPropertyOf, SPIN.PropertyQuery));
}
/* *
* Checks whether a given module has been declared abstract using
* <code>spin:abstract</code.
* @param module the module to test
* @return true if abstract
*/
public static bool isAbstract(IResource module)
{
return(module.hasProperty(SPIN.PropertyAbstract, RDFUtil.TRUE));
}
/* *
* Creates a new NamedGraph element as a blank node in a given Model.
* @param model the Model to generate the NamedGraph in
* @param graphNameNode the URI resource of the graph name
* @param elements the elements in the NamedGraph
* @return a new NamedGraph
*/
public static INamedGraph createNamedGraph(SpinProcessor model, INode graphNameNode, IResource elements)
{
INamedGraph result = (INamedGraph)model.CreateResource(SP.ClassNamedGraph).As(typeof(NamedGraphImpl));
result.AddProperty(SP.PropertyGraphNameNode, graphNameNode);
result.AddProperty(SP.PropertyElements, elements);
return(result);
}
/* *
* Checks whether a given INode represents a SPARQL element, and returns
* an instance of a subclass of Element if so.
* @param resource the INode to check
* @return INode as an Element or null if resource is not an element
*/
public static IElement asElement(IResource resource)
{
if (resource == null)
{
return(null);
}
/*sealed*/
ITriplePattern triplePattern = asTriplePattern(resource);
if (triplePattern != null)
{
return(triplePattern);
}
else if (resource.canAs(SP.ClassTriplePath))
{
return((ITriplePath)resource.As(typeof(TriplePathImpl)));
}
else if (resource.canAs(SP.ClassFilter))
{
return((IFilter)resource.As(typeof(FilterImpl)));
}
else if (resource.canAs(SP.ClassBind))
{
return((IBind)resource.As(typeof(BindImpl)));
}
else if (resource.canAs(SP.ClassOptional))
{
return((IOptional)resource.As(typeof(OptionalImpl)));
}
else if (resource.canAs(SP.ClassNamedGraph))
{
return((INamedGraph)resource.As(typeof(NamedGraphImpl)));
}
else if (resource.canAs(SP.ClassMinus))
{
return((IMinus)resource.As(typeof(MinusImpl)));
}
else if (resource.canAs(SP.ClassExists))
{
return((IExists)resource.As(typeof(ExistsImpl)));
}
else if (resource.canAs(SP.ClassNotExists))
{
return((INotExists)resource.As(typeof(NotExistsImpl)));
}
else if (resource.canAs(SP.ClassService))
{
return((IService)resource.As(typeof(ServiceImpl)));
}
else if (resource.canAs(SP.ClassSubQuery))
{
return((ISubQuery)resource.As(typeof(SubQueryImpl)));
}
else if (resource.canAs(SP.ClassUnion))
{
return((IUnion)resource.As(typeof(UnionImpl)));
}
else if (resource.canAs(SP.ClassValues))
{
return((IValues)resource.As(typeof(ValuesImpl)));
}
else if (isElementList(resource))
{
return((IElementList)resource.As(typeof(ElementListImpl)));
}
else
{
return(null);
}
}
public void Enlist(IResource resource)
{
throw new NotImplementedException();
}
public override void Execute()
{
if (Parameters.Count > 1)
{
if (Parameters[0].StartsWith("/"))
{
Parameters[0] = Parameters[0].Substring(1);
}
LWM2MResource resource = _Client.GetResource(Parameters[0]) as LWM2MResource;
if (resource == null)
{
IResource parentResource = _Client.GetParentResource(Parameters[0]);
resource = parentResource as LWM2MResource;
if (resource == null && parentResource.Parent != null && String.IsNullOrEmpty(parentResource.Parent.Path))
{
// object instance does not exist
LWM2MResources resources = parentResource as LWM2MResources;
string instanceID = Parameters[0].Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries)[1];
parentResource = resource = resources.CreateResource(instanceID);
resources.ModifiedResource = resource;
resources.Changed();
//(parentResource as LWM2MResource).Changed();
resource = null;
}
if (resource == null)
{
LWM2MResources resources = parentResource as LWM2MResources;
if (resources != null)
{
string[] paths = Parameters[0].Split('/');
string name = paths[paths.Length - 1];
LWM2MResource childResource = null;
BooleanResources booleanResources = resources as BooleanResources;
if (booleanResources == null)
{
DateTimeResources dateTimeResources = resources as DateTimeResources;
if (dateTimeResources == null)
{
FloatResources floatResources = resources as FloatResources;
if (floatResources == null)
{
IntegerResources integerResources = resources as IntegerResources;
if (integerResources == null)
{
OpaqueResources opaqueResources = resources as OpaqueResources;
if (opaqueResources == null)
{
StringResources stringResources = resources as StringResources;
if (stringResources == null)
{
}
else
{
childResource = new StringResource(name);
}
}
else
{
childResource = new OpaqueResource(name);
}
}
else
{
childResource = new IntegerResource(name);
}
}
else
{
childResource = new FloatResource(name);
}
}
else
{
childResource = new DateTimeResource(name);
}
}
else
{
childResource = new BooleanResource(name);
}
if (childResource != null)
{
childResource.SetValue(Parameters[1]);
resources.Add(childResource);
}
}
}
else
{
}
}
else
{
resource.SetValue(Parameters[1]);
resource.Changed();
LWM2MResource parent = resource.Parent as LWM2MResource;
if (parent != null)
{
parent.Changed();
LWM2MResources grandparent = parent.Parent as LWM2MResources;
if (grandparent != null)
{
grandparent.Changed();
}
}
}
}
}
public Resource(IResource copy)
: base(copy)
{
}
/* *
* Checks whether a given INode is a TemplateCall. The condition for this
* is stricter than for <code>asTemplateCall</code> as the node also must have
* a valid template assigned to it, i.e. the type of the node must be an
* instance of spin:Template.
* @param node the INode to check
* @return true if node is a TemplateCall
*/
public static bool isTemplateCall(IResource node)
{
ITemplateCall templateCall = asTemplateCall(node);
return(templateCall != null && templateCall.getTemplate() != null);
}
public static void UpdateResourceXml(IResourceCatalog resourceCatalog, Guid workspaceID, IResource effectedResource, IList <ICompileMessageTO> compileMessagesTO)
{
var resourceContents = resourceCatalog.GetResourceContents(workspaceID, effectedResource.ResourceID);
UpdateXmlToDisk(effectedResource, compileMessagesTO, resourceContents);
var serverResource = resourceCatalog.GetResource(Guid.Empty, effectedResource.ResourceName);
if (serverResource != null)
{
resourceContents = resourceCatalog.GetResourceContents(Guid.Empty, serverResource.ResourceID);
UpdateXmlToDisk(serverResource, compileMessagesTO, resourceContents);
}
}
/// <summary>
/// Reads the specified configuration section into the supplied
/// <see cref="System.Collections.Specialized.NameValueCollection"/>.
/// </summary>
/// <param name="resource">The resource to read.</param>
/// <param name="configSection">The section name.</param>
/// <param name="properties">
/// The collection that is to be populated. May be
/// <see langword="null"/>.
/// </param>
/// <returns>
/// A newly populated
/// <see cref="System.Collections.Specialized.NameValueCollection"/>.
/// </returns>
/// <exception cref="System.IO.IOException">
/// If any errors are encountered while attempting to open a stream
/// from the supplied <paramref name="resource"/>.
/// </exception>
/// <exception cref="System.Xml.XmlException">
/// If any errors are encountered while loading or reading (this only applies to
/// v1.1 and greater of the .NET Framework) the actual XML.
/// </exception>
/// <exception cref="System.Exception">
/// If any errors are encountered while loading or reading (this only applies to
/// v1.0 of the .NET Framework).
/// </exception>
/// <exception cref="Spring.Objects.FatalObjectException">
/// If the configuration section was otherwise invalid.
/// </exception>
public static NameValueCollection Read(
IResource resource, string configSection, NameValueCollection properties)
{
return(ConfigurationReader.Read(resource, configSection, properties, true));
}
/* *
* Checks whether a given INode is a variable.
* @param node the node to check
* @return true if node is a variable
*/
public static bool isVariable(IResource node)
{
return(asVariable(node) != null);
}
/// <summary>
/// Creates a new instance of the ObjectDefinitionParsingException class.
/// </summary>
/// <param name="resourceLocation">
/// The resource location (e.g. an XML object definition file) associated
/// with the offending object definition.
/// </param>
/// <param name="message">
/// A message about the exception.
/// </param>
/// <param name="name">
/// The name of the object that triggered the exception.
/// </param>
/// <param name="rootCause">
/// The root exception that is being wrapped.
/// </param>
public ObjectDefinitionParsingException(IResource resourceLocation, string name, string message, Exception rootCause)
: base(resourceLocation, name, message, rootCause)
{
}
/// <summary>
/// Reads the specified configuration section into a
/// <see cref="System.Collections.Specialized.NameValueCollection"/>.
/// </summary>
/// <param name="resource">The resource to read.</param>
/// <param name="configSection">The section name.</param>
/// <returns>
/// A newly populated
/// <see cref="System.Collections.Specialized.NameValueCollection"/>.
/// </returns>
/// <exception cref="System.IO.IOException">
/// If any errors are encountered while attempting to open a stream
/// from the supplied <paramref name="resource"/>.
/// </exception>
/// <exception cref="System.Xml.XmlException">
/// If any errors are encountered while loading or reading (this only applies to
/// v1.1 and greater of the .NET Framework) the actual XML.
/// </exception>
/// <exception cref="System.Exception">
/// If any errors are encountered while loading or reading (this only applies to
/// v1.0 of the .NET Framework).
/// </exception>
/// <exception cref="Spring.Objects.FatalObjectException">
/// If the configuration section was otherwise invalid.
/// </exception>
public static NameValueCollection Read(IResource resource, string configSection)
{
return(ConfigurationReader.Read(resource, configSection, new NameValueCollection()));
}
/// <summary> /// Loads the resource. /// </summary> /// <param name="resource">Resource to load</param> /// <param name="type">Type of resource</param> /// <param name="parameters">Loader parameters</param> /// <returns>Loaded object</returns> public abstract Object Load(IResource resource, Type type, LoaderParameters parameters);
public static Resource FindMatchingResource(AssemblyDefinition adef, IResource item)
{
return(adef.MainModule.Resources.FirstOrDefault(p => p.Name == item.Name));
}
public FEnumItem(Type type, object item)
{
_item = item;
_type = type;
_resource = RResource.Find(_type);
}
public ResourceTypeProperty(IResource resource) : base(resource)
{
}
/// <summary>
/// Applies a HTTP method on a specific resource.
/// </summary>
/// <param name="method">
/// The HTTP method.
/// </param>
/// <param name="resource">
/// The resource.
/// </param>
/// <param name="options">
/// The options.
/// </param>
public void Apply(HttpMethod method, IResource resource, Dictionary <string, object> options)
{
Handle(method, resource, options, new List <Uri>());
}
public SqlServer(IResource resource) : base(resource)
{
}
/// <summary>
/// Indicates wheter a given resource is part of the model.
/// </summary>
/// <param name="resource">A resource object.</param>
/// <param name="transaction">ransaction associated with this action.</param>
/// <returns>True if the resource is part of the model, False if not.</returns>
public bool ContainsResource(IResource resource, ITransaction transaction = null)
{
return(ContainsResource(resource.Uri, transaction));
}
public FEnumItem(object item)
{
_item = item;
_type = item.GetType();
_resource = RResource.Find(_type);
}
public void Remove(IResource resource)
{
myResources.Remove(resource);
OnResourceRemoved(resource);
}
public async Task <HalResourceInspectedContext> OnResourceInspectionAsync(
HalResourceInspectingContext context,
HalResourceInspectionDelegate next)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
if (!context.IsRootResource)
{
throw new NotSupportedException("This inspector does not support embedded resources.");
}
if (context.Resource == null)
{
return(await next());
}
if (context.ActionContext == null)
{
throw new ArgumentException("ActionContext cannot be null.", nameof(context));
}
if (!(context.ActionContext.ActionDescriptor is ControllerActionDescriptor descriptor))
{
throw new HalException("Could not establish ControllerActionDescriptor reference.");
}
if (context.ActionContext.HttpContext == null || context.ActionContext.HttpContext.Features == null)
{
throw new ArgumentException("HttpContext features cannot be null.", nameof(context));
}
if (context.MvcPipeline == null)
{
throw new ArgumentException("Context does not contain the mvc pipeline.", nameof(context));
}
var requestFeature = context.ActionContext.HttpContext.Features.Get <IHttpRequestFeature>();
var links = linkService.GetLinks <HalEmbedAttribute>(descriptor, context.ActionContext, context.OriginalObject);
foreach (var link in links)
{
var halRequestFeature = new HalHttpRequestFeature(requestFeature)
{
Method = "GET",
Path = link.Uri
};
var halContext = new HalHttpContext(context.ActionContext.HttpContext, halRequestFeature);
logger.LogDebug("About to invoke MVC pipeline with a GET request on path '{0}'.", link.Uri);
await context.MvcPipeline.Pipeline(halContext);
var response = halContext.Response as HalHttpResponse;
if (response.StatusCode >= 200 && response.StatusCode <= 299)
{
logger.LogDebug("MVC pipeline returned success status code {0}. Invoking HAL resource factory.", response.StatusCode);
IResource embedded = await context.EmbeddedResourcePipeline(response.ActionContext, response.Resource);
embedded.Rel = link.Rel;
if (embedded is IResourceCollection collection)
{
if (collection.Collection != null)
{
logger.LogDebug("Embedding collection of {0} resources to rel '{0}'", collection.Collection.Count, link.Rel);
foreach (var item in collection.Collection)
{
item.Rel = link.Rel;
context.Resource.Embedded.Add(item);
}
}
}
else
{
logger.LogDebug("Embedding resource to rel '{0}'", link.Rel);
context.Resource.Embedded.Add(embedded);
}
}
else
{
logger.LogWarning("MVC pipeline returned non-success status code {0}. Ignoring result.", response.StatusCode);
}
}
var result = await next();
logger.LogTrace("After invoke next.");
return(result);
}
private void OnResourceRemoved(IResource resource) => ResourceRemoved?.Invoke(this, new ResourceEventArgs(resource));
/// <summary>
/// Removes the given resource from the model and its backing RDF store. Note that there is no verification
/// that the given resource and its stored represenation have identical properties.
/// </summary>
/// <param name="resource">A resource object.</param>
/// <param name="transaction">ransaction associated with this action.</param>
public void DeleteResource(IResource resource, ITransaction transaction = null)
{
DeleteResource(resource.Uri);
}
public bool MatchQuery(string query, IResource res)
{
return(false);
}
public void Add(IResource resource)
{
myResources.Add(resource);
OnResourceAdded(resource);
}
public void ProcessQuery(string query)
{
//-----------------------------------------------------------------
// Avoid perform any UI (and other, generally) work if we are
// shutting down - some components (like DefaultViewPane) may
// already be disposed.
//-----------------------------------------------------------------
if (Core.State != CoreState.Running)
{
return;
}
//-----------------------------------------------------------------
// Extract Search Extension subphrases, extract them out of the
// query and convert them into the list of conditions.
//-----------------------------------------------------------------
int anchorPos;
string[] resTypes = null;
bool parseSuccessful = false;
ArrayList conditions = new ArrayList();
do
{
string anchor;
FindSearchExtension(query, out anchor, out anchorPos);
if (anchorPos != -1)
{
parseSuccessful = ParseSearchExtension(anchor, anchorPos, ref query, out resTypes, conditions);
}
}while((anchorPos != -1) && parseSuccessful);
//-----------------------------------------------------------------
// Create condition from the query
//-----------------------------------------------------------------
IFilterRegistry fMgr = Core.FilterRegistry;
IResource queryCondition = ((FilterRegistry)fMgr).CreateStandardConditionAux(null, query, ConditionOp.QueryMatch);
FilterRegistry.ReferCondition2Template(queryCondition, fMgr.Std.BodyMatchesSearchQueryXName);
conditions.Add(queryCondition);
//-----------------------------------------------------------------
bool showContexts = Core.SettingStore.ReadBool("Resources", "ShowSearchContext", true);
bool showDelItems = Core.SettingStore.ReadBool("Search", "ShowDeletedItems", true);
IResource[] condsList = (IResource[])conditions.ToArray(typeof(IResource));
IResource view = Core.ResourceStore.FindUniqueResource(FilterManagerProps.ViewResName, "DeepName", Core.FilterRegistry.ViewNameForSearchResults);
if (view != null)
{
fMgr.ReregisterView(view, fMgr.ViewNameForSearchResults, resTypes, condsList, null);
}
else
{
view = fMgr.RegisterView(fMgr.ViewNameForSearchResults, resTypes, condsList, null);
}
Core.FilterRegistry.SetVisibleInAllTabs(view);
//-----------------------------------------------------------------
// Set additional properties characteristic only for "Search Results"
// view.
//-----------------------------------------------------------------
ResourceProxy proxy = new ResourceProxy(view);
proxy.BeginUpdate();
proxy.SetProp(Core.Props.Name, AdvancedSearchForm.SearchViewPrefix + query);
proxy.SetProp("_DisplayName", AdvancedSearchForm.SearchViewPrefix + query);
proxy.SetProp(Core.Props.ShowDeletedItems, showDelItems);
proxy.SetProp("ShowContexts", showContexts);
proxy.SetProp("ForceExec", true);
if (Core.SettingStore.ReadBool("Search", "AutoSwitchToResults", true))
{
proxy.SetProp("RunToTabIfSingleTyped", true);
}
else
{
proxy.DeleteProp("RunToTabIfSingleTyped");
}
proxy.EndUpdate();
//-----------------------------------------------------------------
// Add new view to the panel
// Some steps to specify the correct user-ordering for the new view.
//-----------------------------------------------------------------
Core.ResourceTreeManager.LinkToResourceRoot(view, int.MinValue);
new UserResourceOrder(Core.ResourceTreeManager.ResourceTreeRoot).Insert(0, new int[] { view.Id }, false, null);
//-----------------------------------------------------------------
// If we still in the Running mode we can do some UI work...
//-----------------------------------------------------------------
if (Core.State == CoreState.Running)
{
Core.UIManager.BeginUpdateSidebar();
Core.LeftSidebar.ActivateViewPane(StandardViewPanes.ViewsCategories);
Core.UIManager.EndUpdateSidebar();
Core.LeftSidebar.DefaultViewPane.SelectResource(view);
}
}
public bool MatchQuery(string query, IResource res)
{
bool matched = _queryManager.MatchResource(res, query);
return(matched);
}