public ActionResult Edit(ShortLink _shortLink)
{
var validator = new ShortURLValidator();
if (!validator.Validate(_shortLink, out Uri resultURI, out List <string> errMessages))
{
foreach (string errMessage in errMessages)
{
ModelState.AddModelError("", errMessage);
}
return(View());
}
var db = new DataContext();
var shortLink = db.ShortLinks.Find(_shortLink.ShortLinkID);
shortLink.LongUrl = _shortLink.LongUrl;
shortLink.ShortUrl = _shortLink.ShortUrl;
db.Entry(shortLink).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ShortLinkModel SaveShortLink(ShortLink shortLink, string url)
{
ShortLinkModel shortLinkModel = ShortLinkModel.FromEntity(shortLink, url);
_shortLinks.Add(shortLinkModel);
return(shortLinkModel);
}
public async Task <Response> Handle(Command message)
{
if (!Uri.IsWellFormedUriString(message.SourceUrl, UriKind.Absolute))
{
throw new InvalidOperationException("URL is not valid");
}
var existing = await _db.ShortLinks
.Where(x => x.SourceUrl == message.SourceUrl)
.ToListAsync()
// CaseSensitive search; It would be more efficient then making column case sensitive
.ContinueWith(t => t.Result.FirstOrDefault(x => x.SourceUrl == message.SourceUrl))
.ConfigureAwait(false);
if (existing != null)
{
return(_mapper.Map <Response>(existing));
}
var shortLink = new ShortLink(message.SourceUrl);
_db.ShortLinks.Add(shortLink);
await _db.SaveChangesAsync().ConfigureAwait(false);
return(_mapper.Map <Response>(shortLink));
}
/// <summary>
/// Метод проверяет ссылку на корректность
/// </summary>
/// <param name="shortLink">Объект сокращенного URL-а</param>
/// <param name="resultURI">Возвращает Uri</param>
/// <param name="errMessages">Возврвщается список сообщений об ошибке если Validate = false</param>
public bool Validate(ShortLink shortLink, out Uri resultURI, out List <string> errMessages)
{
errMessages = new List <string>();
var validator = new HttpURLValidator();
if (!validator.Validate(shortLink.LongUrl, out resultURI, out string errMessage))
{
errMessages.Add(errMessage);
}
if (string.IsNullOrWhiteSpace(shortLink.ShortUrl))
{
errMessages.Add("2107. Введите сокращенную ссылку!");
}
else if (shortLink.ShortUrl.Length != 6)
{
errMessages.Add("2110. Сокращенная ссылка должна состоит из 6 символов!");
}
if (errMessages.Count > 0)
{
return(false);
}
return(true);
}
//
// GET: /Url/Details/5
public virtual ActionResult Details(string id)
{
try
{
ShortLink shortLink = null;
using (var session = _documentStore.OpenSession())
{
shortLink = session.Load <ShortLink>(id);
}
if (shortLink == null)
{
return(View(Views.NotFound));
}
var model = Mapper.Map <UrlDetailsViewModel>(shortLink);
return(View(Views.Details, model));
}
catch (Exception)
{
throw;
}
}
//
// GET: /Go/key
public virtual ActionResult Index(string key)
{
try
{
ShortLink shortLink = null;
using (var session = _documentStore.OpenSession())
{
var results = from urls in session.Query <ShortLink>()
where urls.Key == key
select urls;
shortLink = results.FirstOrDefault();
if (shortLink != null)
{
shortLink.Request();
session.Store(shortLink);
session.SaveChanges();
}
}
if (shortLink == null)
{
return(View());
}
return(Redirect(shortLink.Url.ToString()));
}
catch (Exception)
{
return(View());
}
}
public void WriteLinkInformation(ShortLink link)
{
using (_connection)
{
_connection.ExecuteAsync(Queries.InsertLink, link);
}
}
public async Task <ShortLink> CreateShortLinkAsync(ShortLink shortLink)
{
await _context.ShortLinks.AddAsync(shortLink);
await _context.SaveChangesAsync();
return(shortLink);
}
public async Task <Result> Handle(Query message)
{
int id = ShortLink.Decode(message.ShortenedUrl);
return(await _db.ShortLinks
.Where(x => x.Id == id)
.ProjectTo <Result>()
.FirstOrDefaultAsync()
.ConfigureAwait(false));
}
public static ShortLinkModel FromEntity(ShortLink model, string hostPrefix) =>
new ShortLinkModel
{
_hostPrefix = hostPrefix,
Id = model.Id,
LongUrl = model.LongUrl,
UrlKey = model.UrlKey,
InsertionDate = model.InsertionDate,
RedirectsCount = model.RedirectsCount
};
/// <summary>
/// Generate a short url with an random unique token
/// </summary>
/// <param name="relatedTo">the related url to be short</param>
/// <returns>The generate shorted link</returns>
public async Task <ShortLink> GenerateAsync(string relatedTo)
{
var tokenEntry = new ShortLink()
{
Token = await GenerateTokenAsync(),
RelatedUrl = relatedTo
};
return(tokenEntry);
}
public async Task InsertAsync(ShortLink entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
await _entities.AddAsync(entity);
await _context.SaveChangesAsync();
}
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 ActionResult Delete(ShortLink _shortLink)
{
var db = new DataContext();
var shortLink = db.ShortLinks.Find(_shortLink.ShortLinkID);
db.ShortLinks.Remove(shortLink);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <ShortLink> CreateAsync(string link)
{
var shortLink = new ShortLink
{
Link = link,
ShortId = _shorten.Create(link)
};
var item = await _shortLinksStorage.CreateAsync(shortLink);
return(item);
}
public IActionResponse <int> Insert(ShortLink model)
{
model.Code = Randomizer.RandomString(8);
_shortLink.Add(model);
var dbRes = _uow.SaveChanges();
return(new ActionResponse <int>()
{
IsSuccessful = dbRes.ToSaveChangeResult(),
Result = model.ShortLinkId
});
}
public async Task CreateShortLink(string shortLink, string fullLink, string userName)
{
var user = string.IsNullOrEmpty(userName) ? null : new User(userName);
var expected = new ShortLink("QWERTY", "https://yahoo.com", user);
_shortLinksRepository.Setup(r => r.InsertAsync(It.IsAny <ShortLink>()))
.Returns(() => Task.Factory.StartNew(() => _shortLinks.Add(expected)));
await _service.CreateShortLinkAsync("https://yahoo.com", It.IsAny <User>());
(await _shortLinksRepository.Object.GetAllAsync()).Should().Contain(expected);
}
public ShortLinkDto(ShortLink shortLink)
{
if (shortLink == null)
{
return;
}
Key = shortLink.Key;
FullLink = shortLink.FullLink;
DateCreated = shortLink.DateCreated;
CallsCount = shortLink.CallsCount;
}
public async Task ReceiveCountIncrementShouldBeApplied()
{
const string shortUrl = "fh84ea";
var shortLing = new ShortLink {
ShortUrl = "fh84ea", SourceUrl = "https://google.com/"
};
DatabaseContextStub.ShortLinks.Add(shortLing);
await ShortenerService.GetSourceUrlByShortenUrlAsync(shortUrl);
Assert.That(shortLing.ReceiveCounter, Is.EqualTo(1));
}
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));
}
/// <summary>
/// Удаляет ссылку из БД.
/// </summary>
/// <returns>true, если ссылка удалена и false, если такой ссылки нет в БД.</returns>
public bool DeleteShortLink(long linkId)
{
ShortLink shortLink = _context.ShortLinks.FirstOrDefault(link => link.Id == linkId);
if (shortLink == null)
{
return(false);
}
_context.ShortLinks.Remove(shortLink);
_context.SaveChanges();
return(true);
}
public ViewResult GetShortLink(string url)
{
var link = new ShortLink();
ICodeGenrator codeGenerator = new CodeGenerator(db.Links.ToList());
link.Url = url;
link.ShortUrl = codeGenerator.GetUniqueRandomCode();
link.Date = DateTime.Now;
link.Counter = 0;
db.Add(link);
db.SaveChanges();
ViewBag.ShortLink = "/" + link.ShortUrl;
return(View());
}
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 ShortLink GenerateShortLink(string fullUrl, IdentityUser user)
{
string shortUrl = FreeUrlGenerate();
var shortLink = new ShortLink()
{
ShortUrl = shortUrl,
FullUrl = fullUrl,
IdentityUser = user,
CountTransitions = 0
};
return(shortLinkRepository.AddShortLink(shortLink));
}
public string CutUrl([FromBody] ParamRequest urlPath)
{
EncodeTest(urlPath);
var link = new ShortLink()
{
Url = urlPath.UrlPath,
Id = urlPath.Id
};
var urlChunk = link.GetUrlChunk();
return(urlChunk);
// return urlPath;
}
public async Task <IActionResult> Create([Bind(Prefix = "NewLink")] NewLinkViewModel model)
{
// try
// {
var link = new ShortLink
{
Key = Guid.NewGuid().ToString().Substring(0, 7),
DestinationUrl = model.DestinationUrl,
Created = DateTime.UtcNow
};
await _dbContext.SaveAsync <ShortLink>(link);
return(RedirectToAction(nameof(Index)));
// }
// catch(exce)
}
public IActionResult To(string url)
{
IQueryable <ShortLink> targetLinks = db.Links.Where((link) => link.ShortUrl.Equals(url));
if (targetLinks.Count() == 0)
{
return(View("Error"));
}
else
{
ShortLink targetLink = targetLinks.First();
targetLink.Counter++;
db.Update(targetLink);
db.SaveChanges();
return(Redirect(targetLink.Url));
}
}
public string ShortenLink(string url)
{
var linksCount = _database.GetLinksCount();
var id = linksCount + 1;
var encodedCount = _encoder.EncodeUrl(linksCount + 1);
var shorUrl = new ShortLink
{
Id = id,
Url = url,
ShortUrl = encodedCount,
CreatedDate = DateTime.UtcNow
};
_database.WriteLinkInformation(shorUrl);
return(encodedCount);
}
public static Task HandleShortenUrl(HttpContext context)
{
//HttpContext context = null;
// Perform basic form validation
if (!context.Request.HasFormContentType || !context.Request.Form.ContainsKey("url"))
{
context.Response.StatusCode = StatusCodes.Status400BadRequest;
return(context.Response.WriteAsync("Cannot process request"));
}
context.Request.Form.TryGetValue("url", out var formData);
var requestedUrl = formData.ToString();
// Test our URL
if (!Uri.TryCreate(requestedUrl, UriKind.Absolute, out Uri result))
{
context.Response.StatusCode = StatusCodes.Status400BadRequest;
return(context.Response.WriteAsync("Could not understand URL."));
}
var url = result.ToString();
// Ask for LiteDB and persist a short link
var liteDB = context.RequestServices.GetService <ILiteDatabase>();
var links = liteDB.GetCollection <ShortLink>(BsonAutoId.Int32);
// Temporary short link
var entry = new ShortLink
{
Url = url
};
// Insert our short-link
links.Insert(entry);
//var urlChunk = entry.GetUrlChunk();
//var responseUri = $"{context.Request.Scheme}://{context.Request.Host}/{urlChunk}";
//return context.Response.WriteAsync(responseUri);
var urlChunk = entry.GetUrlChunk();
var responseUri = $"{context.Request.Scheme}://{context.Request.Host}/{urlChunk}";
context.Response.Redirect($"/#{responseUri}");
return(Task.CompletedTask);
}
public async Task <IActionResult> CutLink(string longUrl)
{
// Фабрика сокращённых ссылок.
var manager = new ShortLink();
// Новая ссылка.
var link = manager.Cut(longUrl);
// Проверка на соответствие ссылки формату.
if (link == null)
{
ViewBag.Message = "Ошибка: Введённая строка не соответствует формату URL";
return(View("Index"));
}
await db.Links.AddAsync(link);
await db.SaveChangesAsync();
return(View(link));
}
