/// <summary> /// Retreaves StringDictionary object from database or file system /// </summary> /// <param name="exType">Extension Type</param> /// <param name="exId">Extension Id</param> /// <returns>StringDictionary object as Stream</returns> public object GetSettings(ExtensionType exType, string exId) { SerializableStringDictionary ssd = null; StringDictionary sd = new StringDictionary(); XmlSerializer serializer = new XmlSerializer(typeof(SerializableStringDictionary)); if (_section.DefaultProvider == "XmlTrainProvider") { Stream stm = (Stream)TrainService.LoadFromDataStore(exType, exId); if (stm != null) { ssd = (SerializableStringDictionary)serializer.Deserialize(stm); stm.Close(); sd = (StringDictionary)ssd; } } else { object o = TrainService.LoadFromDataStore(exType, exId); if (!string.IsNullOrEmpty((string)o)) { using (StringReader reader = new StringReader((string)o)) { ssd = (SerializableStringDictionary)serializer.Deserialize(reader); } sd = (StringDictionary)ssd; } } return sd; }
/// <summary> /// Retreaves StringDictionary object from database or file system /// </summary> /// <param name="extensionType"> /// Extension Type /// </param> /// <param name="extensionId"> /// Extension Id /// </param> /// <returns> /// StringDictionary object as Stream /// </returns> public object GetSettings(ExtensionType extensionType, string extensionId) { SerializableStringDictionary ssd; var sd = new StringDictionary(); var serializer = new XmlSerializer(typeof(SerializableStringDictionary)); if (Section.DefaultProvider == "XmlBlogProvider") { var stm = (Stream)BlogService.LoadFromDataStore(extensionType, extensionId); if (stm != null) { ssd = (SerializableStringDictionary)serializer.Deserialize(stm); stm.Close(); sd = ssd; } } else { var o = BlogService.LoadFromDataStore(extensionType, extensionId); if (!string.IsNullOrEmpty((string)o)) { using (var reader = new StringReader((string)o)) { ssd = (SerializableStringDictionary)serializer.Deserialize(reader); } sd = ssd; } } return sd; }
/// <summary> /// Gets settings from data store /// </summary> /// <param name="extensionType"> /// Extension Type /// </param> /// <param name="extensionId"> /// Extension ID /// </param> /// <returns> /// Settings as Stream /// </returns> public object GetSettings(ExtensionType extensionType, string extensionId) { WidgetData widgetData; var xml = new XmlDocument(); if (Section.DefaultProvider == "XmlBlogProvider") { var stm = (Stream)BlogService.LoadFromDataStore(extensionType, extensionId); if (stm != null) { var x = new XmlSerializer(typeof(XmlDocument)); xml = (XmlDocument)x.Deserialize(stm); stm.Close(); } } else { var o = BlogService.LoadFromDataStore(extensionType, extensionId); if (!string.IsNullOrEmpty((string)o)) { var serializer = new XmlSerializer(typeof(WidgetData)); using (var reader = new StringReader((string)o)) { widgetData = (WidgetData)serializer.Deserialize(reader); } if (widgetData.Settings.Length > 0) { xml.InnerXml = widgetData.Settings; } } } return xml; }
/// <summary> /// Gets settings from data store /// </summary> /// <param name="exType">Extension Type</param> /// <param name="exId">Extension ID</param> /// <returns>Settings as Stream</returns> public object GetSettings(ExtensionType exType, string exId) { WidgetData wd = new WidgetData(); XmlDocument xml = new XmlDocument(); if (_section.DefaultProvider == "XmlTrainProvider") { Stream stm = (Stream)TrainService.LoadFromDataStore(exType, exId); if (stm != null) { XmlSerializer x = new XmlSerializer(typeof(XmlDocument)); xml = (XmlDocument)x.Deserialize(stm); stm.Close(); } } else { object o = TrainService.LoadFromDataStore(exType, exId); if (!string.IsNullOrEmpty((string)o)) { XmlSerializer serializer = new XmlSerializer(typeof(WidgetData)); using (StringReader reader = new StringReader((string)o)) { wd = (WidgetData)serializer.Deserialize(reader); } if (wd.Settings.Length > 0) xml.InnerXml = wd.Settings; } } return xml; }
//--------------------------------------------------------------------- /// <summary> /// Initializes a new instance. /// </summary> /// <param name="name">The extension's name</param> /// <param name="type">The extension's type</param> /// <param name="mainClass">The AssemblyQualifiedName of the /// extension's main class (dervied from ExtensionMain).</param> public ExtensionInfo(string name, ExtensionType type, string mainClass) : base(name, typeof(ExtensionMain), mainClass) { this.type = type; }
/// <summary> /// Initializes a new instance of the <see cref="ClientExtension"/> class. /// </summary> /// <param name="type">Extension type</param> /// <param name="scope">Extension install scope</param> /// <param name="manifestStream">Manifest stream, can be null</param> /// <param name="marketplaceAssetID">The asset ID for Office Marketplace</param> /// <param name="marketplaceContentMarket">The content market for Office Marketplace</param> /// <param name="isAvailable">Whether extension is available</param> /// <param name="isMandatory">Whether extension is mandatory</param> /// <param name="isEnabledByDefault">Whether extension is enabled by default</param> /// <param name="providedTo">Who the extension is provided for (e.g. "entire org" or "specific users")</param> /// <param name="specificUsers">List of users extension is provided for, can be null</param> /// <param name="appStatus">App status</param> /// <param name="etoken">Etoken</param> public ClientExtension( ExtensionType type, ExtensionInstallScope scope, Stream manifestStream, string marketplaceAssetID, string marketplaceContentMarket, bool isAvailable, bool isMandatory, bool isEnabledByDefault, ClientExtensionProvidedTo providedTo, StringList specificUsers, string appStatus, string etoken) : this() { this.Type = type; this.Scope = scope; this.ManifestStream = manifestStream; this.MarketplaceAssetID = marketplaceAssetID; this.MarketplaceContentMarket = marketplaceContentMarket; this.IsAvailable = isAvailable; this.IsMandatory = isMandatory; this.IsEnabledByDefault = isEnabledByDefault; this.ProvidedTo = providedTo; this.SpecificUsers = specificUsers; this.AppStatus = appStatus; this.Etoken = etoken; }
public void SendMessage(object msg, ExtensionType type) { var foundExts = _extensions.Where(x => x.ExtensionType == type); foreach (var ext in foundExts) { ext.Extension.RecieveMessage(msg); } }
/// <summary> /// Saves extension to database or file system /// </summary> /// <param name="exType">Extension Type</param> /// <param name="exId">Extension ID</param> /// <param name="settings">Extension object</param> /// <returns>True if saved</returns> public bool SaveSettings(ExtensionType exType, string exId, object settings) { try { BlogService.SaveToDataStore(exType, exId, settings); return true; } catch (Exception) { throw; } }
/// <summary> /// Initializes new instance of Http2 server. /// </summary> /// <param name="port">Port to listen.</param> public Http2Server(int port) { this.Port = port; ExtensionType[] extensions = new ExtensionType[] { ExtensionType.Renegotiation, ExtensionType.ALPN }; SecurityOptions options = new SecurityOptions(SecureProtocol.Tls1, extensions, ConnectionEnd.Server); options.VerificationType = CredentialVerification.None; options.Certificate = Org.Mentalis.Security.Certificates.Certificate.CreateFromCerFile(@"certificate.pfx"); options.Flags = SecurityFlags.Default; options.AllowedAlgorithms = SslAlgorithms.RSA_AES_128_SHA | SslAlgorithms.NULL_COMPRESSION; _server = new SecureTcpListener(Port, options); }
/// <summary> /// Gets the extensions available for the given type. /// </summary> /// <param name="type">The extension type</param> /// <param name="draft">Whether the entity is a draft or not</param> /// <returns>A list of extensions</returns> public static List<Models.Extension> GetByType(ExtensionType type, bool draft = false) { var ext = new List<Models.Extension>() ; Extensions.Where(extension => extension.ExtensionType.HasFlag(type)).ToList().ForEach(e => { ext.Add(new Models.Extension() { IsDraft = draft, Type = e.Type.ToString(), Body = (IExtension)Activator.CreateInstance(e.Type) }) ; }); return ext ; }
public Load(string name, ExtensionType extensionType, BasicType basicType, object value) { this.name = name; if (extensionType != ExtensionType.List) { throw new Exception("Not supported type"); } this.data = new List(basicType.ToString(), value); }
private static bool AddExtensionToResult(byte[] buffer, ref int currentLen, Int16 extLen, ConnectionEnd end, ExtensionList knownExtensions, ExtensionType type, ref ExtensionList result) { foreach (var extension in knownExtensions) { if (extension.Type == type) { result.Add(extension.Parse(buffer, ref currentLen, extLen, end)); return true; } } return false; }
/// <summary> /// Gets the extensions available for the given type and entity. /// </summary> /// <param name="type">The extension type</param> /// <param name="id">The entity id</param> /// <param name="draft">Whether the entity is a draft or not</param> /// <returns>A list of extensions</returns> public static List<Models.Extension> GetByTypeAndEntity(ExtensionType type, Guid id, bool draft) { var ret = new List<Models.Extension>() ; var tmp = GetByType(type, draft) ; foreach (var e in tmp) { var ext = Models.Extension.GetSingle("extension_type = @0 AND extension_parent_id = @1 AND extension_draft = @2", e.Type, id, draft) ; if (ext != null) ret.Add(ext) ; else ret.Add(e) ; } return ret ; }
/// <summary> /// Save settings to generic data store /// </summary> /// <param name="extensionType"> /// Type of extension /// </param> /// <param name="extensionId"> /// Extension ID /// </param> /// <param name="settings"> /// Stream Settings /// </param> public override void SaveToDataStore(ExtensionType extensionType, string extensionId, object settings) { var fileName = string.Format("{0}{1}.xml", StorageLocation(extensionType), extensionId); if (!Directory.Exists(StorageLocation(extensionType))) { Directory.CreateDirectory(StorageLocation(extensionType)); } using (TextWriter writer = new StreamWriter(fileName)) { var x = new XmlSerializer(settings.GetType()); x.Serialize(writer, settings); } }
/// <summary> /// Loads settings from generic data store /// </summary> /// <param name="extensionType"> /// Extension Type /// </param> /// <param name="extensionId"> /// Extension ID /// </param> /// <returns> /// Stream Settings /// </returns> public override object LoadFromDataStore(ExtensionType extensionType, string extensionId) { var fileName = string.Format("{0}{1}.xml", StorageLocation(extensionType), extensionId); Stream str = null; if (!Directory.Exists(StorageLocation(extensionType))) { Directory.CreateDirectory(StorageLocation(extensionType)); } if (File.Exists(fileName)) { var reader = new StreamReader(fileName); str = reader.BaseStream; } return str; }
/// <summary> /// Save settings to generic data store /// </summary> /// <param name="exType">Type of extension</param> /// <param name="exId">Extension ID</param> /// <param name="settings">Stream Settings</param> public override void SaveToDataStore(ExtensionType exType, string exId, object settings) { string _fileName = StorageLocation(exType) + exId + ".xml"; try { if (!Directory.Exists(StorageLocation(exType))) Directory.CreateDirectory(StorageLocation(exType)); TextWriter writer = new StreamWriter(_fileName); XmlSerializer x = new XmlSerializer(settings.GetType()); x.Serialize(writer, settings); writer.Close(); } catch (Exception e) { string s = e.Message; throw; } }
/// <summary> /// Saves String Dictionary to Data Store /// </summary> /// <param name="exType">Extension Type</param> /// <param name="exId">Extension Id</param> /// <param name="settings">StringDictionary settings</param> /// <returns></returns> public bool SaveSettings(ExtensionType exType, string exId, object settings) { try { StringDictionary sd = (StringDictionary)settings; SerializableStringDictionary ssd = new SerializableStringDictionary(); foreach (DictionaryEntry de in sd) { ssd.Add(de.Key.ToString(), de.Value.ToString()); } TrainService.SaveToDataStore(exType, exId, ssd); return true; } catch (Exception) { throw; } }
/// <summary> /// Construct an Addin for a type. /// </summary> /// <param name="type">The type to be used</param> public Addin( Type type ) { this.typeName = type.AssemblyQualifiedName; object[] attrs = type.GetCustomAttributes( typeof(NUnitAddinAttribute), false ); if ( attrs.Length == 1 ) { NUnitAddinAttribute attr = (NUnitAddinAttribute)attrs[0]; this.name = attr.Name; this.description = attr.Description; this.extensionType = attr.Type; } if ( this.name == null ) this.name = type.Name; if ( this.extensionType == 0 ) this.extensionType = ExtensionType.Core; this.status = AddinStatus.Enabled; }
/// <summary> /// Loads settings from generic data store /// </summary> /// <param name="exType">Extension Type</param> /// <param name="exId">Extension ID</param> /// <returns>Stream Settings</returns> public override object LoadFromDataStore(ExtensionType exType, string exId) { string _fileName = StorageLocation(exType) + exId + ".xml"; StreamReader reader = null; Stream str = null; try { if (!Directory.Exists(StorageLocation(exType))) Directory.CreateDirectory(StorageLocation(exType)); if (File.Exists(_fileName)) { reader = new StreamReader(_fileName); str = reader.BaseStream; } } catch (Exception) { throw; } return str; }
/// <summary> /// Gets the extensions available for the given type. /// </summary> /// <param name="type">The extension type</param> /// <param name="draft">Whether the entity is a draft or not</param> /// <returns>A list of extensions</returns> public List<Models.Extension> GetByType(ExtensionType type, bool draft = false) { var extensions = new List<Models.Extension>() ; foreach (var ext in Extensions.Where(e => e.Metadata.Type.HasFlag(type))) { extensions.Add(new Models.Extension() { IsDraft = draft, Type = ext.Value.GetType().FullName, Body = (IExtension)Activator.CreateInstance(ext.Value.GetType()) }) ; } return extensions ; }
/// <summary> /// Retreaves extension object from database or file system /// </summary> /// <param name="exType">Extension Type</param> /// <param name="exId">Extension ID</param> /// <returns>Extension object as Stream</returns> public object GetSettings(ExtensionType exType, string exId) { return BlogService.LoadFromDataStore(exType, exId); }
/// <summary> /// Saves extension to database or file system /// </summary> /// <param name="extensionType"> /// Extension Type /// </param> /// <param name="extensionId"> /// Extension ID /// </param> /// <param name="settings"> /// Extension object /// </param> /// <returns> /// True if saved /// </returns> public bool SaveSettings(ExtensionType extensionType, string extensionId, object settings) { BlogService.SaveToDataStore(extensionType, extensionId, settings); return true; }
/// <summary> /// Load user data from DataStore /// </summary> /// <param name="exType">type of info</param> /// <param name="exId">id of info</param> /// <returns>stream of detail data</returns> public override object LoadFromDataStore(ExtensionType exType, string exId) { //MemoryStream stream; object o = null; string connString = ConfigurationManager.ConnectionStrings[connStringName].ConnectionString; string providerName = ConfigurationManager.ConnectionStrings[connStringName].ProviderName; DbProviderFactory provider = DbProviderFactories.GetFactory(providerName); using (DbConnection conn = provider.CreateConnection()) { conn.ConnectionString = connString; using (DbCommand cmd = conn.CreateCommand()) { string sqlQuery = "SELECT Settings FROM " + tablePrefix + "DataStoreSettings " + "WHERE ExtensionType = " + parmPrefix + "etype AND ExtensionId = " + parmPrefix + "eid"; cmd.CommandText = sqlQuery; cmd.CommandType = CommandType.Text; conn.Open(); DbParameter dpeType = provider.CreateParameter(); dpeType.ParameterName = parmPrefix + "etype"; dpeType.Value = exType.GetHashCode(); cmd.Parameters.Add(dpeType); DbParameter dpeId = provider.CreateParameter(); dpeId.ParameterName = parmPrefix + "eid"; dpeId.Value = exId; cmd.Parameters.Add(dpeId); o = cmd.ExecuteScalar(); } } return o; }
/// <summary> /// Save to DataStore /// </summary> /// <param name="exType">type of info</param> /// <param name="exId">id of info</param> /// <param name="settings">data of info</param> public override void SaveToDataStore(ExtensionType exType, string exId, object settings) { if (settings == null) throw new ArgumentNullException("settings"); // Save string connString = ConfigurationManager.ConnectionStrings[connStringName].ConnectionString; string providerName = ConfigurationManager.ConnectionStrings[connStringName].ProviderName; DbProviderFactory provider = DbProviderFactories.GetFactory(providerName); XmlSerializer xs = new XmlSerializer(settings.GetType()); string objectXML = string.Empty; using (StringWriter sw = new StringWriter()) { xs.Serialize(sw, settings); objectXML = sw.ToString(); } using (DbConnection conn = provider.CreateConnection()) { conn.ConnectionString = connString; conn.Open(); using (DbCommand cmd = conn.CreateCommand()) { string sqlQuery = "DELETE FROM " + tablePrefix + "DataStoreSettings " + "WHERE ExtensionType = @type AND ExtensionId = @id; "; if (parmPrefix != "@") sqlQuery = sqlQuery.Replace("@", parmPrefix); cmd.CommandText = sqlQuery; cmd.CommandType = CommandType.Text; DbParameter dpID = provider.CreateParameter(); dpID.ParameterName = parmPrefix + "type"; dpID.Value = exType.GetHashCode(); cmd.Parameters.Add(dpID); DbParameter dpType = provider.CreateParameter(); dpType.ParameterName = parmPrefix + "id"; dpType.Value = exId; cmd.Parameters.Add(dpType); cmd.ExecuteNonQuery(); sqlQuery = "INSERT INTO " + tablePrefix + "DataStoreSettings " + "(ExtensionType, ExtensionId, Settings) " + "VALUES (@type, @id, @file)"; if (parmPrefix != "@") sqlQuery = sqlQuery.Replace("@", parmPrefix); cmd.CommandText = sqlQuery; cmd.CommandType = CommandType.Text; DbParameter dpFile = provider.CreateParameter(); dpFile.ParameterName = parmPrefix + "file"; dpFile.Value = objectXML; // settings.ToString(); // file; cmd.Parameters.Add(dpFile); cmd.ExecuteNonQuery(); } } }
/// <summary> /// Deletes an item from the dataStore /// </summary> /// <param name="exType">type of item</param> /// <param name="exId">id of item</param> public override void RemoveFromDataStore(ExtensionType exType, string exId) { string connString = ConfigurationManager.ConnectionStrings[connStringName].ConnectionString; string providerName = ConfigurationManager.ConnectionStrings[connStringName].ProviderName; DbProviderFactory provider = DbProviderFactories.GetFactory(providerName); using (DbConnection conn = provider.CreateConnection()) { conn.ConnectionString = connString; conn.Open(); using (DbCommand cmd = conn.CreateCommand()) { string sqlQuery = "DELETE FROM " + tablePrefix + "DataStoreSettings " + "WHERE ExtensionType = " + parmPrefix + "type AND ExtensionId = " + parmPrefix + "id"; cmd.CommandText = sqlQuery; cmd.CommandType = CommandType.Text; DbParameter dpID = provider.CreateParameter(); dpID.ParameterName = parmPrefix + "type"; dpID.Value = exType; cmd.Parameters.Add(dpID); DbParameter dpType = provider.CreateParameter(); dpType.ParameterName = parmPrefix + "id"; dpType.Value = exId; cmd.Parameters.Add(dpType); cmd.ExecuteNonQuery(); } } }
private static void WriteExtension(Stream output, ExtensionType extType, byte[] extValue) { TlsUtilities.WriteUint16((int)extType, output); TlsUtilities.WriteOpaque16(extValue, output); }
public Extension(ExtensionType type, byte[] data) { _type = type; _data = data; }
/// <summary> /// Gets the extensions available for the given extension type. /// </summary> /// <param name="type">The extension type</param> /// <returns></returns> public IEnumerable<Lazy<IExtension, IExtensionMeta>> GetByExtensionType(ExtensionType type) { return Extensions.Where(e => e.Metadata.Type.HasFlag(type)).ToList() ; }
/// <summary> /// Default Constructor /// </summary> public NUnitAddinAttribute() { this.Type = ExtensionType.Core; }
/// <summary> /// Load user data from DataStore /// </summary> /// <param name="extensionType"> /// type of info /// </param> /// <param name="extensionId"> /// id of info /// </param> /// <returns> /// stream of detail data /// </returns> public override object LoadFromDataStore(ExtensionType extensionType, string extensionId) { // MemoryStream stream; object o = null; using (var conn = this.CreateConnection()) { if (conn.HasConnection) { var sqlQuery = string.Format("SELECT Settings FROM {0}DataStoreSettings WHERE BlogId = {1}blogid AND ExtensionType = {1}etype AND ExtensionId = {1}eid", this.tablePrefix, this.parmPrefix); using (var cmd = conn.CreateTextCommand(sqlQuery)) { var parms = cmd.Parameters; parms.Add(conn.CreateParameter(FormatParamName("blogid"), Blog.CurrentInstance.Id.ToString())); parms.Add(conn.CreateParameter(FormatParamName("etype"), extensionType.GetHashCode())); parms.Add(conn.CreateParameter(FormatParamName("eid"), extensionId)); o = cmd.ExecuteScalar(); } } } return o; }