public override async Task<ProcConvoy> Run( ProcConvoy Convoy )
{
await base.Run( Convoy );
ProcConvoy UsableConvoy;
if ( !TryGetConvoy( out UsableConvoy, ( P, C ) =>
{
return C.Payload is IEnumerable<IStorageFile>
|| C.Payload is string;
} ) ) return Convoy;
string s = "";
if ( UsableConvoy.Payload is string )
{
s += UsableConvoy.Payload + "\n";
}
else
{
IEnumerable<IStorageFile> SrcFiles = UsableConvoy.Payload as IEnumerable<IStorageFile>;
foreach ( IStorageFile ISF in SrcFiles )
{
s += await ISF.ReadString() + "\n";
}
}
IStorageFile tmp = await AppStorage.MkTemp();
await tmp.WriteString( s );
return new ProcConvoy( this, new IStorageFile[] { tmp } );
}
public override async Task<ProcConvoy> Run( ProcConvoy Convoy )
{
await base.Run( Convoy );
ProcConvoy UsableConvoy;
if ( !TryGetConvoy( out UsableConvoy, ( P, C ) =>
{
return C.Payload is IEnumerable<IStorageFile>
|| C.Payload is string;
}
) ) return Convoy;
List<IStorageFile> TargetFiles = new List<IStorageFile>();
if ( UsableConvoy.Payload is string )
{
IStorageFile ISF = await AppStorage.MkTemp();
TargetFiles.Add( await FilterContent( ISF, UsableConvoy.Payload as string ) );
}
else
{
IEnumerable<IStorageFile> SrcFiles = UsableConvoy.Payload as IEnumerable<IStorageFile>;
foreach ( IStorageFile ISF in SrcFiles )
{
TargetFiles.Add( await FilterContent( ISF ) );
}
}
return new ProcConvoy( this, TargetFiles );
}
public override async Task<ProcConvoy> Run( ProcConvoy Convoy )
{
await base.Run( Convoy );
HashSet<string> ConvoyUrls = null;
if ( Incoming )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "IncomingCheck" ), LogType.INFO );
ProcConvoy UsableConvoy = ProcManager.TracePackage(
Convoy, ( P, C ) =>
{
return C.Payload is IEnumerable<string> || C.Payload is string;
}
);
if ( UsableConvoy != null )
{
if ( UsableConvoy.Payload is string )
{
ConvoyUrls = new HashSet<string>();
ConvoyUrls.Add( ( string ) UsableConvoy.Payload );
}
else
{
ConvoyUrls = new HashSet<string>( ( IEnumerable<string> ) UsableConvoy.Payload );
}
}
}
if ( ConvoyUrls == null && Urls.Count == 0 )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "EmptyUrlLIst" ), LogType.WARNING );
}
List<IStorageFile> ISFs = new List<IStorageFile>();
foreach ( string u in Urls )
{
IStorageFile ISF = await ProceduralSpider.DownloadSource( Prefix + u );
if ( ISF != null ) ISFs.Add( ISF );
}
if ( ConvoyUrls != null )
{
foreach ( string u in ConvoyUrls )
{
IStorageFile ISF = await ProceduralSpider.DownloadSource( Prefix + u );
if ( ISF != null ) ISFs.Add( ISF );
}
}
return new ProcConvoy( this, ISFs );
}
private async Task<ProcConvoy> IncomingArguments( ProcConvoy UsableConvoy )
{
if ( UsableConvoy.Payload is string )
{
return new ProcConvoy( this, ApplyParams( ( ( string ) UsableConvoy.Payload ).Split( new char[] { '\n' }, ParamDefs.Count ) ) );
}
else if ( UsableConvoy.Payload is IStorageFile )
{
IStorageFile tmp = await AppStorage.MkTemp();
await tmp.WriteString( ApplyParams( await ( ( IStorageFile ) UsableConvoy.Payload ).ReadLines( ParamDefs.Count ) ) );
return new ProcConvoy( this, tmp );
}
else if ( UsableConvoy.Payload is IEnumerable<IStorageFile> )
{
IEnumerable<IStorageFile> Args = ( IEnumerable<IStorageFile> ) UsableConvoy.Payload;
List<IStorageFile> TemplatedStrs = new List<IStorageFile>();
foreach ( IStorageFile Arg in Args )
{
IStorageFile tmp = await AppStorage.MkTemp();
await tmp.WriteString( ApplyParams( await Arg.ReadLines( ParamDefs.Count ) ) );
TemplatedStrs.Add( tmp );
}
return new ProcConvoy( this, TemplatedStrs );
}
else
{
IEnumerable<string> Args = ( IEnumerable<string> ) UsableConvoy.Payload;
return new ProcConvoy( this, Args.Remap( x => ApplyParams( x ) ) );
}
}
private async Task<ProcConvoy> IncomingTemplates( ProcConvoy UsableConvoy )
{
if ( UsableConvoy.Payload is string )
{
return new ProcConvoy( this, FormatParams( ( string ) UsableConvoy.Payload ) );
}
else if ( UsableConvoy.Payload is IStorageFile )
{
IStorageFile tmp = await AppStorage.MkTemp();
await tmp.WriteString( FormatParams( await ( ( IStorageFile ) UsableConvoy.Payload ).ReadString() ) );
return new ProcConvoy( this, tmp );
}
else if ( UsableConvoy.Payload is IEnumerable<IStorageFile> )
{
IEnumerable<IStorageFile> Templates = ( IEnumerable<IStorageFile> ) UsableConvoy.Payload;
List<IStorageFile> TemplatedStrs = new List<IStorageFile>();
foreach ( IStorageFile Template in Templates )
{
IStorageFile tmp = await AppStorage.MkTemp();
await tmp.WriteString( FormatParams( await Template.ReadString() ) );
TemplatedStrs.Add( tmp );
}
return new ProcConvoy( this, TemplatedStrs );
}
else
{
IEnumerable<string> Templates = ( IEnumerable<string> ) UsableConvoy.Payload;
return new ProcConvoy( this, Templates.Remap( x => FormatParams( x ) ) );
}
}
public override async Task<ProcConvoy> Run( ProcConvoy Convoy )
{
await base.Run( Convoy );
string LoadUrl = TargetUrl;
string Content = "";
ProcConvoy UsableConvoy = ProcManager.TracePackage(
Convoy, ( P, C ) =>
C.Payload is IEnumerable<IStorageFile>
|| C.Payload is IEnumerable<string>
|| C.Payload is IStorageFile
|| C.Payload is string
);
IStorageFile ISF = null;
if ( UsableConvoy != null )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "IncomingCheck" ), LogType.INFO );
if ( UsableConvoy.Payload is IEnumerable<IStorageFile> )
{
ISF = ( UsableConvoy.Payload as IEnumerable<IStorageFile> ).FirstOrDefault();
}
else if ( UsableConvoy.Payload is IStorageFile )
{
ISF = ( IStorageFile ) UsableConvoy.Payload;
}
if ( Incoming )
{
if ( UsableConvoy.Payload is IEnumerable<string> )
{
LoadUrl = ( UsableConvoy.Payload as IEnumerable<string> ).FirstOrDefault();
}
else if ( UsableConvoy.Payload is string )
{
LoadUrl = ( string ) UsableConvoy.Payload;
}
if ( ISF == null && string.IsNullOrEmpty( LoadUrl ) )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "NoUsablePayload" ), LogType.WARNING );
return Convoy;
}
if ( !string.IsNullOrEmpty( LoadUrl ) )
{
LoadUrl = WebUtility.HtmlDecode( LoadUrl );
}
}
else // Incomings are Content
{
if ( UsableConvoy.Payload is IEnumerable<string> )
{
Content = string.Join( "\n", ( IEnumerable<string> ) UsableConvoy.Payload );
}
else if ( UsableConvoy.Payload is string )
{
Content = ( string ) UsableConvoy.Payload;
}
}
}
ProcConvoy BookConvoy = ProcManager.TracePackage( Convoy, ( D, C ) => C.Payload is BookItem );
BookItem BookInst = ( BookConvoy == null )
? new BookInstruction()
: ( BookConvoy.Payload as BookItem )
;
if ( !string.IsNullOrEmpty( LoadUrl ) )
{
BookInst.ReadParam( AppKeys.BINF_ORGURL, LoadUrl );
if ( string.IsNullOrEmpty( Content ) && ISF == null )
{
ISF = await ProceduralSpider.DownloadSource( LoadUrl );
}
}
if ( ISF != null ) Content = await ISF.ReadString();
await ExtractProps( BookInst, Content );
return new ProcConvoy( this, BookInst );
}
public override async Task<ProcConvoy> Run( ProcConvoy Convoy )
{
await base.Run( Convoy );
string LoadUrl = null;
FirstStopped = false;
if ( Incoming )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "IncomingCheck" ), LogType.INFO );
ProcConvoy UsableConvoy = ProcManager.TracePackage(
Convoy, ( P, C ) =>
{
return C.Payload is IEnumerable<string> || C.Payload is string;
}
);
if ( UsableConvoy != null )
{
if ( UsableConvoy.Payload is string )
{
LoadUrl = UsableConvoy.Payload as string;
}
else
{
LoadUrl = ( UsableConvoy.Payload as IEnumerable<string> ).FirstOrDefault();
}
if( !string.IsNullOrEmpty( LoadUrl ) )
{
LoadUrl = WebUtility.HtmlDecode( LoadUrl );
}
}
}
if ( string.IsNullOrEmpty( LoadUrl ) ) LoadUrl = EntryPoint;
if( string.IsNullOrEmpty( LoadUrl ) )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "NoEntryPoint" ), LogType.WARNING );
return Convoy;
}
List<IStorageFile> ISFs = new List<IStorageFile>();
bool Continue = true;
Urls.Clear();
NotifyChanged( "Urls" );
while ( Continue )
{
if( string.IsNullOrEmpty( LoadUrl ) )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "CannotCarrieOn" ), LogType.ERROR );
break;
}
IStorageFile ISF = await ProceduralSpider.DownloadSource( LoadUrl );
string Matchee = await ISF.ReadString();
Continue = NextUrl( Matchee, out LoadUrl ) && !WillStop( Matchee );
if ( Continue || !DiscardUnmatched )
{
ISFs.Add( ISF );
}
}
return new ProcConvoy( this, ISFs );
}
public ProcPassThru( ProcConvoy Convoy, ProcType PType )
: base( ProcType.PASSTHRU | PType )
{
this.Convoy = Convoy;
}
public override async Task<ProcConvoy> Run( ProcConvoy Convoy )
{
await base.Run( Convoy );
// Search for usable convoy
ProcConvoy UsableConvoy;
if ( !TryGetConvoy( out UsableConvoy, ( P, C ) =>
{
return C.Payload is IEnumerable<IStorageFile>
|| C.Payload is string;
}
) ) return Convoy;
try
{
if ( DoNothing() ) return new ProcConvoy( this, null );
Encoding Enc = null;
if ( CodePage != Encoding.UTF8.CodePage )
{
Encoding.RegisterProvider( CodePagesEncodingProvider.Instance );
Enc = Encoding.GetEncoding( CodePage );
}
if ( UsableConvoy.Payload is IEnumerable<IStorageFile> )
{
IEnumerable<IStorageFile> ISFs = ( IEnumerable<IStorageFile> ) UsableConvoy.Payload;
foreach ( IStorageFile ISF in ISFs )
{
string Content;
if ( Enc == null )
{
Content = await ISF.ReadString();
}
else
{
ProcManager.PanelMessage( this, Res.SSTR( "ReadEncoding", Enc.EncodingName ), LogType.INFO );
if ( !DecodeHtml )
{
await ISF.WriteString( await ISF.ReadString( Enc ) );
continue;
}
Content = await ISF.ReadString( Enc );
}
if ( DecodeHtml )
{
await ISF.WriteString( WebUtility.HtmlDecode( Content ) );
}
ProcManager.PanelMessage( this, Res.SSTR( "ConvertEncoding", ISF.Name ), LogType.INFO );
await ISF.WriteString( Content );
}
return new ProcConvoy( this, UsableConvoy.Payload );
}
else
{
string Content = ( string ) UsableConvoy.Payload;
if ( Enc != null )
{
ProcManager.PanelMessage( this, Res.RSTR( "CantConvertStringLiterals" ), LogType.INFO );
}
if ( DecodeHtml )
{
return new ProcConvoy( this, WebUtility.HtmlDecode( Content ) );
}
}
}
catch ( Exception ex )
{
ProcManager.PanelMessage( this, Res.SSTR( "EncodingFalied", ex.Message ), LogType.INFO );
}
return new ProcConvoy( this, null );
}
protected bool TryGetConvoy( out ProcConvoy Con, Func<Procedure, ProcConvoy, bool> Tester )
{
// Search for usable convoy
Con = ProcManager.TracePackage( Convoy, Tester );
if( Con == null )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "NoUsablePayload" ), LogType.WARNING );
Faulted = true;
return false;
}
return true;
}
public override async Task<ProcConvoy> Run( ProcConvoy Convoy )
{
Convoy = await base.Run( Convoy );
ProcConvoy UsableConvoy;
if ( !TryGetConvoy( out UsableConvoy, ( P, C ) =>
{
if ( P.Type.HasFlag( ProcType.FIND ) || P.Type.HasFlag( ProcType.URLLIST ) )
{
return C.Payload is IEnumerable<IStorageFile>;
}
return false;
}
) ) return Convoy;
IInstructionSet SpTOC = null;
// Search for the closest Instruction Set
ProcConvoy SpiderInst = ProcManager.TracePackage(
Convoy
, ( P, C ) => {
return C.Payload is IInstructionSet;
}
);
if( SpiderInst != null )
{
SpTOC = SpiderInst.Payload as IInstructionSet;
}
if( SpTOC == null )
{
SpTOC = new BookInstruction();
}
IEnumerable<IStorageFile> ISFs = UsableConvoy.Payload as IEnumerable<IStorageFile>;
bool VTitleAddOnce = false;
ProcPassThru PPass = new ProcPassThru( new ProcConvoy( this, SpTOC ) );
foreach( IStorageFile ISF in ISFs )
{
string Content = await ISF.ReadString();
ProcFind.RegItem RegTitle = new ProcFind.RegItem( VolPattern, VolTitle, true );
ProcFind.RegItem RegParam = new ProcFind.RegItem( VolPattern, VolParam, true );
if ( !( RegTitle.Validate() || RegParam.Validate() ) ) continue;
MatchCollection matches = RegTitle.RegExObj.Matches( Content );
foreach ( Match match in matches )
{
if ( VTitleAddOnce ) break;
VolInstruction VInst = null;
if( RegTitle.Valid )
{
string FTitle = string.Format(
RegTitle.Format
, match.Groups
.Cast<Group>()
.Select( g => g.Value )
.ToArray()
);
if( string.IsNullOrEmpty( RegTitle.Pattern ) )
{
VTitleAddOnce = true;
}
VInst = new VolInstruction(
VTitleAddOnce ? SpTOC.LastIndex : match.Index
, FTitle.ToCTrad()
);
VInst.ProcMan = VolProcs;
SpTOC.PushInstruction( VInst );
}
else
{
ProcManager.PanelMessage( this, () => Res.RSTR( "InvalidPattern" ), LogType.WARNING );
continue;
}
if ( HasVolProcs && RegParam.Valid )
{
string FParam = string.Format(
RegParam.Format
, match.Groups
.Cast<Group>()
.Select( g => g.Value )
.ToArray()
);
if( VolAsync )
{
VInst.SetProcId( VolProcs.GUID );
VInst.PushConvoyParam( FParam );
}
else
{
ProcConvoy VolConvoy = await VolProcs.CreateSpider().Crawl( new ProcConvoy( PPass, VInst ) );
}
}
}
RegTitle = new ProcFind.RegItem( EpPattern, EpTitle, true );
RegParam = new ProcFind.RegItem( EpPattern, EpParam, true );
if ( !( RegTitle.Validate() || RegParam.Validate() ) ) continue;
matches = RegTitle.RegExObj.Matches( Content );
foreach ( Match match in matches )
{
EpInstruction EInst = null;
if( RegTitle.Valid )
{
string FTitle = string.Format(
RegTitle.Format
, match.Groups
.Cast<Group>()
.Select( g => g.Value )
.ToArray()
);
EInst = new EpInstruction(
VTitleAddOnce ? SpTOC.LastIndex : match.Index
, FTitle.ToCTrad()
);
EInst.ProcMan = EpProcs;
SpTOC.PushInstruction( EInst );
}
else
{
ProcManager.PanelMessage( this, () => Res.RSTR( "InvalidPattern" ), LogType.WARNING );
continue;
}
if ( HasEpProcs && RegParam.Valid )
{
string FParam = string.Format(
RegParam.Format
, match.Groups
.Cast<Group>()
.Select( g => g.Value )
.ToArray()
);
if( EpAsync )
{
EInst.SetProcId( EpProcs.GUID );
EInst.PushConvoyParam( FParam );
}
else
{
ProcConvoy EpConvoy = await EpProcs.CreateSpider().Crawl( new ProcConvoy( PPass, FParam ) );
}
}
}
}
return new ProcConvoy( this, SpTOC );
}
private async Task<string> GetId( ProcConvoy Convoy )
{
Convoy = ProcManager.TracePackage(
Convoy, ( P, C ) =>
C.Payload is IEnumerable<IStorageFile>
|| C.Payload is IEnumerable<string>
|| C.Payload is IStorageFile
|| C.Payload is string
);
if ( Convoy == null ) return null;
if ( Convoy.Payload is IEnumerable<IStorageFile> )
{
IEnumerable<IStorageFile> ISFs = ( IEnumerable<IStorageFile> ) Convoy.Payload;
return await ISFs.FirstOrDefault()?.ReadString();
}
else if ( Convoy.Payload is IEnumerable<string> )
{
IEnumerable<string> Contents = ( IEnumerable<string> ) Convoy.Payload;
return Contents.FirstOrDefault();
}
else if ( Convoy.Payload is IStorageFile )
{
IStorageFile ISF = ( IStorageFile ) Convoy.Payload;
return await ISF.ReadString();
}
else // string
{
return ( string ) Convoy.Payload;
}
}
private async Task SearchBooks( List<BookInstruction> ItemList, ProcPassThru PPass, ProcConvoy KnownBook, string Content )
{
ProcFind.RegItem RegParam = new ProcFind.RegItem( ItemPattern, ItemParam, true );
if ( !RegParam.Validate() ) return;
MatchCollection matches = RegParam.RegExObj.Matches( Content );
foreach ( Match match in matches )
{
if ( HasSubProcs && RegParam.Valid )
{
string FParam = string.Format(
RegParam.Format
, match.Groups
.Cast<Group>()
.Select( g => g.Value )
.ToArray()
);
ProcConvoy ItemConvoy = await ItemProcs.CreateSpider().Crawl( new ProcConvoy( PPass, FParam ) );
string Id = await GetId( ItemConvoy );
if ( string.IsNullOrEmpty( Id ) )
{
ProcManager.PanelMessage( this, () =>
{
StringResources stx = new StringResources( "Error" );
return stx.Str( "NoIdForBook" );
}, LogType.WARNING );
continue;
}
ItemConvoy = ProcManager.TracePackage( ItemConvoy, ( P, C ) => C.Payload is BookInstruction );
if ( !( ItemConvoy == null || ItemConvoy == KnownBook ) )
{
BookInstruction BInst = ( BookInstruction ) ItemConvoy.Payload;
ItemList.Add( BInst );
if ( HasBookSpider ) BInst.PlaceDefs( Id, BookSpider );
}
else
{
ProcManager.PanelMessage( this, () =>
{
StringResources stx = new StringResources( "Error" );
return stx.Str( "NotABook" );
}, LogType.WARNING );
}
}
}
}
public override async Task<ProcConvoy> Run( ProcConvoy Convoy )
{
Convoy = await base.Run( Convoy );
ProcConvoy UsableConvoy;
if ( !TryGetConvoy(
out UsableConvoy
, ( P, C ) =>
C.Payload is IEnumerable<IStorageFile>
|| C.Payload is IEnumerable<string>
|| C.Payload is IStorageFile
|| C.Payload is string
) ) return Convoy;
List<BookInstruction> SpItemList = null;
// Search for the closest Instruction Set
ProcConvoy SpiderInst = ProcManager.TracePackage(
Convoy
, ( P, C ) => C.Payload is IEnumerable<BookInstruction>
);
if ( SpiderInst != null )
{
SpItemList = ( List<BookInstruction> ) SpiderInst.Payload;
}
if ( SpItemList == null )
{
SpItemList = new List<BookInstruction>();
}
ProcPassThru PPass = new ProcPassThru( new ProcConvoy( this, SpItemList ) );
ProcConvoy KnownBook = ProcManager.TracePackage( Convoy, ( P, C ) => C.Payload is BookInstruction );
if ( UsableConvoy.Payload is IEnumerable<IStorageFile> )
{
IEnumerable<IStorageFile> ISFs = ( IEnumerable<IStorageFile> ) UsableConvoy.Payload;
foreach ( IStorageFile ISF in ISFs )
{
string Content = await ISF.ReadString();
await SearchBooks( SpItemList, PPass, KnownBook, Content );
}
}
else if ( UsableConvoy.Payload is IEnumerable<string> )
{
IEnumerable<string> Contents = ( IEnumerable<string> ) UsableConvoy.Payload;
foreach ( string Content in Contents )
{
await SearchBooks( SpItemList, PPass, KnownBook, Content );
}
}
else if ( UsableConvoy.Payload is IStorageFile )
{
IStorageFile ISF = ( IStorageFile ) UsableConvoy.Payload;
string Content = await ISF.ReadString();
await SearchBooks( SpItemList, PPass, KnownBook, Content );
}
else // string
{
await SearchBooks( SpItemList, PPass, KnownBook, ( string ) UsableConvoy.Payload );
}
return new ProcConvoy( this, SpItemList );
}
public static void StoreParams( ProcConvoy Convoy, XRegistry Settings )
{
ProcParameter Defs = ( ProcParameter ) ProcManager.TracePackage( Convoy, ( P, C ) => P is ProcParameter )?.Dispatcher;
if ( Defs == null ) return;
XParameter PDefs = new XParameter( "PPValues" );
Defs.AssignParamDefs( PDefs );
Settings.SetParameter( PDefs );
}
public override async Task<ProcConvoy> Run( ProcConvoy Convoy )
{
await base.Run( Convoy );
ProcConvoy UsableConvoy;
bool IsFeedRun = ( ProcManager.TracePackage( Convoy, ( P, C ) => ( P.Type & ProcType.FEED_RUN ) != 0 ) != null );
ProcManager.PanelMessage( this, () => Res.RSTR( "RunMode", ModeName ), LogType.INFO );
switch ( Mode )
{
case RunMode.FEEDBACK:
if ( !IsFeedRun )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "NotAFeedRun" ), LogType.INFO );
return Convoy;
}
goto case RunMode.DEFINE;
case RunMode.DEFINE:
UsableConvoy = ProcManager.TracePackage( Convoy, ( P, C ) =>
C.Payload is IEnumerable<IStorageFile>
|| C.Payload is IEnumerable<string>
|| C.Payload is IStorageFile
|| C.Payload is string
);
if ( Incoming )
{
if ( UsableConvoy == null )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "NoUsableConvoy" ), LogType.WARNING );
return Convoy;
}
return await IncomingTemplates( UsableConvoy );
}
else if ( UsableConvoy != null )
{
return await IncomingArguments( UsableConvoy );
}
goto DEFAULT_PARAMS;
/*** Belows only accepts incoming templates ***/
case RunMode.INPUT:
if ( IsFeedRun )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "FeedRunning" ), LogType.INFO );
return Convoy;
}
ProcConvoy Con = ProcManager.TracePackage( Convoy, ( P, C ) => ( P.Type & ProcType.TEST_RUN ) != 0 );
if ( Con != null )
{
ProcManager.PanelMessage( this, () => Res.RSTR( "TestRun_UseDefault" ), LogType.INFO );
break;
}
Dialogs.InputProcParam InputDialog = new Dialogs.InputProcParam( this );
await Popups.ShowDialog( InputDialog );
if ( InputDialog.Canceled )
{
throw new OperationCanceledException( "Canceled by user" );
}
// Input sets the dafault values
break;
case RunMode.SOURCE_AVAIL:
if ( !TryGetConvoy( out UsableConvoy, ( P, C ) => P is ProcParameter ) )
return Convoy;
ProcParameter Proc = ( ProcParameter ) UsableConvoy.Dispatcher;
ParamDefs = Proc.ParamDefs;
break;
}
if ( Incoming )
{
if ( !TryGetConvoy( out UsableConvoy, ( P, C ) =>
C.Payload is IEnumerable<IStorageFile>
|| C.Payload is IEnumerable<string>
|| C.Payload is IStorageFile
|| C.Payload is string
) ) return Convoy;
return await IncomingTemplates( UsableConvoy );
}
DEFAULT_PARAMS:
return new ProcConvoy( this, ApplyParams() );
}
virtual public async Task<ProcConvoy> Run( ProcConvoy Convoy )
{
return await Task.Run( () => this.Convoy = Convoy );
}
private void MessageBus_OnDelivery( Message Mesg )
{
ProcConvoy Convoy = Mesg.Payload as ProcConvoy;
if ( Mesg.Content == "RUN_RESULT"
&& Convoy != null
&& Convoy.Dispatcher == EditTarget )
{
BookInstruction TInst = Convoy.Payload as BookInstruction;
ProcConvoy ProcCon = ProcManager.TracePackage( Convoy, ( P, C ) => P is ProcParameter );
if ( ProcCon != null )
{
ProcParameter PPClone = new ProcParameter();
PPClone.ReadParam( ProcCon.Dispatcher.ToXParam() );
ProcCon = new ProcConvoy( PPClone, null );
}
TInst.PackVolumes( ProcCon );
Preview.Navigate(
typeof( TableOfContents )
, new Tuple<Volume[], SelectionChangedEventHandler>( TInst.GetVolumes(), PreviewContent )
);
Preview.BackStack.Clear();
TestRunning.IsActive = false;
}
}
public ProcPassThru( ProcConvoy Convoy )
: base( ProcType.PASSTHRU )
{
this.Convoy = Convoy;
}