public ShortUrl Execute(ShortUrl entity) { entity.LastUsage = DateTime.Now; entity.UsageCount = ++entity.UsageCount; return(entity); }
public void ShouldAddNewShortUrlEntityFromEmptyCode() { var urlShortenDto = new ShortUrlDto { Url = "www.example.com" }; var urlShorten = new ShortUrl { Code = "Code1", Url = "www.example.com" }; creatorService.Setup(x => x.Execute(urlShortenDto)) .Returns(urlShorten); var service = new UrlShortenerService(repository.Object, new GenerateCodeCommand(), creatorService.Object, new ShortenUrlUsageCommand(), mapper.Object); var result = service.Add(urlShortenDto); repository.Verify(x => x.Add(It.IsAny <ShortUrl>()), Times.Once); Assert.False(string.IsNullOrEmpty(result.Code)); Assert.False(string.IsNullOrEmpty(urlShortenDto.Code)); }
public bool Exists(ShortUrl candidate) { var count = _dbContext.ShortUrls .CountDocuments(url => url.Id == candidate.Id); return(count > 0); }
public void ShouldThrowExceptionWhenNotFoundAEntityByCode() { var code = "Code1"; var urlShortenDto = new ShortUrlDto { Code = "Code1", Url = "www.example.com" }; var urlShorten = new ShortUrl { Code = "Code1", Url = "www.example.com" }; creatorService.Setup(x => x.Execute(urlShortenDto)) .Returns(urlShorten); var list = new List <ShortUrl>(); var task = Task.FromResult <IList <ShortUrl> >(list); repository.Setup(x => x.ListAsync(It.IsAny <Expression <Func <ShortUrl, bool> > >())) .Returns(task); var service = new UrlShortenerService(repository.Object, new GenerateCodeCommand(), creatorService.Object, new ShortenUrlUsageCommand(), mapper.Object); Assert.ThrowsAsync <NotFoundException>(() => service.GetUrlByCode(code)); }
public async Task <string> CreateShortUrlForUser(Guid userId, string url) { var isExistUser = await ShortenURlDbContext.UserUrl.FirstOrDefaultAsync(c => c.UserId == userId); var shortUrl = createShortUrlService.MakeShortURL(); var newShortUrl = new ShortUrl() { ShortUrlString = shortUrl, Url = url }; if (isExistUser != null) { isExistUser.ShortUrls.Add(newShortUrl); await ShortenURlDbContext.SaveChangesAsync(); } else { var newUserUrl = new UserUrl() { UserId = userId }; newUserUrl.ShortUrls.Add(newShortUrl); ShortenURlDbContext.UserUrl.Add(newUserUrl); await ShortenURlDbContext.SaveChangesAsync(); } return(shortUrl); }
public async Task <string> CreateShortUrlForIp(string userIp, string url) { var isExistUserIp = await ShortenURlDbContext.UserIp.FirstOrDefaultAsync(c => c.Ip == userIp); var shortUrl = createShortUrlService.MakeShortURL(); var newShortUrl = new ShortUrl() { ShortUrlString = shortUrl, Url = url }; if (isExistUserIp != null) { isExistUserIp.ShortUrls.Add(newShortUrl); await ShortenURlDbContext.SaveChangesAsync(); } else { var newUserIp = new UserIp() { Ip = userIp, }; newUserIp.ShortUrls.Add(newShortUrl); ShortenURlDbContext.UserIp.Add(newUserIp); await ShortenURlDbContext.SaveChangesAsync(); } return(shortUrl); }
public ActionResult NewProgram(Program newProgram) { if (string.IsNullOrWhiteSpace(newProgram.Email)) { return(Json(new { success = false })); } newProgram.ShortUrl = ShortUrl.Create(); newProgram.Created = DateTime.Now; Ownership.Assign(newProgram, this); if (!LoggedInUser.OnboardingTasks.Contains(OnboardingTask.CreatedProgram.ToString())) { LoggedInUser.OnboardingTasks.Add(OnboardingTask.CreatedProgram.ToString()); } RavenSession.Store(newProgram); RavenSession.SaveChanges(); new Emailer(this).SendEmail(EmailEnum.SendToPatient, newProgram.Email, newProgram.ShortUrl, newProgram.Id); // new ProgramEmailer(this).SendToPatient(newProgram.Id, newProgram.Email, newProgram.ShortUrl); return(Json(true)); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } bool isUri = Uri.IsWellFormedUriString(LongUrl, UriKind.Absolute); if (!isUri) { return(Page()); } var shortUrl = new ShortUrl { LongUrl = LongUrl, Expiration = DateTime.UtcNow.AddMinutes(2) }; HttpStatusCode code = HttpStatusCode.BadRequest; (code, shortUrl) = await _urlShortenerService.UpsertShortUrlAsync("1", shortUrl); if (code == HttpStatusCode.OK) { this.ShortUrl = $"{Request.Scheme}://{Request.Host}/s/{shortUrl.Id}"; } else { this.ShortUrl = $"Error:{code}"; } return(Page()); }
public void ShouldGenerateConflictException() { var shortenUrl = new ShortUrl { Code = "AAA123", Url = "www.example.com" }; var mapper = new Mock <IMapper>(); mapper.Setup(x => x.Map <ShortUrl>(It.IsAny <ShortUrlDto>())); var list = new List <ShortUrl> { shortenUrl }; var task = Task.FromResult <IList <ShortUrl> >(list); var repository = new Mock <IRepository <ShortUrl> >(); repository.Setup(x => x.ListAsync(It.IsAny <Expression <Func <ShortUrl, bool> > >())) .Returns(task); var service = new UrlShortenerCreatorService(mapper.Object, repository.Object, this.codeValidator); var shortenUrlDto = new ShortUrlDto { Code = "AAA123", Url = "www.example.com" }; Assert.Throws <ConflictException>(() => service.Execute(shortenUrlDto)); }
public IActionResult Create(string originalUrl, string provider, string memo, bool isPrivate) { var urlPerview = new UrlPerview(); try { urlPerview = _urlPerviewService.GetUrlPerview(originalUrl); } catch (Exception e) { Console.WriteLine(e); } var shortUrl = new ShortUrl { OriginalUrl = originalUrl, Provider = provider, Memo = memo, IsPrivate = isPrivate, MetaTitle = urlPerview?.Title, MetaDescription = urlPerview?.Description, PreviewImageUrl = urlPerview?.ListImages?.FirstOrDefault() }; TryValidateModel(shortUrl); if (ModelState.IsValid) { _shortUrlService.Save(shortUrl); return(RedirectToAction(actionName: nameof(CreateSuccess), routeValues: new { path = shortUrl.Path })); } return(View(shortUrl)); }
public int Save(ShortUrl url) { context.ShortUrls.Add(url); context.SaveChanges(); return(url.Id); }
public ShortUrl Generate(string fullUrl) { try { ShortUrl shortUrl; while (true) { shortUrl = new ShortUrl(fullUrl); if (_shortenerRepository.Exists(shortUrl)) { continue; } break; } _shortenerRepository.Add(shortUrl); _logger.LogInformation("New {@shortUrl} created.", shortUrl); return(shortUrl); } catch (Exception ex) { _logger.LogError(ex, "Error creating new {@shortUrl}", fullUrl); throw; } }
public static ShortUrl Create(ShortUrlDto dto) { // Eğer üretilmek istenen original url kalıcı bir bağlantıysa, // ve daha önce aynı original url için kalıcı bir bağlantı oluşturulmuşsa // yeni bir bağlantı oluşturmak yerine varolanı döndür. // Kullanıcı bazlı olarak!. var shortUrlRecord = db.ShortUrls.FirstOrDefault(x => x.OriginalUrl == dto.OriginalUrl && x.ApiKeyId == dto.ApiKeyId && x.isPermanent == dto.isPermanent ); if (shortUrlRecord != null) { return(shortUrlRecord); } var newShortUrl = new ShortUrl() { OriginalUrl = dto.OriginalUrl, Url = UniqueId.Generate(), isPermanent = dto.isPermanent, CreatorId = dto.CreatorId, ApiKeyId = dto.ApiKeyId, CreatedAt = DateTime.Now, ExpiresAt = DateTime.Now.AddDays(dto.Expiration) }; db.ShortUrls.Add(newShortUrl); db.SaveChanges(); return(newShortUrl); }
public static void ShortUrl() { ShortUrl url = new ShortUrl(); string urlShort = url.GetShortUrl(123123123); Assert.That(url.GetIdFromShortUrl(urlShort) == 123123123); }
public bool add(Agenda _agenda, string baseUrl = "") { using (var context = getContext()) { try { if (_agenda.IdAgenda == 0) { var urlToEncode = baseUrl + "/" + _agenda.Uri; _agenda.ShortUrl = ShortUrl.Shorten(urlToEncode); _agenda.Estado = true; context.Agenda.Add(_agenda); } else { Agenda agenda = context.Agenda.Where(x => x.IdAgenda == _agenda.IdAgenda).SingleOrDefault(); agenda.Titulo = _agenda.Titulo; agenda.Texto = _agenda.Texto; agenda.Uri = _agenda.Uri; agenda.Resumen = _agenda.Resumen; agenda.Lugar = _agenda.Lugar; agenda.Hora = _agenda.Hora; agenda.Fecha = _agenda.Fecha; agenda.Estado = _agenda.Estado; } context.SaveChanges(); return(true); } catch (Exception e) { throw e; } } }
public IActionResult Create([FromBody] ShortUrl shortUrl) { if (!string.IsNullOrEmpty(shortUrl.Slug)) { var url = _shortUrlService.Get(shortUrl.Slug); if (url != null) { return(Conflict($"Slug '{url.Slug}' is in use")); } } if (string.IsNullOrEmpty(shortUrl.Slug)) { var xeger = new Xeger("[a-z0-9]{5}", new Random()); shortUrl.Slug = xeger.Generate(); } shortUrl.Slug = shortUrl.Slug.ToLower(); try { var res = _shortUrlService.Create(shortUrl); return(Ok(res)); } catch (Exception e) { Console.WriteLine(e); return(StatusCode(500)); } }
public static async Task <HttpResponseMessage> Run( [HttpTrigger(AuthorizationLevel.Anonymous, new string[] { "get", "post" }, Route = "Redireciona/{shortUrl}")] HttpRequestMessage req, [Microsoft.Azure.WebJobs.Table("shortlinks", Connection = "AzureWebJobsStorage")] CloudTable cloudTable, string shortUrl, TraceWriter log) { string empty = string.Empty; if (string.IsNullOrWhiteSpace(shortUrl)) { throw new Exception("O ShortLink não existe"); } string partitionKey = shortUrl.Substring(0, 1) ?? ""; log.Info("Busca pela PartitionKey " + partitionKey + " e RowKey " + shortUrl + ".", (string)null); ShortUrl result = (await cloudTable.ExecuteAsync(TableOperation.Retrieve <ShortUrl>(partitionKey, shortUrl, (List <string>)null))).Result as ShortUrl; if (result == null) { throw new Exception("O ShortLink não existe"); } string str = WebUtility.UrlDecode(result.Url); HttpResponseMessage response = req.CreateResponse(HttpStatusCode.Found); response.Headers.Add("Location", str); return(response); }
public override void OnInspectorGUI() { EditorStyles.textField.wordWrap = true; EditorStyles.label.wordWrap = true; EditorStyles.miniLabel.wordWrap = true; EditorStyles.miniTextField.wordWrap = true; EditorStyles.whiteMiniLabel.wordWrap = true; EditorStyles.miniButton.wordWrap = true; EditorStyles.textField.fontStyle = FontStyle.Normal; EditorStyles.label.fontStyle = FontStyle.Normal; EditorStyles.miniLabel.fontStyle = FontStyle.Normal; EditorStyles.miniTextField.fontStyle = FontStyle.Normal; EditorStyles.whiteMiniLabel.fontStyle = FontStyle.Normal; EditorStyles.miniButton.fontStyle = FontStyle.Normal; DrawDefaultInspector(); group.DrawEditor(); GUI.color = Color.cyan; EditorGUILayout.LabelField(new GUIContent("---Unique ID testing---")); if (string.IsNullOrEmpty(GroupTest)) { GroupTest = group.Path; } GroupTest = EditorGUILayout.TextField(GroupTest); if (GUILayout.Button("Test Unique ID")) { UniqueIDTest = ShortUrl.GetUniqueID(GroupTest); } EditorGUILayout.LabelField(new GUIContent(UniqueIDTest)); }
public string SaveUrl(string originalUrl) { if (!_utilities.IsValidUri(originalUrl).Result) { return("Sorry the URL you entered is not live"); } var supposedShortUrl = _utilities.GetRandomUrl(); while (_unitOfWork.ShortUrlRepository.IsShortUrlExists(supposedShortUrl)) { supposedShortUrl = _utilities.GetRandomUrl(); } var shortUrl = new ShortUrl { OriginalUrl = originalUrl, ShortenUrl = supposedShortUrl, InsertDate = DateTime.Now.Date }; _unitOfWork.Add(shortUrl); _unitOfWork.Complete(); return(""); }
public async Task TestMethod_SimpleItemDbContext_Insert() { var store = _fixture.GetService <ISimpleItemDbContext <ShortUrlCosmosDocument> >(); store.Should().NotBeNull(); var shortUrl = new ShortUrl { Expiration = DateTime.UtcNow.AddSeconds(2), Id = "1234", LongUrl = "https://www.google.com" }; var document = new ShortUrlCosmosDocument(shortUrl.ToShortUrlCosmosDocument()); var response = await store.UpsertItemAsync(document); response.StatusCode.Should().Be(HttpStatusCode.OK); var read = await store.GetItemAsync(document.Id); read.Should().NotBeNull(); read.Id.Should().Be(document.Id); // wait 2 seconds. Thread.Sleep(2000); read = await store.GetItemAsync(document.Id); read.Should().BeNull(); }
public async Task <IActionResult> Submit(string longUrl) { string newUrl = tidyUrl(longUrl); if (!validateUrlInput(newUrl)) { ViewData["ErrorText"] = "Invalid url " + newUrl; return(View("UrlError")); } //get existing or create ShortUrl urlReturn = await _context.ShortUrl .FirstOrDefaultAsync(m => m.longUrl == newUrl); if (urlReturn == null) { urlReturn = new ShortUrl(newUrl); while (!keyUnique(urlReturn.key)) { urlReturn = new ShortUrl(newUrl); } if (ModelState.IsValid) { _context.Add(urlReturn); await _context.SaveChangesAsync(); } else { ViewData["ErrorText"] = "Fatal Error"; return(View("UrlError")); } } ViewData["UrlReturn"] = String.Format("{0}://{1}{2}", Request.Scheme, Request.Host, Request.PathBase) + "/" + urlReturn.key; return(View()); }
public void CreateShortUrlEntry(ShortUrlDto shortUrl, HttpContext _httpContext) { var user = _httpContext.User; if (!user.Identity.IsAuthenticated) { throw new AccessViolationException(); } try { var userObject = _userManager.GetUserAsync(user); shortUrl.Owner = userObject.Result; } catch (Exception ex) { throw new AccessViolationException("unable to find {user}"); } var newShortUrl = new ShortUrl(shortUrl); try { _dbContext.Add(newShortUrl); _dbContext.SaveChanges(); // _dbContext.Dispose(); } catch (Exception ex) { throw new Exception(null, ex); } }
public Task <Stat> Click(string segment, string referer, string ip) { return(Task.Run(() => { using (var ctx = new ShortnrContext()) { ShortUrl url = ctx.ShortUrls.Where(u => u.Segment == segment).FirstOrDefault(); if (url == null) { throw new ShortnrNotFoundException(); } url.NumOfClicks = url.NumOfClicks + 1; Stat stat = new Stat() { ClickDate = DateTime.Now, Ip = ip, Referer = referer, ShortUrl = url }; ctx.Stats.Add(stat); ctx.SaveChanges(); return stat; } })); }
public async Task Handle_WhenFoundRandom_ReturnsSuccessfulResponse() { var expectedUrl = new ShortUrl { Adjective = new Adjective { Value = "Adj" }, Adverb = new Adverb { Value = "Adv" }, Noun = new Noun { Value = "Nou" }, BaseDomain = "https://localhost/", DateCreated = DateTimeOffset.UtcNow, TargetUrl = "https://localhost/" }; _shortUrlRepositoryMock.Setup(m => m.GetRandomAsync(It.IsAny <string>())) .ReturnsAsync(expectedUrl); var handler = new GetRandomUrlQueryHandler(_shortUrlRepositoryMock.Object); var actual = await handler.Handle(new GetRandomUrlQuery { LanguageCode = "en" }, CancellationToken.None); Assert.True(actual.IsSuccessful); Assert.Equal(expectedUrl.DateCreated, actual.DateCreated); Assert.Equal(expectedUrl.TargetUrl, actual.TargetUrl); Assert.Equal("en", actual.Language); Assert.Equal($"https://localhost/AdvAdjNou", actual.Url); }
public async Task <IActionResult> Edit(int id, [Bind("id,longUrl,key")] ShortUrl shortUrl) { if (!loggedIn()) { return(View("Login")); } if (id != shortUrl.id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(shortUrl); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ShortUrlExists(shortUrl.id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(shortUrl)); }
public SpamStatus CheckStatus(ShortUrl shortUrl) { Check.Argument.IsNotNull(shortUrl, "shortUrl"); int phishingCount; int malwareCount; googleSafeBrowsing.Verify(shortUrl.Url, out phishingCount, out malwareCount); SpamStatus status = SpamStatus.None; if ((phishingCount > 0) || (malwareCount > 0)) { if (phishingCount > 0) { status |= SpamStatus.Phishing; } if (malwareCount > 0) { status |= SpamStatus.Malware; } } else { status = SpamStatus.Clean; } return(status); }
public int Save(ShortUrl shortUrl) { _context.ShortUrls.Add(shortUrl); _context.SaveChanges(); return(shortUrl.Id); }
public int Save(ShortUrlCreationRequest request) { ShortUrlHost host = HostByName(request.HostName); if (host == null) { throw new Exception($"Host name '{request.HostName}' does not exist!"); } var url = new ShortUrl { HostId = host.Id, Path = request.Path, OriginalUrl = request.OriginalUrl, LetterLink = request.LetterLink, Note = request.Note, UserName = request.UserName, Subject = request.Subject, Created = DateTime.Now }; context.ShortUrls.Add(url); context.SaveChanges(); return(url.Id); }
public async Task <IActionResult> Create([FromBody] ShortUrl shortUrl) { if (!ModelState.IsValid) { return(BadRequest("Invalid input")); } if (!IsUrlValid(shortUrl.Url)) { return(BadRequest("Invalid url")); } if (string.IsNullOrWhiteSpace(shortUrl.Slug)) { shortUrl.Slug = RandomIdGenerator.GetBase62(8); } try { await context.ShortUrls.AddAsync(shortUrl); await context.SaveChangesAsync(); } catch (Exception) { return(BadRequest("Failed to create short url")); } return(Created(Url.Action("Index", "UrlShortener", new { slug = shortUrl.Slug }, Request.Scheme), shortUrl)); }
public void QueueShortUrl(ShortUrl shortUrl) { if (Enabled) { string message = CreateShortUrlEmbed(shortUrl); WebhookQueue.Add(message); } }
public Task<ShortUrl> ShortenUrl(string longUrl, string ip, string segment = "") { return Task.Run(() => { using (var ctx = new ShorturlContext()) { ShortUrl url; url = ctx.ShortUrls.Where(u => u.LongUrl == longUrl).FirstOrDefault(); if (url != null) { return url; } if (!string.IsNullOrEmpty(segment)) { if (ctx.ShortUrls.Where(u => u.Segment == segment).Any()) { throw new ShorturlConflictException(); } } else { segment = this.NewSegment(); } if (string.IsNullOrEmpty(segment)) { throw new ArgumentException("Segment is empty"); } url = new ShortUrl() { Added = DateTime.Now, Ip = ip, LongUrl = longUrl, NumOfClicks = 0, Segment = segment }; ctx.ShortUrls.Add(url); ctx.SaveChanges(); return url; } }); }
public ActionResult Index(FormCollection collection) { //TODO check for valid URL ShortUrl shortUrl = new ShortUrl(); UrlRepository repo = new UrlRepository(); string url = collection["url"]; string shortName = repo.GetShortName(url); shortUrl.URL = url; shortUrl.ShortName = shortName; if (string.IsNullOrEmpty(shortName)) { shortUrl.ShortName = repo.GetNewShortName(); repo.SaveUrl(shortUrl); } shortUrl.URL = string.Format("http://uurl.co/{0}", shortUrl.ShortName); return View(shortUrl); }
/// <summary> /// This is a sync execution of \short_url\share\counts rest call. /// It returns JsonResponse<ShortUrl.Share.CountsResponse> /// Here comes request Comments: ///<para>取得一个短链接在微博上的微博分享数(包含原创和转发的微博) </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/share/counts.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> false 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public JsonResponse<ShortUrl.Share.CountsResponse> ExecuteShortUrlShareCounts(ShortUrl.Share.CountsRequest request) { return ExecuteShortUrlShareCountsAsync(request).Result; }
/// <summary> /// This is a sync execution of \short_url\share\statuses rest call. /// It returns JsonResponse<ShortUrl.Share.StatusesResponse> /// Here comes request Comments: ///<para>取得包含指定单个短链接的最新微博内容 </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/share/statuses.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> true 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public JsonResponse<ShortUrl.Share.StatusesResponse> ExecuteShortUrlShareStatuses(ShortUrl.Share.StatusesRequest request) { return ExecuteShortUrlShareStatusesAsync(request).Result; }
/// <summary> /// This is a sync request of \short_url\expand rest call. ///It returns JsonResponse<Stream> /// Here comes request Comments: ///<para>将一个或多个短链接还原成原始的长链接 </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/expand.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> false 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public JsonResponse<Stream> RequestShortUrlExpand(ShortUrl.ExpandRequest request) { return RequestShortUrlExpandAsync(request).Result; }
/// <summary> /// This is a sync request of \short_url\shorten rest call. ///It returns JsonResponse<Stream> /// Here comes request Comments: ///<para>将一个或多个长链接转换成短链接 </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/shorten.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> false 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public JsonResponse<Stream> RequestShortUrlShorten(ShortUrl.ShortenRequest request) { return RequestShortUrlShortenAsync(request).Result; }
/// <summary> /// This is a async request of \short_url\comment\counts rest call. ///It returns JsonResponse<Stream> /// Here comes request Comments: ///<para>取得一个短链接在微博上的微博评论数 </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/comment/counts.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> false 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public async Task<JsonResponse<Stream>> RequestShortUrlCommentCountsAsync ( ShortUrl.Comment.CountsRequest request, CancellationToken cancellationToken =default(CancellationToken), IProgress<ProgressReport> progress=null ) { return await _requestShortUrlCommentCountsMethod.GetResponseAsync(request, cancellationToken, progress); }
/// <summary> /// This is a sync request of \short_url\comment\counts rest call. ///It returns JsonResponse<Stream> /// Here comes request Comments: ///<para>取得一个短链接在微博上的微博评论数 </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/comment/counts.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> false 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public JsonResponse<Stream> RequestShortUrlCommentCounts(ShortUrl.Comment.CountsRequest request) { return RequestShortUrlCommentCountsAsync(request).Result; }
/// <summary> /// This is a sync request of \short_url\share\counts rest call. ///It returns JsonResponse<Stream> /// Here comes request Comments: ///<para>取得一个短链接在微博上的微博分享数(包含原创和转发的微博) </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/share/counts.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> false 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public JsonResponse<Stream> RequestShortUrlShareCounts(ShortUrl.Share.CountsRequest request) { return RequestShortUrlShareCountsAsync(request).Result; }
/// <summary> /// This is a async request of \short_url\share\statuses rest call. ///It returns JsonResponse<Stream> /// Here comes request Comments: ///<para>取得包含指定单个短链接的最新微博内容 </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/share/statuses.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> true 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public async Task<JsonResponse<Stream>> RequestShortUrlShareStatusesAsync ( ShortUrl.Share.StatusesRequest request, CancellationToken cancellationToken =default(CancellationToken), IProgress<ProgressReport> progress=null ) { return await _requestShortUrlShareStatusesMethod.GetResponseAsync(request, cancellationToken, progress); }
/// <summary> /// This is a sync request of \short_url\share\statuses rest call. ///It returns JsonResponse<Stream> /// Here comes request Comments: ///<para>取得包含指定单个短链接的最新微博内容 </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/share/statuses.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> true 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public JsonResponse<Stream> RequestShortUrlShareStatuses(ShortUrl.Share.StatusesRequest request) { return RequestShortUrlShareStatusesAsync(request).Result; }
/// <summary> /// This is a async execution of \short_url\share\counts rest call. /// It returns JsonResponse<ShortUrl.Share.CountsResponse> /// Here comes request Comments: ///<para>取得一个短链接在微博上的微博分享数(包含原创和转发的微博) </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/share/counts.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> false 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public async Task<JsonResponse<ShortUrl.Share.CountsResponse>> ExecuteShortUrlShareCountsAsync ( ShortUrl.Share.CountsRequest request, CancellationToken cancellationToken =default(CancellationToken), IProgress<ProgressReport> progress=null ) { return await _executeShortUrlShareCountsMethod.GetResponseAsync(request, cancellationToken, progress); }
/// <summary> /// This is a sync execution of \short_url\shorten rest call. /// It returns JsonResponse<ShortUrl.ShortenResponse> /// Here comes request Comments: ///<para>将一个或多个长链接转换成短链接 </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/shorten.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> false 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public JsonResponse<ShortUrl.ShortenResponse> ExecuteShortUrlShorten(ShortUrl.ShortenRequest request) { return ExecuteShortUrlShortenAsync(request).Result; }
/// <summary> /// This is a sync execution of \short_url\comment\counts rest call. /// It returns JsonResponse<ShortUrl.Comment.CountsResponse> /// Here comes request Comments: ///<para>取得一个短链接在微博上的微博评论数 </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/comment/counts.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> false 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public JsonResponse<ShortUrl.Comment.CountsResponse> ExecuteShortUrlCommentCounts(ShortUrl.Comment.CountsRequest request) { return ExecuteShortUrlCommentCountsAsync(request).Result; }
public Task<ShortUrl> ShortenUrl(string longUrl, string ip, string segment = "") { return Task.Run(() => { using (var ctx = new ShortnrContext()) { ShortUrl url; url = ctx.ShortUrls.Where(u => u.LongUrl == longUrl).FirstOrDefault(); if (url != null) { return url; } if (!longUrl.StartsWith("http://") && !longUrl.StartsWith("https://")) { throw new ArgumentException("Invalid URL format"); } Uri urlCheck = new Uri(longUrl); HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlCheck); request.Timeout = 10000; try { HttpWebResponse response = (HttpWebResponse)request.GetResponse(); } catch (Exception) { throw new ShortnrNotFoundException(); } int cap = 0; string capString = ConfigurationManager.AppSettings["MaxNumberShortUrlsPerHour"]; int.TryParse(capString, out cap); DateTime dateToCheck = DateTime.Now.Subtract(new TimeSpan(1, 0, 0)); int count = ctx.ShortUrls.Where(u => u.Ip == ip && u.Added >= dateToCheck).Count(); if (cap != 0 && count > cap) { throw new ArgumentException("Your hourly limit has exceeded"); } if (!string.IsNullOrEmpty(segment)) { if (ctx.ShortUrls.Where(u => u.Segment == segment).Any()) { throw new ShortnrConflictException(); } if (segment.Length > 20 || !Regex.IsMatch(segment, @"^[A-Za-z\d_-]+$")) { throw new ArgumentException("Malformed or too long segment"); } } else { segment = this.NewSegment(); } if (string.IsNullOrEmpty(segment)) { throw new ArgumentException("Segment is empty"); } url = new ShortUrl() { Added = DateTime.Now, Ip = ip, LongUrl = longUrl, NumOfClicks = 0, Segment = segment }; ctx.ShortUrls.Add(url); ctx.SaveChanges(); return url; } }); }
/// <summary> /// This is a sync execution of \short_url\expand rest call. /// It returns JsonResponse<ShortUrl.ExpandResponse> /// Here comes request Comments: ///<para>将一个或多个短链接还原成原始的长链接 </para> ///<para>URL:</para> ///<para> http://api.t.sina.com.cn/short_url/expand.(json|xml)</para> ///<para>支持格式:</para> ///<para> XML/JSON</para> ///<para>HTTP请求方式:</para> ///<para> GET</para> ///<para>是否需要登录:</para> ///<para> false 关于授权机制,参见授权机制声明</para> ///<para>请求数限制:</para> ///<para> true 关于请求数限制,参见接口访问权限说明</para> ///<para></para> /// </summary> public JsonResponse<ShortUrl.ExpandResponse> ExecuteShortUrlExpand(ShortUrl.ExpandRequest request) { return ExecuteShortUrlExpandAsync(request).Result; }