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