/// <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());
}
