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());
}
