public void GivenAnEmptySaltCacheHashWillGenerateSalt()
{
var mockSaltCache = new Mock <ISaltCache>();
var savedSaltKey = "";
var savedSaltValue = "";
mockSaltCache.Setup(s => s.TryAdd(It.IsAny <string>(), It.IsAny <string>())).Callback <string, string>(
(key, value) =>
{
savedSaltKey = key;
savedSaltValue = value;
});
var mockHashProvider = new Mock <IHashProvider>();
var hashResult = new HashResult(Root.Any.String(), Root.Any.String());
mockHashProvider.Setup(h => h.CreateHash(It.IsAny <string>(), It.IsAny <string>())).Returns(hashResult);
var sut = new HashRepository(mockHashProvider.Object, mockSaltCache.Object, true);
const string unhashed = "unhashed";
var entity = new WordMetric(unhashed, unhashed, Root.Any.Integer(), null);
var hashedEntities = sut.Hash(new[] { entity });
var hashedEntity = hashedEntities.First();
Assert.IsFalse(unhashed == hashedEntity.Id);
Assert.AreEqual(hashResult.Hash, hashedEntity.Id);
Assert.AreEqual(hashResult.Salt, hashedEntity.Salt);
Assert.AreEqual(hashResult.Salt, savedSaltValue);
Assert.AreEqual(unhashed, savedSaltKey);
}
public NetworkManager(ITcpServer tcpServer, IHashRepository hashRepository, IHashLoader hashLoader,
[Named("GameUserRepository")] IUserRepository gameUserRepository,
[Named("PendingUserRepository")] IUserRepository pendingUserRepository)
{
Server = (TcpServer)tcpServer;
_hashRepository = (HashRepository)hashRepository;
_hashLoader = (HashLoader)hashLoader;
_userRepository = (GameUserRepository)gameUserRepository;
_pendingRepository = (PendingUserRepository)pendingUserRepository;
}
public void GivenWordWhichExistsInTheCacheThenHashWillReuseSalt()
{
var mockSaltCache = new Mock <ISaltCache>();
var knownSalt = Root.Any.String();
var knownWord = Root.Any.String();
mockSaltCache.Setup(s => s.Get(knownWord)).Returns(knownSalt);
var mockHashProvider = new Mock <IHashProvider>();
var hashResult = new HashResult(Root.Any.String(), knownSalt);
mockHashProvider.Setup(h => h.CreateHash(knownWord, knownSalt)).Returns(hashResult);
var sut = new HashRepository(mockHashProvider.Object, mockSaltCache.Object, true);
var entity = new WordMetric(knownWord, knownWord, Root.Any.Integer(), null);
var hashedEntities = sut.Hash(new[] { entity });
mockHashProvider.Verify(h => h.CreateHash(knownWord, knownSalt), Times.Once);
}
public async Task <ActionResult> Post()
{
// URL обратного вызова
var callbackUrl = Request.Headers.ContainsKey("X-CallbackUrl") ? Request.Headers["X-CallbackUrl"].ToString() : null;
var accept = Request.Headers["Accept"].ToString();
// Получим информацию о файле
var mime = Request.ContentType;
if (mime == null)
{
return(StatusCode(415)); // Unsupported Media Type
}
var type = await TypeRepository.FindByMimeAsync(mime);
if (type == null)
{
return(StatusCode(415)); // Unsupported Media Type
}
// Сформируем объект Image
var newImage = new Image
{
Size = 0, // Исходный
Type = type.Id,
Created = DateTime.Now
};
await using (var ms = new MemoryStream())
{
await Request.Body.CopyToAsync(ms);
newImage.Data = ms.ToArray();
}
newImage.Md5 = newImage.Data.GetMd5Hash();
// Сформируем записи в БД
var imageId = await ImageRepository.CreateAsync(newImage);
await HashRepository.CreateAsync(new Hash { Id = imageId });
// Запрос на получение хешей
_ = Task.Run(async() =>
{
var hashServiceUrl = Configuration.GetValue <string>("HashService");
if (!string.IsNullOrWhiteSpace(hashServiceUrl))
{
using var client = HttpClientFactory.CreateClient();
// Передадим картинку на обработку в сервис распознования
using var request = new HttpRequestMessage(HttpMethod.Post, hashServiceUrl)
{
Content = new ByteArrayContent(newImage.Data)
};
request.Headers.Add("Accept", accept);
request.Content.Headers.ContentType = new MediaTypeHeaderValue(mime);
using var response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
{
var result = new Hash {
Id = imageId
};
// Распарсим результат
if (response.Content.Headers.ContentType.MediaType == "application/json")
{
var json = JObject.Parse(await response.Content.ReadAsStringAsync());
result.AHash = json.SelectToken("aHash").Value <long>();
result.PHash = json.SelectToken("pHash").Value <long>();
result.DHash = json.SelectToken("dHash").Value <long>();
}
else
{
var xml = new XmlDocument();
xml.LoadXml(await response.Content.ReadAsStringAsync());
foreach (XmlNode elem in xml.DocumentElement.ChildNodes)
{
var name = elem.Name;
var value = elem.InnerText;
switch (name)
{
case "AHash":
result.AHash = long.Parse(value);
break;
case "PHash":
result.PHash = long.Parse(value);
break;
case "DHash":
result.DHash = long.Parse(value);
break;
default:
continue;
}
}
}
// Обновим данные в БД картинок
await HashRepository.UpdateAsync(result);
// Передадим загружающему изображение
if (!string.IsNullOrWhiteSpace(callbackUrl))
{
using var returnRequest = new HttpRequestMessage(HttpMethod.Post, callbackUrl)
{
Content = new ByteArrayContent(await response.Content.ReadAsByteArrayAsync())
};
request.Content.Headers.ContentType = new MediaTypeHeaderValue(response.Content.Headers.ContentType.MediaType);
await client.SendAsync(returnRequest);
}
}
}
}
);
var fileName = newImage.Md5.ToString().Replace("-", "").Insert(8, "/").Insert(6, "/").Insert(4, "/").Insert(2, "/");
var fileExt = mime switch
{
"image/gif" => "gif",
"image/png" => "png",
"image/svg+xml" => "svg",
_ => "jpg",
};
return(Ok(new UploadResult {
Uri = $"{Configuration.GetValue<string>("BaseUri")}{fileName}.{fileExt}"
}));
}
public HashBDC()
{
this._hashRepo = new HashRepository();
}
