public ActionResult ChangeCulture(string lang, string returnUrl)
{
Session["Culture"] = new CultureInfo(lang);
using (var api = ApiFactory.Create())
{
var request = new GetPageTranslationsRequest {
PageUrl = returnUrl
};
var xx = api.Pages.Page.Translations.Get(request);
if (xx.Data.TotalCount > 1)
{
List <PageTranslationModel> pages1 = xx.Data.Items.ToList();
foreach (var item in pages1)
{
string language = item.LanguageCode != null ? item.LanguageCode : "vi";
if (language == lang)
{
return(Redirect(item.PageUrl));
}
}
}
}
return(Redirect(returnUrl));
}
public virtual ActionResult Index()
{
var menuItems = new List <MenuItemViewModel>();
using (var api = ApiFactory.Create())
{
var sitemapId = GetSitemapId(api);
if (sitemapId.HasValue)
{
var request = new GetSitemapTreeRequest {
SitemapId = sitemapId.Value
};
var response = api.Pages.Sitemap.Tree.Get(request);
if (response.Data.Count > 0)
{
menuItems = response.Data.Select(mi => new MenuItemViewModel {
Caption = mi.Title, Url = mi.Url
}).ToList();
}
}
}
return(View(menuItems));
}
public void Sitemap_Crud()
{
using (var api = ApiFactory.Create())
{
var sitemaps = api.Pages.Sitemaps.Get(new GetSitemapsRequest());
// Sitemap:
var sitemap = api.Pages.SitemapNew.Get(new GetSitemapRequest
{
SitemapId = sitemaps.Data.Items.First().Id,
Data = new GetSitemapModel
{
IncludeAccessRules = true,
IncludeNodes = true,
}
});
var saveSitmapRequest = sitemap.ToPutRequest();
// Sitemap nodes:
var node = api.Pages.SitemapNew.Node.Get(new GetNodeRequest
{
SitemapId = sitemap.Data.Id,
NodeId = sitemap.Nodes.First().Id
});
var saveNodeRequest = node.ToPutRequest();
}
}
public virtual ActionResult MyFileUploadWidget_Upload(MyFileUploadViewModel model)
{
// LOCAL TESTING
var res = "Form is empty!";
if (string.IsNullOrEmpty(model.Name))
{
return Content(res);
}
using (var api = ApiFactory.Create())
{
var fileId = new Guid("20CB0347-E7AF-4899-92C6-A460009F5F74");
res = "Uploaded new file";
var categoryTreeResponse = api.Root.Category.Nodes.Get(new GetCategoryNodesRequest { CategoryTreeId = new Guid("1BA19133-A833-4127-AD2A-A43500ECE5D2") });
var allCategoryTreeNodes = categoryTreeResponse.Data.Items;
var file = api.Media.File.Get(new GetFileRequest { FileId = fileId });
var putFileRequest = file.ToPutRequest();
putFileRequest.Data.Categories = new List<Guid>();
putFileRequest.Data.Categories.Add(allCategoryTreeNodes[0].Id);
api.Media.File.Put(putFileRequest);
Thread.Sleep(1000);
file = api.Media.File.Get(new GetFileRequest { FileId = fileId });
putFileRequest = file.ToPutRequest();
putFileRequest.Data.Categories = new List<Guid>();
putFileRequest.Data.Categories.Add(allCategoryTreeNodes[1].Id);
api.Media.File.Put(putFileRequest);
}
return Content(res);
}
public ActionResult SitemapMenu(string languageCode)
{
var menuItems = new List <MenuItemViewModel>();
using (var api = ApiFactory.Create())
{
var languageId = GetLanguageId(api, languageCode);
var sitemapId = GetSitemapId(api);
if (sitemapId.HasValue)
{
var request = new GetSitemapTreeRequest {
SitemapId = sitemapId.Value
};
request.Data.LanguageId = languageId;
var response = api.Pages.Sitemap.Tree.Get(request);
if (response.Data.Count > 0)
{
menuItems = response.Data.Select(mi => new MenuItemViewModel {
Caption = mi.Title, Url = mi.Url, IsPublished = mi.PageIsPublished
}).ToList();
}
}
}
return(View("~/Views/SitemapMenu/Index.cshtml", menuItems));
}
private static IApi CreateApi(SiteData site)
{
var apiFactory = new ApiFactory("https://rest.trackmatic.co.za/api/v2");
var api = apiFactory.Create();
api.Login(site.ApiKey).Wait();
return(api);
}
private void TheCallToCreateAPaymentIsMade()
{
using (var apiBuilder = new ApiFactory())
{
var api = apiBuilder.Create();
this.response = api.CreatePayment(this.paymentReference.ToString(), this.payment).Result;
}
}
public ActionResult BlogPosts(RenderWidgetViewModel model)
{
IList <BlogItem> posts;
var isPagingEnabled = model.GetOptionValue <bool>("ShowPager");
var pageSize = model.GetOptionValue <int>("PageSize");
var page = Request.QueryString["blogpage"].ToIntOrDefault();
int postsCount;
using (var api = ApiFactory.Create())
{
var request = new GetBlogPostsModel {
Take = pageSize, IncludeTags = true, IncludeCategories = true
};
SortAndFilterRequest(request);
if (isPagingEnabled)
{
var skipCount = page == 0 ? 0 : (page - 1) * pageSize;
request.Skip = skipCount;
}
request.Take = pageSize;
var pages = api.Blog.BlogPosts.Get(new GetBlogPostsRequest {
Data = request
});
posts = pages.Data.Items.Select(
x => new BlogItem
{
IntroText = x.IntroText,
PublishedOn = x.ActivationDate,
Title = x.Title,
Url = x.BlogPostUrl,
Author = x.AuthorName,
Tags = x.Tags,
Categories = x.Categories
}).ToList();
postsCount = pages.Data.TotalCount;
}
var items = new BlogItemsModel
{
Items = posts,
ShowAuthor = model.GetOptionValue <bool>("ShowAuthor"),
ShowDate = model.GetOptionValue <bool>("ShowDate"),
ShowCategories = model.GetOptionValue <bool>("ShowCategories"),
ShowTags = model.GetOptionValue <bool>("ShowTags"),
ShowPager = isPagingEnabled,
NumberOfPages = (int)Math.Ceiling((double)postsCount / pageSize),
CurrentPage = page > 0 ? page : 1
};
return(View(items));
}
public virtual ActionResult SubMenu(string parentUrl)
{
var menuItems = new List <MenuItemViewModel>();
using (var api = ApiFactory.Create())
{
var pageRequest = new PageExistsRequest {
PageUrl = parentUrl
};
var pageResponse = api.Pages.Page.Exists(pageRequest);
var sitemapId = GetSitemapId(api);
if (sitemapId.HasValue)
{
var parentRequest = new GetSitemapNodesRequest();
parentRequest.SitemapId = sitemapId.Value;
parentRequest.Data.Take = 1;
parentRequest.Data.Filter.Add("ParentId", null);
var filter = new DataFilter(FilterConnector.Or);
parentRequest.Data.Filter.Inner.Add(filter);
filter.Add("Url", parentUrl);
if (pageResponse.Data.Exists)
{
filter.Add("PageId", pageResponse.Data.PageId.Value);
}
parentRequest.Data.Order.Add("DisplayOrder");
var parentResponse = api.Pages.Sitemap.Nodes.Get(parentRequest);
if (parentResponse.Data.Items.Count == 1)
{
var request = new GetSitemapTreeRequest {
SitemapId = sitemapId.Value
};
request.Data.NodeId = parentResponse.Data.Items[0].Id;
var response = api.Pages.Sitemap.Tree.Get(request);
if (response.Data.Count > 0)
{
menuItems = response.Data.Select(mi => new MenuItemViewModel {
Caption = mi.Title, Url = mi.Url
}).ToList();
menuItems.Insert(0, new MenuItemViewModel {
Caption = "Main", Url = parentUrl
});
}
}
}
}
return(View(menuItems));
}
public void Folder_Crud()
{
using (var api = ApiFactory.Create())
{
var folders =
api.Media.Folders.Get(
new GetFoldersRequest {
Data = new BetterCms.Module.Api.Operations.MediaManager.Folders.GetFolderModel()
{
IncludeArchived = true
}
});
}
}
public ActionResult SitemapMenu(string languageCode)
{
var renderIFrame = string.IsNullOrWhiteSpace(languageCode);
var model = new SitemapMenuViewModel
{
ObsoleteMenuItems = new List <MenuItemViewModel>(),
MenuItems = new List <MenuItemViewModel>(),
RenderIFrame = renderIFrame,
LanguageCode = languageCode
};
using (var api = ApiFactory.Create())
{
var languageId = GetLanguageId(api, languageCode);
var sitemapId = GetSitemapId(api);
if (sitemapId.HasValue)
{
var request = new Module.Api.Operations.Pages.Sitemap.Tree.GetSitemapTreeRequest {
SitemapId = sitemapId.Value
};
request.Data.LanguageId = languageId ?? new Guid();
var response = api.Pages.Sitemap.Tree.Get(request);
if (response.Data.Count > 0)
{
model.ObsoleteMenuItems = response.Data.Select(mi => new MenuItemViewModel {
Caption = mi.Title, Url = mi.Url, IsPublished = mi.PageIsPublished
}).ToList();
}
var request1 = new Module.Api.Operations.Pages.Sitemaps.Sitemap.Tree.GetSitemapTreeRequest {
SitemapId = sitemapId.Value
};
request1.Data.LanguageId = languageId ?? new Guid();
var response1 = api.Pages.SitemapNew.Tree.Get(request1);
if (response.Data.Count > 0)
{
model.MenuItems = response1.Data.Select(mi => new MenuItemViewModel {
Caption = mi.Title, Url = mi.Url, IsPublished = mi.PageIsPublished
}).ToList();
}
}
if (model.RenderIFrame)
{
model.LanguageCodes = api.Root.Languages.Get(new GetLanguagesRequest()).Data.Items.Select(l => l.Code).ToList();
}
}
return(View("~/Views/SitemapMenu/Index.cshtml", model));
}
private void AnExistingPayment()
{
this.paymentReference = Guid.NewGuid();
this.payment = new Fixture().Create <Payment>();
using (var apiBuilder = new ApiFactory())
{
var api = apiBuilder.Create();
var result = api.CreatePayment(this.paymentReference.ToString(), this.payment).Result;
if (!result.IsSuccessStatusCode)
{
Assert.Fail("Could not create the payment as part of the setup.");
}
}
}
public ActionResult Upload(TestUploadViewModel model)
{
if (model != null && model.File != null)
{
using (var api = ApiFactory.Create())
{
if (model.Type == "file")
{
var uploadRequest = new UploadFileRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Files.Upload.Post(uploadRequest);
var getRequest = new GetFileRequest {
FileId = uploadResponse.Data.Value
};
var getResponse = api.Media.File.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>File upload successful!</h2> File can be downloaded here: <div><a href='{0}' />{1}</a></div>",
getResponse.Data.FileUrl,
getResponse.Data.Title);
}
else
{
var uploadRequest = new UploadImageRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Images.Upload.Post(uploadRequest);
var getRequest = new GetImageRequest {
ImageId = uploadResponse.Data.Value
};
var getResponse = api.Media.Image.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>Image upload successful!</h2> <div><img src='{0}' alt='{1}' /></div>",
getResponse.Data.ImageUrl,
getResponse.Data.Title);
}
}
}
return(View(model));
}
public virtual ActionResult Index(Guid?categoryId, string tagName)
{
IList <BlogItem> posts;
using (var api = ApiFactory.Create())
{
var request = new GetBlogPostsModel {
Take = 10, IncludeTags = true
};
var orFilter = new DataFilter(FilterConnector.Or);
orFilter.Add("ExpirationDate", null);
orFilter.Add("ExpirationDate", DateTime.Today, FilterOperation.GreaterOrEqual);
request.Order.By.Add(new OrderItem("ActivationDate", OrderDirection.Desc));
request.Order.By.Add(new OrderItem("Id"));
request.Filter.Add("ActivationDate", DateTime.Today, FilterOperation.LessOrEqual);
request.Filter.Inner.Add(orFilter);
if (categoryId.HasValue)
{
request.FilterByCategories = new List <Guid> {
categoryId.Value
};
}
if (!string.IsNullOrEmpty(tagName))
{
request.FilterByTags.Add(tagName);
}
var pages = api.Blog.BlogPosts.Get(new GetBlogPostsRequest {
Data = request
});
posts = pages.Data.Items.Select(
x => new BlogItem
{
IntroText = x.IntroText,
PublishedOn = x.ActivationDate,
Title = x.Title,
Url = x.BlogPostUrl,
Author = x.AuthorName,
Tags = x.Tags
}).ToList();
}
return(View(posts));
}
protected void RunApiActionInTransaction(Action <IApiFacade, ISession> actionInTransaction)
{
if (actionInTransaction == null)
{
Assert.Fail("No action specified.");
}
using (var api = ApiFactory.Create())
{
using (new TransactionScope())
{
var unitOfWork = api.Scope.Resolve <IUnitOfWork>();
actionInTransaction(api, unitOfWork.Session);
}
}
}
public void ShouldCreateAndDisposeApiFacade()
{
using (var api = ApiFactory.Create())
{
Assert.IsNotNull(api.Users);
Assert.IsNotNull(api.Users.User);
Assert.IsNotNull(api.Users.Users);
Assert.IsNotNull(api.Users.Role);
Assert.IsNotNull(api.Users.Roles);
Assert.AreEqual(api.Users.Users.GetType(), System.Type.GetType("BetterCms.Module.Users.Api.Operations.Users.Users.UsersService,BetterCms.Module.Users.Api"));
Assert.AreEqual(api.Users.User.GetType(), System.Type.GetType("BetterCms.Module.Users.Api.Operations.Users.Users.User.UserService,BetterCms.Module.Users.Api"));
Assert.AreEqual(api.Users.Role.GetType(), System.Type.GetType("BetterCms.Module.Users.Api.Operations.Users.Roles.Role.RoleService,BetterCms.Module.Users.Api"));
Assert.AreEqual(api.Users.Roles.GetType(), System.Type.GetType("BetterCms.Module.Users.Api.Operations.Users.Roles.RolesService,BetterCms.Module.Users.Api"));
}
}
public virtual ActionResult ApiTestWidget(ApiTestWidgetModel model)
{
using (var api = ApiFactory.Create())
{
var response = api.Root.Categories.Get(new GetCategoryTreesRequest());
foreach (var item in response.Data.Items)
{
model.Data += item.Id + " " + item.Name + " ";
foreach (var guid in item.AvailableFor)
{
model.Data += guid + " ";
}
model.Data += '\n';
}
}
return(PartialView(model));
}
public ActionResult GetCategories(RenderWidgetViewModel model)
{
var categories = new List <CategoryItem>();
using (var api = ApiFactory.Create())
{
var useSpecificCategoryTree = model.GetOptionValue <bool>("UseSpecificCategoryTree");
var categoryTreeName = model.GetOptionValue <string>("CategoryTreeName");
var treeRequest = new GetCategoryTreesModel();
var treePages = api.Root.Categories.Get(new GetCategoryTreesRequest {
Data = treeRequest
});
var query = treePages.Data.Items.Where(item => item.AvailableFor.Contains(new Guid("75E6C021-1D1F-459E-A416-D18477BF2020")));
if (useSpecificCategoryTree)
{
query = query.Where(item => item.Name == categoryTreeName);
}
var categoryTreeIds = query
.Select(item => item.Id)
.ToList();
foreach (var treeId in categoryTreeIds)
{
var request = new GetCategoryTreeRequest {
CategoryTreeId = treeId, Data = { IncludeNodes = true }
};
var pages = api.Root.Category.Get(request);
categories.AddRange(pages.Nodes
.Where(node => node.ParentId == null)
.OrderBy(node => node.Name)
.Select(node => new CategoryItem
{
Name = node.Name,
Id = node.Id
}));
}
}
return(View(categories));
}
public ActionResult FooterMenu()
{
var menuItems = new List <MenuItemViewModel>();
using (var api = ApiFactory.Create())
{
var sitemapId = GetSitemapId(api);
if (sitemapId.HasValue)
{
var request = new GetSitemapTreeRequest {
SitemapId = sitemapId.Value, Data = new GetSitemapTreeModel {
LanguageId = LanguageHelper.CurrentLanguageId
}
};
var response = api.Pages.Sitemap.Tree.Get(request);
System.Text.StringBuilder sb = new System.Text.StringBuilder();
if (response.Data.Count > 0)
{
foreach (var item in response.Data)
{
if (item.ChildrenNodes.Count > 0)
{
sb.Append("<div class=\"col\">");
sb.Append("<h2>" + item.Title + "</h2>");
sb.Append("<ul>");
foreach (var item1 in item.ChildrenNodes)
{
sb.Append("<li><a href=\"" + item1.Url + "\">" + item1.Title + "</a></li>");
}
sb.Append("<ul>");
sb.Append("</div>");
}
}
menuItems = response.Data.Select(mi => new MenuItemViewModel {
Caption = mi.Title, Url = mi.Url
}).ToList();
}
ViewBag.MenuString = sb.ToString();
}
}
return(View());
}
private static async Task TestApi()
{
IApiFactory factory = new ApiFactory();
IInfuraApi api = factory.Create(endpoint);
var symbolsResponse = await api.GetSymbolsAsync();
Console.WriteLine("GetSymbolsAsync = " + JsonConvert.SerializeObject(symbolsResponse, Formatting.Indented));
var symbolResponse = await api.GetSymbolAsync("ethadt");
Console.WriteLine("GetSymbolAsync = " + JsonConvert.SerializeObject(symbolResponse, Formatting.Indented));
var full = await api.GetSymbolsFullAsync("ethadt");
Console.WriteLine("GetSymbolsFullAsync = " + JsonConvert.SerializeObject(full, Formatting.Indented));
var blacklistedSites = await api.GetBlacklistedDomainsAsync();
Console.WriteLine("GetBlacklistedDomainsAsync = " + JsonConvert.SerializeObject(blacklistedSites, Formatting.Indented));
var blacklistResponse = await api.GetBlacklistAsync();
Console.WriteLine("GetBlacklistAsync = " + JsonConvert.SerializeObject(blacklistResponse, Formatting.Indented));
var methodsResponse = await api.GetMethodsAsync(EthereumNetworkType.Rinkeby);
Console.WriteLine("GetMethodsAsync = " + JsonConvert.SerializeObject(methodsResponse, Formatting.Indented));
var jsonrpcResponse = await api.GetMethodAsync(EthereumNetworkType.Rinkeby, "web3_clientVersion");
Console.WriteLine("GetMethodAsync = " + JsonConvert.SerializeObject(jsonrpcResponse, Formatting.Indented));
var requestEstimateGas = new JSONRPCRequest
{
Id = 42,
Method = JSONRPCPostMethod.EstimateGas
};
var postResult = await api.PostRequestAsync(EthereumNetworkType.Rinkeby, requestEstimateGas);
Console.WriteLine("PostRequestAsync = " + JsonConvert.SerializeObject(postResult, Formatting.Indented));
}
async void UpdateRepositoryList(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
// if we're cloning or creating, only one repo will be added to the list
// so we can handle just one new entry separately
if (isCloning || isCreating)
{
var newrepo = e.NewItems.Cast <ILocalRepositoryModel>().First();
SelectedRepository = newrepo;
if (isCreating)
{
HandleCreatedRepo(newrepo);
}
else
{
HandleClonedRepo(newrepo);
}
isCreating = isCloning = false;
var repo = await ApiFactory.Create(newrepo.CloneUrl).GetRepository();
newrepo.SetIcon(repo.Private, repo.Fork);
}
// looks like it's just a refresh with new stuff on the list, update the icons
else
{
e.NewItems
.Cast <ILocalRepositoryModel>()
.ForEach(async r =>
{
if (Equals(Holder.ActiveRepo, r))
{
SelectedRepository = r;
}
var repo = await ApiFactory.Create(r.CloneUrl).GetRepository();
r.SetIcon(repo.Private, repo.Fork);
});
}
}
}
public virtual ActionResult Last()
{
BlogItem post = null;
using (var api = ApiFactory.Create())
{
var requestLatestNewsModel = new GetBlogPostsModel {
Take = 1, IncludeTags = true
};
var orFilter = new DataFilter(FilterConnector.Or);
orFilter.Add("ExpirationDate", null);
orFilter.Add("ExpirationDate", DateTime.Today, FilterOperation.GreaterOrEqual);
requestLatestNewsModel.Order.By.Add(new OrderItem("ActivationDate", OrderDirection.Desc));
requestLatestNewsModel.Order.By.Add(new OrderItem("Id"));
requestLatestNewsModel.Filter.Add("ActivationDate", DateTime.Today, FilterOperation.LessOrEqual);
requestLatestNewsModel.Filter.Inner.Add(orFilter);
var request = new GetBlogPostsRequest {
Data = requestLatestNewsModel
};
var pages = api.Blog.BlogPosts.Get(request);
post = pages.Data.Items.Select(
x => new BlogItem
{
IntroText = x.IntroText,
PublishedOn = x.ActivationDate,
Title = x.Title,
Url = x.BlogPostUrl,
Author = x.AuthorName,
Tags = x.Tags
}).SingleOrDefault();
}
return(View(post));
}
public virtual ActionResult GetCategories()
{
IList <CategoryItem> categories;
using (var api = ApiFactory.Create())
{
var request = new GetCategoriesRequest();
request.Data.Order.By.Add(new OrderItem("Name"));
var pages = api.Root.Categories.Get(request);
categories = pages.Data.Items.Select(
x => new CategoryItem
{
Id = x.Id,
Name = x.Name
}).ToList();
}
return(View(categories));
}
public virtual ActionResult GetCategories()
{
IList <CategoryItem> categories;
using (var api = ApiFactory.Create())
{
var request = new GetCategoryTreeRequest();
request.CategoryTreeId = new Guid("98FD87B4-A25C-4DDE-933C-83826B6A94D7");
request.Data.IncludeNodes = true;
var pages = api.Root.Category.Get(request);
categories = pages.Nodes.Where(n => n.ParentId == null && n.Id != new Guid("d837bebf-67de-4952-bc60-db03043b1524")).OrderBy(n => n.Name).Select(
x => new CategoryItem
{
Id = x.Id,
Name = x.Name
}).ToList();
}
return(View(categories));
}
public virtual ActionResult Feed()
{
IList <BlogItem> posts;
using (var api = ApiFactory.Create())
{
var request = new GetBlogPostsModel {
Take = 10, IncludeTags = true
};
var orFilter = new DataFilter(FilterConnector.Or);
orFilter.Add("ExpirationDate", null);
orFilter.Add("ExpirationDate", DateTime.Today, FilterOperation.GreaterOrEqual);
request.Order.By.Add(new OrderItem("ActivationDate", OrderDirection.Desc));
request.Order.By.Add(new OrderItem("Id"));
request.Filter.Add("ActivationDate", DateTime.Today, FilterOperation.LessOrEqual);
var pages = api.Blog.BlogPosts.Get(new GetBlogPostsRequest {
Data = request
});
posts = pages.Data.Items.Select(
x => new BlogItem
{
IntroText = x.IntroText,
PublishedOn = x.ActivationDate,
Title = x.Title,
Url = x.BlogPostUrl,
Author = x.AuthorName,
ImageUrl = x.MainImageUrl,
Tags = x.Tags
}).ToList();
}
return(View(posts));
}
protected async Task <bool> IsGitHubRepo()
{
RefreshRepo();
var uri = ActiveRepo?.CloneUrl;
if (uri == null)
{
return(false);
}
var simpleApiClient = await ApiFactory.Create(uri);
var isdotcom = HostAddress.IsGitHubDotComUri(uri.ToRepositoryUrl());
if (!isdotcom)
{
var repo = await simpleApiClient.GetRepository();
var activeRepoFullName = ActiveRepo.Owner + '/' + ActiveRepo.Name;
return((repo.FullName == activeRepoFullName || repo.Id == 0) && await simpleApiClient.IsEnterprise());
}
return(isdotcom);
}
async void UpdateRepositoryList(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
// if we're cloning or creating, only one repo will be added to the list
// so we can handle just one new entry separately
if (isCloning || isCreating)
{
var newrepo = e.NewItems.Cast <ILocalRepositoryModel>().First();
SelectedRepository = newrepo;
if (isCreating)
{
HandleCreatedRepo(newrepo);
}
else
{
HandleClonedRepo(newrepo);
}
isCreating = isCloning = false;
try
{
// TODO: Cache the icon state.
var repo = await ApiFactory.Create(newrepo.CloneUrl).GetRepository();
newrepo.SetIcon(repo.Private, repo.Fork);
}
catch
{
// GetRepository() may throw if the user doesn't have permissions to access the repo
// (because the repo no longer exists, or because the user has logged in on a different
// profile, or their permissions have changed remotely)
// TODO: Log
}
}
// looks like it's just a refresh with new stuff on the list, update the icons
else
{
e.NewItems
.Cast <ILocalRepositoryModel>()
.ForEach(async r =>
{
if (Equals(Holder.ActiveRepo, r))
{
SelectedRepository = r;
}
try
{
// TODO: Cache the icon state.
var repo = await ApiFactory.Create(r.CloneUrl).GetRepository();
r.SetIcon(repo.Private, repo.Fork);
}
catch
{
// GetRepository() may throw if the user doesn't have permissions to access the repo
// (because the repo no longer exists, or because the user has logged in on a different
// profile, or their permissions have changed remotely)
// TODO: Log
}
});
}
}
}
public void ShouldCreateAndDisposeApiFacade()
{
IApiFacade apiContainer;
using (var api = ApiFactory.Create())
{
apiContainer = api;
Assert.IsNotNull(api.Root);
Assert.IsNotNull(api.Root.Layout);
Assert.IsNotNull(api.Root.Layout.Regions);
Assert.IsNotNull(api.Root.Layouts);
Assert.IsNotNull(api.Root.Tags);
Assert.IsNotNull(api.Root.Tag);
Assert.IsNotNull(api.Root.Categories);
Assert.IsNotNull(api.Root.Category);
Assert.IsNotNull(api.Root.Category.Node);
Assert.IsNotNull(api.Root.Category.Nodes);
Assert.IsNotNull(api.Root.Category.Tree);
Assert.IsNotNull(api.Root.Languages);
Assert.IsNotNull(api.Root.Language);
Assert.IsNotNull(api.Root.Version);
Assert.IsNotNull(api.Pages);
Assert.IsNotNull(api.Pages.Pages);
Assert.IsNotNull(api.Pages.Page);
Assert.IsNotNull(api.Pages.Content);
Assert.IsNotNull(api.Pages.Content.Html);
Assert.IsNotNull(api.Pages.Content.History);
Assert.IsNotNull(api.Pages.Content.Draft);
Assert.IsNotNull(api.Pages.Page.Contents);
Assert.IsNotNull(api.Pages.Page.Properties);
Assert.IsNotNull(api.Pages.Redirect);
Assert.IsNotNull(api.Pages.Redirects);
Assert.IsNotNull(api.Pages.Widget);
Assert.IsNotNull(api.Pages.Widget.HtmlContent);
Assert.IsNotNull(api.Pages.Widget.HtmlContent.Options);
Assert.IsNotNull(api.Pages.Widget.ServerControl);
Assert.IsNotNull(api.Pages.Widget.ServerControl.Options);
Assert.IsNotNull(api.Pages.Widgets);
Assert.IsNotNull(api.Pages.Sitemap);
Assert.IsNotNull(api.Pages.Sitemap.Node);
Assert.IsNotNull(api.Pages.Sitemap.Nodes);
Assert.IsNotNull(api.Pages.Sitemap.Tree);
Assert.IsNotNull(api.Pages.SitemapNew);
Assert.IsNotNull(api.Pages.SitemapNew.Node);
Assert.IsNotNull(api.Pages.SitemapNew.Nodes);
Assert.IsNotNull(api.Pages.SitemapNew.Tree);
Assert.IsNotNull(api.Pages.Sitemaps);
Assert.IsNotNull(api.Blog);
Assert.IsNotNull(api.Blog.BlogPost);
Assert.IsNotNull(api.Blog.BlogPost.Content);
Assert.IsNotNull(api.Blog.BlogPost.Properties);
Assert.IsNotNull(api.Blog.BlogPosts);
Assert.IsNotNull(api.Blog.Author);
Assert.IsNotNull(api.Blog.Authors);
Assert.IsNotNull(api.Media);
Assert.IsNotNull(api.Media.MediaTree);
Assert.IsNotNull(api.Media.Folders);
Assert.IsNotNull(api.Media.Image);
Assert.IsNotNull(api.Media.Images);
Assert.IsNotNull(api.Media.File);
Assert.IsNotNull(api.Media.Files);
Assert.IsNotNull(api.Users);
Assert.IsNotNull(api.Users.User);
Assert.IsNotNull(api.Users.Users);
Assert.IsNotNull(api.Users.Role);
Assert.IsNotNull(api.Users.Roles);
}
Assert.IsNull(apiContainer.Scope);
}
void OnPropertyChange(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "IsVisible" && IsVisible && View == null)
{
View = new GitHubConnectContent {
DataContext = this
}
}
;
}
async void UpdateRepositoryList(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
// if we're cloning or creating, only one repo will be added to the list
// so we can handle just one new entry separately
if (isCloning || isCreating)
{
var newrepo = e.NewItems.Cast <ISimpleRepositoryModel>().First();
SelectedRepository = newrepo;
if (isCreating)
{
HandleCreatedRepo(newrepo);
}
else
{
HandleClonedRepo(newrepo);
}
var repo = await ApiFactory.Create(newrepo.CloneUrl).GetRepository();
newrepo.SetIcon(repo.Private, repo.Fork);
}
// looks like it's just a refresh with new stuff on the list, update the icons
else
{
e.NewItems
.Cast <ISimpleRepositoryModel>()
.ForEach(async r =>
{
if (Equals(Holder.ActiveRepo, r))
{
SelectedRepository = r;
}
var repo = await ApiFactory.Create(r.CloneUrl).GetRepository();
r.SetIcon(repo.Private, repo.Fork);
});
}
}
}
void HandleCreatedRepo(ISimpleRepositoryModel newrepo)
{
var msg = string.Format(CultureInfo.CurrentUICulture, Constants.Notification_RepoCreated, newrepo.Name, newrepo.CloneUrl);
msg += " " + string.Format(CultureInfo.CurrentUICulture, Constants.Notification_CreateNewProject, newrepo.LocalPath);
ShowNotification(newrepo, msg);
}
void HandleClonedRepo(ISimpleRepositoryModel newrepo)
{
var msg = string.Format(CultureInfo.CurrentUICulture, Constants.Notification_RepoCloned, newrepo.Name, newrepo.CloneUrl);
if (newrepo.HasCommits() && newrepo.MightContainSolution())
{
msg += " " + string.Format(CultureInfo.CurrentUICulture, Constants.Notification_OpenProject, newrepo.LocalPath);
}
else
{
msg += " " + string.Format(CultureInfo.CurrentUICulture, Constants.Notification_CreateNewProject, newrepo.LocalPath);
}
ShowNotification(newrepo, msg);
}
void ShowNotification(ISimpleRepositoryModel newrepo, string msg)
{
var vsservices = ServiceProvider.GetExportedValue <IVSServices>();
vsservices.ClearNotifications();
vsservices.ShowMessage(
msg,
new RelayCommand(o =>
{
var str = o.ToString();
/* the prefix is the action to perform:
* u: launch browser with url
* c: launch create new project dialog
* o: launch open existing project dialog
*/
var prefix = str.Substring(0, 2);
if (prefix == "u:")
{
OpenInBrowser(ServiceProvider.TryGetService <IVisualStudioBrowser>(), new Uri(str.Substring(2)));
}
else if (prefix == "o:")
{
if (ErrorHandler.Succeeded(ServiceProvider.GetSolution().OpenSolutionViaDlg(str.Substring(2), 1)))
{
ServiceProvider.TryGetService <ITeamExplorer>()?.NavigateToPage(new Guid(TeamExplorerPageIds.Home), null);
}
}
else if (prefix == "c:")
{
vsservices.SetDefaultProjectPath(newrepo.LocalPath);
if (ErrorHandler.Succeeded(ServiceProvider.GetSolution().CreateNewProjectViaDlg(null, null, 0)))
{
ServiceProvider.TryGetService <ITeamExplorer>()?.NavigateToPage(new Guid(TeamExplorerPageIds.Home), null);
}
}
})
);
#if DEBUG
VsOutputLogger.WriteLine(String.Format(CultureInfo.InvariantCulture, "{0} Notification", DateTime.Now));
#endif
}
void RefreshRepositories()
{
connectionManager.RefreshRepositories();
RaisePropertyChanged("Repositories"); // trigger a re-check of the visibility of the listview based on item count
}
public IFluentApi <T> Create <T>() where T : class, new()
{
return(_apiFactory.Create <T>());
}
