public static void getListMemmber()
{
var uri = string.Format("https://{0}.api.mailchimp.com/3.0/lists/{1}/members", dataCenter, listId);
try
{
using (var webClient = new WebClient())
{
webClient.Headers.Add("Accept", "application/json");
webClient.Headers.Add("Authorization", "apikey " + apiKey);
var outputRes = webClient.DownloadString(uri);
RootMember instance = JsonConvert.DeserializeObject <RootMember>(outputRes);
foreach (MCMember itemMember in instance.members)
{
Console.WriteLine("Email: " + itemMember.email_address + ", Status: " + itemMember.status);
DataTable dt = GetUserByEmail(itemMember.email_address);
if (dt.Rows.Count > 0)
{
if (itemMember.status != (Convert.ToBoolean(dt.Rows[0]["Status"]) ? SubscriberStatus.subscribed.ToString() : SubscriberStatus.unsubscribed.ToString()))
{
subscribeAddress(dt);
}
}
}
}
}
catch (WebException we)
{
using (var sr = new StreamReader(we.Response.GetResponseStream()))
{
Console.WriteLine("Error Message" + sr.ReadToEnd());
}
}
}
/// <summary>
/// Builds a code model for C# project
/// </summary>
/// <param name="projectFile">Project file full path</param>
/// <param name="addOns">Optional list of add-ons</param>
/// <returns>Code model root (async)</returns>
public static async Task <RootMember> BuildFromProjectSourcesAsync(string projectFile, IEnumerable <IAddOn> addOns)
{
RootMember root;
var rootBuilder = new RootMemberBuilder();
Console.WriteLine($"Preparing the workspace for {projectFile}");
MSBuildLocator.RegisterDefaults();
using (var msWorkspace = MSBuildWorkspace.Create())
{
Console.WriteLine($"Opening the project {projectFile}");
var project = await msWorkspace.OpenProjectAsync(projectFile);
var compilation = project.GetCompilationAsync().Result;
var assemblySymbol = compilation.Assembly;
//Build the code model
Console.WriteLine("Building the code model...");
rootBuilder.ProjectRootDir = new FileInfo(projectFile).DirectoryName;
rootBuilder.CompilationFiles = compilation.SyntaxTrees.Select(st => st.FilePath).ToList();
Build(assemblySymbol, rootBuilder, null, null, null, 0);
root = new RootMember(rootBuilder, addOns);
Console.WriteLine("Code model build");
Console.WriteLine("Closing the workspace...");
msWorkspace.CloseSolution();
Console.WriteLine("Workspace closed");
}
return(root);
}
public string UpdateUserDataJson(RootMember updatedUserObject, string updatedById = null)
{
var userID = GetUserID();
var jsonUser = JsonConvert.SerializeObject(updatedUserObject);
Console.WriteLine(jsonUser);
updatedById = userID;
var result = mTrackSvc.updateUserDataJson(userID, jsonUser, updatedById, Constants.SPEC_GROUP_TYPE);
return(result);
}
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
UserInfo = await US.GetUserInfo();
if (UserInfo.Err.Count == 0)
{
ProfileBanner.Source = UserInfo.User.Banner;
ProfilePic.Source = UserInfo.User.Avatar;
UserNameTB.Text = $"{UserInfo.User.login}#{UserInfo.User.Id}";
BadgeList Badges = await BS.GetUserBadges(UserInfo.User.Id);
BadgesView.ItemsSource = Badges.Badges;
}
}
/// <summary>
/// Let the add-on to prepare it's own data as a part of <see cref="RootMember"/> constructor.
/// </summary>
/// <remarks>
/// The add-on checks all compilation files for the <NuProp.xxx> comments with source-only package metadata
/// and builds the list of source-only packages and the indexes between the packages and code model members.
/// </remarks>
/// <param name="root">Code model root</param>
/// <param name="builder">Code model buildel root</param>
public void ProcessRootData(RootMember root, RootMemberBuilder builder)
{
ConsoleUtils.WriteInfo("SourceOnlyPackagesAddOn preparing data...");
//Get source-only packages info
var packages = new List <NuProps>();
SourceOnlyPackages = packages;
var sourceOnlyPackagesByMember = new Dictionary <Member, List <NuProps> >();
SourceOnlyPackagesByMember = sourceOnlyPackagesByMember;
var membersBySourceOnlyPackage = new Dictionary <NuProps, List <Member> >();
MembersBySourceOnlyPackage = membersBySourceOnlyPackage;
foreach (var compilationFile in builder.CompilationFiles)
{
var nuProps = new NuProps(compilationFile, builder.CompilationFiles);
if (!nuProps.HasNuProps)
{
continue;
}
packages.Add(nuProps);
//add members to indexes
foreach (var packageFile in nuProps.PackageFiles)
{
if (!root.AllMembersBySourceFile.TryGetValue(packageFile, out var packageMembers))
{
continue;
}
foreach (var packageMember in packageMembers)
{
if (!sourceOnlyPackagesByMember.TryGetValue(packageMember, out var packagesForMember))
{
packagesForMember = new List <NuProps>();
sourceOnlyPackagesByMember.Add(packageMember, packagesForMember);
}
packagesForMember.Add(nuProps);
if (!membersBySourceOnlyPackage.TryGetValue(nuProps, out var membersForPackage))
{
membersForPackage = new List <Member>();
membersBySourceOnlyPackage.Add(nuProps, membersForPackage);
}
membersForPackage.Add(packageMember);
}
}
}
ConsoleUtils.WriteInfo($"SourceOnlyPackagesAddOn finished preparing data - {packages.Count} source only packages found");
}
public RootMember GetUserObject()
{
var userID = GetUserID();
try
{
var objUser = mTrackSvc.getUsrObject(userID, Constants.SPEC_GROUP_TYPE);
var jsonUser = FormatJsonType(objUser.ToString());
RootMember rootMember = JsonConvert.DeserializeObject <RootMember>(jsonUser);
return(rootMember);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
ShowMessageBox(null, ex.Message);
}
return(null);
}
/// <summary>
/// Writes the table of all source-only packages within the code model into the output
/// </summary>
/// <param name="root">Code model root</param>
/// <param name="markup">Markup provider</param>
/// <returns>True when any output has been generated</returns>
public async Task <bool> WriteIndexAsync(RootMember root, IMarkupProvider markup)
{
if (SourceOnlyPackages == null || SourceOnlyPackages.Count < 1)
{
return(false);
}
await markup.WriteH2Async("Source-only packages", "package-list");
await markup.WriteTableHeaderAsync("Name", "Summary");
foreach (var nuProps in SourceOnlyPackages.OrderBy(p => p.PackageId))
{
await markup.WriteTableColsAsync(Link(nuProps.PackageId, nuProps, markup), nuProps.PackageDescription ?? string.Empty);
}
await markup.WriteTableFooterAsync();
return(true);
}
/// <summary>
/// Writes the source-only packages pages into the output
/// </summary>
/// <param name="root">Code model root</param>
/// <param name="markup">Markup provider</param>
/// <param name="generator">Markup generator</param>
/// <returns>Async task</returns>
public async Task WriteOwnPagesAsync(RootMember root, IMarkupProvider markup, MarkupGenerator generator)
{
if (SourceOnlyPackages == null || SourceOnlyPackages.Count < 1)
{
return;
}
if (OutputOptions.SplitNs && !OutputOptions.SplitType)
{
//split by Ns only -> all source only packages will be on single page
await generator.SplitAsync(GetPackagePagesFileName());
}
foreach (var nuProps in SourceOnlyPackages.OrderBy(p => p.PackageId))
{
if (OutputOptions.SplitType)
{
//split by Type -> each source only packages will be on dedicated page
await generator.SplitAsync(GetPackagePageFileName(nuProps));
}
await markup.WriteH2Async($"{nuProps.PackageId} Source only package", GetPackageAnchor(nuProps));
await markup.WriteParaAsync(
markup.Small(
new Txt()
.AddIf($"Version: {nuProps.PackageVersion}", !string.IsNullOrEmpty(nuProps.PackageVersion))
.AddIf(markup.LineBreak(), !string.IsNullOrEmpty(nuProps.PackageVersion))
.AddIf($"Tags: {nuProps.PackageTags}", !string.IsNullOrEmpty(nuProps.PackageTags))
.AddIf(markup.LineBreak(), !string.IsNullOrEmpty(nuProps.PackageTags))
.Add($"Includes: {nuProps.IncludesType}")
.Add(markup.LineBreak())
.Add($"Declaring file: { PathUtils.GetRelativeSourceFile(nuProps.DeclaringFile,root.ProjectRootDir)}")
));
await markup.WriteParaAsync(nuProps.PackageDescription);
if (nuProps.Usings != null && nuProps.Usings.Count > 0)
{
await markup.WriteParaAsync(new Txt()
.Add(markup.Bold("Usings"))
.Add(markup.DescriptionList(
u =>
{
var refPkg = SourceOnlyPackages.FirstOrDefault(p => p.PackageId == u.PackageId);
return(refPkg == null ? u.PackageId : Link(u.PackageId, refPkg, markup));
},
u => string.IsNullOrEmpty(u.PackageVersion) ? string.Empty : $"version: {u.PackageVersion}",
nuProps.Usings)));
}
if (nuProps.ExternalReferences != null && nuProps.ExternalReferences.Count > 0)
{
await markup.WriteParaAsync(new Txt()
.Add(markup.Bold("References needed"))
.Add(markup.DescriptionList(
er => er,
er => string.Empty,
nuProps.ExternalReferences)));
}
if (nuProps.PackageRemarksSource != null &&
root.AllMembersByDocId.TryGetValue(nuProps.PackageRemarksSource, out var member))
{
var remarksDocumentation = member.Documentation?.GetRemarks(member)?.Render(markup, member);
if (!string.IsNullOrEmpty(remarksDocumentation))
{
await markup.WriteH3Async("Remarks");
await markup.WriteParaAsync(remarksDocumentation);
}
}
if (MembersBySourceOnlyPackage.TryGetValue(nuProps, out var members) && members.Count > 0)
{
await markup.WriteParaAsync(new Txt()
.Add(markup.Bold("Package members"))
.Add(markup.DescriptionList(
m => markup.Link($"{m.Name} ({m.MemberKind})", m),
m => m.Documentation?.GetSummary(m)?.Render(markup, m),
members)));
}
await markup.WriteParaAsync(new Txt()
.Add(markup.Bold("Sources"))
.Add(markup.DescriptionList(
f => $"{PathUtils.GetRelativeSourceFile(f,root.ProjectRootDir)}",
f => string.Empty,
nuProps.PackageFiles)));
await generator.WritePageFooterAsync();
}
}
