public ClientApi(string zapAddress, int zapPort)
{
this.zapAddress = zapAddress;
this.zapPort = zapPort;
webClient = new SystemWebClient(zapAddress, zapPort);
InitializeApiObjects();
}
public TwitterAccountProvider(IWebClient webClient, UserCredential userCredential)
:base(webClient)
{
if (userCredential.AccessToken == null)
{
throw new ArgumentException("TwitterAccountProvider didn't receive AccessToken");
}
if (userCredential.AccessTokenSecret == null)
{
throw new ArgumentException("TwitterAccountProvider didn't receive AccessTokenSecret");
}
if (userCredential.ConsumerKey == null)
{
throw new ArgumentException("TwitterAccountProvider didn't receive ConsumerKey");
}
if (userCredential.ConsumerSecret == null)
{
throw new ArgumentException("TwitterAccountProvider didn't receive ConsumerSecret");
}
_accessToken = userCredential.AccessToken;
_accessTokenSecret = userCredential.AccessTokenSecret;
_consumerKey = userCredential.ConsumerKey;
_consumerSecret = userCredential.ConsumerSecret;
}
public void SetUp()
{
// Query to VK api
UserInfoUrl = String.Format(
@"https://api.vk.com/method/users.get?user_id={0}&fields=screen_name,bdate,sex,city,country,photo_max_orig,timezone&v=5.23&access_token={1}",
UserId,
AccessToken);
// Object that we will make Json
_vkUserData = new VkUserData.VkResponse
{
Response = new List<VkUserData>
{
new VkUserData
{
FirstName = "Beseda",
LastName = "Dmitrij",
ScreenName = "Beseda Dmitrij",
Sex = VkUserData.VkSex.Male,
Birthday = "12/1/1992",
City = new VkUserData.VkCity {Id = 1, Title = "Donetsk"},
Country = new VkUserData.VkCountry {Id = 1, Title = "Ukraine"},
Timezone = 2,
Photo = "photo.jpg",
Email = Email
}
}
};
// Make Json
_userToJson = JsonConvert.SerializeObject(_vkUserData);
_webRequest = Substitute.For<IWebClient>();
_webRequest.GetWebData(UserInfoUrl).Returns(Task.FromResult(_userToJson));
}
async Task TryDownloadAsync(TransferSpec spec, IWebClient webClient, IAbsoluteFilePath tmpFile) {
try {
tmpFile.RemoveReadonlyWhenExists();
if (!string.IsNullOrWhiteSpace(spec.Uri.UserInfo))
webClient.SetAuthInfo(spec.Uri);
using (webClient.HandleCancellationToken(spec))
await webClient.DownloadFileTaskAsync(spec.Uri, tmpFile.ToString()).ConfigureAwait(false);
VerifyIfNeeded(spec, tmpFile);
_fileOps.Move(tmpFile, spec.LocalFile);
} catch (OperationCanceledException e) {
_fileOps.DeleteIfExists(tmpFile.ToString());
throw CreateTimeoutException(spec, e);
} catch (WebException ex) {
_fileOps.DeleteIfExists(tmpFile.ToString());
var cancelledEx = ex.InnerException as OperationCanceledException;
if (cancelledEx != null)
throw CreateTimeoutException(spec, cancelledEx);
if (ex.Status == WebExceptionStatus.RequestCanceled)
throw CreateTimeoutException(spec, ex);
var response = ex.Response as HttpWebResponse;
if (response == null)
throw GenerateDownloadException(spec, ex);
switch (response.StatusCode) {
case HttpStatusCode.NotFound:
throw new RequestFailedException("Received a 404: NotFound response", ex);
case HttpStatusCode.Forbidden:
throw new RequestFailedException("Received a 403: Forbidden response", ex);
case HttpStatusCode.Unauthorized:
throw new RequestFailedException("Received a 401: Unauthorized response", ex);
}
throw GenerateDownloadException(spec, ex);
}
}
public JobDispatcher(IJobStore jobStore)
{
if (jobStore == null)
throw new ArgumentNullException(nameof(jobStore));
this.jobStore = jobStore;
this.webClient = new HttpWebClient();
}
public void Setup()
{
// Query to facebook api
UserInfoUrl = String.Format(@"https://graph.facebook.com/v2.0/me?access_token={0}&fields=id,first_name,last_name,name,gender,email,birthday,timezone,location,picture.type(large)",
AccessToken);
// Object that we will make Json
_fbUserData = new FacebookUserData
{
Id = "12345",
FirstName = "Beseda",
LastName = "Dmitrij",
Name = "Beseda Dmitrij",
Gender = "male",
Email = "*****@*****.**",
Birthday = "12/1/1992",
Timqzone = 2,
Location = new FacebookUserData.FbLocation() {Id = "1", Name = "Donetsk, Ukraine"},
Picture = new FacebookUserData.FbPicture()
{
Data = new FacebookUserData.Data
{
Url = "photo.jpg"
}
},
};
_userToJson = JsonConvert.SerializeObject(_fbUserData);
_webRequest = Substitute.For<IWebClient>();
_webRequest.GetWebData(UserInfoUrl).Returns(Task.FromResult(_userToJson));
}
public RssPlugin(IBitTorrentEngine torrentEngine, IDataRepository dataRepository, ITimerFactory timerFactory, IWebClient webClient)
{
_torrentEngine = torrentEngine;
_dataRepository = dataRepository;
_timer = timerFactory.CreateTimer();
_webClient = webClient;
}
public void Setup()
{
client = Substitute.For<IWebClient>();
client.Download().Returns(downloadStringResult);
target = new WebRequestBuilder(client);
}
public void SetUp()
{
_mockWebClient = MockRepository.GenerateStub<IWebClient>();
var uri = new Uri("http://valid");
_uri = uri.ToString();
_resolver = new HttpProjectXmlResolver(uri) { WebClient = _mockWebClient };
}
/// <summary>
/// Initializes a new instance of the <see cref="HtmlForm"/> class.
/// </summary>
/// <param name="webClient">Contains the web client to be used to request and submit the form.</param>
protected HtmlForm( IWebClient webClient )
{
WebClient = webClient;
Attributes = new Dictionary<string, string>( StringComparer.OrdinalIgnoreCase );
Controls = new List<HtmlFormControl>();
}
public static new void ResetTestState()
{
base_context.ResetTestState();
Page = null;
Uri = null;
WebClient = null;
}
public CypherClientFactory(string baseUri, IWebClient webClient, IWebSerializer serializer, IEntityCache entityCache)
{
this._baseUri = baseUri;
this._webClient = webClient;
this._serializer = serializer;
this._entityCache = entityCache;
}
public void ApplyConstraint(IWebClient client)
{
foreach (var constraint in Constraints)
{
constraint.ApplyConstraint(client);
}
}
public void Setup()
{
client = Substitute.For<IWebClient>();
client.Headers.Returns(new WebHeaderCollection());
target = new WebServiceBuilder(client);
}
public WebQueueValidator(Uri managementUri, IWebTokenProvider tokenProvider, IWebClient webClient)
{
_managementUri = managementUri;
_webClient = webClient;
_requestFactory = new WebRequestFactory(tokenProvider);
_uriCreator = new UriCreator(managementUri);
}
public ServiceBusClient(Uri address, IWebTokenProvider tokenManager, IWebClient webClient)
{
_address = address;
_tokenManager = tokenManager;
_webClient = webClient;
_webRequestFactory = new WebRequestFactory(tokenManager);
_serializer = new MessageSerializer();
}
public BuildDataFetcher(ViewUrl viewUrl, IConfigSettings configSettings,
IWebClientFactory webClientFactory)
{
_viewUrl = viewUrl;
_webClientFactory = webClientFactory;
_webClient = webClientFactory.GetWebClient(configSettings.URL);
configSettings.AddObserver(this);
}
public BurritoDayModel(IFiber fiber, IWebClient client)
{
this.fiber = fiber;
this.client = client;
this.fiber.ScheduleOnInterval(this.PollState, 0,
(long)this.interval.TotalMilliseconds);
}
public EpisodeDownloader(ITvService service, ISearchProvider searchProvider, IWebClient webClient, TorrentSearchSettings settings, IAnalyticsService analyticsService)
{
_service = service;
_searchProvider = searchProvider;
_webClient = webClient;
_settings = settings;
_analyticsService = analyticsService;
}
public BuildDataFetcher(CruiseAddress cruiseAddress, IConfigSettings configSettings,
IWebClientFactory webClientFactory)
{
_cruiseAddress = cruiseAddress;
_webClientFactory = webClientFactory;
_webClient = webClientFactory.GetWebClient(configSettings.URL);
configSettings.AddObserver(this);
}
public JiraClient(IWebClient webClient, Func<IJiraRequestUrlBuilder> builderFactory)
{
ArgumentUtility.CheckNotNull ("webClient", webClient);
ArgumentUtility.CheckNotNull ("builderFactory", builderFactory);
_webClient = webClient;
_builderFactory = builderFactory;
}
public KickassSearchProvider(ISearchProvider nextProvider, IWebClient webClient, IAnalyticsService analyticsService)
{
if(nextProvider == null)
throw new ArgumentNullException(nameof(nextProvider), "nextProvider Cannot be null");
NextSearchProvider = nextProvider;
_webClient = webClient;
_analyticsService = analyticsService;
}
public CustomMembershipProvider()
{
_virtualOfficeService = new VirtualOfficeService();
var resolver = DependencyResolver.Current;
_webClient = (IWebClient)resolver.GetService(typeof(IWebClient));
_apiKey = "abc";
_apiSecret = "asdfasdfadfa";
}
public void ApplyConstraint(IWebClient client)
{
client.Headers[Headers.UserAgent] = userAgent;
var dateTime = DateTime.UtcNow.ToString("yyyyMMddHHmmssff");
var signature = BuildSignature(accessId, userAgent, dateTime, secretKey);
client.Headers[Headers.Signature] = accessId + ":" + dateTime + ":" + signature;
}
public BaseSpaceClient(IClientSettings settings, IWebClient client, IRequestOptions defaultOptions = null)
{
if (settings == null || client == null)
{
throw new ArgumentNullException("settings");
}
ClientSettings = settings;
WebClient = client;
SetDefaultRequestOptions(defaultOptions);
}
public void HandleAuthInfo(Uri uri, IWebClient client) {
var authInfo = GetAuthInfoFromUriWithCache(uri);
if (authInfo.Username == null && authInfo.Password == null) {
client.Credentials = null;
return;
}
_storage.SetAuthInfo(uri, authInfo);
client.Credentials = new NetworkCredential(authInfo.Username, authInfo.Password);
}
public FacebookAccountProvider(IWebClient webClient, UserCredential userCredential)
:base(webClient)
{
if (userCredential.AccessToken == null)
{
throw new ArgumentException("FacebookAccountProvider didn't receive accessToken");
}
var accessToken = userCredential.AccessToken;
UserInfoUrl = String.Format(@"https://graph.facebook.com/v2.0/me?access_token={0}&fields=id,first_name,last_name,name,gender,email,birthday,timezone,location,picture.type(large)",
accessToken);
}
public void Setup()
{
_user = new TwitterUser
{
Name = "Azimuth Project",
Location = "Donetsk, Ukraine",
ScreenName = "AzimuthP",
ProfileImageUrl = "photo.jpg"
};
_webClient = Substitute.For<IWebClient>();
_webClient.GetWebData(ConsumerKey, ConsumerSecret, AccessToken, AccessSecret).Returns(Task.FromResult(_user));
}
public VideoStreamingService(ICameraController cameraController, IImageEncoder imageEncoder,
IModuleConfiguration moduleConfiguration, IWebClient webClient)
{
encoder = imageEncoder;
SendImage += OnSendImage;
client = webClient;
controller = cameraController;
configuration = moduleConfiguration;
configuration.StreamingValueChanged += OnStreamingValueChanged;
configuration.CurrentVideoSizeChanged += OnCurrentVideoSizeChanged;
}
public RequestDispatcher(ClientTypeMapper typeMapper,
IWebClient webClient,
ITextSerializerFactory serializerFactory,
IEnumerable<KeyValuePair<string, IEnumerable<string>>> defaultHeaders = null)
{
this.defaultHeaders = defaultHeaders;
if (typeMapper != null)
this.typeMapper = typeMapper;
if (webClient != null)
WebClient = webClient;
if (serializerFactory != null)
this.serializerFactory = serializerFactory;
}
public PlaylistUrlResolver(IWebClient webClient)
{
_webClient = webClient;
}
public MangaKakalotRepository(IWebClient webClient) : base(webClient, "MangaKakalot", RepoRootUriString, "MangaKakalot.png", $"{RepoRootUriString}page", $"{RepoRootUriString}home_json_search")
{
}
/// <summary>
/// The dispose, clears the webclient, forcing it to be set for the next execute even if still in memory.
/// </summary>
private void Dispose()
{
WebClient = null;
}
/// <summary>
/// create an instance of AlphaVantage
/// </summary>
/// <param name="webClient">client to use for web access</param>
public AlphaVantage(IWebClient webClient)
{
this.webClient = webClient;
LoadAPIKey();
}
public MangaEdenEnRepository(IWebClient webClient) : base(webClient, "Manga Eden (EN)", "en/en-directory/", " - EN")
{
}
internal LatestStatusEndpoints(string userAgent, IWebClient webClient, bool testing = false)
{
_internalLatestStatus = new InternalLatestStatus(webClient, userAgent, testing);
}
public DotaWebApi(IWebClient webClient)
{
this.webClient = webClient;
}
public BaseIndexer(string name, string link, string description, IIndexerManagerService manager, IWebClient client, Logger logger, ConfigurationData configData, IProtectionService p, TorznabCapabilities caps = null, string downloadBase = null)
{
if (!link.EndsWith("/"))
{
throw new Exception("Site link must end with a slash.");
}
DisplayName = name;
DisplayDescription = description;
SiteLink = link;
this.logger = logger;
indexerService = manager;
webclient = client;
protectionService = p;
this.downloadUrlBase = downloadBase;
this.configData = configData;
if (caps == null)
{
caps = TorznabUtil.CreateDefaultTorznabTVCaps();
}
TorznabCaps = caps;
}
public MangaNelRepository(IWebClient webClient) : base(webClient, "Manga NEL", RepoRootUriString, "MangaNel.png", RepoRootUriString, $"{RepoRootUriString}home_json_search")
{
}
// minimal constructor used by e.g. cardigann generic indexer
protected BaseWebIndexer(IIndexerConfigurationService configService, IWebClient client, Logger logger, IProtectionService p)
: base("", "/", "", configService, logger, null, p)
{
this.webclient = client;
}
protected BaseCachingWebIndexer(string name, string link, string description, IIndexerConfigurationService configService, IWebClient client, Logger logger, ConfigurationData configData, IProtectionService p, TorznabCapabilities caps = null, string downloadBase = null)
: base(name, link, description, configService, client, logger, configData, p, caps, downloadBase)
{
}
protected BaseWebIndexer(string name, string link, string description, IIndexerConfigurationService configService, IWebClient client, Logger logger, ConfigurationData configData, IProtectionService p, TorznabCapabilities caps = null, string downloadBase = null)
: base(name, link, description, configService, logger, configData, p)
{
this.webclient = client;
this.downloadUrlBase = downloadBase;
if (caps == null)
{
caps = TorznabUtil.CreateDefaultTorznabTVCaps();
}
TorznabCaps = caps;
}
public BlizzardApiReader(IOptions <BlizzardApiConfiguration> apiConfiguration, IWebClient webClient)
{
_config = apiConfiguration?.Value ?? throw new ArgumentNullException(nameof(apiConfiguration));
_webClient = webClient ?? throw new ArgumentNullException(nameof(webClient));
}
public MangaStreamRepository(IWebClient webClient) : base(webClient, "Mangastream", "https://www.mangastream.cc/", "MangaStream.png", false)
{
MangaIndexUri = new Uri(RootUri, "all-manga/");
SearchUri = new Uri(RootUri, "wp-admin/admin-ajax.php");
}
public TypiCodeClient(ITypiCodeConnectionSettings connectionSettings, IWebClient webClient, IJsonDeserializer jsonDeserializer)
{
_connectionSettings = connectionSettings;
_webClient = webClient;
_jsonDeserializer = jsonDeserializer;
}
internal RequestEngine(PrtgClient prtgClient, IWebClient webClient)
{
this.prtgClient = prtgClient;
this.webClient = webClient;
}
protected MangaNelLikeRepository(IWebClient webClient, string name, string uriString, string iconFileName, string featuredSeriesPageUri, string searchUriPattern) : base(webClient, name, uriString, iconFileName, true)
{
FeaturedSeriesPageUri = new Uri(featuredSeriesPageUri, UriKind.Absolute);
SearchUriPattern = searchUriPattern;
ReadUriPattern = $"{RootUri.ToString()}manga/{{0}}";
}
public void Run(IWebClient client)
{
Console.WriteLine("==> Demo - 通过图片Url进行图像搜索 <==");
Console.WriteLine("See https://api-doc.productai.cn/doc/pai.html#通用图像搜索 for details.\r\n");
//复杂Tag查询示例
ISearchTag andTag = new AndTag();
andTag.Add("上衣");
andTag.Add(new List <string> {
"圆领", "无袖"
});
ISearchTag orTag = new OrTag();
orTag.Add("蓝色");
orTag.Add("休闲");
andTag.Add(orTag);
ITag searchTag = new SearchTag
{
Tag = andTag
};
var request = new ImageSearchByImageUrlRequest("k7h9fail")
{
Url = "http://static.esobing.com/images/dog.jpg",
Language = LanguageType.Chinese,
SearchTag = searchTag
};
// you can pass the extra paras to the request
// 如果不需要传递额外的参数，请注释掉如下3行
request.Options.Add("para1", "1");
request.Options.Add("para2", "中文");
request.Options.Add("para3", "value3");
try
{
var response = client.GetResponse(request);
Console.WriteLine("==========================Result==========================");
foreach (var r in response.Results)
{
Console.WriteLine("{0}\t\t{1}", r.Url, r.Score);
}
Console.WriteLine("==========================Result==========================");
}
catch (ServerException ex)
{
Console.WriteLine("ServerException happened: \r\n\tErrorCode: {0}\r\n\tErrorMessage: {1}",
ex.ErrorCode,
ex.ErrorMessage);
}
catch (ClientException ex)
{
Console.WriteLine("ClientException happened: \r\n\tRequestId: {0}\r\n\tErrorCode: {1}\r\n\tErrorMessage: {2}",
ex.RequestId,
ex.ErrorCode,
ex.ErrorMessage);
}
catch (Exception ex)
{
Console.WriteLine("Unknown Exception happened: {0}\r\n{1}", ex.Message, ex.StackTrace);
}
}
public StockProcessor(IWebClient webClient)
{
_webClient = webClient;
}
public AlbumClient(ITypiCodeConnectionSettings connectionSettings, IWebClient webClient, IJsonDeserializer jsonDeserializer)
: base(connectionSettings, webClient, jsonDeserializer)
{
}
public XSpeeds(IIndexerManagerService i, IWebClient wc, Logger l, IProtectionService ps)
: base(name: "XSpeeds",
description: "XSpeeds",
link: "https://www.xspeeds.eu/",
caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
manager: i,
client: wc,
logger: l,
p: ps,
configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
{
Encoding = Encoding.GetEncoding("UTF-8");
Language = "en-us";
configData.DisplayText.Value = "Expect an initial delay (often around 10 seconds) due to XSpeeds CloudFlare DDoS protection";
configData.DisplayText.Name = "Notice";
AddCategoryMapping(70, TorznabCatType.TVAnime); // Anime
AddCategoryMapping(4, TorznabCatType.PC); // Apps
AddCategoryMapping(82, TorznabCatType.PCMac); // Mac
AddCategoryMapping(80, TorznabCatType.AudioAudiobook); // Audiobooks
AddCategoryMapping(66, TorznabCatType.MoviesBluRay); // Blu-Ray
AddCategoryMapping(48, TorznabCatType.Books); // Books Magazines
AddCategoryMapping(68, TorznabCatType.MoviesOther); // Cams/TS
AddCategoryMapping(65, TorznabCatType.TVDocumentary); // Documentaries
AddCategoryMapping(10, TorznabCatType.MoviesDVD); // DVDR
AddCategoryMapping(72, TorznabCatType.MoviesForeign); // Foreign
AddCategoryMapping(74, TorznabCatType.TVOTHER); // Kids
AddCategoryMapping(44, TorznabCatType.TVSport); // MMA
AddCategoryMapping(11, TorznabCatType.Movies); // Movie Boxsets
AddCategoryMapping(12, TorznabCatType.Movies); // Movies
AddCategoryMapping(13, TorznabCatType.Audio); // Music
AddCategoryMapping(15, TorznabCatType.AudioVideo); // Music Videos
AddCategoryMapping(32, TorznabCatType.ConsoleNDS); // NDS Games
AddCategoryMapping(9, TorznabCatType.Other); // Other
AddCategoryMapping(6, TorznabCatType.PCGames); // PC Games
AddCategoryMapping(45, TorznabCatType.Other); // Pictures
AddCategoryMapping(31, TorznabCatType.ConsolePS4); // Playstation
AddCategoryMapping(71, TorznabCatType.TV); // PPV
AddCategoryMapping(54, TorznabCatType.TV); // Soaps
AddCategoryMapping(20, TorznabCatType.TVSport); // Sports
AddCategoryMapping(86, TorznabCatType.TVSport); // MotorSports
AddCategoryMapping(89, TorznabCatType.TVSport); // Olympics 2016
AddCategoryMapping(88, TorznabCatType.TVSport); // World Cup
AddCategoryMapping(83, TorznabCatType.Movies); // TOTM
AddCategoryMapping(21, TorznabCatType.TVSD); // TV Boxsets
AddCategoryMapping(76, TorznabCatType.TVHD); // HD Boxsets
AddCategoryMapping(47, TorznabCatType.TVHD); // TV-HD
AddCategoryMapping(16, TorznabCatType.TVSD); // TV-SD
AddCategoryMapping(7, TorznabCatType.ConsoleWii); // Wii Games
AddCategoryMapping(43, TorznabCatType.TVSport); // Wrestling
AddCategoryMapping(8, TorznabCatType.ConsoleXbox); // Xbox Games
// RSS Textual categories
AddCategoryMapping("Anime", TorznabCatType.TVAnime);
AddCategoryMapping("Apps", TorznabCatType.PC);
AddCategoryMapping("Mac", TorznabCatType.PCMac);
AddCategoryMapping("Audiobooks", TorznabCatType.AudioAudiobook);
AddCategoryMapping("Blu-Ray", TorznabCatType.MoviesBluRay);
AddCategoryMapping("Books Magazines", TorznabCatType.Books);
AddCategoryMapping("Cams/TS", TorznabCatType.MoviesOther);
AddCategoryMapping("Documentaries", TorznabCatType.TVDocumentary);
AddCategoryMapping("DVDR", TorznabCatType.MoviesDVD);
AddCategoryMapping("Foreign", TorznabCatType.MoviesForeign);
AddCategoryMapping("Kids", TorznabCatType.TVOTHER);
AddCategoryMapping("MMA", TorznabCatType.TVSport);
AddCategoryMapping("Movie Boxsets", TorznabCatType.Movies);
AddCategoryMapping("Movies", TorznabCatType.Movies);
AddCategoryMapping("Music", TorznabCatType.Audio);
AddCategoryMapping("Music Videos", TorznabCatType.AudioVideo);
AddCategoryMapping("NDS Games", TorznabCatType.ConsoleNDS);
AddCategoryMapping("Other", TorznabCatType.Other);
AddCategoryMapping("PC Games", TorznabCatType.PCGames);
AddCategoryMapping("Pictures", TorznabCatType.Other);
AddCategoryMapping("Playstation", TorznabCatType.ConsolePS4);
AddCategoryMapping("PPV", TorznabCatType.TV);
AddCategoryMapping("Soaps", TorznabCatType.TV);
AddCategoryMapping("Sports", TorznabCatType.TVSport);
AddCategoryMapping("MotorSports", TorznabCatType.TVSport);
AddCategoryMapping("Olympics 2016", TorznabCatType.TVSport);
AddCategoryMapping("World Cup", TorznabCatType.TVSport);
AddCategoryMapping("TOTM", TorznabCatType.Movies);
AddCategoryMapping("TV Boxsets", TorznabCatType.TVSD);
AddCategoryMapping("HD Boxsets", TorznabCatType.TVHD);
AddCategoryMapping("TV-HD", TorznabCatType.TVHD);
AddCategoryMapping("TV-SD", TorznabCatType.TVSD);
AddCategoryMapping("Wii Games", TorznabCatType.ConsoleWii);
AddCategoryMapping("Wrestling", TorznabCatType.TVSport);
AddCategoryMapping("Xbox Games", TorznabCatType.ConsoleXbox);
}
public T411(IIndexerManagerService i, Logger l, IWebClient wc, IProtectionService ps)
: base(name: "T411",
description: "French Torrent Tracker",
link: "https://t411.ai/",
caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
manager: i,
client: wc,
logger: l,
p: ps,
configData: new ConfigurationDataLoginTokin())
{
Encoding = Encoding.UTF8;
Type = "semi-private";
Language = "fr-fr";
// 210, FilmVidéo
AddCategoryMapping(402, TorznabCatType.Movies, "Vidéoclips");
AddCategoryMapping(433, TorznabCatType.TV, "Série TV");
AddCategoryMapping(455, TorznabCatType.TVAnime, "Animation");
AddCategoryMapping(631, TorznabCatType.Movies, "Film");
AddCategoryMapping(633, TorznabCatType.Movies, "Concert");
AddCategoryMapping(634, TorznabCatType.TVDocumentary, "Documentaire");
AddCategoryMapping(635, TorznabCatType.TV, "Spectacle");
AddCategoryMapping(636, TorznabCatType.TVSport, "Sport");
AddCategoryMapping(637, TorznabCatType.TVAnime, "Animation Série");
AddCategoryMapping(639, TorznabCatType.TV, "Emission TV");
// 233, Application
AddCategoryMapping(234, TorznabCatType.PC0day, "Linux");
AddCategoryMapping(235, TorznabCatType.PCMac, "MacOS");
AddCategoryMapping(236, TorznabCatType.PC0day, "Windows");
AddCategoryMapping(625, TorznabCatType.PCPhoneOther, "Smartphone");
AddCategoryMapping(627, TorznabCatType.PCPhoneOther, "Tablette");
AddCategoryMapping(629, TorznabCatType.PC, "Autre");
AddCategoryMapping(638, TorznabCatType.PC, "Formation");
// 340, Emulation
AddCategoryMapping(342, TorznabCatType.ConsoleOther, "Emulateurs");
AddCategoryMapping(344, TorznabCatType.ConsoleOther, "Roms");
// undefined
AddCategoryMapping(389, TorznabCatType.ConsoleOther, "Jeux vidéo");
// 392, GPS
AddCategoryMapping(391, TorznabCatType.PC0day, "Applications");
AddCategoryMapping(393, TorznabCatType.PC0day, "Cartes");
AddCategoryMapping(394, TorznabCatType.PC0day, "Divers");
// 395, Audio
AddCategoryMapping(400, TorznabCatType.Audio, "Karaoke");
AddCategoryMapping(403, TorznabCatType.Audio, "Samples");
AddCategoryMapping(623, TorznabCatType.Audio, "Musique");
AddCategoryMapping(642, TorznabCatType.Audio, "Podcast Radio");
// 404, eBook
AddCategoryMapping(405, TorznabCatType.Books, "Audio");
AddCategoryMapping(406, TorznabCatType.Books, "Bds");
AddCategoryMapping(407, TorznabCatType.Books, "Comics");
AddCategoryMapping(408, TorznabCatType.Books, "Livres");
AddCategoryMapping(409, TorznabCatType.Books, "Mangas");
AddCategoryMapping(410, TorznabCatType.Books, "Presse");
// 456, xXx
AddCategoryMapping(461, TorznabCatType.XXX, "eBooks");
AddCategoryMapping(462, TorznabCatType.XXX, "Jeux vidéo");
AddCategoryMapping(632, TorznabCatType.XXX, "Video");
AddCategoryMapping(641, TorznabCatType.XXX, "Animation");
// 624, Jeu vidéo
AddCategoryMapping(239, TorznabCatType.PCGames, "Linux");
AddCategoryMapping(245, TorznabCatType.PCMac, "MacOS");
AddCategoryMapping(246, TorznabCatType.PCGames, "Windows");
AddCategoryMapping(307, TorznabCatType.ConsoleNDS, "Nintendo");
AddCategoryMapping(308, TorznabCatType.ConsolePS4, "Sony");
AddCategoryMapping(309, TorznabCatType.ConsoleXbox, "Microsoft");
AddCategoryMapping(626, TorznabCatType.PCPhoneOther, "Smartphone");
AddCategoryMapping(628, TorznabCatType.PCPhoneOther, "Tablette");
AddCategoryMapping(630, TorznabCatType.ConsoleOther, "Autre");
}
public MembersRepository(IWebClient webClient, IAuthenticationService authenticationService, IAppSettings appSettings)
{
_webClient = webClient;
_authenticationService = authenticationService;
_appSettings = appSettings;
}
public EventFetcher(IWebClient webClient)
{
this.webClient = webClient;
}
public WebClient(IWebClient iwb)
{
IWb = iwb;
}
public BraintreeLocalPaymentService(IClientTokenGateway clientTokenGateway, HttpClient httpClient, IWebClient webClient)
{
this.clientTokenGateway = clientTokenGateway;
this.httpClient = httpClient;
this.webClient = webClient;
}
public MangaDexRepository(IWebClient webClient) : base(webClient, "MangaDex", "https://mangadex.org/", "MangaDex.png", true, true, false, true, true)
{
}
public MangaBatRepository(IWebClient webClient) : base(webClient, "MangaBat", RepoRootUriString, "MangaBat.png", $"{RepoRootUriString}web", $"{RepoRootUriString}getsearchstory")
{
}
public MangaEdenItRepository(IWebClient webClient) : base(webClient, "Manga Eden (IT)", "en/it-directory/", " - IT")
{
}
protected MangaEdenRepository(IWebClient webClient, string name, string mangaIndexUri, string searchLabelLanguageSuffix) : base(webClient, name, "http://www.mangaeden.com/", "MangaEden.png", false, true, true, true, true)
{
MangaIndexUri = new Uri(RootUri, mangaIndexUri);
SearchLabelLanguageSuffix = searchLabelLanguageSuffix;
}
