public bool SavePackageSettings(PackageSettingsDto packageSettings, out string errorMessage)
{
errorMessage = string.Empty;
try
{
string value;
var changed = false;
var languagePack = LanguagePackController.GetLanguagePackByPackage(packageSettings.PackageId);
if (packageSettings.EditorActions.TryGetValue("languageId", out value) &&
!string.IsNullOrEmpty(value) && value != languagePack.LanguageID.ToString())
{
languagePack.LanguageID = Convert.ToInt32(value);
changed = true;
}
if (changed)
{
LanguagePackController.SaveLanguagePack(languagePack);
}
return(true);
}
catch (Exception ex)
{
Logger.Error(ex);
errorMessage = ex.Message;
return(false);
}
}
public override void Install()
{
try
{
InstalledLanguagePack = LanguagePackController.GetLanguagePackByPackage(Package.PackageID);
if (InstalledLanguagePack != null)
{
LanguagePack.LanguagePackID = InstalledLanguagePack.LanguagePackID;
}
TempLanguage = Localization.Localization.GetLocale(Language.Code);
if (TempLanguage != null)
{
Language.LanguageID = TempLanguage.LanguageID;
}
if (LanguagePack.PackageType == Localization.LanguagePackType.Core)
{
Localization.Localization.SaveLanguage(Language);
}
LanguagePack.PackageID = Package.PackageID;
LanguagePack.LanguageID = Language.LanguageID;
LanguagePackController.SaveLanguagePack(LanguagePack);
Log.AddInfo(string.Format(Util.LANGUAGE_Registered, Language.Text));
base.Install();
Completed = true;
}
catch (Exception ex)
{
Log.AddFailure(ex);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// The DeleteLanguage method deletes the Language
/// from the data Store.
/// </summary>
/// -----------------------------------------------------------------------------
private void DeleteLanguage()
{
try
{
// Attempt to get the LanguagePack
LanguagePackInfo tempLanguagePack = LanguagePackController.GetLanguagePackByPackage(this.Package.PackageID);
// Attempt to get the Locale
Locale language = LocaleController.Instance.GetLocale(tempLanguagePack.LanguageID);
if (tempLanguagePack != null)
{
LanguagePackController.DeleteLanguagePack(tempLanguagePack);
}
// fix DNN-26330 Removing a language pack extension removes the language
// we should not delete language when deleting language pack, as there is just a loose relationship
// if (language != null && tempLanguagePack.PackageType == LanguagePackType.Core)
// {
// Localization.DeleteLanguage(language);
// }
this.Log.AddInfo(string.Format(Util.LANGUAGE_UnRegistered, language.Text));
}
catch (Exception ex)
{
this.Log.AddFailure(ex);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// The Install method installs the language component
/// </summary>
/// <history>
/// [cnurse] 02/11/2008 created
/// </history>
/// -----------------------------------------------------------------------------
public override void Install()
{
if (LanguagePackType == LanguagePackType.Core || LanguagePack.DependentPackageID > 0)
{
try
{
//Attempt to get the LanguagePack
InstalledLanguagePack = LanguagePackController.GetLanguagePackByPackage(Package.PackageID);
if (InstalledLanguagePack != null)
{
LanguagePack.LanguagePackID = InstalledLanguagePack.LanguagePackID;
}
//Attempt to get the Locale
TempLanguage = LocaleController.Instance.GetLocale(Language.Code);
if (TempLanguage != null)
{
Language.LanguageId = TempLanguage.LanguageId;
}
if (LanguagePack.PackageType == LanguagePackType.Core)
{
//Update language
Localization.Localization.SaveLanguage(Language);
}
var _settings = PortalController.GetCurrentPortalSettings();
if (_settings != null)
{
Locale enabledLanguage;
if (!LocaleController.Instance.GetLocales(_settings.PortalId).TryGetValue(Language.Code, out enabledLanguage))
{
//Add language to portal
Localization.Localization.AddLanguageToPortal(_settings.PortalId, Language.LanguageId, true);
}
}
//Set properties for Language Pack
LanguagePack.PackageID = Package.PackageID;
LanguagePack.LanguageID = Language.LanguageId;
//Update LanguagePack
LanguagePackController.SaveLanguagePack(LanguagePack);
Log.AddInfo(string.Format(Util.LANGUAGE_Registered, Language.Text));
//install (copy the files) by calling the base class
base.Install();
}
catch (Exception ex)
{
Log.AddFailure(ex);
}
}
else
{
Completed = true;
Skipped = true;
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// The Install method installs the language component.
/// </summary>
/// -----------------------------------------------------------------------------
public override void Install()
{
if (this.LanguagePackType == LanguagePackType.Core || this.LanguagePack.DependentPackageID > 0)
{
try
{
// Attempt to get the LanguagePack
this.InstalledLanguagePack = LanguagePackController.GetLanguagePackByPackage(this.Package.PackageID);
if (this.InstalledLanguagePack != null)
{
this.LanguagePack.LanguagePackID = this.InstalledLanguagePack.LanguagePackID;
}
// Attempt to get the Locale
this.TempLanguage = LocaleController.Instance.GetLocale(this.Language.Code);
if (this.TempLanguage != null)
{
this.Language.LanguageId = this.TempLanguage.LanguageId;
}
if (this.LanguagePack.PackageType == LanguagePackType.Core)
{
// Update language
Localization.SaveLanguage(this.Language);
}
// Set properties for Language Pack
this.LanguagePack.PackageID = this.Package.PackageID;
this.LanguagePack.LanguageID = this.Language.LanguageId;
// Update LanguagePack
LanguagePackController.SaveLanguagePack(this.LanguagePack);
this.Log.AddInfo(string.Format(Util.LANGUAGE_Registered, this.Language.Text));
// install (copy the files) by calling the base class
base.Install();
}
catch (Exception ex)
{
this.Log.AddFailure(ex);
}
}
else
{
this.Completed = true;
this.Skipped = true;
}
}
public void DeleteExtensionPackage(PackageInfo package)
{
switch (package.PackageType)
{
case "Auth_System":
AuthenticationInfo authSystem = AuthenticationController.GetAuthenticationServiceByPackageID(package.PackageID);
if (authSystem != null)
{
AuthenticationController.DeleteAuthentication(authSystem);
}
break;
case "CoreLanguagePack":
LanguagePackInfo languagePack = LanguagePackController.GetLanguagePackByPackage(package.PackageID);
if (languagePack != null)
{
LanguagePackController.DeleteLanguagePack(languagePack);
}
break;
case "Module":
var controller = new DesktopModuleController();
DesktopModuleInfo desktopModule = DesktopModuleController.GetDesktopModuleByPackageID(package.PackageID);
if (desktopModule != null)
{
controller.DeleteDesktopModule(desktopModule);
}
break;
case "SkinObject":
SkinControlInfo skinControl = SkinControlController.GetSkinControlByPackageID(package.PackageID);
if (skinControl != null)
{
SkinControlController.DeleteSkinControl(skinControl);
}
break;
}
DeletePackageInternal(package);
}
public PackageInfoDto GetPackageDetail(int portalId, PackageInfo package)
{
var languagePack = LanguagePackController.GetLanguagePackByPackage(package.PackageID);
var languagesTab = TabController.GetTabByTabPath(portalId, "//Admin//Languages", Null.NullString);
var detail = new CoreLanguagePackageDetailDto(portalId, package)
{
Locales = Utility.GetAllLanguagesList(),
LanguageId = languagePack.LanguageID,
EditUrlFormat = this.NavigationManager.NavigateURL(languagesTab, "", "Locale={0}")
};
if (languagePack.PackageType == LanguagePackType.Extension)
{
//Get all the packages but only bind to combo if not a language package
detail.Packages = Utility.GetAllPackagesListExceptLangPacks();
}
return(detail);
}
private void DeleteLanguage()
{
try
{
LanguagePackInfo tempLanguagePack = LanguagePackController.GetLanguagePackByPackage(Package.PackageID);
Locale language = Localization.Localization.GetLocaleByID(tempLanguagePack.LanguageID);
if (tempLanguagePack != null)
{
LanguagePackController.DeleteLanguagePack(tempLanguagePack);
}
if (language != null && tempLanguagePack.PackageType == Localization.LanguagePackType.Core)
{
Localization.Localization.DeleteLanguage(language);
}
Log.AddInfo(string.Format(Util.LANGUAGE_UnRegistered, language.Text));
}
catch (Exception ex)
{
Log.AddFailure(ex);
}
}
public LanguagePackWriter(PackageInfo package) : base(package)
{
_LanguagePack = LanguagePackController.GetLanguagePackByPackage(package.PackageID);
if (LanguagePack != null)
{
_Language = LocaleController.Instance.GetLocale(_LanguagePack.LanguageID);
if (LanguagePack.PackageType == LanguagePackType.Core)
{
BasePath = Null.NullString;
}
else
{
//Get the BasePath of the Dependent Package
PackageInfo dependendentPackage = PackageController.Instance.GetExtensionPackage(Null.NullInteger, p => p.PackageID == LanguagePack.DependentPackageID);
PackageWriterBase dependentPackageWriter = PackageWriterFactory.GetWriter(dependendentPackage);
BasePath = dependentPackageWriter.BasePath;
}
}
else
{
BasePath = Null.NullString;
}
}
public LanguagePackWriter(PackageInfo package)
: base(package)
{
_LanguagePack = LanguagePackController.GetLanguagePackByPackage(package.PackageID);
if (LanguagePack != null)
{
_Language = Localization.Localization.GetLocaleByID(_LanguagePack.LanguageID);
if (LanguagePack.PackageType == LanguagePackType.Core)
{
BasePath = Null.NullString;
}
else
{
PackageInfo dependendentPackage = PackageController.GetPackage(LanguagePack.DependentPackageID);
PackageWriterBase dependentPackageWriter = PackageWriterFactory.GetWriter(dependendentPackage);
BasePath = dependentPackageWriter.BasePath;
}
}
else
{
BasePath = Null.NullString;
}
}
private void GetAvaialableLanguagePacks(IDictionary <string, PackageInfo> validPackages)
{
try
{
StreamReader myResponseReader = UpdateService.GetLanguageList();
var xmlDoc = new XmlDocument();
xmlDoc.Load(myResponseReader);
XmlNodeList languages = xmlDoc.SelectNodes("available/language");
if (languages != null)
{
var installedPackages = PackageController.Instance.GetExtensionPackages(Null.NullInteger, p => p.PackageType == "CoreLanguagePack");
var installedLanguages = installedPackages.Select(package => LanguagePackController.GetLanguagePackByPackage(package.PackageID)).ToList();
foreach (XmlNode language in languages)
{
string cultureCode = "";
string version = "";
foreach (XmlNode child in language.ChildNodes)
{
if (child.Name == "culturecode")
{
cultureCode = child.InnerText;
}
if (child.Name == "version")
{
version = child.InnerText;
}
}
if (!string.IsNullOrEmpty(cultureCode) && !string.IsNullOrEmpty(version) && version.Length == 6)
{
var myCIintl = new CultureInfo(cultureCode, true);
version = version.Insert(4, ".").Insert(2, ".");
var package = new PackageInfo {
Owner = OwnerUpdateService, Name = "LanguagePack-" + myCIintl.Name, FriendlyName = myCIintl.NativeName
};
package.Name = myCIintl.NativeName;
package.PackageType = "CoreLanguagePack";
package.Description = cultureCode;
Version ver = null;
Version.TryParse(version, out ver);
package.Version = ver;
if (
installedLanguages.Any(
l =>
LocaleController.Instance.GetLocale(l.LanguageID).Code.ToLowerInvariant().Equals(cultureCode.ToLowerInvariant()) &&
installedPackages.First(p => p.PackageID == l.PackageID).Version >= ver))
{
continue;
}
if (validPackages.Values.Any(p => p.Name == package.Name))
{
var existPackage = validPackages.Values.First(p => p.Name == package.Name);
if (package.Version > existPackage.Version)
{
existPackage.Version = package.Version;
}
}
else
{
validPackages.Add(cultureCode, package);
}
}
}
}
}
catch (Exception)
{
//suppress for now - need to decide what to do when webservice is unreachable
//throw;
//same problem happens in InstallWizard.aspx.cs in BindLanguageList method
}
}
private void BindGrid(string installPath, DataGrid grid)
{
var packages = new List <PackageInfo>();
var invalidPackages = new List <string>();
foreach (string file in Directory.GetFiles(installPath))
{
if (file.ToLower().EndsWith(".zip") || file.ToLower().EndsWith(".resources"))
{
Stream inputStream = new FileStream(file, FileMode.Open, FileAccess.Read);
var unzip = new ZipInputStream(inputStream);
try
{
ZipEntry entry = unzip.GetNextEntry();
while (entry != null)
{
if (!entry.IsDirectory)
{
string fileName = entry.Name;
string extension = Path.GetExtension(fileName);
if (extension.ToLower() == ".dnn" || extension.ToLower() == ".dnn5")
{
//Manifest
var manifestReader = new StreamReader(unzip);
string manifest = manifestReader.ReadToEnd();
var package = new PackageInfo();
package.Manifest = manifest;
if (!string.IsNullOrEmpty(manifest))
{
var doc = new XPathDocument(new StringReader(manifest));
XPathNavigator rootNav = doc.CreateNavigator().SelectSingleNode("dotnetnuke");
string packageType = String.Empty;
if (rootNav.Name == "dotnetnuke")
{
packageType = XmlUtils.GetAttributeValue(rootNav, "type");
}
else if (rootNav.Name.ToLower() == "languagepack")
{
packageType = "LanguagePack";
}
XPathNavigator nav = null;
switch (packageType.ToLower())
{
case "package":
nav = rootNav.SelectSingleNode("packages/package");
break;
case "languagepack":
nav = Installer.ConvertLegacyNavigator(rootNav, new InstallerInfo()).SelectSingleNode("packages/package");
break;
}
if (nav != null)
{
package.Name = XmlUtils.GetAttributeValue(nav, "name");
package.PackageType = XmlUtils.GetAttributeValue(nav, "type");
package.IsSystemPackage = XmlUtils.GetAttributeValueAsBoolean(nav, "isSystem", false);
package.Version = new Version(XmlUtils.GetAttributeValue(nav, "version"));
package.FriendlyName = XmlUtils.GetNodeValue(nav, "friendlyName");
if (String.IsNullOrEmpty(package.FriendlyName))
{
package.FriendlyName = package.Name;
}
package.Description = XmlUtils.GetNodeValue(nav, "description");
package.FileName = file.Replace(installPath + "\\", "");
packages.Add(package);
}
}
break;
}
}
entry = unzip.GetNextEntry();
}
}
catch (Exception)
{
invalidPackages.Add(file);
}
finally
{
unzip.Close();
unzip.Dispose();
}
}
}
//now add language packs from update service
try
{
StreamReader myResponseReader = UpdateService.GetLanguageList();
var xmlDoc = new XmlDocument();
xmlDoc.Load(myResponseReader);
XmlNodeList languages = xmlDoc.SelectNodes("available/language");
if (languages != null)
{
var installedPackages = PackageController.Instance.GetExtensionPackages(Null.NullInteger, p => p.PackageType == "CoreLanguagePack");
var installedLanguages = installedPackages.Select(package => LanguagePackController.GetLanguagePackByPackage(package.PackageID)).ToList();
foreach (XmlNode language in languages)
{
string cultureCode = "";
string version = "";
foreach (XmlNode child in language.ChildNodes)
{
if (child.Name == "culturecode")
{
cultureCode = child.InnerText;
}
if (child.Name == "version")
{
version = child.InnerText;
}
}
if (!string.IsNullOrEmpty(cultureCode) && !string.IsNullOrEmpty(version) && version.Length == 6)
{
var myCIintl = new CultureInfo(cultureCode, true);
version = version.Insert(4, ".").Insert(2, ".");
var package = new PackageInfo {
Owner = OwnerUpdateService, Name = "LanguagePack-" + myCIintl.Name, FriendlyName = myCIintl.NativeName
};
package.Name = myCIintl.NativeName;
package.Description = cultureCode;
Version ver = null;
Version.TryParse(version, out ver);
package.Version = ver;
if (
installedLanguages.Any(
l =>
LocaleController.Instance.GetLocale(l.LanguageID).Code.ToLowerInvariant().Equals(cultureCode.ToLowerInvariant()) &&
installedPackages.First(p => p.PackageID == l.PackageID).Version >= ver))
{
continue;
}
if (packages.Any(p => p.Name == package.Name))
{
var existPackage = packages.First(p => p.Name == package.Name);
if (package.Version > existPackage.Version)
{
packages.Remove(existPackage);
packages.Add(package);
}
}
else
{
packages.Add(package);
}
}
}
}
}
catch (Exception)
{
//suppress for now - need to decide what to do when webservice is unreachable
//throw;
//same problem happens in InstallWizard.aspx.cs in BindLanguageList method
}
if (invalidPackages.Count > 0)
{
string pkgErrorsMsg = invalidPackages.Aggregate(string.Empty, (current, pkg) => current + (pkg + "<br />"));
Skin.AddModuleMessage(this, Localization.GetString("PackageErrors.Text", LocalResourceFile) + pkgErrorsMsg, ModuleMessage.ModuleMessageType.RedError);
}
grid.DataSource = packages;
grid.DataBind();
}
