public Categories()
{
Dependencies.AddRange(new[]
{
nameof(Posts),
});
ProcessModules = new ModuleList
{
new ReplaceDocuments(nameof(Posts)),
new GroupDocuments(CustomKeys.Category),
new FilterDocuments(Config.FromDocument(doc => !string.IsNullOrEmpty(doc.GetString(Keys.GroupKey)))),
new ForEachDocument(
new SetMetadata(CustomKeys.CategoryPosts, Config.FromDocument(doc => doc.GetChildren())),
new SetMetadata(CustomKeys.Title, Config.FromDocument(doc => doc.GetString(Keys.GroupKey))),
new SetMetadata(CustomKeys.Subtitle, Config.FromDocument(doc => $"Pokémon attrapés avec la méthode <strong>‘{doc.GetString(Keys.GroupKey)}’</strong>")),
new SetMetadata(CustomKeys.WritePath, Config.FromDocument(doc => $"categories/{doc.GetString(Keys.GroupKey).Slugify()}/index.html"))
),
new RenderRazor().WithLayout((NormalizedPath)"/_Category.cshtml"),
new SetDestination(Config.FromDocument(doc => (NormalizedPath)doc.GetString(CustomKeys.WritePath)))
};
OutputModules = new ModuleList
{
new WriteFiles()
};
}
public SiteMapPipeline()
{
Dependencies.AddRange(nameof(PostsPipeline), nameof(HomePipeline));
ProcessModules = new ModuleList(
// pull documents from other pipelines
new ReplaceDocuments(Dependencies.ToArray()),
new SetMetadata(Keys.SitemapItem, Config.FromDocument((doc, ctx) =>
{
var siteMapItem = new SitemapItem(doc.Destination.FullPath)
{
LastModUtc = doc.Get <DateTime?>(KontentKeys.System.LastModified, null)
};
if (!siteMapItem.LastModUtc.HasValue)
{
siteMapItem.LastModUtc = DateTime.UtcNow;
siteMapItem.ChangeFrequency = SitemapChangeFrequency.Weekly;
}
else
{
siteMapItem.ChangeFrequency = SitemapChangeFrequency.Monthly;
}
return(siteMapItem);
})),
new GenerateSitemap()
);
OutputModules = new ModuleList {
new WriteFiles(),
};
}
protected ApplyLayoutPipeline()
{
PostProcessModules = new ModuleList
{
new SetMetadata("template", Config.FromContext(async ctx => await ctx.Outputs
.FromPipeline(nameof(LayoutPipeline))
.First(x => x.Source.FileName == "layout.hbs")
.GetContentStringAsync())),
new RenderHandlebars("template")
.Configure(async(context, document, handlebars) =>
{
foreach (var partial in context.Outputs
.FromPipeline(nameof(LayoutPipeline)).WhereContainsKey("partial"))
{
handlebars.RegisterTemplate(
partial.GetString("partial"),
await partial.GetContentStringAsync());
}
}).WithModel(Config.FromDocument(async(doc, ctx) => new
{
title = doc.GetString(Keys.Title),
body = await doc.GetContentStringAsync(),
link = ctx.GetLink(doc),
year = ctx.Settings.GetString(FeedKeys.Copyright)
})),
new SetContent(Config.FromDocument(x => x.GetString("template")))
};
}
private void InitModules()
{
ModuleList.Clear();
AddedModuleList.Clear();
if (SelectedApplication != null)
{
List <DynEntity> allModules = ApplicationDesignService.GetAllApplictionModuleCollection();
List <DynEntity> currentApplicationModules = ApplicationDesignService.GetAplicationModulesByAplicationID(SelectedApplication.ApplicationID);
foreach (var module in allModules)
{
bool isHave = false;
foreach (var addedModule in currentApplicationModules)
{
if (Convert.Equals(addedModule["ModuleID"], module["ModuleID"]))
{
AddedModuleList.Add(new ApplicationModule()
{
ModuleName = module["ModuleName"] as string, ModuleID = (int)module["ModuleID"]
});
isHave = true;
break;
}
}
if (!isHave)
{
ModuleList.Add(new ApplicationModule()
{
ModuleName = module["ModuleName"] as string, ModuleID = (int)module["ModuleID"]
});
}
}
}
}
public unsafe IntPtr TryGetMarshallerForDelegate(RuntimeTypeHandle delegateTypeHandle)
{
int delegateHashcode = delegateTypeHandle.GetHashCode();
foreach (NativeFormatModuleInfo module in ModuleList.EnumerateModules())
{
NativeReader delegateMapReader;
if (TryGetNativeReaderForBlob(module, ReflectionMapBlob.DelegateMarshallingStubMap, out delegateMapReader))
{
NativeParser delegateMapParser = new NativeParser(delegateMapReader, 0);
NativeHashtable delegateHashtable = new NativeHashtable(delegateMapParser);
ExternalReferencesTable externalReferences = default(ExternalReferencesTable);
externalReferences.InitializeCommonFixupsTable(module);
var lookup = delegateHashtable.Lookup(delegateHashcode);
NativeParser entryParser;
while (!(entryParser = lookup.GetNext()).IsNull)
{
RuntimeTypeHandle foundDelegateType = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
if (foundDelegateType.Equals(delegateTypeHandle))
{
byte *pByte = (byte *)externalReferences.GetIntPtrFromIndex(entryParser.GetUnsigned());
return((IntPtr)pByte);
}
}
}
}
return(IntPtr.Zero);
}
protected IssuePages(TotalIssueCounts totals)
{
Dependencies.Add(nameof(Issues));
ProcessModules = new ModuleList
{
new ExecuteConfig(
Config.FromContext(ctx => ctx.Outputs
.FromPipeline(nameof(Issues))
.Where(doc => DocumentPredicate == null || DocumentPredicate(doc))
.SelectMany(doc => doc
.GetList <Issue>("Issues")
.Where(i => IssuePredicate == null || IssuePredicate(i))
.Select(i => new PagedIssue(i, doc)))
.OrderByDescending(x => x.CreatedAt)
.Partition(24, count => SetTotal(count, totals))
.Select(x => ctx.CreateDocument(new MetadataItems
{
{ "Page", x.Key },
{ "Issues", x.ToList() }
})))),
new GenerateJson(Config.FromDocument(doc => doc["Issues"]))
.WithCamelCase(),
new MinifyJs(),
new SetDestination(Destination)
};
OutputModules = new ModuleList
{
new WriteFiles()
};
}
public PagesPipeline(IDeliveryClient deliveryClient)
{
Dependencies.AddRange(nameof(HomepagePipeline), nameof(SiteMetadataPipeline));
InputModules = new ModuleList {
new Kontent <Page>(deliveryClient)
.WithQuery(new IncludeTotalCountParameter(), new NotEmptyFilter("elements.body")),
new SetDestination(Config.FromDocument((doc, ctx) => GetPath(doc))),
};
ProcessModules = new ModuleList {
new MergeContent(new ReadFiles(patterns: "Index.cshtml")),
new RenderRazor()
.WithModel(Config.FromDocument((document, context) =>
{
var menuItem = document.AsKontent <Page>();
var model = new HomeViewModel(menuItem,
new SidebarViewModel(
context.Outputs.FromPipeline(nameof(HomepagePipeline)).Select(x => x.AsKontent <Homepage>()).FirstOrDefault(),
context.Outputs.FromPipeline(nameof(SiteMetadataPipeline)).Select(x => x.AsKontent <SiteMetadata>()).FirstOrDefault(),
false, menuItem.Url));
return(model);
}
))/*,
* new KontentImageProcessor()*/
};
OutputModules = new ModuleList {
new WriteFiles(),
};
}
public Redirects()
{
Dependencies.Add(nameof(Content));
ProcessModules = new ModuleList
{
new ReplaceDocuments(nameof(Content)),
new FlattenTree(),
new ExecuteConfig(Config.FromSettings(settings =>
{
GenerateRedirects generateRedirects = new GenerateRedirects()
.WithMetaRefreshPages(settings.GetBool(WebKeys.MetaRefreshRedirects, true));
if (settings.GetBool(WebKeys.NetlifyRedirects, false))
{
generateRedirects = generateRedirects.WithAdditionalOutput(
"_redirects",
redirects => string.Join(Environment.NewLine, redirects.Select(r => $"/{r.Key} {r.Value}")));
}
return(generateRedirects);
}))
};
OutputModules = new ModuleList
{
new WriteFiles()
};
}
public List <ServiceItem> UpdateList(ModuleList moduleList)
{
List <ServiceItem> newList = new List <ServiceItem>();
if (moduleList.ModuleInfoList != null)
{
foreach (ModuleInfo moduleInfo in moduleList.ModuleInfoList)
{
string serviceName = moduleInfo.Name + " (" + moduleInfo.Version + ")";
ServiceItem ServiceItem = new ServiceItem();
ServiceItem.ServiceTitle = serviceName;
ServiceItem.Tag = moduleInfo;
if (moduleInfo.Enabled == 0)
{
ServiceItem.MenuEnableHeader = "Enable";
ServiceItem.ServiceStatusColor = (Brush)(new BrushConverter()).ConvertFromString("#FF0000");
}
else
{
ServiceItem.MenuEnableHeader = "Disable";
ServiceItem.ServiceStatusColor = (Brush)(new BrushConverter()).ConvertFromString("#00FF00");
}
newList.Add(ServiceItem);
}
}
return(newList);
}
private void Refresh(bool rmodule, bool rmenu, bool rmenudtl, bool rrole, bool ruser)
{
if (rmodule)
{
ModuleList.Clear();
ModuleList.AddRange(PubMaster.Mod.RoleSql.QueryWcsModuleList());
}
if (rmenu)
{
MenuList.Clear();
MenuList.AddRange(PubMaster.Mod.RoleSql.QueryWcsMenuList());
}
if (rmenudtl)
{
MenuDtlList.Clear();
MenuDtlList.AddRange(PubMaster.Mod.RoleSql.QueryWcsMenuDtlList());
}
if (rrole)
{
RoleList.Clear();
RoleList.AddRange(PubMaster.Mod.RoleSql.QueryWcsRoleList());
}
if (ruser)
{
UserList.Clear();
UserList.AddRange(PubMaster.Mod.RoleSql.QueryWcsUserList());
}
}
public HomePipeline()
{
Dependencies.AddRange(nameof(BookPipeline), nameof(RatingPipeline), nameof(AuthorPipeline), nameof(ContactPipeline));
InputModules = new ModuleList
{
new ReadFiles("index.cshtml")
};
ProcessModules = new ModuleList {
new RenderRazor().WithModel(Config.FromDocument((doc, context) =>
{
var allBooks = XperienceDocumentConverter.ToTreeNodes <Book>(context.Outputs.FromPipeline(nameof(BookPipeline)));
var allAuthors = XperienceDocumentConverter.ToTreeNodes <Author>(context.Outputs.FromPipeline(nameof(AuthorPipeline)));
var allRatings = XperienceDocumentConverter.ToCustomTableItems <RatingsItem>(context.Outputs.FromPipeline(nameof(RatingPipeline)), RatingsItem.CLASS_NAME);
var contactInfo = XperienceDocumentConverter.ToTreeNodes <ContactUs>(context.Outputs.FromPipeline(nameof(ContactPipeline))).FirstOrDefault();
var booksWithReviews = allBooks.Select(b => new BookWithReviews(b, allRatings));
var authorsWithBooks = allAuthors.Select(a => new AuthorWithBooks(a, booksWithReviews));
return(new HomeViewModel()
{
Authors = authorsWithBooks,
Books = booksWithReviews,
ContactInfo = contactInfo
});
})),
new SetDestination(Config.FromDocument((doc, ctx) => {
return(new NormalizedPath("index.html"));
}))
};
OutputModules = new ModuleList {
new WriteFiles()
};
}
public void TestModuleList()
{
CastDate currentDate = new CastDate {
Time = 1492984800000
};
ReportData reportData = TestUtility.PrepareApplicationReportData("CoCRestAPI",
@".\Data\ModulesCoCRA.json", @".\Data\CurrentBCTCmodules.json", "AED/applications/3/snapshots/4", "Snap4_CAIP-8.3ra_RG-1.5.a", "8.3.ra", currentDate,
null, null, null, null, null, null);
var component = new ModuleList();
Dictionary <string, string> config = new Dictionary <string, string>();
var table = component.Content(reportData, config);
var expectedData = new List <string>();
expectedData.AddRange(new List <string> {
"Module Name"
});
expectedData.AddRange(new List <string> {
"AAD-Admin"
});
expectedData.AddRange(new List <string> {
"AED-Admin"
});
expectedData.AddRange(new List <string> {
"ReportGenerator"
});
TestUtility.AssertTableContent(table, expectedData, 1, 4);
Assert.IsTrue(table.HasColumnHeaders);
}
public SocialImages()
{
Dependencies.AddRange(nameof(Inputs));
ProcessModules = new ModuleList
{
new GetPipelineDocuments(ContentType.Content),
// Filter to non-archive content
new FilterDocuments(Config.FromDocument(doc => !Archives.IsArchive(doc))),
// Process the content
new CacheDocuments
{
new AddTitle(),
new SetDestination(true),
new ExecuteIf(Config.FromSetting(WebKeys.OptimizeContentFileNames, true))
{
new OptimizeFileName()
},
new GenerateSocialImage(),
}
};
OutputModules = new ModuleList {
new WriteFiles()
};
}
public NewsFeed()
{
Dependencies.AddRange(
nameof(Blogs.Posts),
nameof(Broadcasts.Episodes));
ProcessModules = new ModuleList
{
new ReplaceDocuments(
nameof(Blogs.Posts),
nameof(Broadcasts.Episodes)),
new FilterDocuments(Config.FromDocument(doc => doc.Get <FeedItem>("FeedItems").Recent)),
new OrderDocuments(Config.FromDocument(doc => doc.Get <FeedItem>("FeedItems").Published)).Descending(),
new GenerateFeeds()
.WithAtomPath("feeds/news.atom")
.WithRssPath("feeds/news.rss")
.WithFeedTitle("Recent News From Discover .NET")
.WithFeedDescription("A roundup of recent blog posts, podcasts, and more.")
.WithItemTitle(Config.FromDocument(doc => doc.Get <FeedItem>("FeedItems").Title))
.WithItemDescription(Config.FromDocument(doc => doc.Get <FeedItem>("FeedItems").Description))
.WithItemPublished(Config.FromDocument(doc => (DateTime?)doc.Get <FeedItem>("FeedItems").Published.DateTime))
.WithItemLink(Config.FromDocument(doc => TypeHelper.Convert <Uri>(doc.Get <FeedItem>("FeedItems").Link)))
.WithItemId(Config.FromDocument(doc => TypeHelper.Convert <Uri>(doc.Get <FeedItem>("FeedItems").Link).ToString()))
.WithItemAuthor(Config.FromDocument(doc =>
doc.Get <FeedItem>("FeedItems").Author
?? doc.GetString("Author")
?? doc.GetString("Title")))
.WithItemImageLink(null)
};
OutputModules = new ModuleList
{
new WriteFiles()
};
}
// Retreiving information from the previous created student list
public StudentDetails(ModuleList store)
{
InitializeComponent();
// Adding Student list items to the datagrid GUI
datagrid_show_all.ItemsSource = _store.StudentList;
}
public Issues()
{
InputModules = new ModuleList
{
new ReadFiles(Config.FromContext(ctx => ctx.FileSystem.RootPath.Combine("../../data/projects/*.yml").FullPath)),
new ExecuteIf(Config.FromContext(ctx => ctx.ApplicationState.IsCommand("preview") || ctx.Settings.GetBool("dev")))
{
new OrderDocuments(Config.FromDocument(x => x.Source)),
new TakeDocuments(10)
}
};
ProcessModules = new ModuleList
{
new LogMessage(Config.FromContext(ctx => $"Getting issue data for {ctx.Inputs.Length} issues...")),
new ParseYaml(),
new SetContent(string.Empty),
new GetIssueGitHubData(),
new FilterDocuments(Config.FromDocument(doc => doc.ContainsKey("Issues"))),
new SetMetadata("ProjectKey", Config.FromDocument(x => x.Source.FileNameWithoutExtension.FullPath)),
new GenerateJson(Config.FromDocument(doc => doc["Issues"]))
.WithCamelCase(),
new MinifyJs(),
new SetDestination(Config.FromDocument(x => (FilePath)$"data/issues/projects/{x.Source.FileName.ChangeExtension(".json")}"))
};
OutputModules = new ModuleList
{
new WriteFiles()
};
}
public TagIndexPipeline()
{
Dependencies.Add(nameof(TagsPipeline));
InputModules = new ModuleList
{
new ReadFiles("_tagIndex.hbs")
};
ProcessModules = new ModuleList
{
new SetDestination(Config.FromValue(new NormalizedPath("./tags/index.html"))),
new RenderHandlebars()
.WithModel(Config.FromContext(context => new
{
tags = context.Outputs.FromPipeline(nameof(TagsPipeline))
.OrderByDescending(x => x.GetChildren().Count)
.ThenBy(x => x.GetString(Keys.GroupKey))
.Select(x => x.AsTag(context)),
}))
};
OutputModules = new ModuleList
{
new WriteFiles()
};
}
/// <summary>
/// Locate the containing module for a method and try to resolve its name based on start address.
/// </summary>
public static string GetMethodNameFromStartAddressIfAvailable(IntPtr methodStartAddress)
{
IntPtr moduleStartAddress = RuntimeAugments.GetOSModuleFromPointer(methodStartAddress);
int rva = (int)((nuint)methodStartAddress - (nuint)moduleStartAddress);
foreach (TypeManagerHandle handle in ModuleList.Enumerate())
{
if (handle.OsModuleBase == moduleStartAddress)
{
string name = _perModuleMethodNameResolverHashtable.GetOrCreateValue(handle.GetIntPtrUNSAFE()).GetMethodNameFromRvaIfAvailable(rva);
if (name != null)
{
return(name);
}
}
}
// We haven't found information in the stack trace metadata tables, but maybe reflection will have this
if (ReflectionExecution.TryGetMethodMetadataFromStartAddress(methodStartAddress,
out MetadataReader reader,
out TypeDefinitionHandle typeHandle,
out MethodHandle methodHandle))
{
return(MethodNameFormatter.FormatMethodName(reader, typeHandle, methodHandle));
}
return(null);
}
public ShellViewModel(IRegionManager rm, IEventAggregator ea)
{
_rm = rm;
#region 加载列表
ea.GetEvent <Models.Events.RegisterMenuEvent>().Subscribe(s =>
{
ModuleList.Add(new Menu_Module
{
IconName = s.IconName,
ModuleNmae = s.MenuName,
PageName = s.PageName,
});
});
#endregion
#region 模块选择命令
ModuleChangedCommand = new DelegateCommand <string>(p =>
{
if (p == null)
{
return;
}
rm.RequestNavigate("主tab", p);
NaviIndex = -1;
});
#endregion
#region 关闭tabItem命令
CloseTabItemCommadn = new DelegateCommand <object>(P =>
{
_rm.Regions["主tab"].Remove(P);
});
#endregion
}
public FeedsPipeline()
{
Dependencies.Add(nameof(PostsPipeline));
ProcessModules = new ModuleList(
// Pull documents from other pipelines
new ReplaceDocuments(Dependencies.ToArray()),
// Set metadata for the feeds module
new SetMetaDataItems(
async(input, context) =>
{
var post = input.AsKontent <Article>();
var html = await ParseHtml(input, context);
var article = html?.GetElementsByTagName("article").FirstOrDefault()?.InnerHtml ?? "";
return(new MetadataItems
{
{ FeedKeys.Title, post.Title },
{ FeedKeys.Content, post.Description },
{ FeedKeys.Description, post.Description },
{ FeedKeys.Image, post.OgImage.FirstOrDefault()?.Url }, // TODO: make that a local image!
{ FeedKeys.Published, post.PublishDate },
{ FeedKeys.Content, article }
});
}),
new GenerateFeeds()
.WithFeedTitle("Lumen Blog")
.WithFeedCopyright($"{DateTime.Today.Year}")
);
OutputModules = new ModuleList(
new WriteFiles()
);
}
public SiteResources()
{
ProcessModules = new ModuleList
{
new CopyFiles("**/*{!.cshtml,!.md,!.less,!.yml,!.scss,}")
};
}
private unsafe bool TryGetStructData(RuntimeTypeHandle structTypeHandle, out ExternalReferencesTable externalReferences, out NativeParser entryParser)
{
int structHashcode = structTypeHandle.GetHashCode();
externalReferences = default(ExternalReferencesTable);
entryParser = default(NativeParser);
foreach (NativeFormatModuleInfo module in ModuleList.EnumerateModules())
{
NativeReader structMapReader;
if (TryGetNativeReaderForBlob(module, ReflectionMapBlob.StructMarshallingStubMap, out structMapReader))
{
NativeParser structMapParser = new NativeParser(structMapReader, 0);
NativeHashtable structHashtable = new NativeHashtable(structMapParser);
externalReferences.InitializeCommonFixupsTable(module);
var lookup = structHashtable.Lookup(structHashcode);
while (!(entryParser = lookup.GetNext()).IsNull)
{
RuntimeTypeHandle foundStructType = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
if (foundStructType.Equals(structTypeHandle))
{
return(true);
}
}
}
}
return(false);
}
public Recent()
{
Dependencies.Add(nameof(Issues));
ProcessModules = new ModuleList
{
new GenerateJson(
Config.FromContext(ctx => ctx.Outputs
.FromPipeline(nameof(Issues))
.SelectMany(doc => doc
.GetList <Issue>("Issues")
.Where(i => i.Recent)
.Select(i => new
{
ProjectKey = doc.GetString("ProjectKey"),
CreatedAt = i.CreatedAt,
Link = i.Link,
Title = i.Title
}))
.OrderByDescending(x => x.CreatedAt)))
.WithCamelCase(),
new MinifyJs(),
new SetDestination((FilePath)"data/issues/recent/all.json")
};
OutputModules = new ModuleList
{
new WriteFiles()
};
}
public Resources()
{
InputModules = new ModuleList
{
new ReadFiles(Config.FromContext(ctx => ctx.FileSystem.RootPath.Combine("../../data/resources/*.yml").FullPath)),
new ExecuteIf(Config.FromContext(ctx => ctx.ApplicationState.IsCommand("preview") || ctx.Settings.GetBool("dev")))
{
new OrderDocuments(Config.FromDocument(x => x.Source)),
new TakeDocuments(10)
}
};
ProcessModules = new ModuleList
{
new ParseYaml(),
new SetContent(string.Empty),
new SetMetadata("Key", Config.FromDocument(x => x.Source.FileNameWithoutExtension.FullPath)),
new SetMetadata("Link", Config.FromDocument(d => d.GetString("Website"))),
new SetMetadata("CardType", "Resource"), // TODO: Do we still need this without groups/events?
new SetMetadata("CardData", Config.FromDocument(x => x.GetMetadata(
"Website",
"Title",
"Image",
"Description",
"CardType",
"Comment",
"Tags",
"DiscoveryDate")))
};
}
public HomePipeline(IDeliveryClient deliveryClient)
{
Dependencies.AddRange(nameof(PostsPipeline), nameof(HomepagePipeline), nameof(SiteMetadataPipeline));
ProcessModules = new ModuleList(
// pull documents from other pipelines
new ReplaceDocuments(nameof(PostsPipeline)),
new PaginateDocuments(4),
new SetDestination(Config.FromDocument((doc, ctx) => Filename(doc))),
new MergeContent(new ReadFiles("Index.cshtml")),
new RenderRazor()
.WithModel(Config.FromDocument((document, context) =>
{
var model = new HomeViewModel(document.AsPagedKontent <Article>(),
new SidebarViewModel(
context.Outputs.FromPipeline(nameof(HomepagePipeline)).Select(x => x.AsKontent <Homepage>()).FirstOrDefault(),
context.Outputs.FromPipeline(nameof(SiteMetadataPipeline)).Select(x => x.AsKontent <SiteMetadata>()).FirstOrDefault(),
true, "/"));
return(model);
}
)),
new KontentImageProcessor()
);
OutputModules = new ModuleList {
new WriteFiles(),
};
}
public Pack()
{
ExecutionPolicy = ExecutionPolicy.Manual;
Dependencies.Add(nameof(Build));
ProcessModules = new ModuleList
{
new ThrowExceptionIf(Config.ContainsSettings("DAVIDGLICK_CERTPASS").IsFalse(), "DAVIDGLICK_CERTPASS setting missing"),
new ReadFiles("src/**/*.csproj"),
new StartProcess("dotnet")
.WithArgument("pack")
.WithArgument("--no-build")
.WithArgument("--no-restore")
.WithArgument("-o", Config.FromContext(ctx => ctx.FileSystem.GetOutputPath().FullPath), true)
.WithArgument(Config.FromDocument(doc => doc.Source.FullPath), true)
.WithParallelExecution(false)
.LogOutput(),
new ReadFiles(Config.FromContext(ctx => ctx.FileSystem.GetOutputPath("*.nupkg").FullPath)),
new StartProcess("nuget")
.WithArgument("sign")
.WithArgument(Config.FromDocument(doc => doc.Source.FullPath), true)
.WithArgument("-CertificatePath", Config.FromContext(ctx => ctx.FileSystem.GetRootFile("davidglick.pfx").Path.FullPath), true)
.WithArgument("-CertificatePassword", Config.FromSetting("DAVIDGLICK_CERTPASS"), true)
.WithArgument("-Timestamper", "http://timestamp.digicert.com", true)
.WithArgument("-NonInteractive")
.WithParallelExecution(false)
.LogOutput()
};
}
/// <summary>
/// Returns a list of modules for the stack 'stackIdx'. It also updates the interning table stackModuleLists, so
/// that the entry cooresponding to stackIdx remembers the answer. This can speed up processing alot since many
/// stacks have the same prefixes to root.
/// </summary>
private ModuleList GetModulesForStack(ModuleList[] stackModuleLists, StackSourceCallStackIndex stackIdx)
{
var ret = stackModuleLists[(int)stackIdx];
if (ret == null)
{
// ret = the module list for the rest of the frames.
var callerIdx = GetCallerIndex(stackIdx);
if (callerIdx != StackSourceCallStackIndex.Invalid)
{
ret = GetModulesForStack(stackModuleLists, callerIdx);
}
// Compute the module for the top most frame, and add it to the list (if we find a module)
TraceModuleFile module = null;
var frameIdx = GetFrameIndex(stackIdx);
if (frameIdx != StackSourceFrameIndex.Invalid)
{
var codeAddress = GetFrameCodeAddress(frameIdx);
if (codeAddress != CodeAddressIndex.Invalid)
{
var moduleFileIdx = TraceLog.CallStacks.CodeAddresses.ModuleFileIndex(codeAddress);
if (moduleFileIdx != ModuleFileIndex.Invalid)
{
module = TraceLog.ModuleFiles[moduleFileIdx];
ret = ModuleList.SetAdd(module, ret);
}
}
}
stackModuleLists[(int)stackIdx] = ret;
}
return(ret);
}
public Pages()
{
InputModules = new ModuleList
{
new ReadFiles("**/{!_,}*.{cshtml,md}")
};
ProcessModules = new ModuleList
{
new CacheDocuments
{
new ExtractFrontMatter(new ParseYaml()),
new ExecuteIf(
Config.FromDocument(doc => doc.MediaTypeEquals("text/markdown")),
new RenderMarkdown().UseExtensions()),
new SetDestination(".html")
}
};
TransformModules = new ModuleList
{
new ExecuteIf(
Config.FromDocument(doc => doc.MediaTypeEquals("text/markdown")),
new RenderRazor().WithLayout((FilePath)"/_markdown.cshtml"))
.Else(new RenderRazor().WithLayout((FilePath)"/_layout.cshtml")),
new MirrorResources()
};
OutputModules = new ModuleList
{
new WriteFiles()
};
}
public ArchivePipeline()
{
Dependencies.Add(nameof(BlogPostPipeline));
InputModules = new ModuleList
{
new ReadFiles("_archive.hbs")
};
ProcessModules = new ModuleList
{
new SetDestination(Config.FromValue(new NormalizedPath("./posts/index.html"))),
new RenderHandlebars()
.WithModel(Config.FromContext(context => new
{
groups = context.Outputs.FromPipeline(nameof(BlogPostPipeline))
.GroupBy(x => x.GetDateTime(FeedKeys.Published).Year)
.OrderByDescending(x => x.Key)
.Select(group => new
{
key = group.Key,
posts = group
.OrderByDescending(x => x.GetDateTime(FeedKeys.Published))
.Select(x => x.AsPost(context)),
})
}))
};
OutputModules = new ModuleList
{
new WriteFiles()
};
}
protected void ModuleList(PacketHeader header, Connection connection, ModuleList moduleList)
{
if (ModuleListEvent != null)
{
ModuleListEvent.Invoke(moduleList.ModuleInfoList, EventArgs.Empty);
}
}
public Debugger(AsyncTaskRunner asyncTaskRunner) {
Dispatch.AsyncTaskRunner = asyncTaskRunner;
this.BreakpointList = new BreakpointList(this);
this.Memory = new Memory(this);
this.ModuleList = new ModuleList(this);
this.ThreadList = new ThreadList(this);
this.CurrentContext = new Context(this);
}
public BusinessClassesList GetAdditionalClasses(ModuleList moduleList) {
#pragma warning disable 612,618
var businessClassesList = new BusinessClassesList(moduleList.SelectMany(@base => @base.AdditionalBusinessClasses));
businessClassesList.AddRange(
moduleList.SelectMany(moduleBase => moduleBase.BusinessClassAssemblies.GetBusinessClasses()));
#pragma warning restore 612,618
businessClassesList.AddRange(moduleList.SelectMany(@base => @base.AdditionalExportedTypes));
return businessClassesList;
}
private void UpdateModulesList(ModuleList sender)
{
modulesListView.BeginUpdate();
modulesListView.Items.Clear();
foreach (Module module in debugger.ModuleList) {
var item = new ListViewItem(new string[]{
module.Handle.ToString("X4"),
module.ModuleType == xe.debug.proto.ModuleType.Kernel ? "Kernel"
: "User",
module.Name,
module.Path,
});
modulesListView.Items.Add(item);
}
modulesListView.EndUpdate();
}
public static Dictionary<string, StringModelStore> GetEmbededModelStores(Func<KeyValuePair<string, ResourceInfo>, bool> func, ModuleList modules) {
return ResourceInfos(modules).Where(func).ToDictionary(pair => pair.Key, pair => new StringModelStore(pair.Value.AspectInfos.First().Xml));
}
private void UpdateModulesList(ModuleList sender)
{
modulesComboBox.BeginUpdate();
modulesComboBox.Items.Clear();
foreach (Module module in debugger.ModuleList) {
modulesComboBox.Items.Add(module);
module.Changed += Module_Changed;
}
modulesComboBox.EndUpdate();
}
public DefaultModuleLoader(ILogger logger, ModuleList moduleList)
{
this.moduleList = moduleList;
this.logger = logger;
}
public BusinessClassesList GetAdditionalClasses(ModuleList moduleList) {
var businessClassesList = new BusinessClassesList(moduleList.SelectMany(@base => @base.AdditionalBusinessClasses));
businessClassesList.AddRange(
moduleList.SelectMany(moduleBase => moduleBase.BusinessClassAssemblies.GetBusinessClasses()));
return businessClassesList;
}
public ExecuteBackgroundCommandOnModuleList(ModuleList moduleList)
{
this.moduleList = moduleList;
}
public IList<Type> GetAdditionalClasses(ModuleList moduleList) {
return new List<Type>(moduleList.SelectMany(@base => @base.AdditionalExportedTypes));
}
public SetCopiesReportHelper(ModuleList modules)
{
ReportsModuleV2 module = ReportsModuleV2.FindReportsModule(modules);
if (module != null)
module.ReportsDataSourceHelper.BeforeShowPreview += ReportsDataSourceHelper_BeforeShowPreview;
}
public ModuleManagement(ServicesDaemon tBase)
{
Modules = new ModuleList();
DataDriver = "";
Base = tBase;
}
public NickServService(LocalClient tMyClient, ServicesCore tMyCore, DataBase tNickDB, ModuleList Modules)
{
this.MyClient = tMyClient;
this.MyCore = tMyCore;
this.NickDB = tNickDB;
this.Modules = Modules;
Help = ((Help.Help) this.Modules["Help"]);
}
public RunCommandOnModuleList(ModuleList moduleList)
{
this.moduleList = moduleList;
}
public override bool ModLoad()
{
DataDriver = MyBase.DataDriver;
//Load the DB into memory
try
{
if (DataDriver.DBExists("floodserv.db"))
{
FloodDB = DataDriver.LoadDB("floodserv.db");
if (FloodDB == null)
{
throw (new Exception("NickServ: Unknown DB Load Error"));
// return false;
}
}
else
{
MakeDB();
}
BlackLight.Services.Timers.Timer FSSaveTimer;
FSSaveTimer = new BlackLight.Services.Timers.Timer(new TimeSpan(0), new TimeSpan(0, 5, 0), - 1, new Timers.TimedCallBack(TimerSaveDB));
MyBase.timerController.addTimer(FSSaveTimer);
MyBase.Core.events.OnFinishedNetBurst += new BlackLight.Services.Core.ServicesCore.ServicesEvents.OnFinishedNetBurstEventHandler(this.OnConnect);
}
catch (Exception ex)
{
MyBase.Core.SendLogMessage("FloodServ", "ModLoad", BlackLight.Services.Error.Errors.ERROR, "Exception", "", ex.Message, ex.StackTrace);
//show("FloodServ Error " + ex.Message + " " + ex.StackTrace);
return false;
}
mFloodServ = new LocalClient("FloodServ",new MessageCallBack(FloodServCallBack) ,MyBase.Core);
ModuleList tModules = new ModuleList();
tModules.Add(MyBase.ModuleManage.Modules["Help"]);
MyService = new FloodServService(mFloodServ, MyBase.Core, FloodDB, tModules);
mFloodServ.host = "services.com";
mFloodServ.modes = "S";
mFloodServ.realname = "FloodServ";
mFloodServ.time = BlackLight.Services.Converters.Time.GetTS(DateTime.Now);
mFloodServ.username = "******";
MyBase.Core.events.onClientConnect += new BlackLight.Services.Core.ServicesCore.ServicesEvents.onClientConnectEventHandler(MyService.OnClientConnect);
mFloodServ.Cmds.Add("HELP", new BlackLight.Services.Nodes.CommandCallBack( MyService.FSHelp));
mFloodServ.Cmds.Add("NPWATCH", new BlackLight.Services.Nodes.CommandCallBack( MyService.FSNPWatch));
mFloodServ.Cmds.Add("NSWATCH", new BlackLight.Services.Nodes.CommandCallBack( MyService.FSNSWatch));
mFloodServ.Cmds.Add("REGWATCH", new BlackLight.Services.Nodes.CommandCallBack( MyService.FSRegWatch));
mFloodServ.Cmds.Add("NPSCAN", new BlackLight.Services.Nodes.CommandCallBack( MyService.FSNPScan));
mFloodServ.Cmds.Add("NSSCAN", new BlackLight.Services.Nodes.CommandCallBack( MyService.FSNSScan));
mFloodServ.Cmds.Add("REGSCAN", new BlackLight.Services.Nodes.CommandCallBack( MyService.FSRegScan));
MyBase.Core.LocalClients.AddClient(mFloodServ);
return true;
}
public FloodServService(LocalClient tMyClient, ServicesCore tMyCore, DataBase tFloodDB, ModuleList Modules)
{
this.MyClient = tMyClient;
this.MyCore = tMyCore;
this.FloodDB = tFloodDB;
this.Modules = Modules;
Help = ((Help.Help) this.Modules["Help"]);
m_NPWatches = new ArrayList();
m_NSWatches = new ArrayList();
m_RegWatches = new ArrayList();
m_Recent = new ServiceList();
updateWatchList(0);
updateWatchList(1);
updateWatchList(2);
}
private void Init(XpandControllersManager xpandControllersManager, string assembliesPath) {
Tracing.Tracer.LogVerboseText("ApplicationModulesManager.Init");
_assembliesPath = assembliesPath;
Modules = new ModuleList(null);
_xpandControllersManager = xpandControllersManager;
}
public override bool ModLoad()
{
DataDriver = MyBase.DataDriver;
//Load the DB into memory
try
{
if (DataDriver.DBExists("nickserv.db"))
{
NickDB = DataDriver.LoadDB("nickserv.db");
if (NickDB == null)
{
throw (new Exception("NickServ: Unknown DB Load Error"));
// return false;
}
}
else
{
MakeDB();
}
BlackLight.Services.Timers.Timer NSSaveTimer;
NSSaveTimer = new BlackLight.Services.Timers.Timer(new TimeSpan(0), new TimeSpan(0, 5, 0), - 1, new Timers.TimedCallBack( TimerSaveDB));
MyBase.timerController.addTimer(NSSaveTimer);
MyBase.Core.events.OnFinishedNetBurst += new BlackLight.Services.Core.ServicesCore.ServicesEvents.OnFinishedNetBurstEventHandler(this.OnConnect);
}
catch (Exception ex)
{
MyBase.Core.SendLogMessage("Nick", "ModLoad", BlackLight.Services.Error.Errors.ERROR, "Exception", "", ex.Message, ex.StackTrace);
//show("NickServ Error " + ex.Message + " " + ex.StackTrace);
return false;
}
mNickServ = new LocalClient("NickServ", new MessageCallBack(NickServCallBack), MyBase.Core);
ModuleList tModules = new ModuleList();
tModules.Add(MyBase.ModuleManage.Modules["Help"]);
MyService = new NickServService(mNickServ, MyBase.Core, NickDB, tModules);
mNickServ.host = "services.com";
mNickServ.modes = "S";
mNickServ.realname = "NickyServ";
mNickServ.time = BlackLight.Services.Converters.Time.GetTS(DateTime.Now);
mNickServ.username = "******";
// Client
mNickServ.Cmds.Add("REGISTER", new BlackLight.Services.Nodes.CommandCallBack( MyService.NSRegister));
// Client
mNickServ.Cmds.Add("IDENTIFY", new BlackLight.Services.Nodes.CommandCallBack( MyService.NSIdentify));
// Client
mNickServ.Cmds.Add("GROUP", new BlackLight.Services.Nodes.CommandCallBack( MyService.NSGroup));
// Client
mNickServ.Cmds.Add("GLIST", new BlackLight.Services.Nodes.CommandCallBack( MyService.NSGList));
// Client/Oper
mNickServ.Cmds.Add("DROP", new BlackLight.Services.Nodes.CommandCallBack( MyService.NSDrop));
// Client
mNickServ.Cmds.Add("GHOST", new BlackLight.Services.Nodes.CommandCallBack( MyService.NSGhost));
mNickServ.Cmds.Add("HELP", new BlackLight.Services.Nodes.CommandCallBack( MyService.NSHelp));
// Client/Open - (oper gets more)
// bNickServ.Cmds.Add("INFO", AddressOf MyService.NullFunction)
// Client
// bNickServ.Cmds.Add("LOGOUT", AddressOf MyService.NullFunction)
// Client
// bNickServ.Cmds.Add("RECOVER", AddressOf MyService.NullFunction)
// Client
// bNickServ.Cmds.Add("RELEASE", AddressOf MyService.NullFunction)
// Client
// bNickServ.Cmds.Add("AJOIN", AddressOf MyService.NullFunction)
// Client / Oper
// bNickServ.Cmds.Add("ACCESS", AddressOf MyService.NullFunction)
// Client / Oper
// bNickServ.Cmds.Add("ALIST", AddressOf MyService.NullFunction)
// Client
// bNickServ.Cmds.Add("STATUS", AddressOf MyService.NullFunction)
// Client/Oper
// bNickServ.Cmds.Add("SET", AddressOf MyService.NullFunction)
// Oper
// bNickServ.Cmds.Add("FIND", AddressOf MyService.NullFunction)
// Oper
// bNickServ.Cmds.Add("FORBID", AddressOf MyService.NullFunction)
// Oper
// bNickServ.Cmds.Add("UNFORBID", AddressOf MyService.NullFunction)
// Oper
// bNickServ.Cmds.Add("SUSPEND", AddressOf MyService.NullFunction)
// Oper
// bNickServ.Cmds.Add("UNSUSPEND", AddressOf MyService.NullFunction)
// Oper - de oper/dc
// bNickServ.Cmds.Add("NOOP", AddressOf MyService.NullFunction)
// Oper
//bNickServ.Cmds.Add("UNIDENTIFY", AddressOf MyService.NullFunction)
MyBase.Core.LocalClients.AddClient(mNickServ);
return true;
}
public ReloadCommandOnModuleList(IDirectoryController directories, ModuleList moduleList, IModuleLoader moduleLoader)
{
this.directories = directories;
this.moduleList = moduleList;
this.moduleLoader = moduleLoader;
}
