public static void PostList(List <TypedItem> properties)
{
try
{
using (SqlConnection cn = new SqlConnection(cnString))
{
cn.Open();
using (SqlCommand cmd = cn.CreateCommand())
{
const string xmlDocParamName = "@xdoc";
const string handlerKeyParamName = "@handler";
cmd.CommandType = CommandType.Text;
cmd.CommandText = "insert into [log].[eXtensibleList]([handlerkey],[xmldoc]) values (" + handlerKeyParamName + "," + xmlDocParamName + ")";
cmd.Parameters.AddWithValue(handlerKeyParamName, "alertHandler");
string xml = GenericSerializer.DbParamFromItem(properties);
cmd.Parameters.AddWithValue(xmlDocParamName, xml);
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
IEventWriter writer = new EventLogWriter();
string m = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
var props = eXtensibleConfig.GetProperties();
props.Add("location", "SqlServerEventWriter.line.105");
writer.WriteError(m, SeverityType.Critical, "EventWriter", props);
}
}
private static void PostAlert(eXAlert model)
{
const string appKeyName = "@key";
const string appZoneName = "@zone";
const string appInstanceName = "@instance";
const string titleParamName = "@title";
const string sourceParamName = "@source";
const string importanceParamName = "@importance";
const string urgencyParamName = "@urgency";
const string xmlDataParamName = "@xmldata";
const string dispositionParamName = "@disposition";
const string createdAtParamName = "@createdat";
try
{
using (SqlConnection cn = new SqlConnection(cnString))
{
cn.Open();
using (SqlCommand cmd = cn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
string sql = "insert into [log].[alert] ([appkey],[appzone],[appinstance],[title],[source],[importance],[urgency],[xmldata],[disposition],[createdat]) values ( " +
appKeyName + "," + appZoneName + "," + appInstanceName + "," + titleParamName + "," + sourceParamName + "," + importanceParamName + "," +
urgencyParamName + "," + xmlDataParamName + "," + dispositionParamName + "," + createdAtParamName + ")";
cmd.Parameters.AddWithValue(appKeyName, model.ApplicationKey);
cmd.Parameters.AddWithValue(appZoneName, model.Zone);
string appinstance;
if (model.Items.TryGet <string>("app.context.instance", out appinstance))
{
cmd.Parameters.AddWithValue(appInstanceName, appinstance);
}
else
{
cmd.Parameters.AddWithValue(appInstanceName, "none");
}
cmd.Parameters.AddWithValue(titleParamName, model.Title);
cmd.Parameters.AddWithValue(sourceParamName, !String.IsNullOrWhiteSpace(model.Source) ? model.Source : "none");
cmd.Parameters.AddWithValue(importanceParamName, model.Importance);
cmd.Parameters.AddWithValue(urgencyParamName, model.Urgency);
var xml = GenericSerializer.DbParamFromItem(model);
cmd.Parameters.AddWithValue(XmlDataParamName, xml);
cmd.Parameters.AddWithValue(dispositionParamName, "none");
cmd.Parameters.AddWithValue(createdAtParamName, DateTime.Now);
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
IEventWriter writer = new EventLogWriter();
string m = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
var props = eXtensibleConfig.GetProperties();
props.Add("location", "SqlServerEventWriter.line.105");
writer.WriteError(m, SeverityType.Critical, "EventWriter", props);
}
}
public static void Write <T>(T t, bool isClearText) where T : class, new()
{
string filepath = GenerateFilepath <T>(isClearText);
if (isClearText)
{
GenericSerializer.WriteGenericItem <T>(t, filepath);
}
else
{
GenericSerializer.WriteGenericItemBinary <T>(t, filepath);
}
}
void IContext.Set <U>(U u)
{
if (typeof(T).IsSerializable)
{
try
{
string s = GenericSerializer.GenericItemToParam <U>(u);
_Items.Add(new TypedItem(XFConstants.EventWriter.ModelT, u));
}
catch
{
_Items.Add(new TypedItem(XFConstants.EventWriter.ModelT, "Model could not be serialized."));
}
}
}
private static void PostError(eXError model)
{
if (isInitialized)
{
try
{
using (SqlConnection cn = new SqlConnection(cnString))
{
cn.Open();
using (SqlCommand cmd = cn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
string schema = eXtensibleConfig.Zone.Equals("production", StringComparison.OrdinalIgnoreCase) ? DateTime.Today.ToString("MMM").ToLower() : "log";
string sql = "insert into [" + schema + "].[Error] ( [ApplicationKey],[Zone],[AppContextInstance],[MessageId]," +
"[Category],[Severity],[Message],[XmlData] ) values (" +
ApplicationKeyParamName + "," + ZoneParamName + "," + AppContextInstanceParamName + "," +
MessageIdParamName + "," + CategoryParamName + "," + SeverityParamName + "," +
MessageParamName + "," + XmlDataParamName + ")";
cmd.CommandText = sql;
cmd.Parameters.AddWithValue(ApplicationKeyParamName, model.ApplicationKey.Truncate(15));
cmd.Parameters.AddWithValue(ZoneParamName, model.Zone.Truncate(15));
cmd.Parameters.AddWithValue(AppContextInstanceParamName, model.AppContextInstance.Truncate(25));
cmd.Parameters.AddWithValue(MessageIdParamName, model.MessageId);
cmd.Parameters.AddWithValue(CategoryParamName, model.Category.Truncate(25));
cmd.Parameters.AddWithValue(SeverityParamName, model.Severity.Truncate(15));
cmd.Parameters.AddWithValue(MessageParamName, model.Message.Truncate(100));
string items = GenericSerializer.DbParamFromItem(model.Items);
cmd.Parameters.AddWithValue(XmlDataParamName, items);
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
IEventWriter writer = new EventLogWriter();
string m = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
var props = eXtensibleConfig.GetProperties();
props.Add("location", "SqlServerEventWriter.line.105");
writer.WriteError(m, SeverityType.Critical, "EventWriter", props);
}
}
}
public virtual void Assimilate(DataPacket item)
{
item.Items.Clear();
item.Items = this.Items;
switch (item.ModelAction)
{
case ModelActionOption.None:
break;
case ModelActionOption.Delete:
break;
case ModelActionOption.Post:
case ModelActionOption.Put:
case ModelActionOption.Get:
if (this.Content != null && this.Content.Count >= 1 && this.Content[0] != null)
{
item.Buffer = GenericSerializer.ItemToByteArray(Content[0]);
}
break;
case ModelActionOption.GetAll:
case ModelActionOption.GetAllProjections:
if (this.Content != null)
{
item.Buffer = GenericSerializer.ItemToByteArray(this.Content);
}
break;
case ModelActionOption.ExecuteAction:
break;
case ModelActionOption.ExecuteCommand:
item.Tables = new DataSet();
if (this.Data != null && this.Data.Tables.Count > 0)
{
item.Tables = this.Data;
}
break;
default:
break;
}
}
private IResponse <T, U> ExecuteRpc <T, U>(T model, ICriterion criterion) where T : class, new()
{
ICriterion c = criterion ?? new Criterion();
DataPacket packetRequest = _Serializer.Serialize <T>(Context, ModelActionOption.ExecuteAction, c.Items);
packetRequest.Buffer = GenericSerializer.ItemToByteArray(model);
//object o = GenericSerializer.Deserialize<T>(packetRequest.Buffer);
//object oo = GenericSerializer.ByteArrayToItem(packetRequest.Buffer,typeof(T));
string s = Activator.CreateInstance <U>().GetType().AssemblyQualifiedName;
packetRequest.Criteria.Add(XFConstants.Application.ActionResultModelType, s);
DataPacket packetResponse = _DataPacketService.ExecuteRpc(packetRequest);
IResponse <T, U> response = _Serializer.Deserialize <T, U>(packetResponse);
return(response);
}
public static T Read <T>() where T : class, new()
{
T t = default(T);
bool isClearText = true;
string filename = String.Empty;
string s = GetModelName <T>().ToLower();
var folderpath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
DirectoryInfo directory = new DirectoryInfo(folderpath);
if (directory.Exists)
{
bool b = false;
var files = directory.GetFiles();
for (int i = 0; !b && i < files.Count(); i++)
{
var file = files[i];
string name = file.Name.ToLower();
string extension = file.Extension.ToLower();
if (name.Contains(s))
{
filename = name;
isClearText = extension.Equals(".xml", StringComparison.OrdinalIgnoreCase);
b = true;
}
}
if (b)
{
string filepath = Path.Combine(folderpath, filename);
if (isClearText)
{
t = GenericSerializer.ReadGenericItem <T>(filepath);
}
else
{
t = GenericSerializer.ReadGenericItemBinary <T>(filepath);
}
}
}
return(t);
}
static SqlResolver()
{
List <XF.Common.Db.DbConfig> list = new List <Db.DbConfig>();
string[] filepaths = null;
// look for dbConfigs in special folder
if (Directory.Exists(eXtensibleConfig.DbConfigs))
{
filepaths = Directory.GetFiles(eXtensibleConfig.DbConfigs, "*.dbconfig.xml", SearchOption.AllDirectories);
}
if (filepaths == null)
{
filepaths = Directory.GetFiles(eXtensibleConfig.BaseDirectory, "$.dbconfig.xml", SearchOption.TopDirectoryOnly);
}
if (filepaths != null && filepaths.Length > 0)
{
foreach (var filepath in filepaths)
{
if (File.Exists(filepath))
{
try
{
var config = GenericSerializer.ReadGenericItem <XF.Common.Db.DbConfig>(filepath);
list.Add(config);
}
catch (Exception ex)
{
EventWriter.WriteError(ex.Message, SeverityType.Error, "DataAccess", eXtensibleConfig.GetProperties());
EventWriter.Inform(String.Format("Unable to load: ", filepath));
}
}
}
}
Configs = new Db.DbConfigCollection();
foreach (var item in list)
{
Configs.Add(item);
}
}
private static List <TypedItem> Convert(IDictionary <string, object> properties)
{
List <TypedItem> list = new List <TypedItem>();
HashSet <string> hs = new HashSet <string>();
foreach (var prop in properties)
{
if (!String.IsNullOrEmpty(prop.Key) && prop.Value != null)
{
string key = prop.Key;
if (!key.Equals(XFConstants.EventWriter.EventType) && hs.Add(key))
{
if (typeWhitelist.Contains(prop.Value.GetType()) | prop.Value.GetType().BaseType.Equals(typeof(Enum)))
{
list.Add(new TypedItem(key, prop.Value));
}
else
{
bool b = false;
try
{
string s = GenericSerializer.XmlStringFromItem(prop.Value);
list.Add(new TypedItem(key, s));
b = true;
}
catch { }
if (!b)
{
list.Add(new TypedItem(key, prop.ToString()));
}
}
}
}
}
return(list);
}
public override void Assimilate(DataPacket item)
{
item.Items.Clear();
item.Items = this.Items;
item.Buffer = GenericSerializer.Serialize(ActionResult);
}
