public void LinkIsNotCreatedWhenAnInvalidUrlIsSupplied() { // Arrange var validator = new CreateLinkRequestValidator(); var urls = new List <string> { "http", "http://", "http://www", ".com", "SomeUrl", "SomeUrl.c", "http://someurl.##", "http://someurl.a", "1.1" }; // Act foreach (var url in urls) { var request = new CreateLinkRequest { Url = url }; var actual = validator.Validate(request); // Assert Assert.AreEqual(1, actual.Errors.Count); Assert.AreEqual("The URL provided is invalid. Please provide a valid URL.", actual.Errors.Last(x => x.PropertyName == "Url").ErrorMessage); } }
public async Task <IActionResult> Create(LinkEditModel model) { if (ModelState.IsValid) { var verifyResult = _linkVerifier.Verify(model.OriginUrl, Url, Request); switch (verifyResult) { case LinkVerifyResult.InvalidFormat: return(BadRequest("Not a valid URL.")); case LinkVerifyResult.InvalidLocal: return(BadRequest("Can not use local URL.")); case LinkVerifyResult.InvalidSelfReference: return(BadRequest("Can not use url pointing to this site.")); } var createLinkRequest = new CreateLinkRequest { OriginUrl = model.OriginUrl, Note = model.Note, AkaName = string.IsNullOrWhiteSpace(model.AkaName) ? null : model.AkaName, IsEnabled = model.IsEnabled, TTL = model.TTL }; var response = await _linkForwarderService.CreateLinkAsync(createLinkRequest); return(Json(response)); } return(BadRequest("Invalid ModelState")); }
public void LinkIsCreatedWhenAValidUrlIsSupplied() { // Arrange var validator = new CreateLinkRequestValidator(); var urls = new List <string> { "someurl.com", "someurl.co", "www.someurl.com", "http://www.someurl.com", "https://www.someurl.com", "https://www.someurl.com/", "https://www.someurl.com/someroute", "https://www.someurl.com/someroute?q=", "https://www.someurl.com/someroute?q=asdasd", "192.168.1.1", "1.1.1.1" }; // Act foreach (var url in urls) { var request = new CreateLinkRequest { Url = url }; var actual = validator.Validate(request); // Assert Assert.AreEqual(0, actual.Errors.Count); } }
public async Task <IActionResult> CreateLinkAsync([FromBody] CreateLinkRequest request) { request.ShouldNotBeNull(nameof(request)); request.OriginalLink = request.OriginalLink?.Trim(); request.OriginalLink.ShouldNotBeNullOrEmpty(nameof(request)); var link = await service.CreateLinkAsync(request.OriginalLink).ConfigureAwait(false); return(Created($"/v1/links/{link.PrettyLink}", Mapper.Map <DomainLink, Link>(link))); }
public IActionResult Post([FromBody] CreateLinkRequest createLink) { if (!ModelState.IsValid) { return(BadRequest(@"Link url format is not correct. Use full link started from http:// or https://")); } _repository.AddLink(createLink.GetLink()); return(Ok()); }
public IActionResult Post([FromBody] CreateLinkRequest createLink) { if (!ModelState.IsValid) { return(BadRequest(@"Не верный формат ссылки, используйте http:// или https://")); } _repository.AddLink(createLink.GetLink()); return(Ok()); }
public async Task <IActionResult> Create(CreateLinkRequest request) { var shortCode = GenerateNewShortCode(); await _shortUrlsTable.PutItemAsync(new Document { { "short_code", shortCode }, { "url", request.Url } }); return(CreatedAtAction(nameof(RedirectToUrl), new { shortCode }, null)); }
/// <summary> /// Upload the HttpContent to dropbox /// </summary> /// <param name="filename">Name of the file</param> /// <param name="content">HttpContent</param> /// <param name="progress">IProgress</param> /// <param name="cancellationToken">CancellationToken</param> /// <returns>Url as string</returns> private async Task <string> UploadAsync(string filename, HttpContent content, IProgress <int> progress = null, CancellationToken cancellationToken = default(CancellationToken)) { var oAuthHttpBehaviour = _oAuthHttpBehaviour.ShallowClone(); // Use UploadProgress if (progress != null) { oAuthHttpBehaviour.UploadProgress = percent => { UiContext.RunOn(() => progress.Report((int)(percent * 100))); }; } oAuthHttpBehaviour.MakeCurrent(); // Build the upload content together var uploadContent = new Upload { Content = content }; // This is needed if (!filename.StartsWith("/")) { filename = "/" + filename; } // Create the upload request parameters var parameters = new UploadRequest { Path = filename }; // Add it to the headers uploadContent.Headers.Add("Dropbox-API-Arg", JsonConvert.SerializeObject(parameters, Formatting.None)); _oAuthHttpBehaviour.MakeCurrent(); // Post everything, and return the upload reply or an error var response = await DropboxContentUri.PostAsync <HttpResponse <UploadReply, Error> >(uploadContent, cancellationToken).ConfigureAwait(false); if (response.HasError) { throw new ApplicationException(response.ErrorResponse.Summary); } // Take the response from the upload, and use the information to request dropbox to create a link var createLinkRequest = new CreateLinkRequest { Path = response.Response.PathDisplay }; var reply = await DropboxApiUri .AppendSegments("2", "sharing", "create_shared_link_with_settings") .PostAsync <HttpResponse <CreateLinkReply, Error> >(createLinkRequest, cancellationToken).ConfigureAwait(false); if (reply.HasError) { throw new ApplicationException(reply.ErrorResponse.Summary); } return(reply.Response.Url); }
public void CreateLinkThrowsIfBannedKey() { var client = CreateClient(); var req = new CreateLinkRequest() { Key = KeyValidator.BannedTags[0], Url = "http://www.google.com" }; Assert.Throws <WebServiceException>(() => client.Post(req)); }
public async Task <Response <string> > CreateLinkAsync(CreateLinkRequest createLinkRequest) { try { using (var conn = DbConnection) { const string sqlLinkExist = "SELECT TOP 1 FwToken FROM Link l WHERE l.OriginUrl = @originUrl"; var tempToken = await conn.ExecuteScalarAsync <string>(sqlLinkExist, new { createLinkRequest.OriginUrl }); if (null != tempToken) { if (_tokenGenerator.TryParseToken(tempToken, out var tk)) { _logger.LogInformation($"Link already exists for token '{tk}'"); return(new SuccessResponse <string>(tk)); } string message = $"Invalid token '{tempToken}' found for existing url '{createLinkRequest.OriginUrl}'"; _logger.LogError(message); } const string sqlTokenExist = "SELECT TOP 1 1 FROM Link l WHERE l.FwToken = @token"; string token; do { token = _tokenGenerator.GenerateToken(); } while (await conn.ExecuteScalarAsync <int>(sqlTokenExist, new { token }) == 1); _logger.LogInformation($"Generated Token '{token}' for url '{createLinkRequest.OriginUrl}'"); var link = new Link { FwToken = token, IsEnabled = createLinkRequest.IsEnabled, Note = createLinkRequest.Note, AkaName = createLinkRequest.AkaName, OriginUrl = createLinkRequest.OriginUrl, UpdateTimeUtc = DateTime.UtcNow }; const string sqlInsertLk = @"INSERT INTO Link (OriginUrl, FwToken, Note, AkaName, IsEnabled, UpdateTimeUtc) VALUES (@OriginUrl, @FwToken, @Note, @AkaName, @IsEnabled, @UpdateTimeUtc)"; await conn.ExecuteAsync(sqlInsertLk, link); return(new SuccessResponse <string>(link.FwToken)); } } catch (Exception e) { _logger.LogError(e, e.Message); return(new FailedResponse <string>(e.Message)); } }
public static CreateLinkCommand ToCreateLinkCommand(this CreateLinkRequest request) { return(new CreateLinkCommand { NodeA = new Node(request.NodeAId, StoryboardNodeTypes.GetFromValue(request.NodeAType)), NodeB = new Node(request.NodeBId, StoryboardNodeTypes.GetFromValue(request.NodeBType)), Strength = request.Strength, Direction = (LinkFlow)request.Direction, Type = new LinkType { Id = request.Type } }); }
public IActionResult CreateLink([FromBody] CreateLinkRequest linkToCreate) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } Link link = linkToCreate.GetLink(); link.ShortLink = _hasher.GetHash(link.OriginalLink); return(Ok(_linkRepository.CreateLink(link) != null)); }
public void LinkPersistedInDatabase() { var sut = GetService(); var req = new CreateLinkRequest() { Key = "Hello", Url = "http://www.google.com", }; var res = (LinkResponse)sut.Post(req); Assert.IsNotNull(_db.Single <Link>(m => m.Id == res.Id)); }
public void CanCreateLink() { var sut = GetService(); var req = new CreateLinkRequest() { Key = "Hello", Url = "http://www.google.com", }; var res = (LinkResponse)sut.Post(req); Assert.AreNotEqual(0, res.Id); }
public void CanCreateLinkWithoutKey() { var sut = GetService(); var req = new CreateLinkRequest() { Url = "http://www.google.com", }; var res = (LinkResponse)sut.Post(req); Assert.AreNotEqual(0, res.Id); Assert.IsNotNull(res.Key); }
public void CreatedLinkContainsUrl() { var sut = GetService(); var req = new CreateLinkRequest() { Key = "Hello", Url = "http://www.google.com" }; var res = (LinkResponse)sut.Post(req); Assert.AreEqual(req.Url, _db.Single <Link>(m => m.Id == res.Id).Url); }
public LinkControllerTests() { dataService = Mock.Create <ILinkDataService>(); target = new LinkController(dataService); defaultRequest = new CreateLinkRequest { NodeAId = 101, NodeAType = StoryboardNodeTypes.Story.Id, NodeBId = 203, NodeBType = StoryboardNodeTypes.Actor.Id, Direction = (int)LinkFlow.AtoB, Strength = 0.5f, Type = 23 }; }
public IActionResult Create([FromBody] CreateLinkRequest request) { LinkModel link = _linkManager.CreateLink(CurrentUserId.Value, request.Name, request.Description, request.ShortUrl, request.OriginalUrl, request.IsActive); if (link == null) { return(BadRequest()); } return(CreatedAtAction(nameof(GetById), new { id = link.Id }, null)); }
public void LinkIsNotCreatedWhenNoUrlIsSupplied() { // Arrange var validator = new CreateLinkRequestValidator(); var request = new CreateLinkRequest { Url = string.Empty }; // Act var actual = validator.Validate(request); // Assert Assert.AreEqual(2, actual.Errors.Count); Assert.AreEqual("Please enter a URL", actual.Errors.First(x => x.PropertyName == "Url").ErrorMessage); Assert.AreEqual("The URL provided is invalid. Please provide a valid URL.", actual.Errors.Last(x => x.PropertyName == "Url").ErrorMessage); }
public void CreateLinkThrowsIfDuplicateKey() { var client = CreateClient(); _appHost.Db.Insert(new Link() { Key = "Hello", Url = "http://www.test.com", SessionId = "test" }); var req = new CreateLinkRequest() { Key = "Hello", Url = "http://www.google.com" }; Assert.Throws <WebServiceException>(() => client.Post(req)); }
public async Task <JsonResponse> CreateLinkAsync([FromBody] CreateLinkRequest createLinkRequest) { try { var toBeCreatedLink = _mapper.Map <CreateLinkRequest, ILink>(createLinkRequest); await _linksService.CreateLinkAsync(toBeCreatedLink, base.User); return(new JsonResponse(null, HttpStatusCode.Created)); } catch (Exception ex) { await _logger.LogErrorAsync(ex.Message, ex).ConfigureAwait(false); // TODO: When creating a release, don't send ex.Message in response return(new JsonResponse(ex.Message, HttpStatusCode.BadRequest)); } }
public void CreateLinkAlsoGeneratesScreenshot() { var sut = GetService(); var req = new CreateLinkRequest() { Key = "Hello", Url = "http://www.google.com", }; var res = (LinkResponse)sut.Post(req); var link = _db.Single <Link>(m => m.Id == res.Id); Assert.IsNotNull(link); Assert.IsNotNull(link.ScreenshotUrl); }
public async Task <string> CreateLinkAsync(CreateLinkRequest createLinkRequest) { var l = await _connection.Link.FirstOrDefaultAsync(p => p.OriginUrl == createLinkRequest.OriginUrl); var tempToken = l?.FwToken; if (tempToken is not null) { if (_tokenGenerator.TryParseToken(tempToken, out var tk)) { _logger.LogInformation($"Link already exists for token '{tk}'"); return(tk); } string message = $"Invalid token '{tempToken}' found for existing url '{createLinkRequest.OriginUrl}'"; _logger.LogError(message); } string token; do { token = _tokenGenerator.GenerateToken(); } while (await _connection.Link.AnyAsync(p => p.FwToken == token)); _logger.LogInformation($"Generated Token '{token}' for url '{createLinkRequest.OriginUrl}'"); var link = new Link { FwToken = token, IsEnabled = createLinkRequest.IsEnabled, Note = createLinkRequest.Note, AkaName = createLinkRequest.AkaName, OriginUrl = createLinkRequest.OriginUrl, UpdateTimeUtc = DateTime.UtcNow, TTL = createLinkRequest.TTL }; await _connection.InsertAsync(link); return(link.FwToken); }
public IActionResult CreateLink([FromBody] CreateLinkRequest request) { // Retrieve existing var linkedResource = request.ToDto(); var existingLink = _dataService.LinkedResource.Get(request.Url); // If there is no existing resource create a new one if (existingLink == null) { linkedResource = _dataService.LinkedResource.Save(linkedResource); } else { linkedResource = existingLink; } // Generate the Key and EncodedUrl properties linkedResource.EncodeKey(_appSettings.EncodedUrlBase); return(Ok(linkedResource)); }
public void NewLinkIsCreatedWhenLinkDoesNotExist() { // Arrange var expected = new LinkedResourceDto { Id = 1, Url = "http://some.site" }; var expectedKey = "MQ"; var expectedEncodedUrl = $"http://lync.ninja/{expectedKey}"; var request = new CreateLinkRequest { Url = expected.Url }; var encodedUrlBase = "http://lync.ninja/"; var linkController = new LinkControllerSetup(); linkController.Mock_AppSettings.Value.Returns(new AppSettings { EncodedUrlBase = encodedUrlBase }); linkController.Mock_DataService.LinkedResource.Get(Arg.Any <string>()).Returns(x => null); linkController.Mock_DataService.LinkedResource.Save(Arg.Any <LinkedResourceDto>()).Returns(expected); // Act var actualResult = linkController.Scope.CreateLink(request); // Assert var actual = AssertOkResult(actualResult); Assert.AreEqual(expected.Url, actual.Url); Assert.AreEqual(expected.Id, actual.Id); Assert.AreEqual(expectedKey, actual.Key); Assert.AreEqual(expectedEncodedUrl, actual.EncodedUrl); var decodedKey = Base64.Decode(expected.Key); Assert.AreEqual(expected.Id.ToString(), decodedKey); linkController.Mock_DataService.LinkedResource.Received(1).Get(Arg.Any <string>()); linkController.Mock_DataService.LinkedResource.Received(1).Save(Arg.Any <LinkedResourceDto>()); }
public async Task <IActionResult> CreateLink( [FromBody] CreateLinkRequest request, CancellationToken cancellationToken) { var createLink = new CreateLinkCommand( request.Data, request.IsEncrypted, request.Secrets, request.TtlSeconds); var link = await Mediator.Send(createLink, cancellationToken); var response = new CreateLinkResponse { ExpiresAt = link.ExpiresAt, LinkId = link.LinkId }; await LinksService.AddLinksAsync(response); return(Created("links/{{hash}}", response)); }
public void CanCreateLinkWithTags() { var sut = GetService(); var tags = new [] { new Tag() { Key = "T1" }, new Tag() { Key = "T2" }, new Tag() { Key = "T3" }, }; _db.SaveAll(tags); var req = new CreateLinkRequest() { Key = "Hello", Url = "http://www.google.com", Tags = new HashSet <string>() { tags[0].Key, tags[1].Key } }; var res = (LinkResponse)sut.Post(req); Assert.AreNotEqual(0, res.Id); Assert.AreEqual(2, res.Tags.Count); Assert.Contains(tags[0].Key, res.Tags.ToList()); Assert.Contains(tags[1].Key, res.Tags.ToList()); }
public async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] [RequestBodyType(typeof(CreateLinkRequest), "Get Link")] CreateLinkRequest req, ILogger log) { try { var request = JsonConvert.SerializeObject(req); log.LogInformation($"CreateLink {request}"); CreateLinkResponse response = await _mediator.Send(req); return(new OkObjectResult(ResponseWrapper <CreateLinkResponse, CommunicationServiceErrorCode> .CreateSuccessfulResponse(response))); } catch (Exception exc) { log.LogError("Exception occured in Create Link", exc); return(new ObjectResult(ResponseWrapper <CreateLinkResponse, CommunicationServiceErrorCode> .CreateUnsuccessfulResponse(CommunicationServiceErrorCode.InternalServerError, "Internal Error")) { StatusCode = StatusCodes.Status500InternalServerError }); } }
public void CreateLinkWithTagsPersistedInDatabase() { var sut = GetService(); var tags = new [] { new Tag() { Key = "T1" }, new Tag() { Key = "T2" }, new Tag() { Key = "T3" }, }; _db.SaveAll(tags); var req = new CreateLinkRequest() { Key = "Hello", Url = "http://www.google.com", Tags = new HashSet <string>() { tags[0].Key, tags[1].Key } }; var res = (LinkResponse)sut.Post(req); Assert.AreEqual(2, _db.Count <LinkTag>(m => m.LinkId == res.Id)); }
public void Post([FromBody] CreateLinkRequest request) { dataService.Add(request.ToCreateLinkCommand()); }