public async Task <IActionResult> Edit(Guid guid, [FromBody] ShortLinkModel newShortLink)
{
var shortLink = Db.ShortLinks.Find(guid);
if (shortLink == null)
{
return(NotFound(ErrorModel.NotFound()));
}
if (!shortLink.ValidateIdent())
{
return(BadRequest(ErrorModel.BadRequest("invalid short ident")));
}
if (!CheckShortIdent(newShortLink, shortLink.GUID))
{
return(BadRequest(ErrorModel.BadRequest("short ident already in use")));
}
if (!await newShortLink.ValidateURI())
{
return(BadRequest(ErrorModel.BadRequest("invalid root link")));
}
shortLink.Update(newShortLink);
shortLink.Sanitize();
Db.ShortLinks.Update(shortLink);
await Db.SaveChangesAsync();
return(Ok(shortLink));
}
public IActionResult Save([FromBody] ShortLinkModel shortLink)
{
if (shortLink == null)
{
_log.LogError(Constants.Messages.CannotSaveLink);
return(Problem(Constants.Messages.CannotSaveLink));
}
if (string.IsNullOrWhiteSpace(shortLink.LongUrl.Trim()))
{
_log.LogError(Constants.Messages.LinkAddressIsEmpty);
return(Problem(title: Constants.Messages.LinkAddressIsEmpty));
}
try
{
var result = _shortLinkService.SaveShortLink(shortLink, UrlPrefix);
return(Ok(result));
}
catch (Exception ex)
{
_log.LogError(ex.Message);
return(Problem(Constants.Messages.CannotSaveLink));
}
}
public IActionResult Update([FromBody] ShortLinkModel shortLink)
{
if (shortLink == null)
{
_log.LogError(Constants.Messages.CannotUpdateChanges);
return(Problem(Constants.Messages.CannotUpdateChanges));
}
if (string.IsNullOrWhiteSpace(shortLink.LongUrl.Trim()))
{
_log.LogError(Constants.Messages.LinkAddressIsEmpty);
return(Problem(Constants.Messages.LinkAddressIsEmpty));
}
try
{
if (string.IsNullOrWhiteSpace(shortLink.UrlKey))
{
shortLink.UrlKey = StringUtils.GenRandomString(6);
}
var result = _shortLinkService.UpdateShortLink(shortLink, UrlPrefix);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
catch (Exception ex)
{
_log.LogError(ex.Message);
return(Problem(Constants.Messages.CannotUpdateChanges));
}
}
public ShortLinkModel SaveShortLink(ShortLink shortLink, string url)
{
ShortLinkModel shortLinkModel = ShortLinkModel.FromEntity(shortLink, url);
_shortLinks.Add(shortLinkModel);
return(shortLinkModel);
}
public ShortLinkModel UpdateShortLink(ShortLink shortLink, string url)
{
bool success = DeleteShortLink(shortLink.Id);
if (!success)
{
return(null);
}
SaveShortLink(shortLink, url);
return(ShortLinkModel.FromEntity(shortLink, url));
}
public ShortLinkModel SaveShortLink(ShortLink shortLink, string url)
{
shortLink.Id = 0;
shortLink.InsertionDate = DateTimeOffset.Now;
if (string.IsNullOrWhiteSpace(shortLink.UrlKey))
{
shortLink.UrlKey = StringUtils.GenRandomString(6);
}
var result = _context.ShortLinks.Add(shortLink);
_context.SaveChanges();
return(ShortLinkModel.FromEntity(result.Entity, url));
}
public ShortLinkModel UpdateShortLink(ShortLink shortLink, string url)
{
ShortLink result = _context.ShortLinks.FirstOrDefault(x => x.Id == shortLink.Id);
if (result == null)
{
return(null);
}
result.LongUrl = shortLink.LongUrl;
result.UrlKey = shortLink.UrlKey;
result.RedirectsCount = shortLink.RedirectsCount;
_context.SaveChanges();
return(ShortLinkModel.FromEntity(result, url));
}
public void Save_And_GetShortLinkByUrlKey_Test()
{
string urlKey = Guid.NewGuid().ToString();
string wrongKey = Guid.NewGuid().ToString();
_shortLinkService.SaveShortLink(new ShortLink {
UrlKey = urlKey
}, null);
ShortLinkModel shortLinkModel = _shortLinkService.GetShortLinkByUrlKey(urlKey, null);
Assert.NotNull(shortLinkModel);
shortLinkModel = _shortLinkService.GetShortLinkByUrlKey(wrongKey, null);
Assert.Null(shortLinkModel);
}
public void Save_And_GetShortLinkById_Test()
{
_shortLinkService.SaveShortLink(new ShortLink {
Id = 1
}, null);
_shortLinkService.SaveShortLink(new ShortLink {
Id = 2
}, null);
ShortLinkModel shortLinkModel = _shortLinkService.GetShortLinkById(1, null);
Assert.NotNull(shortLinkModel);
shortLinkModel = _shortLinkService.GetShortLinkById(3, null);
Assert.Null(shortLinkModel);
}
public IActionResult Get(string urlKey)
{
try
{
ShortLinkModel link = _shortLinkService.GetShortLinkByUrlKey(urlKey, UrlPrefix);
if (link == null)
{
_log.LogWarning(Constants.Messages.LinkNotFound);
return(NotFound());
}
return(Redirect(link.LongUrl));
}
catch (Exception ex)
{
_log.LogError(ex.Message);
return(Problem(Constants.Messages.InternalServerError));
}
}
public ShortLinkModel GetShortLinkByUrlKey(string urlKey, string url)
{
ShortLinkModel link = _repo.GetShortLinkByUrlKey(urlKey, url);
if (link == null)
{
return(link);
}
link.RedirectsCount++;
ShortLinkModel result = _repo.UpdateShortLink(link, url);
if (result == null)
{
return(null);
}
return(link);
}
public IActionResult GetShortLink(long linkId)
{
try
{
ShortLinkModel shortLink = _shortLinkService.GetShortLinkById(linkId, UrlPrefix);
if (shortLink == null)
{
_log.LogError(Constants.Messages.LinkNotFound);
return(NotFound());
}
return(Ok(shortLink));
}
catch (Exception ex)
{
_log.LogError(ex.Message);
return(Problem(Constants.Messages.InternalServerError));
}
}
// ------------------------------------------------
// -- HELPERS
public bool IsValid(ShortLinkModel shortLink)
{
if (shortLink == null ||
!shortLink.IsActive ||
shortLink.Activates.CompareTo(DateTime.Now) > 0 ||
shortLink.Expires.CompareTo(DateTime.Now) <= 0)
{
return(false);
}
if (shortLink.MaxUses > 0)
{
var accessCount = DbCache.GetAccesses(shortLink.GUID)
.ToArray()
.Count(a => a.IsUnique);
return(accessCount < shortLink.MaxUses);
}
return(true);
}
public void Save_And_UpdateShortLink_Test()
{
string urlKey = Guid.NewGuid().ToString();
long id = 1;
ShortLink shortLink = new ShortLink {
Id = id
};
_shortLinkService.SaveShortLink(shortLink, null);
ShortLink shortLinkToUpdate = new ShortLink {
Id = 1, UrlKey = urlKey
};
_shortLinkService.UpdateShortLink(shortLinkToUpdate, null);
ShortLinkModel found = _shortLinkService.GetShortLinkById(id, null);
Assert.NotNull(found);
Assert.Equal(id, found.Id);
Assert.Equal(urlKey, found.UrlKey);
}
public async Task <IActionResult> Create([FromBody] ShortLinkModel shortLink)
{
if (!shortLink.ValidateIdent())
{
return(BadRequest(ErrorModel.BadRequest("invalid short ident")));
}
if (!CheckShortIdent(shortLink))
{
return(BadRequest(ErrorModel.BadRequest("short ident already in use")));
}
if (!await shortLink.ValidateURI())
{
return(BadRequest(ErrorModel.BadRequest("invalid root link")));
}
shortLink.Sanitize(asNew: true);
Db.ShortLinks.Add(shortLink);
await Db.SaveChangesAsync();
return(Created(shortLink.GUID.ToString(), shortLink));
}
public ShortLinkModel GetShortLinkByUrlKey(string urlKey, string url)
{
ShortLink shortLink = _context.ShortLinks.FirstOrDefault(l => l.UrlKey == urlKey);
return(shortLink == null ? null : ShortLinkModel.FromEntity(shortLink, url));
}
public IEnumerable <ShortLinkModel> GetAllShortLinks(string url)
{
return(_context.ShortLinks.Select(m => ShortLinkModel.FromEntity(m, url)));
}
public ShortLinkModel GetShortLinkById(long linkId, string url)
{
ShortLink shortLink = _context.ShortLinks.FirstOrDefault(link => link.Id == linkId);
return(ShortLinkModel.FromEntity(shortLink, url));
}
public ShortLinkModel UpdateShortLink(ShortLink shortLink, string url)
{
ShortLinkModel result = _repo.UpdateShortLink(shortLink, url);
return(result);
}
public ShortLinkModel GetShortLinkById(long linkId, string url)
{
ShortLinkModel shortLink = _repo.GetShortLinkById(linkId, url);
return(shortLink);
}
private bool CheckShortIdent(ShortLinkModel shortLink, Guid guid) => Db.ShortLinks .Where(sl => sl.ShortIdent.Equals(shortLink.ShortIdent) && !sl.GUID.Equals(guid)) .Count() == 0;
public async Task CountRedirect(ShortLinkModel shortLink, bool disableTracking)
{
var addr = HttpContext.Connection.RemoteIpAddress;
bool isUnique = true;
if (IPCache.Contains(addr))
{
var guid = IPCache.Get(addr);
isUnique = !guid.HasValue || guid.Value != shortLink.GUID;
}
//Db.ShortLinks.Update(shortLink);
var ipInfoToken = Configuration.GetSection("secrets")?.GetValue <string>("ipinfotoken");
var ipInfo = new IPInfoModel();
if (!ipInfoToken.IsEmpty())
{
try
{
ipInfo = await IPInfo.GetInfo(addr, ipInfoToken);
}
catch (Exception e)
{
Logger.LogError("Failed getting IPInfo: ", e);
}
}
else
{
Logger.LogWarning("IPInfo could not be collected because no IPInfo API token was provided");
}
var access = new AccessModel()
{
ShortLinkGUID = shortLink.GUID,
IsUnique = isUnique,
Timestamp = DateTime.Now,
};
if (!disableTracking)
{
access.ShortLinkGUID = shortLink.GUID;
access.City = ipInfo.City;
access.Country = ipInfo.Country;
access.IsUnique = isUnique;
access.Org = ipInfo.Org;
access.Postal = ipInfo.Postal;
access.Region = ipInfo.Region;
access.Timestamp = DateTime.Now;
access.Timezone = ipInfo.Timezone;
access.UserAgent = HttpContext.Request.Headers["User-Agent"].ToString();
}
DbCache.AddAccess(access);
if (isUnique)
{
IPCache.Push(addr, shortLink.GUID);
}
//await Db.SaveChangesAsync();
}
public bool DeleteShortLink(long linkId)
{
ShortLinkModel shortLink = GetShortLinkById(linkId, null);
return(_shortLinks.Remove(shortLink));
}
