/// <summary>
/// A collection links that belong to this base asset filtered by the passed in filter
/// </summary>
public ICollection <Link> GetLinks(LinkFilter filter)
{
filter = filter ?? new LinkFilter();
filter.Asset.Clear();
filter.Asset.Add(this);
return(Instance.Get.Links(filter));
}
public IList <LinkDto> GetLinkForWorkflow(LinkFilter filter)
{
var sp = new GetLinks(filter.Rn, filter.Direction);
var result = ExecuteStoreProcedure <LinkDto>(sp);
return(result);
}
public IList <LinkDto> GetLinkForWorkflow(LinkFilter filter)
{
var result = new DomainGenerator()
.With <LinkDto>(x => x.For(c => c.InDocument, (long)1, val => val + 1))
.With <LinkDto>(x => x.For(c => c.OutDocument, (long)3, val => val + 1))
.Many <LinkDto>(10);
return(new List <LinkDto>(result));
}
public static void List(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Usage: WorkItemHelper.List <URL for TFS> <server path>");
//Environment.Exit(1);
return;
}
TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(new Uri(args[0]));
VersionControlServer vcs = tpc.GetService <VersionControlServer>();
// Get the changeset artifact URIs for each changeset in the history query
List <string> changesetArtifactUris = new List <string>();
foreach (Object obj in vcs.QueryHistory(args[1], // path we care about ($/project/whatever)
VersionSpec.Latest, // version of that path
0, // deletion ID (0 = not deleted)
RecursionType.Full, // entire tree - full recursion
null, // include changesets from all users
new ChangesetVersionSpec(1), // start at the beginning of time
VersionSpec.Latest, // end at latest
100, // only return these max count rows
false, // we don't want the files changed
true)) // do history on the path
{
Changeset c = obj as Changeset;
changesetArtifactUris.Add(c.ArtifactUri.AbsoluteUri);
}
// We'll use the linking service to get information about the associated work items
ILinking linkingService = tpc.GetService <ILinking>();
LinkFilter linkFilter = new LinkFilter();
linkFilter.FilterType = FilterType.ToolType;
linkFilter.FilterValues = new string[1] {
ToolNames.WorkItemTracking
}; // we only want work items
// Convert the artifact URIs for the work items into strongly-typed objects holding the properties rather than name/value pairs
Artifact[] artifacts = linkingService.GetReferencingArtifacts(changesetArtifactUris.ToArray(), new LinkFilter[1] {
linkFilter
});
AssociatedWorkItemInfo[] workItemInfos = AssociatedWorkItemInfo.FromArtifacts(artifacts);
// Here we'll just print the IDs and titles of the work items
foreach (AssociatedWorkItemInfo workItemInfo in workItemInfos.OrderByDescending(a => a.Id).ToList())
{
Console.WriteLine("Id: " + workItemInfo.Id + " Title: " + workItemInfo.Title);
}
}
public LinkResult GetClickedLinks(int campaignId, LinkFilter filter)
{
if (filter == null)
{
return(new LinkResult
{
Status = Status.Error,
Message = "Filter is null"
});
}
var url = $"{this._baseUrl}/campaigns/listClicks/";
var request = new LinkRequest
{
ApiKey = this._apiKey,
CampaignId = campaignId,
};
if (filter.Type.HasValue)
{
request.TrackingType = filter.Type.Value;
}
if (filter.FromDate.HasValue)
{
request.FromDate = filter.FromDate.Value;
}
if (filter.ToDate.HasValue)
{
request.ToDate = filter.ToDate.Value;
}
var xmlRequest = this._parser.Serialize(request);
var httpResponse = this._httpClient.Request(url, xmlRequest);
if (httpResponse.Status != HttpStatus.Successful)
{
return(new LinkResult
{
Status = Status.Error,
Message = "Http error"
});
}
var linkResult = this._parser.Deserialize <LinkResult>(httpResponse.Result);
return(linkResult);
}
public async Task <IActionResult> UpdateLinkFilter(ulong guildId, LinkFilterViewModel vm)
{
var currentSettings = await _moderationModuleUtils.GetModerationSettings(guildId);
var filter = await _entityServiceLinkFilter.GetFirst(f => f.GuildId == guildId);
var createNewFilter = false;
if (filter is null)
{
filter = new LinkFilter {
GuildId = guildId
};
createNewFilter = true;
}
filter.Enabled = vm.Enabled;
filter.WarningExpirePeriod = vm.WarningExpirePeriod;
if (createNewFilter)
{
await _entityServiceLinkFilter.Create(filter);
}
else
{
await _entityServiceLinkFilter.Update(filter);
}
var newChannelState = GetNewChannelState(currentSettings, FilterType.Link, vm.SelectedChannels);
var newRolesState = GetNewRolesState(currentSettings, FilterType.Link, vm.SelectedRoles);
var newLinkState = GetNewLinksState(currentSettings, vm.SelectedLinks);
await _entityServiceWhitelistedChannels.CreateBulk(newChannelState.ChannelsToAdd);
await _entityServiceWhitelistedChannels.RemoveBulk(newChannelState.ChannelsToRemove);
await _entityServiceWhitelistedRoles.CreateBulk(newRolesState.RolesToAdd);
await _entityServiceWhitelistedRoles.RemoveBulk(newRolesState.RolesToRemove);
await _entityServiceWhitelistedLinks.CreateBulk(newLinkState.LinksToAdd);
await _entityServiceWhitelistedLinks.RemoveBulk(newLinkState.LinksToRemove);
return(RedirectToAction("linkfilter"));
}
public static async Task Main(string[] args)
{
Console.OutputEncoding = System.Text.Encoding.UTF8;
LinkRepository linkRepository = new LinkRepository();
LinkFilter linkFilter = new LinkFilter();
LinkService linkService = new LinkService(linkRepository);
LinkView linkView = new LinkView();
LinkController linkController = new LinkController(linkService, linkView);
linkController.StartWork();
}
private bool IsValid(Page sourcePage, Uri link, LinkFilter filter)
{
var reason = "";
if (!filter.StayOnHost | sourcePage.Url.Host != link.Host)
{
Log.Debug($"Excluded: {link} (Host '{link.Host}' differs from source page's host '{sourcePage.Url.Host}')");
return(false);
}
var valid = filter.IsValid(link, ref reason);
Log.Debug(valid
? $"Added: {link}"
: $"Excluded: {link} ({reason})");
return(valid);
}
public IEnumerable <IWorkItem> GetWorkItems(ICollection <HistoryItem> historyItems)
{
Debug.WriteLine($"Getting WorkItems for {historyItems.Count} HistoryItems");
LinkFilter linkFilter = new LinkFilter();
linkFilter.FilterType = FilterType.ToolType;
linkFilter.FilterValues = new String[1] {
ToolNames.WorkItemTracking
};
Artifact[] artifacts = _linkingService.GetReferencingArtifacts(historyItems.Select(item => item.ChangeSet.ArtifactUri.AbsoluteUri).ToArray(), new LinkFilter[1] {
linkFilter
});
var col = IWorkItem.FromArtifacts(artifacts, WorkItemFactory);
Debug.WriteLine($"{col.Count} WorkItems Fetched");
return(col.OrderByDescending(item => item.Id));
}
private bool ContainsIllegalLink(LinkFilter linkFilter, string message)
{
// Normalize message to lowercase and split into array of words.
var messageWords = message.ToLower().Split(" ");
// Regular expression for detecting url patterns
var urlCheck = new Regex(@"[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&\/=]*)");
// Flag for tracking whether current url is whitelisted
var isLinkLegal = false;
// Check each word for illegal link
foreach (var word in messageWords)
{
if (urlCheck.IsMatch(word))
{
foreach (var link in linkFilter.WhitelistedLinks.Select(l => l.Link))
{
var rgx = WildCardToRegular(link);
if (Regex.IsMatch(word, rgx))
{
isLinkLegal = true;
break;
}
}
if (!isLinkLegal)
{
return(true);
}
isLinkLegal = false;
}
}
return(false);
}
public static bool IsValid(this LinkFilter filter, Uri url, ref string excludeReason)
{
var isValid = !filter.ExcludeAsDefault;
if (filter.ExcludePagesWithQueryParameters && !string.IsNullOrEmpty(url.Query))
{
excludeReason = $"ExcludePagesWithQueryParameters is enabled";
return(false);
}
if (filter.ExcludeExtensions.Any())
{
var extension = url.GetExtension();
foreach (var excludeExtension in filter.ExcludeExtensions.Where(excludeExtension => excludeExtension == extension))
{
excludeReason = $"Extension {excludeExtension} is configured to be exluced";
return(false);
}
}
foreach (var regex in filter.ExcludeRegex)
{
if (!Matches(url, regex))
{
continue;
}
excludeReason = $"Matches exclude regex {regex}";
return(false);
}
if (filter.IncludeRegex.Any(regex => Matches(url, regex)))
{
return(true);
}
if (isValid == false)
{
excludeReason = "Matches no include regex and ExcludeAsDefault is enabled";
}
return(isValid);
}
/// <summary>
/// Get links filtered by the criteria specified in the passed in filter.
/// </summary>
/// <param name="filter">Limit the items returned. If null, then all items returned.</param>
/// <returns>ICollection of items as specified in the filter.</returns>
public ICollection <Link> Links(LinkFilter filter)
{
return(Get <Link>(filter ?? new LinkFilter()));
}
public LinkRepository()
{
this.Links = new List <Link>();
this.LinkFilter = new LinkFilter();
}
public IList <Uri> GetValidLinks(Page sourcePage, IList <Uri> links, LinkFilter filter)
{
return(links
.Where(link => IsValid(sourcePage, link, filter))
.ToList());
}
public LinkController(ILinkService linkService, ILinkView linkView)
{
this.LinkService = linkService;
this.LinkView = linkView;
this.LinkFilter = new LinkFilter();
}
