public IEnumerable <UserContentViewModel> GetActivityFeed(ActivityFeedRequestViewModel vm)
{
try
{
List <UserContent> allModels = userContentDomainService.GetActivityFeed(vm.GameId, vm.UserId, vm.Languages, vm.OldestId, vm.OldestDate, vm.ArticlesOnly, vm.Count).ToList();
IEnumerable <UserContentViewModel> viewModels = mapper.Map <IEnumerable <UserContent>, IEnumerable <UserContentViewModel> >(allModels);
foreach (UserContentViewModel item in viewModels)
{
item.CreateDate = item.CreateDate.ToLocalTime();
item.PublishDate = item.PublishDate.ToLocalTime();
UserProfile authorProfile = GetCachedProfileByUserId(item.UserId);
if (authorProfile == null)
{
item.AuthorName = Constants.UnknownSoul;
}
else
{
item.AuthorName = authorProfile.Name;
}
item.AuthorPicture = UrlFormatter.ProfileImage(item.UserId, 40);
item.IsArticle = !string.IsNullOrWhiteSpace(item.Title) && !string.IsNullOrWhiteSpace(item.Introduction);
item.FeaturedMediaType = GetMediaType(item.FeaturedImage);
if (item.FeaturedMediaType == MediaType.Youtube)
{
item.Content = string.Empty;
}
if (item.FeaturedMediaType != MediaType.Youtube)
{
SetFeaturedImage(item);
}
item.HasFeaturedImage = !string.IsNullOrWhiteSpace(item.FeaturedImage) && !item.FeaturedImage.Contains(Constants.DefaultFeaturedImage);
item.LikeCount = item.Likes.Count;
item.CommentCount = item.Comments.Count;
item.Poll = SetPoll(vm.CurrentUserId, item.Id);
LoadAuthenticatedData(vm.CurrentUserId, item);
item.Content = item.Content.ReplaceCloudname();
}
return(viewModels);
}
catch (Exception ex)
{
string msg = $"Unable to get the Activity Feed.";
logger.Log(LogLevel.Error, ex, msg);
throw;
}
}
public async Task <UploadResult> UploadAudioAsync(Guid userId, UploadAudioRequest request)
{
return(await BaseInvokeCheckModelAsync(request, async() =>
{
User user = _dbContext.Users.FirstOrDefault(x => x.Id == userId);
if (user == null)
{
throw new Exception("User not found, but token does");
}
var responseBuilder =
ResponseBuilder <UploadResult>
.Fail();
if (user.IsUploadingAudio)
{
return responseBuilder.SetInfoAndBuild("User already uploading audio");
}
user.IsUploadingAudio = true;
_dbContext.SaveChanges();
using (var transaction = _dbContext.Database.BeginTransaction())
{
try
{
GetInfoResult result = await GetInfoAsync(new UrlRequest {
Url = request.Url
});
if (!result.Ok)
{
return responseBuilder
.SetErrors(result.Errors)
.SetInfoAndBuild(result.Info);
}
string videoId = UrlFormatter.GetYoutubeVideoIdentifier(request.Url);
IFile videoFile = await _saveVideo.SaveAsync(request.Url);
IFile audioFile = await _extractAudio.ExtractAsync(videoFile);
//TODO: create upload for FileSystem, Blob, etc...
string accessUrl = _uploadAudio.Upload(audioFile, StorageType.FileSystem);
var generalPlayList = _dbContext.Playlists.FirstOrDefault(x => x.OwnerId == userId && x.IsGeneral);
if (generalPlayList == null)
{
throw new Exception("Playlist not found");
}
var audio = new Audio
{
Id = Guid.NewGuid(),
AccessUrl = accessUrl,
DateCreated = DateTime.Now,
Artist = request.Artist,
Song = request.Song,
Duration = audioFile.Duration,
Extension = audioFile.Extension,
FileName = audioFile.Filename,
UniqueIdentifier = videoId,
UploaderId = userId
};
var audioPlaylist = new AudioPlaylist
{
AudioId = audio.Id,
DateCreated = DateTime.Now,
PlaylistId = generalPlayList.Id,
Order = generalPlayList.OrderValue
};
//update max index in playlist
generalPlayList.OrderValue++;
//add entities
_dbContext.AudioPlaylists.Add(audioPlaylist);
Audio audioEntity = _dbContext.Audios.Add(audio).Entity;
_dbContext.SaveChanges();
transaction.Commit();
return ResponseBuilder <UploadResult> .SuccessBuild(new UploadResult
{
Audio = AudioMapper.ToApi.FromData(audioEntity)
});
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
finally
{
//skip upload process
user.IsUploadingAudio = false;
_dbContext.SaveChanges();
}
}
}));
}
public void HttpsRedirectDoesntReturnCyclicRedirect()
{
// create redirect processor
var configuration = new Configuration
{
DefaultUrl = TestData.TestData.DefaultHost,
ForceHttpHostPatterns = new[]
{
"www\\.test\\.local"
}
};
// create url and redirect parser
var urlFormatter = new UrlFormatter();
var urlParser = new UrlParser();
var urlHelper = new UrlHelper(
configuration,
urlParser,
urlFormatter);
var redirectParser = new RedirectParser(
configuration,
urlParser,
urlFormatter);
// create redirect processor
var testHttpClient =
new TestHttpClient();
var redirectProcessor = new RedirectProcessor(
configuration,
urlHelper,
testHttpClient,
urlParser,
urlFormatter,
new RedirectHelper(
configuration,
urlParser,
urlFormatter));
// parse redirects
var redirects = new[] {
new Redirect
{
OldUrl = "http://www.test.local/url1",
NewUrl = "https://www.test.local/url1"
},
new Redirect
{
OldUrl = "https://www.test.local/url1",
NewUrl = "https://www.test.local/url2"
},
new Redirect
{
OldUrl = "https://www.test.local/url2",
NewUrl = "https://www.test.local/url3"
}
};
// parse redirects
var parsedRedirects = new List <IParsedRedirect>();
foreach (var redirect in redirects)
{
parsedRedirects.Add(
redirectParser.ParseRedirect(
redirect));
}
// preload parsed redirects
redirectProcessor.PreloadParsedRedirects(
parsedRedirects);
// process redirects using redirect processor
var processedRedirects = TestData.TestData.GetProcessedRedirects(
parsedRedirects,
new[] { redirectProcessor });
// verify cyclic redirect is not detected
var cyclicRedirect = processedRedirects
.FirstOrDefault(pr => pr.Results.Any(
r => r.Type.Equals(ResultTypes.CyclicRedirect)));
Assert.IsNull(cyclicRedirect);
// verify optimized redirect is detected
var optimizedRedirect = processedRedirects
.FirstOrDefault(pr => pr.Results.Any(
r => r.Type.Equals(ResultTypes.OptimizedRedirect)));
Assert.IsNotNull(optimizedRedirect);
}
public AuthController()
{
_authUrl = UrlFormatter.MagentoAuthUrl();
}
private static void FormatConnectionImages(UserConnectionViewModel item, UserProfileEssentialVo profile)
{
item.ProfileImageUrl = UrlFormatter.ProfileImage(item.TargetUserId);
item.CoverImageUrl = UrlFormatter.ProfileCoverImage(item.TargetUserId, profile.Id, profile.LastUpdateDate, profile.HasCoverImage);
}
private void FormatExternalLinks(GameViewModel vm)
{
ProfileViewModel authorProfile = GetUserProfileWithCache(vm.UserId);
ExternalLinkBaseViewModel itchProfile = authorProfile.ExternalLinks.FirstOrDefault(x => x.Provider == ExternalLinkProvider.ItchIo);
foreach (ExternalLinkBaseViewModel item in vm.ExternalLinks)
{
ExternalLinkInfoAttribute uiInfo = item.Provider.GetAttributeOfType <ExternalLinkInfoAttribute>();
item.Display = uiInfo.Display;
item.IconClass = uiInfo.Class;
item.ColorClass = uiInfo.ColorClass;
item.IsStore = uiInfo.IsStore;
item.Order = uiInfo.Order;
switch (item.Provider)
{
case ExternalLinkProvider.Website:
item.Value = UrlFormatter.Website(item.Value);
break;
case ExternalLinkProvider.Facebook:
item.Value = UrlFormatter.Facebook(item.Value);
break;
case ExternalLinkProvider.Twitter:
item.Value = UrlFormatter.Twitter(item.Value);
break;
case ExternalLinkProvider.Instagram:
item.Value = UrlFormatter.Instagram(item.Value);
break;
case ExternalLinkProvider.Youtube:
item.Value = UrlFormatter.Youtube(item.Value);
break;
case ExternalLinkProvider.XboxLive:
item.Value = UrlFormatter.XboxLiveGame(item.Value);
break;
case ExternalLinkProvider.PlaystationStore:
item.Value = UrlFormatter.PlayStationStoreGame(item.Value);
break;
case ExternalLinkProvider.Steam:
item.Value = UrlFormatter.SteamGame(item.Value);
break;
case ExternalLinkProvider.GameJolt:
item.Value = UrlFormatter.GameJoltGame(item.Value);
break;
case ExternalLinkProvider.ItchIo:
item.Value = UrlFormatter.ItchIoGame(itchProfile?.Value, item.Value);
break;
case ExternalLinkProvider.GamedevNet:
item.Value = UrlFormatter.GamedevNetGame(item.Value);
break;
case ExternalLinkProvider.IndieDb:
item.Value = UrlFormatter.IndieDbGame(item.Value);
break;
case ExternalLinkProvider.UnityConnect:
item.Value = UrlFormatter.UnityConnectGame(item.Value);
break;
case ExternalLinkProvider.GooglePlayStore:
item.Value = UrlFormatter.GooglePlayStoreGame(item.Value);
break;
case ExternalLinkProvider.AppleAppStore:
item.Value = UrlFormatter.AppleAppStoreGame(item.Value);
break;
case ExternalLinkProvider.IndiExpo:
item.Value = UrlFormatter.IndiExpoGame(item.Value);
break;
case ExternalLinkProvider.Discord:
item.Value = UrlFormatter.DiscordGame(item.Value);
break;
}
}
}
public void RedirectProcessorRedirectsOldUrlWithReplaceType()
{
var configuration =
TestData.TestData.DefaultConfiguration;
var urlParser = new UrlParser();
var urlFormatter = new UrlFormatter();
var redirectParser = new RedirectParser(
configuration,
urlParser,
urlFormatter);
// create redirect processor
var testHttpClient =
new TestHttpClient();
var redirectProcessor = new RedirectProcessor(
configuration,
new UrlHelper(
configuration,
urlParser,
urlFormatter),
testHttpClient,
urlParser,
urlFormatter,
new RedirectHelper(
configuration,
urlParser,
urlFormatter));
// parse redirect with old url replace type
var parsedRedirects = TestData.TestData.GetParsedRedirects(
configuration,
new[]
{
new Redirect
{
OldUrl = "/url1",
NewUrl = "/url2",
RedirectType = RedirectType.Replace
}
})
.ToList();
// parse redirects to verify replace redirect works
var parsedRedirects2 = TestData.TestData.GetParsedRedirects(
configuration,
new[]
{
new Redirect
{
OldUrl = "/url1/replace/redirect",
NewUrl = "/url2/replace/redirect"
}
})
.ToList();
// preload parsed redirects
redirectProcessor.PreloadParsedRedirects(
parsedRedirects);
var processedRedirects = new []
{
new ProcessedRedirect
{
ParsedRedirect = parsedRedirects[0]
},
new ProcessedRedirect
{
ParsedRedirect = parsedRedirects2[0]
}
};
// process redirects
foreach (var processedRedirect in processedRedirects)
{
redirectProcessor.Process(
processedRedirect);
}
// verify
var urlResponseResult = processedRedirects[1]
.Results
.FirstOrDefault(x => x.Type == ResultTypes.UrlResponse);
Assert.IsNotNull(urlResponseResult);
Assert.AreEqual(
"http://www.test.local/url2/replace/redirect",
urlResponseResult.Url);
}
static int Main(string[] args)
{
// write webredirects title
System.Console.ForegroundColor = ConsoleColor.Cyan;
System.Console.WriteLine(
string.Format(
"FirstRealize App WebRedirects v{0}",
Assembly.GetExecutingAssembly().GetName().Version));
System.Console.WriteLine(string.Empty);
if (args.Length == 0)
{
Usage();
return(1);
}
// expand environment variables in arguments
args = args.Select(x =>
Environment.ExpandEnvironmentVariables(x))
.ToArray();
var argumentParser =
new ArgumentParser(args);
// parse arguments
string configurationFile = argumentParser
.ParseArgumentValue("^(-c|--config)");
// write error, if configuration file argument is not defined
if (string.IsNullOrWhiteSpace(configurationFile))
{
System.Console.WriteLine(
"ERROR: Configuration file argument is not defined");
Usage();
return(1);
}
// write progessing redirects
System.Console.ForegroundColor = ConsoleColor.Yellow;
System.Console.WriteLine(
string.Format(
"Reading configuration file '{0}'",
configurationFile));
// write error, if configuration file doesn't exist
if (!File.Exists(configurationFile))
{
System.Console.WriteLine(
"ERROR: Configuration file '{0}' doesn't exist",
configurationFile);
Usage();
return(1);
}
// load configuration file
Configuration configuration;
using (var configurationJsonReader = new ConfigurationJsonReader())
{
configuration = configurationJsonReader
.ReadConfiguationFile(configurationFile) as Configuration;
}
// write read configuration file done
System.Console.ForegroundColor = ConsoleColor.Green;
System.Console.WriteLine("Done");
System.Console.WriteLine(string.Empty);
if (string.IsNullOrWhiteSpace(configuration.OutputDir))
{
configuration.OutputDir = Path.GetDirectoryName(
configurationFile);
}
// TODO: Apply if needed
//ServicePointManager.SecurityProtocol =
// SecurityProtocolType.Tls12;
// create http client depending use test http client
var urlParser = new UrlParser();
IHttpClient httpClient;
if (configuration.UseTestHttpClient)
{
httpClient = new TestHttpClient();
}
else
{
httpClient = new HttpClient(
configuration,
urlParser);
}
// create redirect engine
var urlFormatter = new UrlFormatter();
var urlHelper = new UrlHelper(
configuration,
urlParser,
urlFormatter);
var redirectParser = new RedirectParser(
configuration,
urlParser,
urlFormatter);
var redirectEngine = new RedirectEngine(
configuration,
urlHelper,
urlParser,
urlFormatter,
redirectParser,
httpClient);
// create processed redirect validator
var processedRedirectValidator =
new ProcessedRedirectValidator(
configuration,
urlHelper);
// handle processed redirect event to show progress
redirectEngine.RedirectProcessed += (o, e) =>
{
System.Console.ForegroundColor = ConsoleColor.Green;
var result = ".";
if (e.ProcessedRedirect.Results.Any(
r => r.Type.Equals(ResultTypes.UnknownErrorResult)))
{
System.Console.ForegroundColor = ConsoleColor.Red;
result = "X";
}
else if (e.ProcessedRedirect.Results.Any(
r => r.Type.Equals(ResultTypes.ExcludedRedirect)))
{
System.Console.ForegroundColor = ConsoleColor.Red;
result = "%";
}
else if (e.ProcessedRedirect.Results.Any(
r => r.Type.Equals(ResultTypes.InvalidResult)))
{
System.Console.ForegroundColor = ConsoleColor.Red;
result = "?";
}
else if (e.ProcessedRedirect.Results.Any(
r => r.Type.Equals(ResultTypes.IdenticalResult)))
{
System.Console.ForegroundColor = ConsoleColor.Red;
result = "=";
}
else if (e.ProcessedRedirect.Results.Any(
r => r.Type.Equals(ResultTypes.CyclicRedirect)))
{
System.Console.ForegroundColor = ConsoleColor.Red;
result = "O";
}
else if (e.ProcessedRedirect.Results.Any(
r => r.Type.Equals(ResultTypes.TooManyRedirects)))
{
System.Console.ForegroundColor = ConsoleColor.Red;
result = "*";
}
else
{
var urlResponseResult = e
.ProcessedRedirect
.Results
.OfType <UrlResponseResult>()
.FirstOrDefault(r => r.Type.Equals(ResultTypes.UrlResponse));
if (urlResponseResult != null && !urlHelper.AreIdentical(
e.ProcessedRedirect.ParsedRedirect.NewUrl.Formatted,
urlResponseResult.Url))
{
System.Console.ForegroundColor = ConsoleColor.Yellow;
result = "!";
}
}
System.Console.Write(result);
};
// run redirect engine
System.Console.ForegroundColor = ConsoleColor.Yellow;
System.Console.WriteLine("Processing redirects");
var redirectProcessingResult =
redirectEngine.Run();
System.Console.ForegroundColor = ConsoleColor.Green;
System.Console.WriteLine(string.Empty);
System.Console.WriteLine("Done");
System.Console.WriteLine(string.Empty);
if (configuration.Mode == Mode.Process)
{
Reports(
configuration.OutputDir,
redirectProcessingResult,
processedRedirectValidator);
}
return(0);
}
public void RedirectProcessorCachesResponse()
{
var configuration =
TestData.TestData.DefaultConfiguration;
var urlParser = new UrlParser();
var urlFormatter = new UrlFormatter();
var redirectParser = new RedirectParser(
configuration,
urlParser,
urlFormatter);
// create redirect processor
var testHttpClient =
new TestHttpClient();
var redirectProcessor = new RedirectProcessor(
configuration,
new UrlHelper(
configuration,
urlParser,
urlFormatter),
testHttpClient,
urlParser,
urlFormatter,
new RedirectHelper(
configuration,
urlParser,
urlFormatter));
// create and parse redirects
var redirects = new List <IRedirect>
{
new Redirect
{
OldUrl = "/url1",
NewUrl = "/url3"
},
new Redirect
{
OldUrl = "/url2",
NewUrl = "/url3"
}
};
var parsedRedirects = new List <IParsedRedirect>();
foreach (var redirect in redirects)
{
parsedRedirects.Add(
redirectParser.ParseRedirect(
redirect));
}
// preload parsed redirects
redirectProcessor.PreloadParsedRedirects(
parsedRedirects);
// verify controlled http client doesn't have any responses
Assert.AreEqual(
0,
testHttpClient.Responses.Count);
// process redirects and verify responses are cached by overriding responses
UrlResponseResult urlResponseResult = null;
var processedRedirects = new List <IProcessedRedirect>();
foreach (var parsedRedirect in parsedRedirects)
{
var processedRedirect = new ProcessedRedirect
{
ParsedRedirect = parsedRedirect
};
redirectProcessor.Process(
processedRedirect);
// get url response result, if url response result is null and
// controlled http client has a response for old url
if (urlResponseResult == null &&
testHttpClient.Responses.ContainsKey(
parsedRedirect.NewUrl.Formatted))
{
urlResponseResult = processedRedirect.Results
.FirstOrDefault(r => r.Type.Equals(
ResultTypes.UrlResponse)) as UrlResponseResult;
}
else
{
// override response with forbidden status code
testHttpClient.Responses[
parsedRedirect.NewUrl.Formatted] =
new HttpResponse
{
StatusCode = 401
};
}
}
// verify url response result for /url3 has status code ok and not forbidden
Assert.IsNotNull(
urlResponseResult);
Assert.AreEqual(
"http://www.test.local/url3",
urlResponseResult.Url);
Assert.AreEqual(
404,
urlResponseResult.StatusCode
);
}
public void RedirectProcessorHandlesLowercasedRedirects()
{
var configuration =
TestData.TestData.DefaultConfiguration;
var urlParser = new UrlParser();
var urlFormatter = new UrlFormatter();
var redirectParser = new RedirectParser(
configuration,
urlParser,
urlFormatter);
// create redirect processor
var testHttpClient =
new TestHttpClient();
var redirectProcessor = new RedirectProcessor(
configuration,
new UrlHelper(
configuration,
urlParser,
urlFormatter),
testHttpClient,
urlParser,
urlFormatter,
new RedirectHelper(
configuration,
urlParser,
urlFormatter));
// parse redirects with uppercased old url
var parsedRedirects = TestData.TestData.GetParsedRedirects(
configuration,
new[]
{
new Redirect
{
OldUrl = "/Url1",
NewUrl = "/url2"
}
})
.ToList();
// simulate uppercased url redirects to lowercased url
testHttpClient.Responses[
parsedRedirects[0].OldUrl.Formatted] =
new HttpResponse
{
StatusCode = 301,
Headers = new Dictionary <string, string>
{
{ "Location", "/url1" }
}
};
// preload parsed redirects
redirectProcessor.PreloadParsedRedirects(
parsedRedirects);
// process redirects
var processedRedirect = new ProcessedRedirect
{
ParsedRedirect = parsedRedirects[0]
};
redirectProcessor.Process(
processedRedirect);
// verify
var urlResponseResult = processedRedirect
.Results
.FirstOrDefault(x => x.Type == ResultTypes.UrlResponse);
Assert.IsNotNull(urlResponseResult);
Assert.AreEqual(
"http://www.test.local/url2",
urlResponseResult.Url);
}
public void DetectTooManyRedirects()
{
var configuration =
TestData.TestData.DefaultConfiguration;
var urlParser = new UrlParser();
var urlFormatter = new UrlFormatter();
var redirectParser = new RedirectParser(
configuration,
urlParser,
urlFormatter);
// create redirect processor
var redirectProcessor = new RedirectProcessor(
configuration,
new UrlHelper(
configuration,
urlParser,
urlFormatter),
new TestHttpClient(),
urlParser,
urlFormatter,
new RedirectHelper(
configuration,
urlParser,
urlFormatter));
// add redirects
var parsedRedirects = new List <IParsedRedirect>();
for (var i = 1; i <= configuration.MaxRedirectCount; i++)
{
var redirect = new Redirect
{
OldUrl = string.Format("/url{0}", i),
NewUrl = string.Format("/url{0}", i + 1)
};
parsedRedirects.Add(
redirectParser.ParseRedirect(
redirect));
}
// preload redirects
redirectProcessor.PreloadParsedRedirects(
parsedRedirects);
// process redirects using redirect processor
var processedRedirects = TestData.TestData.GetProcessedRedirects(
parsedRedirects,
new[] { redirectProcessor });
// verify processed redirects has too many redirects result
var redirectWithTooManyRedirects =
processedRedirects
.Where(pr => pr.Results.Any(r => r.Type.Equals(ResultTypes.TooManyRedirects)))
.ToList();
Assert.AreEqual(
1,
redirectWithTooManyRedirects.Count);
var redirectWithTooManyRedirect = redirectWithTooManyRedirects
.FirstOrDefault();
Assert.IsNotNull(redirectWithTooManyRedirect);
Assert.AreEqual(
"http://www.test.local/url1",
redirectWithTooManyRedirect.ParsedRedirect.OldUrl.Formatted);
Assert.AreEqual(
"http://www.test.local/url2",
redirectWithTooManyRedirect.ParsedRedirect.NewUrl.Formatted);
}
public void DetectOptimizedRedirect()
{
var configuration =
TestData.TestData.DefaultConfiguration;
var urlParser = new UrlParser();
var urlFormatter = new UrlFormatter();
var redirectParser = new RedirectParser(
configuration,
urlParser,
urlFormatter);
// create redirect processor
var redirectProcessor = new RedirectProcessor(
configuration,
new UrlHelper(
configuration,
urlParser,
urlFormatter),
new TestHttpClient(),
urlParser,
urlFormatter,
new RedirectHelper(
configuration,
urlParser,
urlFormatter));
// add redirects for optimizing
var redirect1 = new Redirect
{
OldUrl = "/optimize-url1",
NewUrl = "/optimize-url2"
};
var redirect2 = new Redirect
{
OldUrl = "/optimize-url2",
NewUrl = "/optimize-url3"
};
var parsedRedirects = new List <IParsedRedirect>();
foreach (var redirect in new[] { redirect1, redirect2 })
{
parsedRedirects.Add(
redirectParser.ParseRedirect(
redirect));
}
// preload redirects
redirectProcessor.PreloadParsedRedirects(
parsedRedirects);
// process redirects using redirect processor
var processedRedirects = TestData.TestData.GetProcessedRedirects(
parsedRedirects,
new[] { redirectProcessor });
// verify processed redirects has optimized redirect result
var optimizedRedirects =
processedRedirects
.Where(pr => pr.Results.Any(r => r.Type.Equals(ResultTypes.OptimizedRedirect)))
.ToList();
Assert.AreNotEqual(0, optimizedRedirects.Count);
var optimizedRedirect = optimizedRedirects
.FirstOrDefault(or => or.ParsedRedirect.OldUrl.Formatted.Equals("http://www.test.local/optimize-url1"));
Assert.IsNotNull(optimizedRedirect);
var optimizedRedirectResult = optimizedRedirect.Results
.FirstOrDefault(r => r.Type.Equals(ResultTypes.OptimizedRedirect) &&
r.Url != null && r.Url.Equals("http://www.test.local/optimize-url3"));
Assert.IsNotNull(optimizedRedirectResult);
}
public void DetectUrlResponse()
{
// create test http client
var testHttpClient = new TestHttpClient();
// parsed redirects
var parsedRedirects =
TestData.TestData.GetParsedRedirects();
// add moved response for parsed redirects
foreach (var redirect in parsedRedirects)
{
testHttpClient.Responses[
redirect.OldUrl.Formatted] = new HttpResponse
{
StatusCode = 301,
Headers = new Dictionary <string, string>
{
{ "Location", redirect.NewUrl.Formatted }
}
};
}
// override redirect old url with ok response
testHttpClient.Responses[
"http://www.test.local/new-url"] = new HttpResponse
{
StatusCode = 200
};
// create redirect processor
var configuration = new Configuration
{
DefaultUrl = TestData.TestData.DefaultHost,
ForceHttpHostPatterns = new[]
{
"www\\.test\\.local"
}
};
var urlParser = new UrlParser();
var urlFormatter = new UrlFormatter();
var redirectProcessor = new RedirectProcessor(
configuration,
new UrlHelper(
configuration,
urlParser,
urlFormatter),
testHttpClient,
urlParser,
urlFormatter,
new RedirectHelper(
configuration,
urlParser,
urlFormatter));
// preload redirects
redirectProcessor.PreloadParsedRedirects(
parsedRedirects);
// process redirects
var processedRedirects = TestData.TestData.GetProcessedRedirects(
parsedRedirects,
new[] { redirectProcessor });
// verify redirect processor detects overridden url with response
var urlResponse = redirectProcessor.Results
.FirstOrDefault(x => x.Type.Equals(ResultTypes.UrlResponse));
Assert.IsNotNull(urlResponse);
Assert.AreEqual(
"http://www.test.local/new-url",
urlResponse.Url);
}
public BaseController()
{
UrlFormatter = new UrlFormatter();
}
internal static void UpdateFromDictionary(this NameValueCollection queryString, Dictionary <string, object> queryStringUpdates, UrlFormatter provider)
{
if (queryString == null || queryString.Count < 0)
{
return;
}
if (queryStringUpdates == null || queryStringUpdates.Count < 0)
{
return;
}
foreach (var kv in queryStringUpdates.Where(kv => !kv.Key.IsNullOrEmpty()))
{
if (kv.Value == null)
{
queryString.Remove(kv.Key);
continue;
}
var resolved = provider.CreateString(kv.Value);
if (resolved != null)
{
queryString[kv.Key] = resolved;
}
else
{
queryString.Remove(kv.Key);
}
}
}
public void ReadConfigurationFile()
{
// write empty redirects csv files
var redirects1CsvFile = Path.Combine(
TestData.TestData.CurrentDirectory,
"redirects1.csv");
File.WriteAllText(
redirects1CsvFile,
string.Empty);
var redirects2CsvFile = Path.Combine(
TestData.TestData.CurrentDirectory,
"redirects2.csv");
File.WriteAllText(
redirects2CsvFile,
string.Empty);
// configuration json
var configurationJson = @"{{
mode: ""Export"",
redirectCsvFiles: [
""{0}"",
""{1}""
],
defaultUrl: ""http://www.oldurl.local"",
oldUrlExcludePatterns: [
""/oldurl-exclude""
],
newUrlExcludePatterns: [
""/newurl-exclude""
],
duplicateOldUrlStrategy: ""KeepLast"",
excludeOldUrlRootRedirects: ""True"",
useTestHttpClient: ""True"",
testHttpClientNewUrlStatusCode: ""200"",
forceHttpHostPatterns: [
""www\\.oldurl\\.local""
],
maxRedirectCount: ""50"",
sampleCount: ""100"",
exporter: ""WebConfig"",
httpClientTimeout: 600,
defaultRedirectType: ""Replace""
}}";
// write configuration file
var configurationFile =
Path.Combine(
TestData.TestData.CurrentDirectory,
"test_configuration.json");
File.WriteAllText(
configurationFile,
string.Format(
configurationJson,
redirects1CsvFile.Replace("\\", "\\\\"),
redirects2CsvFile.Replace("\\", "\\\\")));
IConfiguration configuration;
using (var configurationJsonReader = new ConfigurationJsonReader())
{
configuration = configurationJsonReader
.ReadConfiguationFile(configurationFile);
}
var urlFormatter = new UrlFormatter();
Assert.IsNotNull(configuration);
Assert.AreEqual(
Mode.Export,
configuration.Mode);
var redirectCsvFiles = configuration.RedirectCsvFiles.ToList();
Assert.AreEqual(2, redirectCsvFiles.Count);
Assert.AreEqual(
redirects1CsvFile,
redirectCsvFiles[0]);
Assert.AreEqual(
redirects2CsvFile,
redirectCsvFiles[1]);
Assert.AreEqual(
"http://www.oldurl.local/",
urlFormatter.Format(configuration.DefaultUrl));
Assert.AreEqual(
"/oldurl-exclude",
configuration.OldUrlExcludePatterns.FirstOrDefault());
Assert.AreEqual(
"/newurl-exclude",
configuration.NewUrlExcludePatterns.FirstOrDefault());
Assert.AreEqual(
DuplicateUrlStrategy.KeepLast,
configuration.DuplicateOldUrlStrategy);
Assert.AreEqual(
true,
configuration.ExcludeOldUrlRootRedirects);
Assert.AreEqual(
true,
configuration.UseTestHttpClient);
Assert.AreEqual(
200,
configuration.TestHttpClientNewUrlStatusCode);
Assert.AreEqual(
"www\\.oldurl\\.local",
configuration.ForceHttpHostPatterns.FirstOrDefault());
Assert.AreEqual(
50,
configuration.MaxRedirectCount);
Assert.AreEqual(
100,
configuration.SampleCount);
Assert.AreEqual(
"WebConfig",
configuration.Exporter);
Assert.AreEqual(
600,
configuration.HttpClientTimeout);
Assert.AreEqual(
RedirectType.Replace,
configuration.DefaultRedirectType);
}
private int GetJob()
{
var url = UrlFormatter.AddNameToRoot(JobApi, JobName);
return(_Client.Get <JobResource>(url).Result.ID);
}
private void SetImages(ProfileViewModel vm, bool hasCoverImage)
{
vm.ProfileImageUrl = UrlFormatter.ProfileImage(vm.UserId, vm.LastUpdateDate, 84);
vm.CoverImageUrl = UrlFormatter.ProfileCoverImage(vm.UserId, vm.Id, vm.LastUpdateDate, hasCoverImage, 1110);
}
private int GetSiteID()
{
var url = UrlFormatter.AddNameToRoot(SiteApi, SiteName);
return(_Client.Get <Identifiable>(url).Result.ID);
}
private void FormatExternalLinks(ProfileViewModel vm)
{
foreach (ExternalLinkBaseViewModel item in vm.ExternalLinks)
{
ExternalLinkInfoAttribute uiInfo = item.Provider.GetAttributeOfType <ExternalLinkInfoAttribute>();
item.Display = uiInfo.Display;
item.IconClass = uiInfo.Class;
item.ColorClass = uiInfo.ColorClass;
item.Order = uiInfo.Order;
switch (item.Provider)
{
case ExternalLinkProvider.Website:
item.Value = UrlFormatter.Website(item.Value);
break;
case ExternalLinkProvider.Facebook:
item.Value = UrlFormatter.Facebook(item.Value);
break;
case ExternalLinkProvider.Twitter:
item.Value = UrlFormatter.Twitter(item.Value);
break;
case ExternalLinkProvider.Instagram:
item.Value = UrlFormatter.Instagram(item.Value);
break;
case ExternalLinkProvider.Youtube:
item.Value = UrlFormatter.Youtube(item.Value);
break;
case ExternalLinkProvider.XboxLive:
item.Value = UrlFormatter.XboxLiveProfile(item.Value);
break;
case ExternalLinkProvider.PlaystationStore:
item.Value = UrlFormatter.PlayStationStoreProfile(item.Value);
break;
case ExternalLinkProvider.Steam:
item.Value = UrlFormatter.SteamGame(item.Value);
break;
case ExternalLinkProvider.GameJolt:
item.Value = UrlFormatter.GameJoltProfile(item.Value);
break;
case ExternalLinkProvider.ItchIo:
item.Value = UrlFormatter.ItchIoProfile(item.Value);
break;
case ExternalLinkProvider.GamedevNet:
item.Value = UrlFormatter.GamedevNetProfile(item.Value);
break;
case ExternalLinkProvider.IndieDb:
item.Value = UrlFormatter.IndieDbPofile(item.Value);
break;
case ExternalLinkProvider.UnityConnect:
item.Value = UrlFormatter.UnityConnectProfile(item.Value);
break;
case ExternalLinkProvider.GooglePlayStore:
item.Value = UrlFormatter.GooglePlayStoreProfile(item.Value);
break;
case ExternalLinkProvider.AppleAppStore:
item.Value = UrlFormatter.AppleAppStoreProfile(item.Value);
break;
case ExternalLinkProvider.IndiExpo:
item.Value = UrlFormatter.IndiExpoProfile(item.Value);
break;
case ExternalLinkProvider.Artstation:
item.Value = UrlFormatter.ArtstationProfile(item.Value);
break;
case ExternalLinkProvider.DeviantArt:
item.Value = UrlFormatter.DeviantArtProfile(item.Value);
break;
case ExternalLinkProvider.DevTo:
item.Value = UrlFormatter.DevToProfile(item.Value);
break;
case ExternalLinkProvider.GitHub:
item.Value = UrlFormatter.GitHubProfile(item.Value);
break;
case ExternalLinkProvider.HackerRank:
item.Value = UrlFormatter.HackerRankProfile(item.Value);
break;
case ExternalLinkProvider.LinkedIn:
item.Value = UrlFormatter.LinkedInProfile(item.Value);
break;
case ExternalLinkProvider.Patreon:
item.Value = UrlFormatter.PatreonProfile(item.Value);
break;
case ExternalLinkProvider.Medium:
item.Value = UrlFormatter.MediumProfile(item.Value);
break;
case ExternalLinkProvider.Discord:
item.Value = UrlFormatter.DiscordProfile(item.Value);
break;
}
}
}
private bool IsUrlLocal(ActionExecutingContext filterContext, string returnUrl)
{
var baseUrl = RequestUtils.GetBaseUrl(filterContext.HttpContext.Request).ToString();
return(UrlFormatter.IsReturnUrlValid(baseUrl, returnUrl));
}
private void SetImages(GameViewModel vm)
{
vm.ThumbnailUrl = string.IsNullOrWhiteSpace(vm.ThumbnailUrl) || Constants.DefaultGameThumbnail.NoExtension().Contains(vm.ThumbnailUrl.NoExtension()) ? Constants.DefaultGameThumbnail : UrlFormatter.Image(vm.UserId, ImageType.GameThumbnail, vm.ThumbnailUrl);
vm.CoverImageUrl = string.IsNullOrWhiteSpace(vm.CoverImageUrl) || Constants.DefaultGameCoverImage.Contains(vm.CoverImageUrl) ? Constants.DefaultGameCoverImage : UrlFormatter.Image(vm.UserId, ImageType.GameCover, vm.CoverImageUrl);
vm.AuthorPicture = UrlFormatter.ProfileImage(vm.UserId, 90);
}
public void BuildRedirectSummaryReport()
{
var oldUrlRaw = "http://www.test.local/old";
var newUrlRaw = "http://www.test.local/new";
var oldUrlParsed = new Uri(oldUrlRaw);
var newUrlParsed = new Uri(newUrlRaw);
var parsedRedirect = TestData.TestData.GetParsedRedirects(
new[]
{
new Redirect
{
OldUrl = "http://www.test.local/old",
NewUrl = "http://www.test.local/new"
}
})
.FirstOrDefault();
var redirectProcessingResult = new RedirectProcessingResult
{
ProcessedRedirects = new[]
{
new ProcessedRedirect
{
ParsedRedirect = parsedRedirect,
Results = new []
{
new Result
{
Type = ResultTypes.ExcludedRedirect,
Message = ResultTypes.ExcludedRedirect,
Url = newUrlRaw
},
new Result
{
Type = ResultTypes.DuplicateOfFirst,
Message = ResultTypes.DuplicateOfFirst,
Url = newUrlRaw
},
new Result
{
Type = ResultTypes.DuplicateOfLast,
Message = ResultTypes.DuplicateOfLast,
Url = newUrlRaw
}
}
}
}
};
// create and build redirect summary report
var configuration =
TestData.TestData.DefaultConfiguration;
var urlFormatter = new UrlFormatter();
var urlParser = new UrlParser();
var urlHelper = new UrlHelper(
configuration,
urlParser,
urlFormatter);
var redirectSummaryReport = new RedirectSummaryReport(
new ProcessedRedirectValidator(
configuration,
urlHelper));
redirectSummaryReport.Build(redirectProcessingResult);
// verify redirect summary records are build
var records = redirectSummaryReport
.GetRecords()
.ToList();
Assert.AreNotEqual(0, records.Count);
}
