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