/// <summary> /// Saca el contenido de los datos a un archivo /// </summary> /// <param name="data">Datos</param> /// <param name="state">Estado de la enumeración</param> protected override IData OnProcessData(IData data, EEnumerableDataState state) { string file = FileName; if (FileNameSource == EFileSource.Input) { foreach (object o in data) { if (o is string) { file = o.ToString(); break; } } } Pr.Process pr = new Pr.Process(); pr.StartInfo = new Pr.ProcessStartInfo(file, Arguments) { CreateNoWindow = CreateNoWindow, Domain = Domain, Password = string.IsNullOrEmpty(Password) ? null : ToSecure(Password), UserName = UserName, UseShellExecute = true, WindowStyle = WindowStyle, }; pr.Start(); return(data); }
/// <summary> /// Saca el contenido de los datos a un archivo /// </summary> /// <param name="data">Datos</param> /// <param name="state">Estado de la enumeración</param> protected override IData OnProcessData(IData data, EEnumerableDataState state) { switch (Count) { case ECount.All: { foreach (object o in data) { if (!Compare(TrimBefore, o.ToString(), Text, Expected)) { return(DataBreak()); } } return(data); } case ECount.Any: { foreach (object o in data) { if (Compare(TrimBefore, o.ToString(), Text, Expected)) { return(data); } } break; } } return(DataBreak()); }
/// <summary> /// Saca el contenido de los datos a un archivo /// </summary> /// <param name="data">Datos</param> /// <param name="state">Estado de la enumeración</param> protected override IData OnProcessData(IData data, EEnumerableDataState state) { if (FileName == null) { return(DataBreak()); } string file = Environment.ExpandEnvironmentVariables(FileName); if (string.IsNullOrEmpty(file) || !File.Exists(file)) { return(DataBreak()); } using (FileStream stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read)) { byte[] d = new byte[stream.Length]; StreamHelper.ReadFull(stream, d, 0, d.Length); if (ConvertToString) { Encoding codec = SerializationHelper.GetEncoding(StringEncoding); return(DataObject(codec.GetString(d))); } return(DataObject(d)); } }
/// <summary> /// Saca el contenido de los datos a un archivo /// </summary> /// <param name="data">Datos</param> /// <param name="state">Estado de la enumeración</param> protected override IData OnProcessData(IData data, EEnumerableDataState state) { if (Regex == null) { return(DataEmpty()); } List <object> l = new List <object>(); foreach (object d in data) { MatchCollection mt = Regex.Matches(d.ToString()); foreach (Match m in mt) { if ((Expected && m.Success) || (!Expected && !m.Success)) { if (string.IsNullOrEmpty(Group)) { l.Add(m.Value); } else { l.Add(m.Groups[Group]); } } } } return(Reduce(EReduceZeroEntries.Empty, l)); }
/// <summary> /// Saca el contenido de los datos a un archivo /// </summary> /// <param name="data">Datos</param> /// <param name="state">Estado de la enumeración</param> protected override IData OnProcessData(IData data, EEnumerableDataState state) { List <object> ls = new List <object>(); if (data != null) { foreach (object o in data) { if (o == null) { continue; } string cad = Alter(o, Trim, Case); // Control de vacios if (string.IsNullOrEmpty(cad)) { if (!ReturnEmpty) { continue; } cad = ""; } ls.Add(cad); } } return(Reduce(EReduceZeroEntries.Empty, ls)); }
/// <summary> /// Saca el contenido de los datos a un Rest /// </summary> /// <param name="data">Datos</param> /// <param name="state">Estado de la enumeración</param> protected override IData OnProcessData(IData data, EEnumerableDataState state) { // Cacheamos la respuesta using (MemoryStream stream = data.ToStream(StringEncoding)) _CacheData = stream.ToArray(); return(data); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { if (_Script == null) { return(DataEmpty()); } return(_Script.ProcessData(this, data, state)); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { object obj = data.GetInternalObject(); if (obj == null) { return(DataEmpty()); } return(DataObject(SerializationHelper.Serialize(obj, Format))); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { if (data == null) { return(data); } foreach (object obj in data) { if (obj == null) { continue; } string file = null; if (obj is DataTable) { DataTable dt = (DataTable)obj; file = GetFile(data); if (!string.IsNullOrEmpty(file)) { ExcelHelper.CreateXlsFromDataTable(file, dt); } } else { if (obj is DataSet) { DataSet dt = (DataSet)obj; file = GetFile(data); if (!string.IsNullOrEmpty(file)) { ExcelHelper.CreateXlsFromDataTable(file, dt.Tables.Cast <DataTable>().ToArray()); } } } if (!string.IsNullOrEmpty(file)) { if (Return == EReturnMode.FileName) { return(DataObject(file)); } } } if (Return == EReturnMode.FileName) { return(null); } return(data); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { object o = data.GetInternalObject(); if (o == null) { return(null); } if (!FEditObjectProperties.ShowForm(FormTitle, o)) { return(null); } return(data); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { if (data != null) { foreach (object o in data) { if (o == null) { continue; } _Bot.Value.SendMessage(o.ToString(), MessageMode, null, _Bot.Value.AllowedChats); } } return(data); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { if (data == null) { Value = null; } else { Value = data.GetInternalObject(); } if (BreakPoint) { ObjectEditor.ShowValue(Value); } return(data); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { if (data == null) { return(DataBreak()); } object obj = data.GetInternalObject(); if (obj == null) { return(DataBreak()); } DateTime date, utc = DateTime.UtcNow; List <object> lo = new List <object>(); foreach (object o in data) { string ser = SerializationHelper.Serialize(o, Format).Trim(); if (IgnoreCase) { ser = ser.ToLowerInvariant(); } lock (Cache) { if (Cache.TryGetValue(ser, out date) && date > utc) { continue; } if (!AllowMultipleCache) { Cache.Clear(); } Cache[ser] = utc.Add(ExpireIn); } lo.Add(o); } return(Reduce(EReduceZeroEntries.Break, lo)); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { if (data == null) { return(DataEmpty()); } List <DataTable> dt = new List <DataTable>(); if (ExcelSource != EExcelSource.Input && !string.IsNullOrEmpty(FileName)) { DataTable d = ReadExcel(FileName); if (d != null) { dt.Add(d); } } if (ExcelSource != EExcelSource.FileName) { foreach (object o in data) { DataTable d = ReadExcel(o.ToString()); if (d != null) { dt.Add(d); } } } if (dt.Count == 0) { return(DataEmpty()); } if (dt.Count == 1) { return(DataObject(dt[0])); } if (ReturnAsEnumerable) { return(DataEnumerable(dt.ToArray())); } return(DataArray(dt.ToArray())); }
/// <summary> /// Saca el contenido de los datos a un archivo /// </summary> /// <param name="data">Datos</param> /// <param name="state">Estado de la enumeración</param> protected override IData OnProcessData(IData data, EEnumerableDataState state) { // Formato del archivo bool add = Append || state == EEnumerableDataState.Middle || state == EEnumerableDataState.End; using (MemoryStream ms = data.ToStream(StringEncoding)) using (FileStream stream = new FileStream(Environment.ExpandEnvironmentVariables(FileName), add ? FileMode.OpenOrCreate : FileMode.Create, FileAccess.Write, FileShare.None)) { if (add) { stream.Seek(0, SeekOrigin.End); } ms.CopyTo(stream); } return(data); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { if (data == null || data is DataEmpty) { return(data); } if (data is DataObject) { DataObject d = (DataObject)data; byte[] buff = null; if (d.Data != null && d.Data is string) { buff = Encoding.UTF8.GetBytes(d.Data.ToString()); } if (buff != null) { // Ya tenemos la página web, vamos a tratarla using (MemoryStream ms = new MemoryStream(buff)) using (StreamReader te = new StreamReader(ms, Encoding.UTF8)) { Channel[] ar = getChannelQuery(XDocument.Load(te)).ToArray(); if (ar == null || ar.Length <= 0) { return(DataEmpty()); } if (ar.Length == 1) { return(DataObject(ar[0])); } return(DataArray(ar)); } } } return(DataEmpty()); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { if (data == null || data is DataEmpty) { return(data); } List <string> ls = new List <string>(); foreach (object o in data) { if (o == null) { continue; } ls.Add(Format(o, Sanetization)); } return(Reduce(EReduceZeroEntries.Break, ls.ToArray())); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { List <object> l = new List <object>(); foreach (object o in data) { if (o == null) { continue; } string s = o.ToString(); if (string.IsNullOrEmpty(s)) { continue; } l.Add(FormatStr(s)); } return(Reduce(EReduceZeroEntries.Empty, l)); }
protected override IData OnProcessData(IData data, EEnumerableDataState state) { if (data == null || data is DataEmpty) { if (!SendEmpty) { return(data); } } MailMessage msg = new MailMessage(); msg.From = new MailAddress(From); msg.Subject = Subject; msg.Body = Body; foreach (string t in To) { msg.To.Add(t); } foreach (string t in BCC) { msg.Bcc.Add(t); } using (MemoryStream ms = data.ToStream(StringEncoding)) msg.Attachments.Add(new Attachment(ms, AttachmentName, ContentType)); if (SendAsync) { _Smtp.SendAsync(msg, null); } else { _Smtp.Send(msg); } return(data); }
/// <summary> /// Saca el contenido de los datos a un archivo /// </summary> /// <param name="data">Datos</param> /// <param name="state">Estado de la enumeración</param> protected override IData OnProcessData(IData data, EEnumerableDataState state) { List <object> ls = new List <object>(); if (data != null) { foreach (object o in data) { if (o == null) { continue; } string cad = o.ToString(); switch (Trim) { case ETrim.All: cad = cad.Trim(); break; case ETrim.End: cad = cad.TrimEnd(); break; case ETrim.Start: cad = cad.TrimStart(); break; } // Control de vacios if (string.IsNullOrEmpty(cad)) { if (!ReturnEmpty) { continue; } cad = ""; } ls.Add(cad); } } return(Reduce(EReduceZeroEntries.Empty, ls)); }
/// <summary> /// Recibe una información /// </summary> /// <param name="data">Información</param> /// <param name="state">Estado de la enumeración</param> /// <returns>Devuelve una información</returns> protected virtual IData OnProcessData(IData data, EEnumerableDataState state) { return(data); }
public virtual IData ProcessData(IDataProcess sender, IData data, EEnumerableDataState state) { return(new DataBreak(sender)); }
/// <summary> /// Saca el contenido de los datos a un archivo /// </summary> /// <param name="data">Datos</param> /// <param name="state">Estado de la enumeración</param> protected override IData OnProcessData(IData data, EEnumerableDataState state) { DataInputEventListener.RaiseEvent(this, EventName, AttachData ? data : null); return(data); }
/// <summary> /// Procesa los datos de entrada /// </summary> /// <param name="source">Origen</param> /// <param name="data">Datos</param> /// <param name="useParallel">Usar paralelismo</param> public void ProcessData(ITopologyItem source, IData data, bool useParallel) { if (data == null) { return; } // Si es un enumerador, hay que pasar fila a fila al procesado if (data is DataEnumerable) { // Lo ejecuta secuencial using (IEnumerator <object> enumerator = ((DataEnumerable)data).GetEnumerator()) { EEnumerableDataState state = EEnumerableDataState.Start; bool last = !enumerator.MoveNext(); IData current; while (!last) { current = new DataObject(data.Source, enumerator.Current); last = !enumerator.MoveNext(); if (last) { // Si es el último y era el primero, solo hay uno, sino, ha llegado al final if (state == EEnumerableDataState.Start) { state = EEnumerableDataState.OnlyOne; } else { state = EEnumerableDataState.End; } } // Ejecuta el procesado if (useParallel && Count > 1) { //Parallel.For(0, Count, i => { this[i].ProcessData(current, i, state); }); Parallel.ForEach <IDataProcess>(this, p => { p.ProcessData(data, source, state); }); } else { foreach (IDataProcess p in this) { p.ProcessData(current, source, state); } } state = EEnumerableDataState.Middle; } } // Liberar los recursos del enumerado, posiblemente no se pueda reutilizar data.Dispose(); } else { // Ejecuta el procesado if (useParallel && Count > 1) { //Parallel.For(0, Count, i => { this[i].ProcessData(data, i, EEnumerableDataState.NonEnumerable); }); Parallel.ForEach <IDataProcess>(this, p => { p.ProcessData(data, source, EEnumerableDataState.NonEnumerable); }); } else { foreach (IDataProcess p in this) { p.ProcessData(data, source, EEnumerableDataState.NonEnumerable); } } } }
/// <summary> /// Procesa los datos /// </summary> /// <param name="data">Datos</param> /// <param name="caller">Item que lo llama</param> /// <param name="state">Estado de la enumeración</param> public void ProcessData(IData data, ITopologyItem caller, EEnumerableDataState state) { if (data == null) { return; } // Si tiene varios origenes de datos, se tiene que esperar a estan todos llenos IData jdata; if (_Data.Count > 1 && CallMethod != ECallMode.PeerCall) { // Esperamos a que el conjunto esperado esté disponible if (!_Data.SetData(data, caller) && CallMethod == ECallMode.WaitAll) { return; } if (_IsBusy) { return; } _IsBusy = true; // Los datos a devolver tienen que ser los del array jdata = new DataJoin(this, _Data.Items) { HandledDispose = true }; } else { if (_IsBusy) { return; } _IsBusy = true; jdata = data; } // Procesa los datos RaiseOnProcess(EProcessState.PreProcess); IData ret; try { ret = OnProcessData(jdata, state); } catch (Exception e) { OnError(e); ret = null; } RaiseOnProcess(EProcessState.PostProcess); // Siempre que no sea null se reenvia a otros nodos if (ret != null && !(ret is DataBreak)) { // Se los envia a otros procesadores Process.ProcessData(this, ret, UseParallel); // Liberación de recursos if (ret != data && !ret.HandledDispose) { ret.Dispose(); } } _IsBusy = false; }