private async Task WriteCacheItem(ResourceRequestModel requestModel, ResourceResponseModel responseModel, CancellationToken cancel)
{
if (cacheProvider != null)
{
await cacheProvider.WriteChacheItemAsync(requestModel, responseModel, cancel);
}
}
public Task WriteChacheItemAsync(ResourceRequestModel requestModel, ResourceResponseModel responseModel, CancellationToken cancel)
{
var hashKey = BuildRequestHashCode(requestModel);
cancel.ThrowIfCancellationRequested();
memoryCache.Set(hashKey, responseModel);
return(Task.CompletedTask);
}
protected string ResolveRequestSync(string resourceName, string?culture = null)
{
culture ??= options.DefaultCulture;
string?appName = null;
if (options.UseApplicationName && !string.IsNullOrEmpty(options.ApplicationName))
{
appName = options.ApplicationName;
}
var requestModel = new ResourceRequestModel(resourceName, culture, appName);
var result = localizeService.Localize(requestModel);
return(result.Value);
}
public Task <ResourceResponseModel?> GetCachedItemAsync(ResourceRequestModel model, CancellationToken cancel)
{
var hashKey = BuildRequestHashCode(model);
cancel.ThrowIfCancellationRequested();
var success = memoryCache.TryGetValue(hashKey, out ResourceResponseModel result);
if (success)
{
return(Task.FromResult <ResourceResponseModel?>(result));
}
else
{
return(Task.FromResult <ResourceResponseModel?>(null));
}
}
public HttpResponseMessage Put([FromUri] string model)
{
try
{
JObject jObj = JObject.Parse(model);
ResourceRequestModel myModel = new ResourceRequestModel();
myModel = jObj.ToObject <ResourceRequestModel>();
var resource = ModelDataConversion.RequestModelToDataModel(myModel);
ResourceRepository.UpdateResourceInfo(resource);
var response = ModelDataConversion.DataModelToResponseModel(myModel);
return(Request.CreateResponse(System.Net.HttpStatusCode.OK, response));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(System.Net.HttpStatusCode.NotFound, ex));
}
}
public static string DataModelToResponseModel(ResourceRequestModel request)
{
string jsonRsponse = @"{
'header': {
'sourceRequest': {
'requestId': " + request.header.requestId + @"
'requestType': " + request.header.requestType + @"
'version': " + request.header.version + @"
},
'messageType':" + request.header.requestType + @"
'version':" + request.header.version + @"
'dateMsg': " + request.header.dateMsg + @"
},
'body':{
'resourceState': {
'id':" + request.body.itemSet.items.id + @"
'updateDataDate':" + DateTime.Now + @"
'tags': {
'Id': " + request.body.itemSet.items.tags.Id + @" ,
'TypeId': " + request.body.itemSet.items.tags.TypeId + @",
'Type': " + request.body.itemSet.items.tags.Type + @",
'StatusId': " + request.body.itemSet.items.tags.StatusId + @",
'Status': " + request.body.itemSet.items.tags.Status + @",
'LocationId': " + request.body.itemSet.items.tags.LocationId + @",
'LocationValue': {
'Id': " + request.body.itemSet.items.tags.LocationValue.Id + @" ,
'X': " + request.body.itemSet.items.tags.LocationValue.X + @" ,
'Y': " + request.body.itemSet.items.tags.LocationValue.Y + @" ,
'Z': " + request.body.itemSet.items.tags.LocationValue.Z + @" ,
'Rotation': " + request.body.itemSet.items.tags.LocationValue.Rotation + @"
},
'Name': " + request.body.itemSet.items.tags.Name + @"
}
}
}
}";
jsonRsponse = jsonRsponse.Replace("\n", "").ToString();
jsonRsponse = jsonRsponse.Replace("\t", "").ToString();
jsonRsponse = jsonRsponse.Replace("\r", "").ToString();
return(jsonRsponse);
}
public async Task <IActionResult> GetAsync([FromQuery] ResourceRequestModel request)
{
try
{
// TODO: Use automapper here!
var appRequest = new ResourcePaginatedRequestDto
{
WithId = request.WithId,
WithKey = request.WithKey
//LanguageCode = request.lang
};
var appResponse = await _resourcesAppService.GetAllAsync(appRequest);
var response = appResponse.ToPaginatedResponseModel <ResourceModel, ResourceDto>();
return(Ok(response));
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
private string BuildRequestHashCode(ResourceRequestModel model)
{
var hashAlg = MD5.Create();
var sb = new StringBuilder();
sb.Append(typeof(ResourceRequestModel).FullName);
sb.Append("!;");
sb.Append(model.Key);
sb.Append("!;");
sb.Append(model.Culture);
sb.Append("!;");
sb.Append(model.System);
var array = Encoding.ASCII.GetBytes(sb.ToString());
var hashBytes = hashAlg.ComputeHash(array);
sb = new StringBuilder();
foreach (var hashByte in hashBytes)
{
sb.Append(hashByte.ToString("X2"));
}
return(sb.ToString());
}
public async Task <ResourceResponseModel> LocalizeAsync(ResourceRequestModel request, CancellationToken cancel)
{
if (cacheProvider != null)
{
var result = await cacheProvider.GetCachedItemAsync(request, cancel);
if (result != null)
{
return(result);
}
}
var sb = new StringBuilder();
sb.Append(apiPath);
sb.Append(request.Key);
sb.Append("/");
sb.Append(request.Culture);
if (request.System != null)
{
sb.Append("?system=" + request.System);
}
var webRequest = await httpClient.GetAsync(sb.ToString());
if (webRequest.StatusCode == System.Net.HttpStatusCode.OK)
{
var response = JsonConvert.DeserializeObject <ResourceResponseModel>(await webRequest.Content.ReadAsStringAsync());
if (response != null)
{
if (cacheProvider != null && response.ResolveState.HasFlag(Common.Models.Utils.EResolveState.CultureComplete))
{
await cacheProvider.WriteChacheItemAsync(request, response, cancel);
}
return(response);
}
}
throw new ApplicationException("Resource Server isn't reachable");
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
var provider = new ServiceCollection()
.AddMemoryCache()
.AddSingleton(new WebLocalizeConfiguration
{
Host = "localhost",
Port = 5001
})
.AddTransient <ILocalizeCacheProvider, MemoryLocalizeCacheProvider>()
.AddTransient <ILocalizeService, WebLocalizeService>()
.BuildServiceProvider();
var serivce = provider.GetRequiredService <ILocalizeService>();
var request = new ResourceRequestModel("test", "de-de", null);
var stopwatch = new Stopwatch();
Console.WriteLine("Start request 1...");
stopwatch.Start();
var response = await serivce.LocalizeAsync(request, CancellationToken.None);
stopwatch.Stop();
Console.WriteLine($"Ergebnis: {response.Value} in {stopwatch.ElapsedMilliseconds}ms.");
stopwatch = new Stopwatch();
Console.WriteLine("Start request 2...");
stopwatch.Start();
response = await serivce.LocalizeAsync(request, CancellationToken.None);
stopwatch.Stop();
Console.WriteLine($"Ergebnis: {response.Value} in {stopwatch.ElapsedMilliseconds}ms.");
Console.ReadKey();
}
public static ResourceResponseModel Localize(this ILocalizeService localizeService, ResourceRequestModel requestModel)
{
var task = localizeService.LocalizeAsync(requestModel, CancellationToken.None);
task.Wait();
return(task.Result);
}
public async Task <ResourceResponseModel> LocalizeAsync(ResourceRequestModel request, CancellationToken cancel)
{
if (cacheProvider != null)
{
var entry = await cacheProvider.GetCachedItemAsync(request, cancel);
if (entry != null)
{
return(entry);
}
}
var itemCursor = await collection.FindAsync(m => m.ResourceKey == request.Key, cancellationToken : cancel);
var item = itemCursor.FirstOrDefault();
if (item == null)
{
return(new ResourceResponseModel(request.Key, EResolveState.None));
}
var partCulture = string.Empty;
var itemCandidates = item.ResourceItems.Where(m => m.Culture != null && m.Culture !.Equals(request.Culture, StringComparison.CurrentCultureIgnoreCase));
IEnumerable <MongoDbResourceItem> partCultureCandidatestes = new List <MongoDbResourceItem>();
if (request.Culture.Contains('-'))
{
partCulture = request.Culture.Split('-')[0];
partCultureCandidatestes = item.ResourceItems.Where(m => m.Culture != null && m.Culture !.Equals(partCulture, StringComparison.CurrentCultureIgnoreCase));
}
cancel.ThrowIfCancellationRequested();
MongoDbResourceItem?resultItem;
if (request.System != null)
{
resultItem = itemCandidates.FirstOrDefault(m => m.Application != null && m.Application !.Equals(request.System, StringComparison.CurrentCultureIgnoreCase));
if (resultItem != null)
{
var result = new ResourceResponseModel(resultItem.Value, EResolveState.System | EResolveState.CultureComplete);
await WriteCacheItem(request, result, cancel);
return(result);
}
resultItem = partCultureCandidatestes.FirstOrDefault(m => m.Application != null && m.Application !.Equals(request.System, StringComparison.CurrentCultureIgnoreCase));
if (resultItem != null)
{
return(new ResourceResponseModel(resultItem.Value, EResolveState.System | EResolveState.CultureParent));
}
}
cancel.ThrowIfCancellationRequested();
resultItem = itemCandidates.FirstOrDefault(m => string.IsNullOrEmpty(m.Application));
if (resultItem != null)
{
var result = new ResourceResponseModel(resultItem.Value, EResolveState.CultureComplete);
if (request.System == null)
{
await WriteCacheItem(request, result, cancel);
}
return(result);
}
cancel.ThrowIfCancellationRequested();
resultItem = partCultureCandidatestes.FirstOrDefault(m => string.IsNullOrEmpty(m.Application));
if (resultItem != null)
{
return(new ResourceResponseModel(resultItem.Value, EResolveState.CultureParent));
}
return(new ResourceResponseModel(request.Key, EResolveState.None));
}
public async Task <ActionResult <ResourceResponseModel> > Localize(string key, string culture, CancellationToken cancel, string application = null)
{
var model = new ResourceRequestModel(key, culture, application);
return(await Localize(model, cancel));
}
public async Task <ActionResult <ResourceResponseModel> > Localize(ResourceRequestModel model, CancellationToken cancel)
{
return(await localizeService.LocalizeAsync(model, cancel));
}
public static ResourceWithValue RequestModelToDataModel(ResourceRequestModel data)
{
return(data.body.itemSet.items.tags);
}
