/// <summary> /// Abstract SettingsProvider method /// </summary> public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties) { SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); string sectionName = GetSectionName(context); // Look for this section in both applicationSettingsGroup and userSettingsGroup IDictionary appSettings = Store.ReadSettings(sectionName, false); IDictionary userSettings = Store.ReadSettings(sectionName, true); ConnectionStringSettingsCollection connStrings = Store.ReadConnectionStrings(); // Now map each SettingProperty to the right StoredSetting and deserialize the value if found. foreach (SettingsProperty setting in properties) { string settingName = setting.Name; SettingsPropertyValue value = new SettingsPropertyValue(setting); // First look for and handle "special" settings SpecialSettingAttribute attr = setting.Attributes[typeof(SpecialSettingAttribute)] as SpecialSettingAttribute; bool isConnString = (attr != null) ? (attr.SpecialSetting == SpecialSetting.ConnectionString) : false; if (isConnString) { string connStringName = sectionName + "." + settingName; if (connStrings != null && connStrings[connStringName] != null) { value.PropertyValue = connStrings[connStringName].ConnectionString; } else if (setting.DefaultValue != null && setting.DefaultValue is string) { value.PropertyValue = setting.DefaultValue; } else { //No value found and no default specified value.PropertyValue = string.Empty; } value.IsDirty = false; //reset IsDirty so that it is correct when SetPropertyValues is called values.Add(value); continue; } // Not a "special" setting bool isUserSetting = IsUserSetting(setting); if (isUserSetting && !ConfigurationManagerInternalFactory.Instance.SupportsUserConfig) { // We encountered a user setting, but the current configuration system does not support // user settings. throw new ConfigurationErrorsException(SR.UserSettingsNotSupported); } IDictionary settings = isUserSetting ? userSettings : appSettings; if (settings.Contains(settingName)) { StoredSetting ss = (StoredSetting)settings[settingName]; string valueString = ss.Value.InnerXml; // We need to un-escape string serialized values if (ss.SerializeAs == SettingsSerializeAs.String) { valueString = Escaper.Unescape(valueString); } value.SerializedValue = valueString; } else if (setting.DefaultValue != null) { value.SerializedValue = setting.DefaultValue; } else { //No value found and no default specified value.PropertyValue = null; } value.IsDirty = false; //reset IsDirty so that it is correct when SetPropertyValues is called values.Add(value); } return(values); }
private void WriteSqlMethod(SqlFunction method) { o.WriteLine(); o.Write("\t\t///<summary>{0} (Id notation)</summary>\r\n", method.Comment); o.Write("\t\tpublic {0}[] {1} (long {2}Id) {{\r\n", method.ReturnType.TargetType.Name, method.Name, Cls.Name.ToLowerInvariant()); o.Write(@" return Model.{0}.GetAll (""select id from {1} ( '""+{2}Id+""')""); ", method.ReturnType.TargetType.Name, method.FullName.Replace("\"", "\\\""), Cls.Name.ToLowerInvariant()); o.WriteLine("\t\t}"); o.WriteLine(); o.Write("\t\t///<summary>{0} (Code notation)</summary>\r\n", method.Comment); o.Write("\t\tpublic {0}[] {1} (string {2}Code) {{\r\n", method.ReturnType.TargetType.Name, method.Name, Cls.Name.ToLowerInvariant()); o.Write(@" return Model.{0}.GetAll (""select id from {1} ( '""+{2}Code+""')""); ", method.ReturnType.TargetType.Name, method.FullName.Replace("\"", "\\\""), Cls.Name.ToLowerInvariant()); o.WriteLine("\t\t}"); o.WriteLine(); o.Write("\t\t///<summary>{0}</summary>\r\n", method.Comment); o.Write("\t\tpublic {0}[] {1} ({2} {3}) {{\r\n", method.ReturnType.TargetType.Name, method.Name, Cls.Name, Escaper.EscapeCSharpKeyword(Cls.Name.ToLowerInvariant())); o.Write(@" return {0} ({1}.Id); ", method.Name, Escaper.EscapeCSharpKeyword(Cls.Name.ToLowerInvariant())); o.WriteLine("\t\t}"); }
public static List <string> Escape(this List <string> sources) { return(sources.Select(p => Escaper.Process(p)).ToList()); }
private static string Escape(string @string) { return(Escaper.Escape(@string)); }
private unsafe void WriteStringUnsafe(string value) { Debug.Assert(value != null); string indentation = null; var pendingIndentation = false; int offset = 0; while (true) { fixed(char *pSrcStart = value) { offset += WriteStringUnsafe(pSrcStart + offset, pSrcStart + value.Length); } if (pendingIndentation) { WriteRawUnsafe(indentation); pendingIndentation = false; } else { break; } } int WriteStringUnsafe(char *pSrcStart, char *pSrcEnd) { fixed(char *pDstStart = _bufChars) { char *pDst = pDstStart + _bufPos; char *pSrc = pSrcStart; int ch = 0; do { char *pDstEnd = pDst + (pSrcEnd - pSrc); if (pDstEnd > pDstStart + _bufLen) { pDstEnd = pDstStart + _bufLen; } while (pDst < pDstEnd) { ch = *pSrc; if (ch == 10 || ch == 13 || Escaper.ShouldBeEscaped((char)ch)) { break; } pSrc++; *pDst = (char)ch; pDst++; Length++; } if (pSrc >= pSrcEnd) { break; } if (pDst >= pDstEnd) { _bufPos = (int)(pDst - pDstStart); FlushBuffer(); pDst = pDstStart; continue; } switch (ch) { case (char)10: { OnBeforeWriteLine(); switch (NewLineHandling) { case NewLineHandling.Replace: { pDst = WriteRaw(NewLineChars, pDst); break; } case NewLineHandling.None: { *pDst = (char)ch; pDst++; Length++; break; } } OnAfterWriteLine(); if (IsPendingIndentation()) { pendingIndentation = true; } break; } case (char)13: { OnBeforeWriteLine(); switch (NewLineHandling) { case NewLineHandling.Replace: { if (pSrc < pSrcEnd && pSrc[1] == '\n') { pSrc++; } pDst = WriteRaw(NewLineChars, pDst); break; } case NewLineHandling.None: { *pDst = (char)ch; pDst++; Length++; break; } } OnAfterWriteLine(); if (IsPendingIndentation()) { pendingIndentation = true; } break; } case '>': case '<': { string escapedChar = EscapeChar(ch); pDst = WriteRaw(escapedChar, pDst); break; } default: { *pDst = MarkdownCharEscaper.DefaultEscapingChar; pDst++; Length++; *pDst = (char)ch; pDst++; Length++; break; } } pSrc++; } while (!pendingIndentation); _bufPos = (int)(pDst - pDstStart); return((int)(pSrc - pSrcStart)); } char *WriteRaw(string text, char *pDst) { fixed(char *pDstStart = _bufChars) { _bufPos = (int)(pDst - pDstStart); WriteRawUnsafe(text); return(pDstStart + _bufPos); } } } bool IsPendingIndentation() { if (indentation == null) { indentation = base.GetIndentation(); } return(indentation.Length > 0); } }
private void InternalInit(IIdentity caller, ClientRecord record, ClientResult result) { CheckCaller(caller); if (string.IsNullOrWhiteSpace(record.Name)) { throw new ArgumentException("no client name supplied", nameof(record.Name)); } if (string.IsNullOrWhiteSpace(record.SysName)) { record.SysName = Escaper.OrganizationSysName(record.Name); } if (string.IsNullOrWhiteSpace(record.SysName) || record.SysName != Escaper.OrganizationSysName(record.SysName)) { throw new ArgumentException("invalid sysname " + record.SysName, nameof(record.SysName)); } var groupLogin = record.SysName + "@groups"; var existed = Users.GetUser(groupLogin); if (null != existed) { throw new SecurityException("group already exists"); } var group = new User { Active = true, Login = groupLogin, IsGroup = true, Name = record.Name, Email = record.UserEmail, Roles = new[] { SecurityConst.ROLE_DEMO_ACCESS }, Expire = DateTime.Today.AddDays(1).Add(SecurityConst.LEASE_DEMO), Custom = new Dictionary <string, object> { { "contact", record.Phone } } }; Users.Store(group); var userLogin = "******" + record.SysName; existed = Users.GetUser(userLogin); if (null != existed) { throw new SecurityException("user already exists"); } var name = string.IsNullOrWhiteSpace(record.UserName) ? record.Name : record.UserName; var user = new User { Login = userLogin, Name = name, Logable = true, Domain = record.SysName, Groups = new[] { record.SysName }, Active = true, Expire = group.Expire, Roles = new[] { SecurityConst.ROLE_DOMAIN_ADMIN } }; var pass = string.IsNullOrWhiteSpace(record.Password) ? PasswordManager.Generate() : record.Password; if (!PasswordManager.GetPolicy(pass).Ok) { throw new SecurityException("password not match policy"); } PasswordManager.SetPassword(user, pass, true); Users.Store(user); result.GeneratedSysName = record.SysName; result.GeneratedPassword = pass; result.Group = group; result.User = user; }
public void TestCheckingLiterals(string c, EscapingType type, bool res) { Assert.AreEqual(Escaper.IsLiteral(c, type), res); }
public void OrganizationSystemName(string input, string result) { Assert.AreEqual(result, Escaper.OrganizationSysName(input)); }
public void TestCheckingLiteral(char c, EscapingType type, bool first, bool res) { Assert.AreEqual(Escaper.IsLiteral(c, type, first), res); }
public void TranslitTest(string input, string result) { Assert.AreEqual(result, Escaper.Translit(input)); }
public override void WriteString(string text) { string indentation = null; try { BeforeWriteString(); ThrowIfClosed(); if (string.IsNullOrEmpty(text)) { return; } int length = text.Length; int prev = 0; int i = 0; while (i < length) { char ch = text[i]; switch (ch) { case '\n': { OnBeforeWriteLine(); if (NewLineHandling == NewLineHandling.Replace) { WriteSubstring(text, prev, i - prev); WriteNewLine(); } else if (NewLineHandling == NewLineHandling.None) { WriteSubstring(text, prev, i + 1 - prev); } OnAfterWriteLine(); WriteIndentation(); prev = ++i; continue; } case '\r': { OnBeforeWriteLine(); if (i < length - 1 && text[i + 1] == 10) { if (NewLineHandling == NewLineHandling.Replace) { WriteSubstring(text, prev, i - prev); WriteNewLine(); } else if (NewLineHandling == NewLineHandling.None) { WriteSubstring(text, prev, i + 2 - prev); } i++; } else if (NewLineHandling == NewLineHandling.Replace) { WriteSubstring(text, prev, i - prev); WriteNewLine(); } else if (NewLineHandling == NewLineHandling.None) { WriteSubstring(text, prev, i + 1 - prev); } OnAfterWriteLine(); WriteIndentation(); prev = ++i; continue; } case '<': case '>': { if (Escaper.ShouldBeEscaped(ch)) { WriteSubstring(text, prev, i - prev); WriteString(EscapeChar(ch)); prev = ++i; } else { i++; } continue; } } if (Escaper.ShouldBeEscaped(ch)) { WriteSubstring(text, prev, i - prev); WriteChar(MarkdownCharEscaper.DefaultEscapingChar); WriteChar(ch); prev = ++i; } else { i++; } } WriteSubstring(text, prev, text.Length - prev); } catch { _state = State.Error; throw; } void WriteString(string value) { ThrowIfClosed(); _sb.Append(value); } void WriteSubstring(string value, int startIndex, int count) { ThrowIfClosed(); _sb.Append(value, startIndex, count); } void WriteChar(char ch) { ThrowIfClosed(); _sb.Append(ch); } void WriteNewLine() { ThrowIfClosed(); _sb.Append(NewLineChars); } void WriteIndentation() { if (indentation == null) { indentation = GetIndentation(); } _sb.Append(indentation); } }
public static Database DatabaseFactory(Extractor extractor, IEnumerable <DBLint.DataAccess.DBObjects.Schema> selectedSchemas, IEnumerable <DBLint.DataAccess.DBObjects.TableID> ignoredTables) { var database = new Database(extractor.DatabaseName, extractor.Database); var ignoredDictionary = DictionaryFactory.CreateTableID <TableID>(); foreach (var ignoredTable in ignoredTables) { var tblid = new TableID(extractor.DatabaseName, ignoredTable.SchemaName, ignoredTable.TableName); ignoredDictionary.Add(tblid, tblid); } using (var db = database) { var dbSchemas = extractor.Database.GetSchemas(); foreach (var dbSchema in dbSchemas) { using (var schema = new Schema(db.DatabaseName, dbSchema.SchemaName)) { if (!selectedSchemas.Any(p => p.Equals(dbSchema))) { continue; } schema.Database = db; db._schemas.Add(schema); #region Table and table columns var dbTables = extractor.Database.GetTables(schema.SchemaName); var tables = from dbTable in dbTables orderby dbTable.TableName select dbTable; foreach (var dbTable in tables) { var table = new DataTable(db.DatabaseName, schema.SchemaName, dbTable.TableName, extractor.Database); if (ignoredDictionary.ContainsKey(table)) { database.IgnoredTables.Add(table); continue; } schema._tables.Add(table); db.tableDictionary.Add(table, table); table.Database = db; table.Schema = schema; } var dbColumns = extractor.Database.GetColumns(schema.SchemaName); var columnID = new ColumnID(extractor.DatabaseName, schema.SchemaName, null, null); foreach (var dbColumn in dbColumns) { columnID.TableName = dbColumn.TableName; columnID.ColumnName = dbColumn.ColumnName; if (db.tableDictionary.ContainsKey(columnID)) { var column = new Column(db.DatabaseName, schema.SchemaName, dbColumn.TableName, dbColumn.ColumnName); var table = db.tableDictionary[column]; table._columns.Add(column); column.DataType = dbColumn.DataType; column.DefaultValue = dbColumn.DefaultValue; column.OrdinalPosition = dbColumn.OrdinalPosition; column.CharacterMaxLength = dbColumn.CharacterMaxLength; column.IsNullable = dbColumn.IsNullable; column.NumericPrecision = dbColumn.NumericPrecision; column.NumericScale = dbColumn.NumericScale; column.Table = table; column.Schema = schema; column.Database = db; column.IsSequence = dbColumn.IsSequence; column.IsDefaultValueAFunction = dbColumn.DefaultIsFunction; } } #endregion #region Views and view columns var dbViews = extractor.Database.GetViews(schema.SchemaName); var views = from dbView in dbViews orderby dbView.ViewName select dbView; foreach (var dbView in views) { var view = new View(db.DatabaseName, schema.SchemaName, dbView.ViewName); schema._views.Add(view); db.viewDictionary.Add(view, view); view.Database = db; view.Schema = schema; } var dbViewColumns = extractor.Database.GetViewColumns(schema.SchemaName); var viewColumnID = new ViewColumnID(extractor.DatabaseName, schema.SchemaName, null, null); foreach (var dbViewColumn in dbViewColumns) { viewColumnID.ViewName = dbViewColumn.ViewName; viewColumnID.ColumnName = dbViewColumn.ColumnName; if (db.viewDictionary.ContainsKey(viewColumnID)) { var viewColumn = new ViewColumn(db.DatabaseName, schema.SchemaName, dbViewColumn.ViewName, dbViewColumn.ColumnName); var view = db.viewDictionary[viewColumn]; view._columns.Add(viewColumn); viewColumn.Database = db; viewColumn.Schema = schema; viewColumn.View = view; viewColumn.DataType = dbViewColumn.DataType; viewColumn.DefaultValue = dbViewColumn.DefaultValue; viewColumn.OrdinalPosition = dbViewColumn.OrdinalPosition; viewColumn.CharacterMaxLength = dbViewColumn.CharacterMaxLength; viewColumn.IsNullable = dbViewColumn.IsNullable; viewColumn.NumericPrecision = dbViewColumn.NumericPrecision; viewColumn.NumericScale = dbViewColumn.NumericScale; viewColumn.Privileges = dbViewColumn.Privileges; } } #endregion // Adding functions var functions = extractor.Database.GetFunctions(schema.SchemaName); foreach (var function in functions) { var f = new Function( database.DatabaseName, function.SchemaName, function.RoutineName); f.Database = database; f.Schema = schema; schema._functions.Add(f); } var fParameters = extractor.Database.GetFunctionsParameters(schema.SchemaName); foreach (var fParameter in fParameters) { var fp = new Parameter(database.DatabaseName, fParameter.SchemaName, fParameter.RoutineName, fParameter.ParameterName); fp.Database = schema.Database; fp.Schema = schema; fp.DataType = fParameter.DataType; fp.Direction = fParameter.Direction; fp.CharacterMaxLength = fParameter.CharacterMaxLength; fp.NumericPrecision = fParameter.NumericPrecision; fp.NumericScale = fParameter.NumericScale; fp.OrdinalPosition = fParameter.OrdinalPosition; var tmpF = schema._functions.Where(f => f.FunctionName.Equals(fp.RoutineName)).FirstOrDefault(); if (tmpF != null) { fp.Routine = tmpF; tmpF._parameters.Add(fp); } } // Adding stored procedures var storedProcedures = extractor.Database.GetStoredProcedures(schema.SchemaName); foreach (var storedProcedure in storedProcedures) { var sp = new StoredProcedure( database.DatabaseName, storedProcedure.SchemaName, storedProcedure.RoutineName); sp.Database = database; sp.Schema = schema; schema._storedProcedures.Add(sp); } var parameters = extractor.Database.GetStoredProceduresParameters(schema.SchemaName); foreach (var parameter in parameters) { var p = new Parameter(database.DatabaseName, parameter.SchemaName, parameter.RoutineName, parameter.ParameterName); p.Database = schema.Database; p.Schema = schema; p.DataType = parameter.DataType; p.Direction = parameter.Direction; p.CharacterMaxLength = parameter.CharacterMaxLength; p.NumericPrecision = parameter.NumericPrecision; p.NumericScale = parameter.NumericScale; p.OrdinalPosition = parameter.OrdinalPosition; var tmpSp = schema._storedProcedures.Where(sp => sp.StoredProcedureName.Equals(p.RoutineName)).FirstOrDefault(); if (tmpSp != null) { p.Routine = tmpSp; tmpSp._parameters.Add(p); } } } } } AddForeignKeys(extractor, database); AddPrimaryKeys(extractor, database); AddIndices(extractor, database); AddUniqueConstraints(extractor, database); foreach (var tbl in database.Tables) { tbl.Dispose(); } foreach (var view in database.Views) { view.Dispose(); } AddCardinalities(database.tableDictionary, extractor, selectedSchemas); database.Escaper = Escaper.GetEscaper(extractor.Database.DBMS); database.DBMS = extractor.Database.DBMS; return(database); }
public static string ParseString(this TextReader reader, ref int c) { if (!c.IsQuoteChar()) { return(null); } int q = c; var sb = new StringBuilder(); while (true) { c = reader.Read(); if (c < 0) { return(null); } if (c == q) { c = reader.Read(); break; } if (c == '\\') { c = reader.Read(); if (c == 'u') { int h = 0; for (int i = 0; i < 4; ++i) { c = reader.Read(); if (c < 0) { throw new FormatException("Unexpected end of stream"); } if (!c.IsHexDigit()) { throw new FormatException( string.Format("Bad unicode symbol. '{0}' is not hex digit.", (char)c)); } h += Hex.ToDecimal(c); } sb.Append((char)h); } else if (c == 'x') { int h = 0; int n = 0; while (true) { c = reader.Read(); if (c < 0) { throw new FormatException("Unexpected end of stream"); } if (!c.IsHexDigit()) { break; } ++n; h += Hex.ToDecimal(c); } if (n == 0) { sb.Append("\\x"); } else { sb.Append((char)h); } } else if (Escaper.UnescapeChar(ref c)) { sb.Append((char)c); } else { sb.Append('\\'); sb.Append((char)c); } } else { sb.Append((char)c); } } return(sb.ToString()); }