/// <summary>
/// Initializes a new instance of the <see cref="LocaleStringResourceModel"/> class.
/// Initializing this way indicates that the resource exists
/// </summary>
/// <param name="resource">The existing resoruce.</param>
public LocaleStringResourceModel(LocaleStringResource resource)
{
IsMissing = false;
_resource = resource;
if (_resource != null) return;
_resource = new LocaleStringResource();
IsMissing = true;
}
/// <summary>
/// Deletes a locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
public virtual void DeleteLocaleStringResource(LocaleStringResource localeStringResource)
{
//if (localeStringResource == null)
// throw new ArgumentNullException("localeStringResource");
//_lsrRepository.Delete(localeStringResource);
////cache
//_cacheManager.RemoveByPattern(LOCALSTRINGRESOURCES_PATTERN_KEY);
////event notification
//_eventPublisher.EntityDeleted(localeStringResource);
}
public IActionResult PutResource([FromBody] LocaleStringResource model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var entity = _localizationService.GetById(model.Id);
entity.ResourceName = model.ResourceName;
entity.ResourceValue = model.ResourceValue;
_localizationService.Update(model);
return(NoContent());
}
/// <summary>
/// Updates the locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
public virtual void UpdateLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException(nameof(localeStringResource));
}
_lsrRepository.Update(localeStringResource);
//cache
_cacheManager.RemoveByPattern(GSLocalizationDefaults.LocaleStringResourcesPatternCacheKey);
//event notification
_eventPublisher.EntityUpdated(localeStringResource);
}
protected void SaveAndStayButton_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
try
{
LocaleStringResource localeStringResource = Save();
Response.Redirect("LocaleStringResourceDetails.aspx?LocaleStringResourceID=" + localeStringResource.LocaleStringResourceId.ToString());
}
catch (Exception exc)
{
ProcessException(exc);
}
}
}
/// <summary>
/// Deletes a locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
public virtual void DeleteLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException("localeStringResource");
}
_lsrRepository.Delete(localeStringResource);
//cache
_cacheManager.RemoveByPattern(LOCALSTRINGRESOURCES_PATTERN_KEY);
//event notification
_eventPublisher.EntityDeleted(localeStringResource);
}
/// <summary>
/// 更新区域语言字符串资源
/// </summary>
/// <param name="localeStringResource">区域语言字符串资源</param>
public virtual void UpdateLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException(nameof(localeStringResource));
}
_lsrRepository.Update(localeStringResource);
//删除缓存
_cacheManager.RemoveByPattern(LOCALSTRINGRESOURCES_PATTERN_KEY);
//发布更新通知
_eventPublisher.EntityUpdated(localeStringResource);
}
/// <summary>
/// Inserts a locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
public virtual void InsertLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException(nameof(localeStringResource));
}
_lsrRepository.Insert(localeStringResource);
//cache
_cacheManager.RemoveByPrefix(QNetLocalizationDefaults.LocaleStringResourcesPrefixCacheKey);
//event notification
_eventPublisher.EntityInserted(localeStringResource);
}
public virtual void UpdateLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException(nameof(localeStringResource));
}
using (var client = DbFactory.GetClient())
{
client.Updateable(localeStringResource).ExecuteCommand();
}
//_cacheManager.Remove<AllResources>();
_eventPublisher.EntityUpdated(localeStringResource);
}
protected void SaveButton_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
try
{
LocaleStringResource localeStringResource = ctrlLocaleStringResourceInfo.SaveInfo();
Response.Redirect("LocaleStringResources.aspx?LanguageID=" + localeStringResource.LanguageId.ToString());
}
catch (Exception exc)
{
ProcessException(exc);
}
}
}
public virtual void UpdateLocaleStringResource(LocaleStringResource resource)
{
Guard.NotNull(resource, nameof(resource));
// cache
object origKey = null;
if (_dbContext.TryGetModifiedProperty(resource, "ResourceName", out origKey))
{
ClearCacheSegment((string)origKey, resource.LanguageId);
}
ClearCacheSegment(resource.ResourceName, resource.LanguageId);
_lsrRepository.Update(resource);
}
/// <summary>
/// Deletes a locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
public virtual async Task DeleteLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException("localeStringResource");
}
await _lsrRepository.DeleteAsync(localeStringResource);
//cache
await _cacheManager.RemoveByPrefix(LOCALSTRINGRESOURCES_PATTERN_KEY);
//event notification
await _mediator.EntityDeleted(localeStringResource);
}
private void btnConfirm_Click(object sender, EventArgs e)
{
this.btnConfirm.Enabled = false;
string yEn = this.txtFormer.Text;
string text = this.txtResult.Text;
LocaleStringResource LocaleStringResource = (from x in this.efHelper.TextsOK
where x.LocaleResourceKey.Name == yEn
select x).FirstOrDefault <LocaleStringResource>();
bool flag = LocaleStringResource != null;
if (flag)
{
LocaleStringResource.ResourceValue = text;
this.listViewOK.Items[LocaleStringResource.Id.ToString()].SubItems[2].Text = LocaleStringResource.ResourceValue;
}
else
{
LocaleStringResource = (from x in this.efHelper.TextsNo
where x.LocaleResourceKey.Name == yEn
select x).FirstOrDefault <LocaleStringResource>();
bool flag2 = LocaleStringResource != null;
if (flag2)
{
this.efHelper.TextsNo.Remove(LocaleStringResource);
this.listViewNo.Items.Remove(this.listViewNo.SelectedItems[0]);
LocaleStringResource.ResourceValue = text;
this.efHelper.TextsOK.Add(LocaleStringResource);
}
ListViewItem listViewItem = this.listViewOK.Items.Add(LocaleStringResource.Id.ToString());
listViewItem.SubItems.Add(LocaleStringResource.LocaleResourceKey.Name);
listViewItem.SubItems.Add(LocaleStringResource.ResourceValue);
}
try
{
bool flag3 = this.listViewNo.Items.Count - 1 > this.listViewNo.SelectedItems[0].Index;
if (flag3)
{
this.listViewNo.Items[this.listViewNo.SelectedItems[0].Index].Selected = true;
this.listViewNo.Items[this.listViewNo.SelectedItems[0].Index].EnsureVisible();
}
}
catch (Exception value)
{
Console.WriteLine(value);
}
this.btnConfirm.Enabled = true;
this.listViewNo.Items[0].Selected = true;
}
public ActionResult ResourceAdd(int languageId, [Bind(Exclude = "Id")] LanguageResourceModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageLanguages))
{
return(AccessDeniedView());
}
if (model.Name != null)
{
model.Name = model.Name.Trim();
}
if (model.Value != null)
{
model.Value = model.Value.Trim();
}
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
var res = _localizationService.GetLocaleStringResourceByName(model.Name, model.LanguageId, false);
if (res == null)
{
var resource = new LocaleStringResource {
LanguageId = languageId
};
resource.ResourceName = model.Name;
resource.ResourceValue = model.Value;
_localizationService.InsertLocaleStringResource(resource);
}
else
{
return
(Json(new DataSourceResult
{
Errors =
string.Format(
_localizationService.GetResource(
"Admin.Configuration.Languages.Resources.NameAlreadyExists"), model.Name)
}));
}
return(new NullJsonResult());
}
/// <summary>
/// Inserts a locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
public virtual async Task InsertLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException("localeStringResource");
}
localeStringResource.ResourceName = localeStringResource.ResourceName.ToLowerInvariant();
await _lsrRepository.InsertAsync(localeStringResource);
//cache
await _cacheBase.RemoveByPrefix(CacheKey.LOCALSTRINGRESOURCES_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(localeStringResource);
}
public IActionResult Put(LocaleStringResource entityModel)
{
var localeStringResource = _localeStringResourceService.FirstOrDefault(x => x.Id == entityModel.Id);
//save it and respond
localeStringResource.ResourceName = entityModel.ResourceName;
localeStringResource.ResourceValue = entityModel.ResourceValue;
localeStringResource.LanguageId = entityModel.LanguageId;
_localeStringResourceService.Update(localeStringResource);
VerboseReporter.ReportSuccess("Sửa ngôn ngữ thành công", "post");
return(RespondSuccess(localeStringResource));
}
/// <summary>
/// Updates the locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
public virtual async Task UpdateLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException("localeStringResource");
}
localeStringResource.ResourceName = localeStringResource.ResourceName.ToLowerInvariant();
await _lsrRepository.UpdateAsync(localeStringResource);
//cache
await _cacheManager.RemoveByPattern(LOCALSTRINGRESOURCES_PATTERN_KEY);
//event notification
await _mediator.EntityUpdated(localeStringResource);
}
private LocaleStringResource DataRowToLocaleStringResource(DataRow data)
{
if (data == null)
{
return(null);
}
var cat = new LocaleStringResource();
cat.Id = new Guid(data["Id"].ToString());
cat.ResourceValue = data["ResourceValue"].ToString();
cat.LocaleResourceKey_Id = new Guid(data["LocaleResourceKey_Id"].ToString());
cat.Language_Id = new Guid(data["Language_Id"].ToString());
return(cat);
}
/// <summary>
/// Deletes a locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
public virtual void DeleteLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException("localeStringResource");
}
// cache
this.GetResourceValues(localeStringResource.LanguageId).Remove(localeStringResource.ResourceName);
// db
_lsrRepository.Delete(localeStringResource);
//event notification
_eventPublisher.EntityDeleted(localeStringResource);
}
/// <summary>
/// Updates the locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
public virtual void UpdateLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException("localeStringResource");
}
localeStringResource.ResourceName = localeStringResource.ResourceName.ToLowerInvariant();
_lsrRepository.Update(localeStringResource);
//cache
_cacheManager.RemoveByPattern(LOCALSTRINGRESOURCES_PATTERN_KEY);
//event notification
_eventPublisher.EntityUpdated(localeStringResource);
}
/// <summary>
/// Add a locale resource (if new) or update an existing one
/// </summary>
/// <param name="plugin">Plugin</param>
/// <param name="localizationService">Localization service</param>
/// <param name="languageService">Language service</param>
/// <param name="resourceName">Resource name</param>
/// <param name="resourceValue">Resource value</param>
/// <param name="languageCulture">Language culture code. If null or empty, then a resource will be added for all languages</param>
public static async Task AddOrUpdatePluginLocaleResource(this BasePlugin plugin,
ILocalizationService localizationService, ILanguageService languageService,
string resourceName, string resourceValue, string languageCulture = null)
{
//actually plugin instance is not required
if (plugin == null)
{
throw new ArgumentNullException("plugin");
}
if (localizationService == null)
{
throw new ArgumentNullException("localizationService");
}
if (languageService == null)
{
throw new ArgumentNullException("languageService");
}
if (string.IsNullOrEmpty(resourceName))
{
resourceName = resourceName.ToLowerInvariant();
}
foreach (var lang in await languageService.GetAllLanguages(true))
{
if (!String.IsNullOrEmpty(languageCulture) && !languageCulture.Equals(lang.LanguageCulture))
{
continue;
}
var lsr = await localizationService.GetLocaleStringResourceByName(resourceName, lang.Id, false);
if (lsr == null)
{
lsr = new LocaleStringResource
{
LanguageId = lang.Id,
ResourceName = resourceName,
ResourceValue = resourceValue
};
await localizationService.InsertLocaleStringResource(lsr);
}
else
{
lsr.ResourceValue = resourceValue;
await localizationService.UpdateLocaleStringResource(lsr);
}
}
}
private void BindData()
{
LocaleStringResource localeStringResource = LocaleStringResourceManager.GetLocaleStringResourceByID(this.LocaleStringResourceID);
if (localeStringResource != null)
{
Language language = LanguageManager.GetLanguageByID(localeStringResource.LanguageID);
if (language != null)
{
hlBackToResources.NavigateUrl = CommonHelper.GetStoreAdminLocation() + "LocaleStringResources.aspx?LanguageID=" + localeStringResource.LanguageID.ToString();
}
}
else
{
Response.Redirect("LocaleStringResources.aspx");
}
}
public ActionResult OptionCreatePopup(string btnId, string formId, LanguageResourceModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageLanguages))
{
return(AccessDeniedView());
}
if (model.Name != null)
{
model.Name = model.Name.Trim();
}
if (model.Value != null)
{
model.Value = model.Value.Trim();
}
if (!ModelState.IsValid)
{
//display the first model error
var modelStateErrors = this.ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage);
return(Content(modelStateErrors.FirstOrDefault()));
}
var res = _localizationService.GetLocaleStringResourceByName(model.Name, model.LanguageId, false);
if (res == null)
{
var resource = new LocaleStringResource {
LanguageId = model.LanguageId
};
resource.ResourceName = model.Name;
resource.ResourceValue = model.Value;
resource.IsTouched = true;
_localizationService.InsertLocaleStringResource(resource);
}
else
{
return(Content(string.Format(_localizationService.GetResource("Admin.Configuration.Languages.Resources.NameAlreadyExists"), model.Name)));
}
ViewBag.RefreshPage = true;
ViewBag.btnId = btnId;
ViewBag.formId = formId;
//If we got this far, something failed, redisplay form
return(View(model));
}
// PUT api/<controller>/5
/// <summary>
/// Puts the specified identifier.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
/// <exception cref="HttpResponseException"></exception>
public LocaleStringResource Put(string id, [FromBody] LocaleStringResource value)
{
LocaleStringResource objItem = new LocaleStringResource();
try
{
objItem = LocaleStringResourceManager.UpdateItem(value);
}
catch (Exception ObjEx)
{
IfindLogManager.AddItem(new IfindLog()
{
LinkUrl = Request.RequestUri.AbsoluteUri, Exception = ObjEx.Message, Message = ObjEx.StackTrace
});
}
return(objItem);
}
public void ExportCsv()
{
var testGuid = Guid.NewGuid();
var resourceKey1 = new LocaleResourceKey
{
DateAdded = DateTime.UtcNow,
Id = Guid.NewGuid(),
Name = "testKey1",
Notes = "test notes"
};
var resourceValue1 = new LocaleStringResource
{
LocaleResourceKey = resourceKey1,
ResourceValue = "testValue1"
};
var resourceKey2 = new LocaleResourceKey
{
DateAdded = DateTime.UtcNow,
Id = Guid.NewGuid(),
Name = "testKey2",
Notes = "test notes"
};
var resourceValue2 = new LocaleStringResource
{
LocaleResourceKey = resourceKey2,
ResourceValue = "testValue2"
};
var language = new Language {
Id = testGuid, LanguageCulture = "en-GB", Name = "TestLanguage"
};
_localizationRepositorySub.AllLanguageResources(testGuid).Returns(new List <LocaleStringResource> {
resourceValue1, resourceValue2
});
_localizationRepositorySub.Get(testGuid).Returns(language);
var csv = _localizationService.ToCsv(language);
Assert.AreEqual(csv, "testKey1,testValue1\r\ntestKey2,testValue2\r\n");
}
public LocaleStringResource SaveInfo()
{
LocaleStringResource localeStringResource = LocaleStringResourceManager.GetLocaleStringResourceByID(this.LocaleStringResourceID);
if (localeStringResource != null)
{
localeStringResource = LocaleStringResourceManager.UpdateLocaleStringResource(localeStringResource.LocaleStringResourceID,
localeStringResource.LanguageID, txtResourceName.Text, txtResourceValue.Text);
}
else
{
localeStringResource = LocaleStringResourceManager.InsertLocaleStringResource(
this.LanguageID, txtResourceName.Text,
txtResourceValue.Text);
}
return(localeStringResource);
}
public void Edit(LocaleStringResource locstr)
{
try
{
var bls = new LocaleStringResourceBusiness();
bls.Edit(locstr);
}
catch (Exception ex)
{
var httpError = new HttpResponseMessage()
{
StatusCode = (HttpStatusCode)422,
ReasonPhrase = ex.Message
};
throw new HttpResponseException(httpError);
}
}
/// <summary>
/// Inserts a locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
public virtual void InsertLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException("localeStringResource");
}
_lsrRepository.Insert(localeStringResource);
//// cache
var holder = this.GetResourceValues(localeStringResource.LanguageId) as ConcurrentDictionary <string, Tuple <int, string> >;
holder.TryAdd(
localeStringResource.ResourceName,
new Tuple <int, string>(localeStringResource.Id, localeStringResource.ResourceValue));
//event notification
_eventPublisher.EntityInserted(localeStringResource);
}
public static void AddOrUpdatePluginLocaleResource(this TemelEklenti plugin,
ILocalizationService localizationService, ILanguageService languageService,
string resourceName, string resourceValue, string languageCulture = null)
{
//actually plugin instance is not required
if (plugin == null)
{
throw new ArgumentNullException(nameof(plugin));
}
if (localizationService == null)
{
throw new ArgumentNullException(nameof(localizationService));
}
if (languageService == null)
{
throw new ArgumentNullException(nameof(languageService));
}
foreach (var lang in languageService.GetAllLanguages(true))
{
if (!string.IsNullOrEmpty(languageCulture) && !languageCulture.Equals(lang.DilKültürü))
{
continue;
}
var lsr = localizationService.GetLocaleStringResourceByName(resourceName, lang.Id, false);
if (lsr == null)
{
lsr = new LocaleStringResource
{
LanguageId = lang.Id,
ResourceName = resourceName,
ResourceValue = resourceValue
};
localizationService.InsertLocaleStringResource(lsr);
}
else
{
lsr.ResourceValue = resourceValue;
localizationService.UpdateLocaleStringResource(lsr);
}
}
}
protected void DeleteButton_Click(object sender, EventArgs e)
{
try
{
LocaleStringResourceManager.DeleteLocaleStringResource(this.LocaleStringResourceID);
LocaleStringResource localeStringResource = LocaleStringResourceManager.GetLocaleStringResourceByID(this.LocaleStringResourceID);
if (localeStringResource != null)
{
Response.Redirect("LocaleStringResources.aspx?LanguageID=" + localeStringResource.LanguageID.ToString());
}
else
{
Response.Redirect("LocaleStringResources.aspx");
}
}
catch (Exception exc)
{
ProcessException(exc);
}
}
/// <summary>
/// Add a locale resource (if new) or update an existing one
/// </summary>
/// <param name="plugin">Plugin</param>
/// <param name="localizationService">Localization service</param>
/// <param name="languageService">Language service</param>
/// <param name="resourceName">Resource name</param>
/// <param name="resourceValue">Resource value</param>
public static void AddOrUpdatePluginLocaleResource(this BasePlugin plugin,
ILocalizationService localizationService,
ILanguageService languageService,
string resourceName,
string resourceValue)
{
// Actually plugin instance is not required
if (plugin == null)
{
throw new ArgumentNullException("plugin");
}
if (localizationService == null)
{
throw new ArgumentNullException("localizationService");
}
if (languageService == null)
{
throw new ArgumentNullException("languageService");
}
foreach (var lang in languageService.GetAllLanguages(true))
{
var lsr = localizationService.GetLocaleStringResourceByName(resourceName, lang.Id, false);
if (lsr == null)
{
lsr = new LocaleStringResource()
{
LanguageId = lang.Id,
ResourceName = resourceName,
ResourceValue = resourceValue,
IsFromPlugin = true
};
localizationService.InsertLocaleStringResource(lsr);
}
else
{
lsr.ResourceValue = resourceValue;
localizationService.UpdateLocaleStringResource(lsr);
}
}
}
public ActionResult ResourceAdd(int id, LanguageResourceModel model, GridCommand command)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageLanguages))
{
return(AccessDeniedView());
}
if (model.Name != null)
{
model.Name = model.Name.Trim();
}
if (model.Value != null)
{
model.Value = model.Value.Trim();
}
if (!ModelState.IsValid)
{
//display the first model error
var modelStateErrors = this.ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage);
return(Content(modelStateErrors.FirstOrDefault()));
}
var res = _localizationService.GetLocaleStringResourceByName(model.Name, model.LanguageId, false);
if (res == null)
{
var resource = new LocaleStringResource {
LanguageId = id
};
resource.ResourceName = model.Name;
resource.ResourceValue = model.Value;
resource.IsTouched = true;
_localizationService.InsertLocaleStringResource(resource);
}
else
{
return(Content(string.Format(_localizationService.GetResource("Admin.Configuration.Languages.Resources.NameAlreadyExists"), model.Name)));
}
return(Resources(id, command));
}
/// <summary>
/// Inserts a locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
/// <remarks></remarks>
public virtual LocaleStringResource InsertLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
throw new ArgumentNullException("localeStringResource");
_localeStringResourceCollection.Insert(localeStringResource);
//cache
_cacheManager.RemoveByPattern(LOCALSTRINGRESOURCES_PATTERN_KEY);
return localeStringResource;
}
/// <summary>
/// Deserialize the xml language file to an in memory collection for modification (and maybe inserting?)
/// </summary>
/// <param name="languagesXmlFileLocation">The languages XML file location.</param>
/// <returns></returns>
public List<Pair<Language, List<LocaleStringResource>>> DeserializeLanguagesFile(string languagesXmlFileLocation)
{
var result = new List<Pair<Language, List<LocaleStringResource>>>();
var originalXmlDocument = new XmlDocument();
originalXmlDocument.Load(languagesXmlFileLocation);
foreach (XmlNode languageNode in originalXmlDocument.SelectNodes(@"//Languages/Language"))
{
var pair = new Pair<Language, List<LocaleStringResource>>();
pair.First = GetLanguage(languageNode);
pair.Second = new List<LocaleStringResource>();
result.Add(pair);
var resources = new List<LocaleStringResourceParent>();
foreach (XmlNode resNode in languageNode.SelectNodes(@"LocaleResource"))
resources.Add(new LocaleStringResourceParent(resNode));
var sb = new StringBuilder();
var writer = XmlWriter.Create(sb);
writer.WriteStartDocument();
writer.WriteStartElement("Language", "");
writer.WriteStartAttribute("Name", "");
writer.WriteString(languageNode.Attributes["Name"].InnerText.Trim());
writer.WriteEndAttribute();
foreach (var resource in resources)
RecursivelyWriteResource(resource, writer);
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
//read and parse resources (without <Children> elements)
var resXml = new XmlDocument();
var sr = new StringReader(sb.ToString());
resXml.Load(sr);
var resNodeList = resXml.SelectNodes(@"//Language/LocaleResource");
foreach (XmlNode resNode in resNodeList)
{
if (resNode.Attributes != null && resNode.Attributes["Name"] != null)
{
var resName = resNode.Attributes["Name"].InnerText.Trim();
var resValue = resNode.SelectSingleNode("Value").InnerText;
if (!String.IsNullOrEmpty(resName))
{
//ensure it's not duplicate
var duplicate =
pair.Second.Any(
res1 =>
resName.Equals(res1.ResourceName, StringComparison.InvariantCultureIgnoreCase));
if (duplicate)
continue;
//insert resource
var lsr = new LocaleStringResource
{
ResourceName = resName,
ResourceValue = resValue
};
pair.Second.Add(lsr);
}
}
}
}
return result;
}
/// <summary>
/// Updates the locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
/// <remarks></remarks>
public virtual LocaleStringResource UpdateLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
throw new ArgumentNullException("localeStringResource");
_localeStringResourceCollection.Update(Query.EQ("_id", localeStringResource.Id), Update<LocaleStringResource>.Replace(localeStringResource));
//cache
_cacheManager.RemoveByPattern(LOCALSTRINGRESOURCES_PATTERN_KEY);
return localeStringResource;
}
public ActionResult ResourceAdd(int id, LanguageResourceModel model, GridCommand command)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageLanguages))
return AccessDeniedView();
if (model.Name != null)
model.Name = model.Name.Trim();
if (model.Value != null)
model.Value = model.Value.Trim();
if (!ModelState.IsValid)
{
//display the first model error
var modelStateErrors = this.ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage);
return Content(modelStateErrors.FirstOrDefault());
}
var res = _localizationService.GetLocaleStringResourceByName(model.Name, model.LanguageId, false);
if (res == null)
{
var resource = new LocaleStringResource { LanguageId = id };
resource.ResourceName = model.Name;
resource.ResourceValue = model.Value;
_localizationService.InsertLocaleStringResource(resource);
}
else
{
return Content(string.Format(_localizationService.GetResource("Admin.Configuration.Languages.Resources.NameAlreadyExists"), model.Name));
}
return Resources(id, command);
}
/// <summary>
/// Add a new resource key
/// </summary>
/// <param name="newLocaleResourceKey"></param>
public LocaleResourceKey Add(LocaleResourceKey newLocaleResourceKey)
{
// Trim name to stop any issues
newLocaleResourceKey.Name = newLocaleResourceKey.Name.Trim();
// Check to see if a respource key of this name already exists
var existingResourceKey = GetResourceKey(newLocaleResourceKey.Name);
if (existingResourceKey != null)
{
throw new ApplicationException(
$"The resource key with name '{newLocaleResourceKey.Name}' already exists.");
}
newLocaleResourceKey.DateAdded = DateTime.UtcNow;
// Now add an empty value for each language
newLocaleResourceKey.LocaleStringResources = new List<LocaleStringResource>();
foreach (var language in GetAll())
{
var resourceValue = new LocaleStringResource
{
Language = language,
LocaleResourceKey = newLocaleResourceKey,
ResourceValue = string.Empty
};
language.LocaleStringResources.Add(resourceValue);
}
//Sanitze
newLocaleResourceKey = SanitizeLocaleResourceKey(newLocaleResourceKey);
// Add the key
var result = _context.LocaleResourceKey.Add(newLocaleResourceKey);
// Clear hard cache for Languages
_cacheService.ClearStartsWith(AppConstants.LocalisationCacheName);
return result;
}
public void Update(LocaleStringResource item)
{
// Check there's not an object with same identifier already in context
if (_context.LocaleStringResource.Local.Select(x => x.Id == item.Id).Any())
{
throw new ApplicationException("Object already exists in context - you do not need to call Update. Save occurs on Commit");
}
_context.Entry(item).State = EntityState.Modified;
}
/// <summary>
/// Add a new language into the system (does NOT set current language)
/// </summary>
/// <param name="language"></param>
public void Add(Language language)
{
// Does the language already exist by name or language-locale?
var existingLanguage = GetLanguageByLanguageCulture(language.LanguageCulture);
if (existingLanguage != null)
{
throw new LanguageOrCultureAlreadyExistsException(
$"There is already a language defined for language-culture '{existingLanguage.LanguageCulture}'");
}
// Make sure that the new language has a set of empty resources
language.LocaleStringResources = new List<LocaleStringResource>();
foreach (var localeResourceKey in GetAllResourceKeys())
{
var localeStringResource = new LocaleStringResource
{
Language = language,
LocaleResourceKey = localeResourceKey,
ResourceValue = string.Empty
};
language.LocaleStringResources.Add(localeStringResource);
}
language = SanitizeLanguage(language);
_cacheService.ClearStartsWith(AppConstants.LocalisationCacheName);
_context.Language.Add(language);
}
public LocaleStringResource SanitizeLocaleStringResource(LocaleStringResource localeStringResource)
{
localeStringResource.ResourceValue = StringUtils.SafePlainText(localeStringResource.ResourceValue);
return localeStringResource;
}
public CsvReport FromCsv(Language language, List<string> allLines)
{
var commaSeparator = new[] { ',' };
var report = new CsvReport();
if (allLines == null || allLines.Count == 0)
{
report.Errors.Add(new CsvErrorWarning
{
ErrorWarningType = CsvErrorWarningType.BadDataFormat,
Message = "No language keys or values found."
});
return report;
}
try
{
//var allResourceKeys = GetAllResourceKeys();
var lineCounter = 0;
foreach (var line in allLines)
{
lineCounter++;
//var keyValuePair = line.Split(commaSeparator);
var keyValuePair = line.Split(commaSeparator, 2, StringSplitOptions.None);
if (keyValuePair.Length < 2)
{
report.Errors.Add(new CsvErrorWarning
{
ErrorWarningType = CsvErrorWarningType.MissingKeyOrValue,
Message = $"Line {lineCounter}: a key and a value are required."
});
continue;
}
var key = keyValuePair[0];
if (string.IsNullOrEmpty(key))
{
// Ignore empty keys
continue;
}
key = key.Trim();
var value = keyValuePair[1];
var resourceKey = GetResourceKey(key);
if (language == null)
{
throw new ApplicationException("Unable to create language");
}
// If key does not exist, it is a new one to be created
if (resourceKey == null)
{
resourceKey = new LocaleResourceKey
{
Name = key,
DateAdded = DateTime.UtcNow,
};
Add(resourceKey);
report.Warnings.Add(new CsvErrorWarning
{
ErrorWarningType = CsvErrorWarningType.NewKeyCreated,
Message =
$"A new key named '{key}' has been created, and will require a value in all languages."
});
}
// In the new language (only) set the value for the resource
var stringResource = language.LocaleStringResources.FirstOrDefault(res => res.LocaleResourceKey.Name == resourceKey.Name);
if (stringResource != null)
{
if (!stringResource.ResourceValue.Equals(value))
{
stringResource.ResourceValue = value;
}
}
else
{
// No string resources have been created, so most probably
// this is the installer creating the keys so we need to create the
// string resource to go with it and add it
stringResource = new LocaleStringResource
{
Language = language,
LocaleResourceKey = resourceKey,
ResourceValue = value
};
Add(stringResource);
}
}
}
catch (Exception ex)
{
report.Errors.Add(new CsvErrorWarning { ErrorWarningType = CsvErrorWarningType.GeneralError, Message = ex.Message });
}
_cacheService.ClearStartsWith(AppConstants.LocalisationCacheName);
return report;
}
public void DeleteResourceValue(LocaleStringResource resourceValue)
{
_context.LocaleStringResource.Remove(resourceValue);
}
public void Delete(LocaleStringResource item)
{
_context.LocaleStringResource.Remove(item);
}
public LocaleStringResource Add(LocaleStringResource newLocaleStringResource)
{
_context.LocaleStringResource.Add(newLocaleStringResource);
return newLocaleStringResource;
}
