/// <summary>
/// Gets all issues across owned and member repositories for the authenticated user.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="request">Used to filter and sort the list of issues returned</param>
/// <param name="options">Options for changing the API response</param>
/// <returns>A signal containing one or more <see cref="Issue"/>s.</returns>
public IObservable <Issue> GetAllForOwnedAndMemberRepositories(IssueRequest request, ApiOptions options)
{
Ensure.ArgumentNotNull(request, "request");
Ensure.ArgumentNotNull(options, "options");
return(_connection.GetAndFlattenAllPages <Issue>(ApiUrls.IssuesForOwnedAndMember(), request.ToParametersDictionary(), options));
}
/// <summary>
/// Gets all issues across owned and member repositories for the authenticated user.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="request">Used to filter and sort the list of issues returned</param>
/// <param name="options">Options for changing the API response</param>
public IObservable <Issue> GetAllForOwnedAndMemberRepositories(IssueRequest request, ApiOptions options)
{
Ensure.ArgumentNotNull(request, nameof(request));
Ensure.ArgumentNotNull(options, nameof(options));
return(_connection.GetAndFlattenAllPages <Issue>(ApiUrls.IssuesForOwnedAndMember(), request.ToParametersDictionary(), AcceptHeaders.ReactionsPreview, options));
}
/// <summary>
/// Gets all issues for a given organization for the authenticated user.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="organization">The name of the organization</param>
/// <param name="request">Used to filter and sort the list of issues returned</param>
/// <returns>A signal containing one or more <see cref="Issue"/>s.</returns>
public IObservable <Issue> GetAllForOrganization(string organization, IssueRequest request)
{
Ensure.ArgumentNotNullOrEmptyString(organization, "organization");
Ensure.ArgumentNotNull(request, "request");
return(GetAllForOrganization(organization, request, ApiOptions.None));
}
/// <summary>
/// Gets all issues across all the authenticated user’s visible repositories including owned repositories,
/// member repositories, and organization repositories.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="request">Used to filter and sort the list of issues returned</param>
/// <param name="options">Options for changing the API response</param>
public IObservable <Issue> GetAllForCurrent(IssueRequest request, ApiOptions options)
{
Ensure.ArgumentNotNull(request, "request");
Ensure.ArgumentNotNull(options, "options");
return(_connection.GetAndFlattenAllPages <Issue>(ApiUrls.Issues(), request.ToParametersDictionary(), AcceptHeaders.ReactionsPreview, options));
}
private void dgIncidents_DeleteCommand(object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
{
int pop3MailRequestId = int.Parse(e.CommandArgument.ToString());
IssueRequest.Delete(pop3MailRequestId);
BindDataGrid();
}
public async Task CreateAsync(RequestInputModel input, string userId, string rootPath)
{
var requesterId = this.institutionsService.GetByUserId(userId).Id;
var request = new IssueRequest
{
IssueId = input.IssueId,
RequesterId = requesterId,
IsApproved = null,
IsSolveRequest = input.IsSolveRequest,
Description = input.Description,
};
if (input.Attachments != null && input.Attachments.Any())
{
foreach (var att in input.Attachments)
{
var attachment = await this.attService.CreateAsync(userId, rootPath, att);
var requestAttachment = new IssueRequestAttachment
{
Attachment = attachment,
IssueRequest = request,
};
await this.issueRequestAttsService.AddAsync(requestAttachment);
await this.attRepo.AddAsync(attachment);
}
}
await this.requestsRepo.AddAsync(request);
await this.requestsRepo.SaveChangesAsync();
}
/// <summary>
/// Gets all issues for a given organization for the authenticated user.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="organization">The name of the organization</param>
/// <param name="request">Used to filter and sort the list of issues returned</param>
/// <returns></returns>
public IObservable <Issue> GetAllForOrganization(string organization, IssueRequest request)
{
Ensure.ArgumentNotNullOrEmptyString(organization, "organization");
Ensure.ArgumentNotNull(request, "request");
return(_connection.GetAndFlattenAllPages <Issue>(ApiUrls.Issues(organization), request.ToParametersDictionary()));
}
public async Task <IActionResult> Issue([FromBody] IssueRequest model)
{
if (model.Amount <= 0)
{
throw new BackendException("Amount can't be less or equal to zero", ErrorCode.BadInputParameter);
}
await ValidateAddress(model.Address);
var asset = await _assetRepository.GetItemAsync(model.Asset);
if (asset == null)
{
throw new BackendException("Provided Asset is missing in database", ErrorCode.AssetNotFound);
}
var transactionId = await _builder.AddTransactionId(model.TransactionId, $"Issue: {model.ToJson()}");
await _transactionQueueWriter.AddCommand(transactionId, TransactionCommandType.Issue, new IssueCommand
{
Amount = model.Amount,
Asset = model.Asset,
Address = model.Address
}.ToJson());
return(Ok(new TransactionIdResponse
{
TransactionId = transactionId
}));
}
/// <summary>
/// Gets all issues for a given organization for the authenticated user.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="organization">The name of the organization</param>
/// <param name="request">Used to filter and sort the list of issues returned</param>
/// <param name="options">Options for changing the API response</param>
public IObservable <Issue> GetAllForOrganization(string organization, IssueRequest request, ApiOptions options)
{
Ensure.ArgumentNotNullOrEmptyString(organization, "organization");
Ensure.ArgumentNotNull(request, "request");
Ensure.ArgumentNotNull(options, "options");
return(_connection.GetAndFlattenAllPages <Issue>(ApiUrls.Issues(organization), request.ToParametersDictionary(), AcceptHeaders.ReactionsPreview, options));
}
public async Task <OnchainResponse> IssueAsync(IssueData data)
{
var request = new IssueRequest(data.TransactionId, data.Address, data.AssetId, (decimal)data.Amount);
var response = await _apiClient.ApiEnqueueTransactionIssuePostAsync(request);
return(PrepareOnchainResult(response));
}
private void Approve(bool createExternalUser)
{
int projectId = int.Parse(ddlProjects.SelectedValue);
IssueRequest.Update(RequestId, txtSubject.Text, txtDescription.Text, int.Parse(ddlPriority.SelectedValue));
int NewId = -1; //IssueRequest.Approve(RequestId, projectId, createExternalUser);
Util.CommonHelper.ReloadTopFrame("ActiveWork.ascx", "../Incidents/IncidentView.aspx?IncidentId=" + NewId, Response);
}
internal async Task <Model.ResultPage> GetIssues(IEnumerable <long?> repository_ids,
string filter = "all",
string state = "all",
IEnumerable <string> labels = null,
DateTime?since = null,
string sort = "created",
string direction = "desc",
string milestone = null,
string assignee = null,
string creator = null,
string mentioned = null,
int?pageSize = null,
int?pageNo = null)
{
List <IssuesWrapper> issues = null;
if (null != repository_ids && repository_ids.Count() > 0)
{
RepositoryIssueRequest reposotoryIssueRequest = new RepositoryIssueRequest();
IssueRequest(reposotoryIssueRequest, null, state, labels, sort, direction, since);
RepositoryIssueRequest(reposotoryIssueRequest, milestone, assignee, creator, mentioned);
issues = (await Task.WhenAll(repository_ids.Select(async r =>
new IssuesWrapper
{
repo_id = r,
issues = await _githubCli.Issue.GetAllForRepository(r.Value, reposotoryIssueRequest,
Utils.ApiOptions(pageSize, pageNo))
}))).ToList();
}
else
{
issues = new List <IssuesWrapper>();
IssueRequest issueRequest = new IssueRequest()
{
};
IssueRequest(issueRequest, filter, state, labels, sort, direction, since);
issues.Add(new IssuesWrapper()
{
repo_id = null,
issues = await _githubCli.Issue.GetAllForCurrent(issueRequest, Utils.ApiOptions(pageSize, pageNo))
});
}
//foreach(var i in issues) Utils.Save2File($"05_repo_issues_{i?.repo_id ?? 0}.json", i.issues.Where(ii => ii == i.issues.Skip(1).First()));
//foreach (var i in issues) Utils.Save2File($"05_repo_issues_{i?.repo_id ?? 0}.json", i.issues));
return(Utils.ToResult(issues.SelectMany(i => i.issues,
(repo, i) => new
{
id = i.Id,
number = i.Number,
state = i.State.StringValue,
title = i.Title,
assignee = i.Assignee?.Name,
repo_id = i?.Repository?.Id ?? repo.repo_id
}), pageNo));
}
public void DeletaIssue()
{
#region
string statusCode = "NoContent";
#endregion
IssueRequest issueRequest = new IssueRequest(Method.DELETE, IssueDBSteps.RetornaIdIssue());
IRestResponse <dynamic> response = issueRequest.ExecuteRequest();
Assert.AreEqual(statusCode, response.StatusCode.ToString());
}
public void ReturnsDictionaryOfDefaultValues()
{
var request = new IssueRequest();
var parameters = request.ToParametersDictionary();
Assert.Equal("assigned", parameters["filter"]);
Assert.Equal("open", parameters["state"]);
Assert.Equal("created", parameters["sort"]);
Assert.Equal("desc", parameters["direction"]);
}
public bool IsEnable(object Sender, object Element)
{
bool retval = false;
if (IssueRequest.MailIssuesEnabled())
{
retval = true;
}
return(retval);
}
public async Task SecretPki_SetUpRootCA_CanIssueCertificatesWithAltNames()
{
using (var server = new VaultTestServer())
{
var client = server.TestClient();
var mountPoint = Guid.NewGuid().ToString();
await client.Sys.Mount(mountPoint, new MountInfo { Type = "pki" });
var mountConfig = new MountConfig
{
MaxLeaseTtl = "87600h"
};
await client.Sys.TuneMount(mountPoint, mountConfig);
var rootCaConfig = new RootGenerateRequest
{
CommonName = "Vault Testing Root Certificate Authority",
Ttl = "87600h"
};
await client.Secret.Write($"{mountPoint}/root/generate/internal", rootCaConfig);
var roleName = Guid.NewGuid().ToString();
var role = new RolesRequest
{
AllowAnyDomain = true,
EnforceHostnames = false,
MaxTtl = "1h"
};
await client.Secret.Write($"{mountPoint}/roles/{roleName}", role);
var commonName = Guid.NewGuid().ToString();
var certRequest = new IssueRequest
{
CommonName = commonName,
AltNames = new List <string> {
"example.com", "test.example.com"
},
Format = CertificateFormat.Der
};
var cert =
await
client.Secret.Write <IssueRequest, IssueResponse>($"{mountPoint}/issue/{roleName}",
certRequest);
Assert.NotNull(cert.Data);
Assert.NotNull(cert.Data.Certificate);
Assert.NotNull(cert.Data.PrivateKey);
var x509Cert = new X509Certificate2(Encoding.UTF8.GetBytes(cert.Data.Certificate));
Assert.Equal($"CN={commonName}", x509Cert.SubjectName.Name);
}
}
public override IEnumerable <object> Pull(IRequest request, PullType pullType = PullType.AdapterDefault, ActionConfig actionConfig = null)
{
PullConfig pullConfig = actionConfig as PullConfig ?? new PullConfig();
RevisionRequest rr = request as RevisionRequest;
if (rr != null)
{
return(GetRevisions(rr).OfType <object>());
}
IssueRequest ir = request as IssueRequest;
if (ir != null)
{
return(GetIssues(ir, pullConfig).OfType <object>());
}
AuditRequest ar = request as AuditRequest;
if (ar != null)
{
if (ar.Audit == null)
{
BH.Engine.Reflection.Compute.RecordWarning("Please specify the Audit whose Issues you want to pull from 3DRepo in the request.");
return(null);
}
ir = new IssueRequest()
{
ModelId = ar.ModelId,
RevisionId = ar.RevisionId,
TeamSpace = ar.TeamSpace,
UserAPIKey = ar.UserAPIKey
};
Audit audit = ar.Audit.DeepClone();
// The conversion between 3DRepo issues and BHoM Issues
// will need to be passed any Pulled media file Name, if they were pulled with the Issues.
Dictionary <oM.Adapters.TDRepo.Issue, List <string> > mediaFilenames_perIssue = new Dictionary <oM.Adapters.TDRepo.Issue, List <string> >();
List <oM.Inspection.Issue> pulledIssues = GetIssues(ir, pullConfig, true, mediaFilenames_perIssue);
// Return the Audit with the Pulled issues from 3DRepo.
return(new List <object>()
{
audit
});
}
BH.Engine.Reflection.Compute.RecordWarning($"The specified request is not compatible with {this.GetType().Name}.");
return(new List <object>());
}
public async Task <IActionResult> Issue([FromBody] IssueRequest request)
{
var restRequest = new RestRequest($"tracker/{_mantleConfig.ProductId}/assets/issue", Method.POST);
restRequest.AddJsonBody(request);
var response = await _mantleRestClient.ExecutePostTaskAsync(restRequest);
if (response.StatusCode != HttpStatusCode.OK)
{
return(StatusCode((int)response.StatusCode, response.Content));
}
return(StatusCode((int)response.StatusCode));
}
public void CriarIssueMinimal()
{
#region
string summary = "Summary_" + GeneralHelpers.ReturnStringWithRandomNumbers(2);
string descricao = "descricao_" + GeneralHelpers.ReturnStringWithRandomNumbers(2);
string nomeCategoria = "General";
string nomeProjeto = "Nome_Projeto 30";
string status = "Created";
#endregion
IssueRequest issueRequest = new IssueRequest(Method.POST);
issueRequest.SetBodyIssueMinimal(summary, descricao, nomeCategoria, nomeProjeto);
IRestResponse <dynamic> response = issueRequest.ExecuteRequest();
Assert.AreEqual(status, response.StatusCode.ToString());
}
public void GetUmIssueNaoEncontrado()
{
#region
string id = "123";
string msg = "Issue #123 not found";
string code = "1100";
string localized = "Issue 123 not found.";
#endregion
IssueRequest issueRequest = new IssueRequest(Method.GET, id);
IRestResponse <dynamic> response = issueRequest.ExecuteRequest();
Assert.Multiple(() => {
Assert.AreEqual(msg, response.Data["message"].ToString());
Assert.AreEqual(code, response.Data["code"].ToString());
Assert.AreEqual(localized, response.Data["localized"].ToString());
});
}
public Response Issue(String CorpNum, MgtKeyType KeyType, String MgtKey, String Memo, String EmailSubject, bool ForceIssue, String UserID)
{
if (String.IsNullOrEmpty(MgtKey))
{
throw new PopbillException(-99999999, "관리번호가 입력되지 않았습니다.");
}
IssueRequest request = new IssueRequest();
request.memo = Memo;
request.emailSubject = EmailSubject;
request.forceIssue = ForceIssue;
String PostData = toJsonString(request);
return(httppost <Response>("/Taxinvoice/" + KeyType.ToString() + "/" + MgtKey, CorpNum, UserID, PostData, "ISSUE"));
}
/// <summary>
/// Gets the user information.
/// </summary>
/// <returns></returns>
public async Task <string> GetUserIssuesInfoString()
{
string issuesString = string.Empty;
var recently = new IssueRequest
{
Filter = IssueFilter.All,
State = ItemStateFilter.All,
Since = DateTimeOffset.Now.Subtract(TimeSpan.FromDays(GeneralConstants.IssuesByDays))
};
IReadOnlyList <Issue> issues = await client.Issue.GetAllForOwnedAndMemberRepositories(recently);
return(issues.Aggregate(issuesString, (current, issue) =>
current + $" | Title: {issue.Title} , Comments: {issue.Comments} , Issue URL: {issue.HtmlUrl} " +
$"Created: {issue.CreatedAt}, Status: {issue.State} \n\n\n\n"));
}
private void BindToolbar()
{
if (MailBoxId > 0 && this.Parent.Parent is IPageViewMenu)
{
PageViewMenu secHeader = (PageViewMenu)((IPageViewMenu)this.Parent.Parent).GetToolBar();
if (secHeader != null)
{
using (IDataReader reader = IssueRequest.GetMailBoxById(MailBoxId))
{
if (reader.Read())
{
secHeader.Title = LocRM.GetString("Box") + " - " + reader["Name"].ToString();
}
}
}
}
}
//발행
public IssueResponse Issue(string CorpNum, MgtKeyType KeyType, string MgtKey, bool ForceIssue = false,
string Memo = null, string EmailSubject = null, string UserID = null)
{
if (string.IsNullOrEmpty(MgtKey))
{
throw new PopbillException(-99999999, "문서번호가 입력되지 않았습니다.");
}
IssueRequest request = new IssueRequest {
memo = Memo, emailSubject = EmailSubject, forceIssue = ForceIssue
};
string PostData = toJsonString(request);
return(httppost <IssueResponse>("/Taxinvoice/" + KeyType.ToString() + "/" + MgtKey, CorpNum, PostData, "ISSUE",
null, UserID));
}
public async Task SecretPki_SetUpRootCA_CanIssueCertificates()
{
using (var server = new VaultTestServer())
{
var client = server.TestClient();
var mountPoint = Guid.NewGuid().ToString();
await client.Sys.Mount(mountPoint, new MountInfo { Type = "pki" });
var mountConfig = new MountConfig
{
MaxLeaseTtl = "87600h"
};
await client.Sys.TuneMount(mountPoint, mountConfig);
var rootCaConfig = new RootGenerateRequest
{
CommonName = "Vault Testing Root Certificate Authority",
Ttl = "87600h"
};
await client.Secret.Write($"{mountPoint}/root/generate/internal", rootCaConfig);
var roleName = Guid.NewGuid().ToString();
var role = new RolesRequest
{
AllowAnyDomain = true,
EnforceHostnames = false,
MaxTtl = "1h"
};
await client.Secret.Write($"{mountPoint}/roles/{roleName}", role);
var certRequest = new IssueRequest
{
CommonName = "Test Cert"
};
var cert =
await
client.Secret.Write <IssueRequest, IssueResponse>($"{mountPoint}/issue/{roleName}",
certRequest);
Assert.NotNull(cert.Data);
Assert.NotNull(cert.Data.Certificate);
Assert.NotNull(cert.Data.PrivateKey);
}
}
public static async Task <bool> IsValidKeyAsync(string apiKey)
{
try
{
var client = Create(apiKey);
var request = new IssueRequest
{
Since = DateTimeOffset.Now
};
await client.Issue.GetAllForCurrent(request);
}
catch (Exception)
{
return(false);
}
return(true);
}
public override async Task Execute()
{
if (!IsUserLoggedIn())
{
return;
}
var options = new IssueRequest
{
Filter = issuesFilter,
State = issuesState,
};
if (issuesSince != null)
{
options.Since = issuesSince;
}
Console.WriteLine("Getting your issues...");
var issues = await GHClient.client.Issue.GetAllForCurrent(options);
foreach (var issue in issues)
{
Ui.WriteCyan($"{issue.Repository.Name} ");
Console.Write($"#{issue.Number} - ");
Ui.WriteBlue(issue.Title);
Console.WriteLine($", created by {issue.User.Name}");
var date = issue.CreatedAt;
Console.Write($"At {date.Day}/{date.Month}/{date.Year}, ");
if (issue.State.StringValue == "open")
{
Ui.WriteLineGreen($"open");
}
else
{
Ui.WriteLineRed($"closed");
}
Console.WriteLine();
}
}
static async Task <Issue> GetIssueAsync(IssueRequest request)
{
Issue issue = null;
//var byteArray = Encoding.ASCII.GetBytes("username:password");
//client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
string path = GetGitHubIssueApiUrl(request.Owner, request.RepoName, request.IssueId);
HttpResponseMessage response = await client.GetAsync(path);
if (response.IsSuccessStatusCode)
{
issue = await response.Content.ReadAsAsync <Issue>();
}
else
{
Console.WriteLine(response);
}
return(issue);
}
public void CriarIssueComAcessorios()
{
#region
string summary = "Sample REST issue with attachment";
string description = "Description for sample REST issue.";
string name = "mantisbt";
string nameCategory = "bugtracker";
string customFieldsName = "The City";
string value = "Seattle";
string fileName1 = "test.txt";
string fileContent1 = "VGhpcyBpcyBhIFRFU1QuDQpUaGlzIGlzIGEgVEVTVC4NClRoaXMgaXMgYSBURVNULg0KVGhpcyBpcyBhIFRFU1QuDQpUaGlzIGlzIGEgVEVTVC4";
string fileName2 = "test2.txt";
string fileContent2 = "VGhpcyBpcyBhIFRFU1QuDQpUaGlzIGlzIGEgVEVTVC4NClRoaXMgaXMgYSBURVNULg0KVGhpcyBpcyBhIFRFU1QuDQpUaGlzIGlzIGEgVEVTVC4";
string statusCode = "OK";
#endregion
IssueRequest issueRequest = new IssueRequest(Method.POST);
issueRequest.SetBodyIssueWithAttachments(summary, description, name, nameCategory, customFieldsName, value, fileName1, fileContent1, fileName2, fileContent2);
IRestResponse <dynamic> response = issueRequest.ExecuteRequest();
Assert.AreEqual(statusCode, response.StatusCode.ToString());
}
public async Task <IEnumerable <GitsteemRepo> > GetRepos()
{
GitHubClient client = CreateAuthorizedClient();
var currentUser = await client.User.Current();
var request = new RepositoryRequest
{
Type = RepositoryType.Owner
};
var repos = await client.Repository.GetAllForCurrent(request);
var issuesRequest = new IssueRequest
{
Filter = IssueFilter.All,
State = ItemStateFilter.All
};
var issues = await client.Issue.GetAllForCurrent(issuesRequest);
var mappedIssues = issues.Select(i => new GitsteemIssue
{
Id = i.Id,
RepoName = i.Repository.Name,
RepoId = i.Repository.Id,
Title = i.Title,
State = i.State.StringValue
});
return(repos.Select(r => new GitsteemRepo
{
Issues = mappedIssues.Where(i => i.RepoId == r.Id).ToArray(),
Name = r.Name,
Id = r.Id,
IsPosted = false
}));
}
/// <summary>
/// Gets all issues across all the authenticated user’s visible repositories including owned repositories,
/// member repositories, and organization repositories.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="request">Used to filter and sort the list of issues returned</param>
public IObservable<Issue> GetAllForCurrent(IssueRequest request)
{
Ensure.ArgumentNotNull(request, "request");
return GetAllForCurrent(request, ApiOptions.None);
}
/// <summary>
/// Gets all issues across owned and member repositories for the authenticated user.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="request">Used to filter and sort the list of issues returned</param>
/// <returns></returns>
public IObservable<Issue> GetAllForOwnedAndMemberRepositories(IssueRequest request)
{
Ensure.ArgumentNotNull(request, "request");
return _connection.GetAndFlattenAllPages<Issue>(ApiUrls.IssuesForOwnedAndMember(), request.ToParametersDictionary());
}
/// <summary>
/// Gets all issues across owned and member repositories for the authenticated user.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="request">Used to filter and sort the list of issues returned</param>
public IObservable<Issue> GetAllForOwnedAndMemberRepositories(IssueRequest request)
{
Ensure.ArgumentNotNull(request, "request");
return GetAllForOwnedAndMemberRepositories(request, ApiOptions.None);
}
/// <summary>
/// Gets all issues across all the authenticated user’s visible repositories including owned repositories,
/// member repositories, and organization repositories.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="request">Used to filter and sort the list of issues returned</param>
/// <returns></returns>
public IObservable<Issue> GetAllForCurrent(IssueRequest request)
{
Ensure.ArgumentNotNull(request, "request");
return _connection.GetAndFlattenAllPages<Issue>(ApiUrls.Issues(), request.ToParametersDictionary());
}
/// <summary>
/// Gets all issues for a given organization for the authenticated user.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="organization">The name of the organization</param>
/// <param name="request">Used to filter and sort the list of issues returned</param>
/// <returns></returns>
public IObservable<Issue> GetAllForOrganization(string organization, IssueRequest request)
{
Ensure.ArgumentNotNullOrEmptyString(organization, "organization");
Ensure.ArgumentNotNull(request, "request");
return _connection.GetAndFlattenAllPages<Issue>(ApiUrls.Issues(organization), request.ToParametersDictionary());
}
/// <summary>
/// Gets all issues across owned and member repositories for the authenticated user.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="request">Used to filter and sort the list of issues returned</param>
/// <param name="options">Options for changing the API response</param>
public IObservable<Issue> GetAllForOwnedAndMemberRepositories(IssueRequest request, ApiOptions options)
{
Ensure.ArgumentNotNull(request, "request");
Ensure.ArgumentNotNull(options, "options");
return _connection.GetAndFlattenAllPages<Issue>(ApiUrls.IssuesForOwnedAndMember(), request.ToParametersDictionary(), AcceptHeaders.ReactionsPreview, options);
}
/// <summary>
/// Gets all issues for a given organization for the authenticated user.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="organization">The name of the organization</param>
/// <param name="request">Used to filter and sort the list of issues returned</param>
public IObservable<Issue> GetAllForOrganization(string organization, IssueRequest request)
{
Ensure.ArgumentNotNullOrEmptyString(organization, "organization");
Ensure.ArgumentNotNull(request, "request");
return GetAllForOrganization(organization, request, ApiOptions.None);
}
/// <summary>
/// Gets all issues for a given organization for the authenticated user.
/// </summary>
/// <remarks>
/// http://developer.github.com/v3/issues/#list-issues
/// </remarks>
/// <param name="organization">The name of the organization</param>
/// <param name="request">Used to filter and sort the list of issues returned</param>
/// <param name="options">Options for changing the API response</param>
public IObservable<Issue> GetAllForOrganization(string organization, IssueRequest request, ApiOptions options)
{
Ensure.ArgumentNotNullOrEmptyString(organization, "organization");
Ensure.ArgumentNotNull(request, "request");
Ensure.ArgumentNotNull(options, "options");
return _connection.GetAndFlattenAllPages<Issue>(ApiUrls.Issues(organization), request.ToParametersDictionary(), AcceptHeaders.ReactionsPreview, options);
}
