private Predicate <object> MakeResponseFilterForRule(Rule r)
{
// make a closure scanning the response dict for just this rule's responses.
ResponseSystemWPF ResponseRuleSystem = RRSys;
// CLI seems to be having trouble with typedefs, so for now introspect the
// necesasry properties
System.Reflection.PropertyInfo valprop = RRSys.ResponseGroupsDict[0].GetType().GetProperty("Val");
return(x =>
{
// clumsy hack to filter out NullResponse
ResponseGroup g = valprop.GetValue(x, null) as ResponseGroup;
if (g.Count < 1)
{
return false;
}
int idx = ResponseRuleSystem.ResponseGroupBinding.IndexOf(x);
for (int i = 0; i < r.NumCriteria; i++)
{
if (r.get_ResponseIndices(i) == idx)
{
return true;
}
}
return false;
});
}
private void DebuggerResponseGroupGrid_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
/*
* if (BindingForResponseDetailInDebuggerPane == null)
* {
* BindingForResponseDetailInDebuggerPane = new Binding();
* BindingForResponseDetailInDebuggerPane.Mode = BindingMode.OneWay;
* DebuggerResponseGroupsDetail.SetBinding(ItemsControl.ItemsSourceProperty, BindingForResponseDetailInDebuggerPane);
* }
*/
if (e.AddedItems.Count == 0)
{
DebuggerResponseGroupsDetail.SetBinding(ItemsControl.ItemsSourceProperty, (System.Windows.Data.BindingBase)null);
}
else
{
// icky use of metadata
ResponseGroup g = e.AddedItems[0].GetType().GetProperty("Val").GetValue(e.AddedItems[0], null) as ResponseGroup;
Binding b = new Binding();
b.Source = new ListCollectionView(g.ResponsesList);
b.Mode = BindingMode.OneWay;
DebuggerResponseGroupsDetail.SetBinding(ItemsControl.ItemsSourceProperty, b);
}
}
/// <summary>
/// 获取用户收藏列表
/// </summary>
/// <param name="client"></param>
/// <param name="uid">UID</param>
/// <param name="cat">收藏类型</param>
/// <param name="ids">收藏条目 ID</param>
/// <param name="responseGroup"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static Task <CollectionSubject[]> GetUserCollectionAsync(
this IBangumiClient client,
long uid,
CollectionType cat,
int[] ids = null,
ResponseGroup responseGroup = ResponseGroup.Medium,
CancellationToken cancellationToken = default(CancellationToken))
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (responseGroup == ResponseGroup.Large)
{
throw new NotSupportedException();
}
var url = $"/user/{uid}/collection?cat={cat.GetValue()}";
if (ids != null)
{
url += $"&ids={string.Join(",", ids)}";
}
url += $"&responseGroup={responseGroup.GetValue()}";
return(client.GetAsync <CollectionSubject[]>(url, cancellationToken));
}
public ActionResult <List <ResponseGroup> > GetCommandGroupsForServer(string serverId)
{
var commandGroups = _context.CommandList.AsQueryable().Where(c => c.ServerId == serverId)
.AsEnumerable()
.GroupBy(command => command.CommandString);
var commandGroupList = new List <ResponseGroup>(commandGroups.Count());
int nextId = 0;
foreach (IGrouping <string, Command> group in commandGroups)
{
var newGroup = new ResponseGroup()
{
id = nextId++,
command = group.Key,
responses = new List <Response>()
};
foreach (Command command in group)
{
newGroup.responses.Add(new Response()
{
id = command.Id,
response = command.EntryValue,
modOnly = command.ModOnly ?? 0,
});
}
commandGroupList.Add(newGroup);
}
return(Ok(commandGroupList));
}
public override string ToString()
{
var retVal = new List <string>();
retVal.Add(string.Format("page={0}", PageNumber));
retVal.Add(string.Format("page_size={0}", PageSize));
retVal.Add(string.Format("respGroup={0}", ResponseGroup.ToString()));
if (Keyword != null)
{
retVal.Add(string.Format("q={0}", Keyword));
}
if (CategoryId != null)
{
retVal.Add(string.Format("categoryId={0}", CategoryId));
}
if (VendorId != null)
{
retVal.Add(string.Format("vendor={0}", VendorId));
}
if (VendorIds != null)
{
retVal.Add(string.Format("vendors={0}", string.Join(",", this.VendorIds)));
}
return(string.Join("&", retVal));
}
/// <summary>
/// Determines whether the specified group contains group.
/// </summary>
/// <param name="group">The group.</param>
/// <returns>
/// <c>true</c> if the specified group contains group; otherwise, <c>false</c>.
/// </returns>
public bool ContainsGroup(ResponseGroup group)
{
if ((_ResponseGroups & group) == group)
{
return(true);
}
else
{
return(false);
}
}
public IActionResult Submit(SollicitantViewModel model, string id)
{
IngevuldeVacature vac = new IngevuldeVacature();
vac.Vacature = _vacatureRepository.GetBy(id);
IEnumerable <IVraag> vragen = _vacatureRepository.GetAllQuestions();
IVraag vraag = null;
Mogelijkheid optie = null;
ResponseGroup resgroup = null;
// Todo vervangen door velden voornaam, achternaam, email en telefoon
//vac.Sollicitant = (Sollicitant) _userManager.GetUserAsync(HttpContext.User).Result;
vac.AchternaamSollicitant = model.Achternaam;
vac.VoornaamSollicitant = model.Voornaam;
vac.TelefoonSollicitant = model.TelefoonNummer;
vac.EmailSollicitant = model.EmailAdres;
foreach (var group in model.Competenties)
{
foreach (var comp in group.Values)
{
resgroup = new ResponseGroup();
foreach (var item in comp.VraagViewModels)
{
vraag = vragen.SingleOrDefault(v => v.Id.Equals(item.VraagId));
if (vraag is VraagMeerkeuze)
{
optie = ((VraagMeerkeuze)vraag).Opties.SingleOrDefault(c => c.Id.Equals(item.OptieKeuzeId));
resgroup.Responses.Add(new Response {
Vraag = vraag, OptieKeuze = optie
});
}
else if (vraag is VraagRubrics)
{
optie = ((VraagRubrics)vraag).Opties.SingleOrDefault(c => c.Id.Equals(item.OptieKeuzeId));
resgroup.Responses.Add(new Response {
Vraag = vraag, OptieKeuze = optie
});
}
else
{
resgroup.Responses.Add(new Response {
OpenAntwoord = item.Redenering, Vraag = vraag
});
}
}
resgroup.Competentie = vraag.Competentie;
vac.ResponseGroup.Add(resgroup);
}
}
_ingevuldeVacatureRepository.Add(vac);
return(RedirectToAction("Index", "Home"));
}
public async Task <Subject> Get(int id, ResponseGroup responseGroup = ResponseGroup.Small)
{
if (!Enum.IsDefined(typeof(ResponseGroup), responseGroup))
{
throw new ArgumentOutOfRangeException(nameof(responseGroup));
}
var url = $"/subject/{id}?responseGroup={responseGroup.ToString().ToLowerInvariant()}";
using (var client = new BangumiClient())
{
var json = await client.GetStringAsync(url);
return(JsonConvert.DeserializeObject <Subject>(json));
}
}
public override string ToString()
{
var parts = new string[]
{
ResponseGroup.GetHashCode().ToString(),
Keyword,
CategoryId,
CatalogId,
Start.ToString(),
Count.ToString(),
GetAllCategories.ToString(),
PropertyValues != null?string.Join(";", PropertyValues.Select(x => x.ToString())) : null
};
return(string.Join("-", parts.Where(x => !String.IsNullOrEmpty(x)).ToArray()));
}
private BackupObject GetBackupObject(Action <ExportImportProgressInfo> progressCallback)
{
const ResponseGroup responseGroup = ResponseGroup.Full;
var searchResponse = _catalogSearchService.Search(new SearchCriteria {
Count = int.MaxValue, GetAllCategories = true, Start = 0, ResponseGroup = responseGroup
});
var retVal = new BackupObject();
var progressNotifier = new ProgressNotifier("{0} of {1} catalogs loaded", searchResponse.Catalogs.Count(), progressCallback);
foreach (var catalog in searchResponse.Catalogs)
{
retVal.Catalogs.Add(_catalogService.GetById(catalog.Id));
progressNotifier.Notify();
}
progressNotifier = new ProgressNotifier("{0} of {1} categories loaded", searchResponse.Categories.Count(), progressCallback);
foreach (var category in searchResponse.Categories)
{
retVal.Categories.Add(_categoryService.GetById(category.Id));
progressNotifier.Notify();
}
progressNotifier = new ProgressNotifier("{0} of {1} products loaded", searchResponse.TotalCount, progressCallback);
foreach (var product in searchResponse.Products)
{
retVal.Products.Add(_itemService.GetById(product.Id, ItemResponseGroup.ItemMedium | ItemResponseGroup.Variations | ItemResponseGroup.Seo));
progressNotifier.Notify();
}
var catalogsPropertiesIds = retVal.Catalogs.SelectMany(x => _propertyService.GetCatalogProperties(x.Id)).Select(x => x.Id).ToArray();
var categoriesPropertiesIds = retVal.Categories.SelectMany(x => _propertyService.GetCategoryProperties(x.Id)).Select(x => x.Id).ToArray();
var propertiesIds = catalogsPropertiesIds.Concat(categoriesPropertiesIds).Distinct().ToArray();
progressNotifier = new ProgressNotifier("{0} of {1} properties loaded", propertiesIds.Count(), progressCallback);
foreach (var propertyId in propertiesIds)
{
var property = _propertyService.GetById(propertyId);
retVal.Properties.Add(property);
progressNotifier.Notify();
}
return(retVal);
}
public static string GetValue(this ResponseGroup responseGroup)
{
switch (responseGroup)
{
case ResponseGroup.Small:
return("small");
case ResponseGroup.Medium:
return("medium");
case ResponseGroup.Large:
return("large");
default:
return(responseGroup.ToString());
}
}
private void showGroup_Click(object sender, EventArgs e)
{
listDroup.Items.Clear();
string reqStrTemplate = "https://api.vk.com/method/{0}?access_token={1}&{2}v=5.92";
string method = "groups.get";
string par = "extended=1&";
var f = GET(reqStrTemplate, method, token, par);
var test = JsonConvert.DeserializeObject(f) as JObject;
GroupArray = JsonConvert.DeserializeObject <ResponseGroup>(f);
for (int i = 0; i < GroupArray.groups.items.Count(); i++)
{
string info = "";
info = GroupArray.groups.items[i].ID + "\t" + GroupArray.groups.items[i].Name; /* + "\t\t" +
* GroupArray.groups.items[i].Type;*/
listDroup.Items.Add(info);
}
}
public DnsResult GroupResponses(string groupName, IEnumerable <Response> responses)
{
if (groupName == null)
{
groupName = string.Join(", ", responses.Select(r => r.RequestDataMart.DataMart.Name));
}
else
{
groupName = groupName.Trim();
}
if (groupName.NullOrEmpty())
{
return(DnsResult.Failed("Cannot create a group with empty name"));
}
var reqs = responses.Select(r => r.RequestDataMart.RequestID).Distinct().Take(2).ToList();
if (reqs.Count > 1)
{
return(DnsResult.Failed("Cannot group responses that come from different requests"));
}
using (var db = new DataContext()) {
if (!AsyncHelpers.RunSync(() => db.HasPermissions <Request>(Auth.ApiIdentity, responses.Select(r => r.RequestDataMart.RequestID).ToArray(), PermissionIdentifiers.DataMartInProject.GroupResponses)))
{
return(DnsResult.Failed("You do not have permission to group these responses"));
}
//This reloads the responses because this function is getting passed entities that are not attached to the data context and thus don't save right.
var instanceIDs = responses.Select(r => r.ID).ToArray();
var responseList = (from r in db.Responses where instanceIDs.Contains(r.ID) select r).ToArray();
var rg = new ResponseGroup {
Name = groupName, Responses = responseList
};
db.ResponseGroups.Add(rg);
db.SaveChanges();
return(DnsResult.Success);
}
}
public DnsResult UngroupResponses(ResponseGroup Group)
{
using (var db = new DataContext())
{
if (!AsyncHelpers.RunSync(() => db.HasPermissions <Request>(Auth.ApiIdentity, Group.Responses.Select(r => r.RequestDataMart.RequestID).ToArray(), PermissionIdentifiers.DataMartInProject.GroupResponses)))
{
return(DnsResult.Failed("You do not have permission to group these responses"));
}
var gr = (from g in db.ResponseGroups where g.ID == Group.ID select g).Single();
var instances = (from i in db.Responses where i.ResponseGroupID != null && i.ResponseGroupID.Value == gr.ID select i).ToArray();
instances.ForEach(i => i.ResponseGroupID = null);
db.SaveChanges();
return(DnsResult.Success);
}
}
public override async Task <Lpp.Workflow.Engine.CompletionResult> Complete(string data, Guid?activityResultID)
{
//Ad params that come through using Json and deserialize on each activity result and handle the logic.
if (!activityResultID.HasValue)
{
throw new ArgumentNullException(CommonMessages.ActivityResultIDRequired);
}
if (activityResultID.Value == SaveResultID)
{
return(new CompletionResult
{
ResultID = SaveResultID
});
}
if (activityResultID.Value == GroupResultID)
{
GroupingRequestModel model = Newtonsoft.Json.JsonConvert.DeserializeObject <GroupingRequestModel>(data);
var responses = await db.Responses.Include(r => r.RequestDataMart).Where(r => model.Responses.Any(x => x == r.ID)).ToArrayAsync();
if (responses.Select(r => r.RequestDataMart.RequestID).Distinct().Count() > 1)
{
throw new ArgumentException("Cannot group responses that come from different requests.");
}
Guid[] requestDataMartIDs = responses.Select(rsp => rsp.RequestDataMartID).Distinct().ToArray();
var pq = (from rdm in db.RequestDataMarts
let permissionID = PermissionIdentifiers.DataMartInProject.GroupResponses.ID
let identityID = _workflow.Identity.ID
let acls = db.GlobalAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID)).Select(a => a.Allowed)
.Concat(db.ProjectAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
.Concat(db.DataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.ProjectDataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.OrganizationAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Organization.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
where requestDataMartIDs.Contains(rdm.ID) &&
acls.Any() && acls.All(a => a == true)
select rdm.ID);
var allowedResponses = await pq.ToArrayAsync();
if (allowedResponses.Length != requestDataMartIDs.Length)
{
throw new SecurityException("Insufficient permission to group one or more of the specified responses.");
}
if (string.IsNullOrWhiteSpace(model.GroupName))
{
model.GroupName = string.Join(", ", db.Responses.Where(r => model.Responses.Any(x => x == r.ID)).Select(r => r.RequestDataMart.DataMart.Name).Distinct());
}
ResponseGroup grouping = db.ResponseGroups.Add(new ResponseGroup(model.GroupName));
foreach (var response in responses)
{
grouping.Responses.Add(response);
response.RequestDataMart.ResultsGrouped = true;
}
//log the save against the current task
await LogTaskModified();
await db.SaveChangesAsync();
}
else if (activityResultID.Value == UngroupResultID)
{
IEnumerable <Guid> groupID = (from r in data.Split(',')
where !string.IsNullOrWhiteSpace(r)
select Guid.Parse(r.Trim())).ToArray();
List <Guid> requestDataMartIDs = await db.ResponseGroups.Include(g => g.Responses).Where(g => groupID.Contains(g.ID)).SelectMany(g => g.Responses.Select(r => r.RequestDataMartID)).ToListAsync();
var pq = (from rdm in db.RequestDataMarts
let permissionID = PermissionIdentifiers.DataMartInProject.GroupResponses.ID
let identityID = _workflow.Identity.ID
let acls = db.GlobalAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID)).Select(a => a.Allowed)
.Concat(db.ProjectAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
.Concat(db.DataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.ProjectDataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.OrganizationAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Organization.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
where requestDataMartIDs.Contains(rdm.ID) &&
acls.Any() && acls.All(a => a == true)
select rdm.ID);
var allowedResponses = await pq.ToArrayAsync();
if (allowedResponses.Length != requestDataMartIDs.Count)
{
throw new SecurityException("Insufficient permission to ungroup routings for the specified request.");
}
var groups = await db.ResponseGroups.Include(g => g.Responses).Where(g => groupID.Contains(g.ID)).ToArrayAsync();
foreach (var group in groups)
{
group.Responses.Clear();
db.ResponseGroups.Remove(group);
}
var routings = await db.RequestDataMarts.Where(dm => requestDataMartIDs.Contains(dm.ID)).ToArrayAsync();
foreach (var routing in routings)
{
routing.ResultsGrouped = false;
}
await LogTaskModified();
await db.SaveChangesAsync();
}
else if (activityResultID.Value == AddDataMartsResultID)
{
string[] guids = data.Split(',');
var revisionSetIDs = await(from req in db.Requests
join rdm in db.RequestDataMarts on req.ID equals rdm.RequestID
join res in db.Responses on rdm.ID equals res.RequestDataMartID
join reqDoc in db.RequestDocuments on res.ID equals reqDoc.ResponseID
where req.ID == _entity.ID && reqDoc.DocumentType == DTO.Enums.RequestDocumentType.Input
select reqDoc.RevisionSetID).Distinct().ToArrayAsync();
var allTasks = await db.ActionReferences.Where(tr => tr.ItemID == _entity.ID &&
tr.Type == DTO.Enums.TaskItemTypes.Request &&
tr.Task.Type == DTO.Enums.TaskTypes.Task
)
.Select(tr => tr.Task.ID).ToArrayAsync();
var attachments = await(from doc in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => allTasks.Contains(dd.ItemID))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on doc.ID equals x
where allTasks.Contains(doc.ItemID) && doc.Kind == "Attachment.Input"
orderby doc.ItemID descending, doc.RevisionSetID descending, doc.CreatedOn descending
select doc).ToArrayAsync();
foreach (var guid in guids)
{
Guid dmGuid = new Guid(guid);
var dm = RequestDataMart.Create(_entity.ID, dmGuid, _workflow.Identity.ID);
dm.Status = DTO.Enums.RoutingStatus.Submitted;
dm.Priority = _entity.Priority;
dm.DueDate = _entity.DueDate;
_entity.DataMarts.Add(dm);
foreach (var revset in revisionSetIDs)
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = revset, ResponseID = dm.Responses.FirstOrDefault().ID, DocumentType = DTO.Enums.RequestDocumentType.Input
});
}
foreach (var attachment in attachments)
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = attachment.RevisionSetID.Value, ResponseID = dm.Responses.FirstOrDefault().ID, DocumentType = DTO.Enums.RequestDocumentType.AttachmentInput
});
}
}
await LogTaskModified();
await db.SaveChangesAsync();
}
else if (activityResultID.Value == RemoveDataMartsResultID)
{
Guid[] guids = data.Split(',').Select(s => Guid.Parse(s)).ToArray();
var routings = await db.RequestDataMarts.Where(dm => guids.Contains(dm.ID)).ToArrayAsync();
foreach (var routing in routings)
{
routing.Status = DTO.Enums.RoutingStatus.Canceled;
}
await LogTaskModified();
await db.SaveChangesAsync();
var originalStatus = _entity.Status;
await db.SaveChangesAsync();
await db.Entry(_entity).ReloadAsync();
if (originalStatus != DTO.Enums.RequestStatuses.Complete && _entity.Status == DTO.Enums.RequestStatuses.Complete)
{
await NotifyRequestStatusChanged(originalStatus, DTO.Enums.RequestStatuses.Complete);
}
}
else if (activityResultID.Value == EditRoutingStatusResultID)
{
var dataMarts = Newtonsoft.Json.JsonConvert.DeserializeObject <IEnumerable <RoutingChangeRequestModel> >(data);
await UpdateDataMartRoutingStatus(dataMarts);
return(new CompletionResult
{
ResultID = EditRoutingStatusResultID
});
}
else if (activityResultID.Value == RoutingsBulkEditID)
{
return(new CompletionResult
{
ResultID = RoutingsBulkEditID
});
}
else if (activityResultID.Value == ResubmitResultID)
{
//data will contain a list of routings to resubmit, the ID may also be for a group
ResubmitRoutingsModel resubmitModel = Newtonsoft.Json.JsonConvert.DeserializeObject <ResubmitRoutingsModel>(data);
var datamarts = await(
from dm in db.RequestDataMarts.Include(dm => dm.Responses)
where dm.RequestID == _entity.ID &&
dm.Responses.Any(r => resubmitModel.Responses.Contains(r.ID) || (r.ResponseGroupID.HasValue && resubmitModel.Responses.Contains(r.ResponseGroupID.Value)))
select dm
).ToArrayAsync();
var revisions = await(from rdm in db.RequestDataMarts
join rdmr in db.Responses on rdm.ID equals rdmr.RequestDataMartID
join rdoc in db.RequestDocuments on rdmr.ID equals rdoc.ResponseID
where rdoc.DocumentType == DTO.Enums.RequestDocumentType.Input && rdm.RequestID == _entity.ID
select new
{
DataMartID = rdm.ID,
RevisionSetID = rdoc.RevisionSetID,
ResponseID = rdoc.ResponseID
}).ToArrayAsync();
var allTasks = await db.ActionReferences.Where(tr => tr.ItemID == _entity.ID &&
tr.Type == DTO.Enums.TaskItemTypes.Request &&
tr.Task.Type == DTO.Enums.TaskTypes.Task
)
.Select(tr => tr.Task.ID).ToArrayAsync();
//attachments are associated to the task they were uploaded on, any existing attachment should be included with the routing
var attachments = await(from doc in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => allTasks.Contains(dd.ItemID))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on doc.ID equals x
where allTasks.Contains(doc.ItemID) && doc.Kind == "Attachment.Input"
orderby doc.ItemID descending, doc.RevisionSetID descending, doc.CreatedOn descending
select doc).ToArrayAsync();
DateTime reSubmittedOn = DateTime.UtcNow;
foreach (var dm in datamarts)
{
var response = dm.AddResponse(_workflow.Identity.ID);
response.SubmittedOn = reSubmittedOn;
response.SubmitMessage = resubmitModel.ResubmissionMessage;
dm.Status = DTO.Enums.RoutingStatus.Resubmitted;
foreach (var revset in revisions.Where(x => x.DataMartID == dm.ID).Distinct())
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = revset.RevisionSetID, ResponseID = response.ID, DocumentType = DTO.Enums.RequestDocumentType.Input
});
}
foreach (var attachment in attachments)
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = attachment.RevisionSetID.Value, ResponseID = response.ID, DocumentType = DTO.Enums.RequestDocumentType.AttachmentInput
});
}
}
_entity.Status = DTO.Enums.RequestStatuses.Submitted;
var task = await PmnTask.GetActiveTaskForRequestActivityAsync(_entity.ID, ID, db);
await LogTaskModified();
if (task != null)
{
task.EndOn = DateTime.UtcNow;
task.Status = DTO.Enums.TaskStatuses.Complete;
task.PercentComplete = 100;
await db.SaveChangesAsync();
}
await db.SaveChangesAsync();
}
else if (activityResultID.Value == CompleteResultID)
{
var originalStatus = _entity.Status;
if (originalStatus != DTO.Enums.RequestStatuses.Complete && originalStatus != DTO.Enums.RequestStatuses.CompleteWithReport)
{
await SetRequestStatus(DTO.Enums.RequestStatuses.Complete);
await NotifyRequestStatusChanged(originalStatus, DTO.Enums.RequestStatuses.Complete);
}
var task = await PmnTask.GetActiveTaskForRequestActivityAsync(_entity.ID, ID, db);
await MarkTaskComplete(task);
}
else
{
throw new NotSupportedException(CommonMessages.ActivityResultNotSupported);
}
return(new CompletionResult
{
ResultID = activityResultID.Value
});
}
/// <summary>
/// Initializes a new instance of the <see cref="SiteResponseGroup"/> class.
/// </summary>
/// <param name="responseGroups">The response groups.</param>
public SiteResponseGroup(ResponseGroup responseGroups)
{
_ResponseGroups = responseGroups;
}
public override async Task <CompletionResult> Complete(string data, Guid?activityResultID)
{
if (!activityResultID.HasValue)
{
throw new ArgumentNullException(CommonMessages.ActivityResultIDRequired);
}
var task = await PmnTask.GetActiveTaskForRequestActivityAsync(_workflow.Entity.ID, ID, db);
if (task == null)
{
task = db.Actions.Add(PmnTask.CreateForWorkflowActivity(_workflow.Entity.ID, ID, _workflow.ID, db));
}
if (activityResultID.Value == SaveResultID)
{
return(new CompletionResult
{
ResultID = SaveResultID
});
}
if (activityResultID.Value == EditRoutingStatusResultID)
{
var dataMarts = Newtonsoft.Json.JsonConvert.DeserializeObject <IEnumerable <RoutingChangeRequestModel> >(data);
await UpdateDataMartRoutingStatus(dataMarts);
return(new CompletionResult
{
ResultID = EditRoutingStatusResultID
});
}
else if (activityResultID.Value == RoutingsBulkEditID)
{
return(new CompletionResult
{
ResultID = RoutingsBulkEditID
});
}
else if (activityResultID.Value == RemoveDataMartsResultID)
{
Guid[] guids = data.Split(',').Select(s => Guid.Parse(s)).ToArray();
var routings = await db.RequestDataMarts.Where(dm => guids.Contains(dm.ID)).ToArrayAsync();
foreach (var routing in routings)
{
routing.Status = DTO.Enums.RoutingStatus.Canceled;
}
await LogTaskModified();
await db.SaveChangesAsync();
var originalStatus = _entity.Status;
await db.SaveChangesAsync();
await db.Entry(_entity).ReloadAsync();
if (originalStatus != DTO.Enums.RequestStatuses.Complete && _entity.Status == DTO.Enums.RequestStatuses.Complete)
{
await NotifyRequestStatusChanged(originalStatus, DTO.Enums.RequestStatuses.Complete);
}
}
else if (activityResultID.Value == AddDataMartsResultID)
{
DTO.QueryComposer.QueryComposerRequestDTO requestDTO = Newtonsoft.Json.JsonConvert.DeserializeObject <DTO.QueryComposer.QueryComposerRequestDTO>(_entity.Query);
var modularTerm = requestDTO.Where.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == SimpleModularProgramWorkflowConfiguration.ModularProgramTermID)).FirstOrDefault();
var termValues = Newtonsoft.Json.JsonConvert.DeserializeObject <ModularProgramTermValues>(modularTerm.Values["Values"].ToString());
string[] datamartIDs = data.Split(',');
var allTasks = await db.ActionReferences.Where(tr => tr.ItemID == _entity.ID &&
tr.Type == DTO.Enums.TaskItemTypes.Request &&
tr.Task.Type == DTO.Enums.TaskTypes.Task
)
.Select(tr => tr.Task.ID).ToArrayAsync();
var attachments = await(from doc in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => allTasks.Contains(dd.ItemID))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on doc.ID equals x
where allTasks.Contains(doc.ItemID) && doc.Kind == "Attachment.Input"
orderby doc.ItemID descending, doc.RevisionSetID descending, doc.CreatedOn descending
select doc).ToArrayAsync();
foreach (var guid in datamartIDs)
{
Guid dmGuid = new Guid(guid);
var dm = RequestDataMart.Create(_entity.ID, dmGuid, _workflow.Identity.ID);
dm.Status = DTO.Enums.RoutingStatus.Submitted;
dm.DueDate = _entity.DueDate;
dm.Priority = _entity.Priority;
_entity.DataMarts.Add(dm);
Response rsp = dm.Responses.OrderByDescending(r => r.Count).FirstOrDefault();
//add the request document associations
foreach (var revisionSetID in termValues.Documents.Select(d => d.RevisionSetID))
{
db.RequestDocuments.Add(new RequestDocument {
DocumentType = DTO.Enums.RequestDocumentType.Input, ResponseID = rsp.ID, RevisionSetID = revisionSetID
});
}
foreach (var attachment in attachments)
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = attachment.RevisionSetID.Value, ResponseID = rsp.ID, DocumentType = DTO.Enums.RequestDocumentType.AttachmentInput
});
}
}
await LogTaskModified();
await db.SaveChangesAsync();
}
//Grouping
if (activityResultID.Value == GroupResultID)
{
GroupingRequestModel model = Newtonsoft.Json.JsonConvert.DeserializeObject <GroupingRequestModel>(data);
var responses = await db.Responses.Include(r => r.RequestDataMart).Where(r => model.Responses.Any(x => x == r.ID)).ToArrayAsync();
if (responses.Select(r => r.RequestDataMart.RequestID).Distinct().Count() > 1)
{
throw new ArgumentException("Cannot group responses that come from different requests.");
}
Guid[] requestDataMartIDs = responses.Select(rsp => rsp.RequestDataMartID).Distinct().ToArray();
var pq = (from rdm in db.RequestDataMarts
let permissionID = PermissionIdentifiers.DataMartInProject.GroupResponses.ID
let identityID = _workflow.Identity.ID
let acls = db.GlobalAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID)).Select(a => a.Allowed)
.Concat(db.ProjectAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
.Concat(db.DataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.ProjectDataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.OrganizationAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Organization.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
where requestDataMartIDs.Contains(rdm.ID) &&
acls.Any() && acls.All(a => a == true)
select rdm.ID);
var allowedResponses = await pq.ToArrayAsync();
if (allowedResponses.Length != requestDataMartIDs.Length)
{
throw new SecurityException("Insufficient permission to group one or more of the specified responses.");
}
if (string.IsNullOrWhiteSpace(model.GroupName))
{
model.GroupName = string.Join(", ", db.Responses.Where(r => model.Responses.Any(x => x == r.ID)).Select(r => r.RequestDataMart.DataMart.Name).Distinct());
}
ResponseGroup grouping = db.ResponseGroups.Add(new ResponseGroup(model.GroupName));
foreach (var response in responses)
{
grouping.Responses.Add(response);
response.RequestDataMart.ResultsGrouped = true;
}
await LogTaskModified("Grouped results.");
await db.SaveChangesAsync();
}
//Un-grouping
if (activityResultID.Value == UngroupResultID)
{
IEnumerable <Guid> groupID = (from r in data.Split(',')
where !string.IsNullOrWhiteSpace(r)
select Guid.Parse(r.Trim())).ToArray();
List <Guid> requestDataMartIDs = await db.ResponseGroups.Include(g => g.Responses).Where(g => groupID.Contains(g.ID)).SelectMany(g => g.Responses.Select(r => r.RequestDataMartID)).ToListAsync();
var pq = (from rdm in db.RequestDataMarts
let permissionID = PermissionIdentifiers.DataMartInProject.GroupResponses.ID
let identityID = _workflow.Identity.ID
let acls = db.GlobalAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID)).Select(a => a.Allowed)
.Concat(db.ProjectAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
.Concat(db.DataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.ProjectDataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.OrganizationAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Organization.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
where requestDataMartIDs.Contains(rdm.ID) &&
acls.Any() && acls.All(a => a == true)
select rdm.ID);
var allowedResponses = await pq.ToArrayAsync();
if (allowedResponses.Length != requestDataMartIDs.Count)
{
throw new SecurityException("Insufficient permission to ungroup routings for the specified request.");
}
var groups = await db.ResponseGroups.Include(g => g.Responses).Where(g => groupID.Contains(g.ID)).ToArrayAsync();
foreach (var group in groups)
{
requestDataMartIDs.AddRange(group.Responses.Select(r => r.RequestDataMartID));
group.Responses.Clear();
db.ResponseGroups.Remove(group);
}
var routings = await db.RequestDataMarts.Where(dm => requestDataMartIDs.Contains(dm.ID)).ToArrayAsync();
foreach (var routing in routings)
{
routing.ResultsGrouped = false;
}
await LogTaskModified("Ungrouped results.");
await db.SaveChangesAsync();
}
if (activityResultID.Value == TerminateResultID)
{
_workflow.Entity.CancelledByID = _workflow.Identity.ID;
_workflow.Entity.CancelledOn = DateTime.UtcNow;
task.Status = DTO.Enums.TaskStatuses.Cancelled;
await db.SaveChangesAsync();
return(new CompletionResult
{
ResultID = TerminateResultID
});
}
if (activityResultID.Value == RedistributeResultID)
{
if (!await db.HasPermissions <Project>(_workflow.Identity, _entity.ProjectID, Lpp.Dns.DTO.Security.PermissionIdentifiers.Project.ResubmitRequests))
{
throw new System.Security.SecurityException(CommonMessages.RequirePermissionToResubmitRequest, Lpp.Dns.DTO.Security.PermissionIdentifiers.Project.ResubmitRequests.GetType());
}
//TODO: is this applicable in workflow?
//bool canSkipSubmissionApproval = await db.HasPermissions<Request>(Workflow.Identity, Request.ID, Lpp.Dns.DTO.Security.PermissionIdentifiers.Request.SkipSubmissionApproval);
//data will contain a list of routings to resubmit, the ID may also be for a group
ResubmitRoutingsModel resubmitModel = Newtonsoft.Json.JsonConvert.DeserializeObject <ResubmitRoutingsModel>(data);
var datamarts = await(
from dm in db.RequestDataMarts.Include(dm => dm.Responses)
where dm.RequestID == _entity.ID &&
dm.Responses.Any(r => resubmitModel.Responses.Contains(r.ID) || (r.ResponseGroupID.HasValue && resubmitModel.Responses.Contains(r.ResponseGroupID.Value)))
select dm
).ToArrayAsync();
//get the previously submitted input RequestDocument links
var previousInputRequestDocuments = await(from rd in db.RequestDocuments
where rd.DocumentType == DTO.Enums.RequestDocumentType.Input &&
resubmitModel.Responses.Contains(rd.ResponseID)
select new { RequestDataMartID = rd.Response.RequestDataMartID, RevisionSetID = rd.RevisionSetID }).ToArrayAsync();
var allTasks = await db.ActionReferences.Where(tr => tr.ItemID == _entity.ID &&
tr.Type == DTO.Enums.TaskItemTypes.Request &&
tr.Task.Type == DTO.Enums.TaskTypes.Task
)
.Select(tr => tr.Task.ID).ToArrayAsync();
//attachments are associated to the task they were uploaded on, any existing attachment should be included with the routing
var attachments = await(from doc in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => allTasks.Contains(dd.ItemID))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on doc.ID equals x
where allTasks.Contains(doc.ItemID) && doc.Kind == "Attachment.Input"
orderby doc.ItemID descending, doc.RevisionSetID descending, doc.CreatedOn descending
select doc).ToArrayAsync();
DateTime reSubmittedOn = DateTime.UtcNow;
foreach (var dm in datamarts)
{
var response = dm.AddResponse(_workflow.Identity.ID);
response.SubmittedOn = reSubmittedOn;
response.SubmitMessage = resubmitModel.ResubmissionMessage;
dm.Status = DTO.Enums.RoutingStatus.Resubmitted;
foreach (var requestDoc in previousInputRequestDocuments.Where(rd => rd.RequestDataMartID == dm.ID))
{
db.RequestDocuments.Add(new RequestDocument {
ResponseID = response.ID, RevisionSetID = requestDoc.RevisionSetID, DocumentType = DTO.Enums.RequestDocumentType.Input
});
}
foreach (var attachment in attachments)
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = attachment.RevisionSetID.Value, ResponseID = response.ID, DocumentType = DTO.Enums.RequestDocumentType.AttachmentInput
});
}
}
await SetRequestStatus(DTO.Enums.RequestStatuses.Submitted);
await LogTaskModified();
await MarkTaskComplete(task);
}
else if (activityResultID.Value == CompleteResultID)
{
var originalStatus = _entity.Status;
await SetRequestStatus(DTO.Enums.RequestStatuses.PendingDraftReport);
await NotifyRequestStatusChanged(originalStatus, DTO.Enums.RequestStatuses.PendingDraftReport);
await MarkTaskComplete(task);
}
else if (activityResultID.Value == CompleteWorkflowResultID)
{
var originalStatus = _entity.Status;
if (originalStatus != DTO.Enums.RequestStatuses.Complete && originalStatus != DTO.Enums.RequestStatuses.CompleteWithReport)
{
await SetRequestStatus(DTO.Enums.RequestStatuses.Complete);
await NotifyRequestStatusChanged(originalStatus, DTO.Enums.RequestStatuses.Complete);
}
await MarkTaskComplete(task);
}
return(new CompletionResult
{
ResultID = activityResultID.Value
});
}
public async Task <UserCollection[]> GetCollection(int uid, CollectionCategory category, ResponseGroup responseGroup = ResponseGroup.Medium)
{
if (!Enum.IsDefined(typeof(CollectionCategory), category))
{
throw new ArgumentOutOfRangeException(nameof(category));
}
if (!Enum.IsDefined(typeof(ResponseGroup), responseGroup))
{
throw new ArgumentOutOfRangeException(nameof(responseGroup));
}
var url = $"/user/{uid}/collection?cat={(category == CollectionCategory.Watching ? "watching" : "all_watching")}&responseGroup={responseGroup.ToString().ToLowerInvariant()}";
using (var client = new BangumiClient())
{
var json = await client.GetStringAsync(url);
return(JsonConvert.DeserializeObject <UserCollection[]>(json));
}
}
/// <summary>
/// 条目搜索
/// </summary>
/// <param name="client"></param>
/// <param name="keywords">关键词</param>
/// <param name="start">开始条数</param>
/// <param name="maxResults">每页条数</param>
/// <param name="type">类型</param>
/// <param name="responseGroup">返回数据大小</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static async Task <SearchResult> SearchAsync(this IBangumiClient client, string keywords, int start, int maxResults, SubjectType?type = null, ResponseGroup responseGroup = ResponseGroup.Small, CancellationToken cancellationToken = default(CancellationToken))
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
var url = $"/search/subject/{WebUtility.UrlEncode(keywords)}?";
if (type.HasValue)
{
url += $"type={(int)type}";
}
url += $"&responseGroup={responseGroup.GetValue()}&start={start}&max_results={maxResults}";
var result = await client.GetAsync <SearchResult>(url, cancellationToken);
if (result.ErrorCode == (int)HttpStatusCode.NotFound)
{
result = new SearchResult
{
List = Array.Empty <Subject>()
};
}
return(result);
}
private BackupObject GetBackupObject(Action <ExportImportProgressInfo> progressCallback, bool loadBinaryData)
{
var progressInfo = new ExportImportProgressInfo {
Description = "loading data..."
};
progressCallback(progressInfo);
const ResponseGroup responseGroup = ResponseGroup.WithCatalogs | ResponseGroup.WithCategories | ResponseGroup.WithProducts;
var searchResponse = _catalogSearchService.Search(new SearchCriteria {
Count = int.MaxValue, GetAllCategories = true, Start = 0, ResponseGroup = responseGroup
});
var retVal = new BackupObject();
progressInfo.Description = String.Format("{0} catalogs loading", searchResponse.Catalogs.Count());
progressCallback(progressInfo);
//Catalogs
retVal.Catalogs = searchResponse.Catalogs.Select(x => _catalogService.GetById(x.Id)).ToList();
progressInfo.Description = String.Format("{0} categories loading", searchResponse.Categories.Count());
progressCallback(progressInfo);
//Categories
retVal.Categories = searchResponse.Categories.Select(x => _categoryService.GetById(x.Id)).ToList();
//Products
for (int i = 0; i < searchResponse.Products.Count(); i += 50)
{
var products = _itemService.GetByIds(searchResponse.Products.Skip(i).Take(50).Select(x => x.Id).ToArray(), ItemResponseGroup.ItemMedium | ItemResponseGroup.Variations | ItemResponseGroup.Seo);
retVal.Products.AddRange(products);
progressInfo.Description = String.Format("{0} of {1} products loaded", Math.Min(searchResponse.TotalCount, i), searchResponse.TotalCount);
progressCallback(progressInfo);
}
//Binary data
if (loadBinaryData)
{
var allImages = retVal.Products.SelectMany(x => x.Images);
allImages = allImages.Concat(retVal.Categories.SelectMany(x => x.Images));
allImages = allImages.Concat(retVal.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images));
var index = 0;
var progressTemplate = "{0} of " + allImages.Count() + " images downloading";
foreach (var image in allImages)
{
progressInfo.Description = String.Format(progressTemplate, index);
progressCallback(progressInfo);
try
{
image.BinaryData = _blobStorageProvider.OpenReadOnly(image.Url).ReadFully();
}
catch (Exception ex)
{
progressInfo.Errors.Add(ex.ToString());
progressCallback(progressInfo);
}
index++;
}
}
//Properties
var catalogsPropertiesIds = retVal.Catalogs.SelectMany(x => _propertyService.GetCatalogProperties(x.Id)).Select(x => x.Id).ToArray();
var categoriesPropertiesIds = retVal.Categories.SelectMany(x => _propertyService.GetCategoryProperties(x.Id)).Select(x => x.Id).ToArray();
var propertiesIds = catalogsPropertiesIds.Concat(categoriesPropertiesIds).Distinct().ToArray();
progressInfo.Description = String.Format("{0} properties loading", propertiesIds.Count());
progressCallback(progressInfo);
retVal.Properties = propertiesIds.Select(x => _propertyService.GetById(x)).ToList();
return(retVal);
}
/// <summary>
/// Initializes a new instance of the <see cref="CatalogNodeResponseGroup"/> class.
/// </summary>
/// <param name="responseGroups">The response groups.</param>
public CatalogNodeResponseGroup(ResponseGroup responseGroups)
{
_ResponseGroups = responseGroups;
}
public async Task <ListResult <Subject> > Search(string keywords, SubjectType?type = null, ResponseGroup responseGroup = ResponseGroup.Small, int start = 0, int maxResults = 10)
{
if (keywords == null)
{
throw new ArgumentNullException(nameof(keywords));
}
if (start < 0)
{
throw new ArgumentOutOfRangeException(nameof(start));
}
if (maxResults <= 0)
{
throw new ArgumentOutOfRangeException(nameof(maxResults));
}
var url = $"/search/subject/{WebUtility.UrlEncode(keywords)}";
var query = new Dictionary <string, string>();
if (type.HasValue)
{
query["type"] = ((int)type.Value).ToString();
}
query["responseGroup"] = responseGroup.ToString().ToLowerInvariant();
query["start"] = start.ToString();
query["max_results"] = maxResults.ToString();
if (query.Count > 0)
{
url += "?" + string.Join("&", query.Select(temp => temp.Key + "=" + WebUtility.UrlEncode(temp.Value)));
}
using (var client = new BangumiClient())
{
var json = await client.GetStringAsync(url);
return(JsonConvert.DeserializeObject <ListResult <Subject> >(json));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CatalogEntryResponseGroup"/> class.
/// </summary>
/// <param name="responseGroups">The response groups.</param>
public CatalogEntryResponseGroup(ResponseGroup responseGroups)
{
_ResponseGroups = responseGroups;
}
/// <summary>
/// Initializes a new instance of the <see cref="CatalogRelationResponseGroup"/> class.
/// </summary>
/// <param name="responseGroups">The response groups.</param>
public CatalogRelationResponseGroup(ResponseGroup responseGroups)
{
_ResponseGroups = responseGroups;
}
/// <summary>
/// 获取条目信息
/// </summary>
/// <param name="client"></param>
/// <param name="id">条目 ID</param>
/// <param name="responseGroup">返回数据大小</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static Task <Subject> GetSubjectAsync(this IBangumiClient client, int id, ResponseGroup responseGroup = ResponseGroup.Small, CancellationToken cancellationToken = default(CancellationToken))
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
var url = $"/subject/{id}?responseGroup={responseGroup.GetValue()}";
return(client.GetAsync <Subject>(url, cancellationToken));
}
