/// <summary> /// Item1 = name. Item2 = directory. /// </summary> /// <param name="templateID"></param> /// <returns></returns> public static Tuple<string, string> GetTemplateById(string templateID) { string strFileName = string.Empty; string strFolderName = string.Empty; List<Template> retList = new List<Template>(); DirectoryInfo directoryInfo = new DirectoryInfo( Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Program.Model.Settings.TemplateDirectory)); if (directoryInfo.Exists) { try { var serializer = new XmlSerializer(typeof(Template)); var files = directoryInfo.GetFiles("*.xml"); foreach (FileInfo file in files) { try { var doc = new XmlDocument(); doc.Load(file.FullName); if (AppVersionHelper.IsNotDebug()) { var cryptoProcessor = new CryptoProcessor( Program.Model.Settings.SystemSettings.PublicKeyXmlSign, Program.Model.Settings.SystemSettings.PrivateKeyXmlDecrypt); cryptoProcessor.DecryptXmlDocument(doc); } // // #248 - fix memory leaks during XML files processing // // var nodeReader = new XmlNodeReader(doc); using (var nodeReader = new XmlNodeReader(doc)) { using (var xmlReader = XmlReader.Create(nodeReader, XmlUtils.GetXmlReaderSettings())) { var template = (Template)serializer.Deserialize(xmlReader); if (templateID == template.Id) { strFileName = file.Name; strFolderName = file.DirectoryName; } } } } catch (Exception ex) { log.Error(ex); if (file != null) { log.ErrorFormat("File:'{0}'", file); } log.ErrorFormat("Folder:'{0}'", directoryInfo); } } } catch (Exception ex) { log.Error(ex); log.ErrorFormat("Folder:'{0}'", directoryInfo); } } else { log.Error("Folder with models is not exists"); log.ErrorFormat("Folder:'{0}'", directoryInfo); } return new Tuple<string, string>(strFileName, strFolderName); }
/// <summary> /// Load queries from Xml-file /// </summary> /// <param name="fileName">Xml-file name</param> /// <param name="cryptoProcessor">Encoder</param> /// <param name="isExternal">Is opened from user file template</param> /// <returns>List of queries</returns> public static List<QueryInfo> LoadFromXml(string fileName, CryptoProcessor cryptoProcessor, bool isExternal) { if (AppVersionHelper.IsDebug() || isExternal) { if (cryptoProcessor == null) { return LoadFromXml(fileName); } } try { XmlDocument doc = new XmlDocument(); doc.PreserveWhitespace = true; doc.Load(fileName); if (AppVersionHelper.IsRelease() || (AppVersionHelper.IsNotRelease() && cryptoProcessor != null)) { cryptoProcessor.DecryptXmlDocument(doc); } byte[] bytes = Encoding.UTF8.GetBytes(doc.OuterXml); XmlSerializer s = new XmlSerializer(typeof (LoaderRootWrapper)); using (var includingReader = new MemoryStream(bytes)) { using (var xmlReader = XmlReader.Create(includingReader, XmlUtils.GetXmlReaderSettings())) { return GetQueries(((LoaderRootWrapper) s.Deserialize(xmlReader))); } } } catch (Exception exception) { log.Error(exception); if (AppVersionHelper.IsDebug() || isExternal) { return LoadFromXml(fileName); } throw; } }
/// <summary> /// Save queries to encoded file /// </summary> /// <param name="fileName">Xml-file name</param> /// <param name="queries">Collection of queries</param> /// <param name="cryptoProcessor">Encoder</param> public static void SaveToXml(string fileName, List<QueryInfo> queries, CryptoProcessor cryptoProcessor) { XmlDocument doc = new XmlDocument(); SaveToXml(fileName, queries); doc.PreserveWhitespace = true; doc.Load(fileName); cryptoProcessor.EncryptXmlDocument(doc); doc.Save(fileName); }
private void processQueryFilesInner( Dictionary<String, List<String>> queriesInQueryFiles, string srcFolder, CryptoProcessor cryptoProcessor ) { var systemSettings = SystemSettingsInfo.LoadFrom(Settings.SystemSettingsFile); foreach (var pair in queriesInQueryFiles) { try { var srcFileName = Path.Combine(srcFolder, pair.Key); this._logger.WriteToLog("Start file processing: {0}", srcFileName); if (File.Exists(srcFileName)) { List<QueryInfo> queries = QueriesLoader.LoadFromXml(srcFileName); foreach (string qName in pair.Value) { if (queries.All(c => c.Name != qName)) { this._logger.WriteToLog(string.Format(GetText("QueriyNotFoundInFile"), qName, pair.Key)); } } string dstQueriesFileName = GetDstFileName(pair.Key, true, subDir: systemSettings.TemplateDirectory); processQueryFile(srcFileName, dstQueriesFileName, cryptoProcessor); } else { this._logger.WriteToLog("QueryFile was not found: {0}", srcFileName); } this._logger.WriteToLog("File has been processed: {0}", srcFileName); } catch (Exception e) { this._logger.WriteToLog("ERROR: Some files has not been processed: {0}", srcFolder); this._logger.WriteToLog("ERROR: Query processing error: {0}", e.Message); } } this._logger.WriteToLog("Query processing has been completed."); }
/// <summary> /// The sign query item. /// </summary> /// <param name="cryptoProcessor">The crypto processor.</param> /// <param name="itemInfo">The item info.</param> /// <param name="query">The query.</param> private void SignQueryItem(CryptoProcessor cryptoProcessor, QueryItemInfo itemInfo, QueryInfo query) { this._logger.WriteToLog("prepare to sign the query...."); itemInfo.ParentQuery = query; new QueryPreparator(this.Settings, this._logger).PrepareIfNeeds(itemInfo); this._logger.WriteToLog("Sign query...."); itemInfo.Signature = cryptoProcessor.Sign(itemInfo.Text); }
/// <summary> /// Load queries with signature check /// </summary> /// <param name="filename">Xml-file name</param> /// <param name="isExternal">Is opened from user file template</param> /// <returns>Queries list</returns> public List<QueryInfo> LoadQueries(string filename, bool isExternal) { log.InfoFormat("filename:'{0}',isExternal:'{1}'", filename ?? "<null>", isExternal ); List<string> wrongQueries = new List<string>(); CryptoProcessor cryptoProcessor = null; try { if (AppVersionHelper.IsNotDebug()) { cryptoProcessor = new CryptoProcessor( Settings.SystemSettings.PublicKeyXmlSign, Settings.SystemSettings.PrivateKeyXmlDecrypt ); } } catch (System.Security.XmlSyntaxException ex) { log.Error(ex); } catch (Exception ex) { log.Error(ex); log.Error(ex.GetBaseException()); } List<QueryInfo> queries = QueriesLoader.LoadFromXml(filename, cryptoProcessor, isExternal); for (int i = queries.Count - 1; i >= 0; i--) { QueryInfo query = queries[i]; log.InfoFormat("query:'{0}'", query); if (AppVersionHelper.IsNotDebug() && !isExternal) { for (int j = query.DatabaseSelect.Count - 1; j >= 0; j--) { QueryItemInfo queryItem = query.DatabaseSelect[j]; if (cryptoProcessor != null && !cryptoProcessor.Verify(queryItem.Text, queryItem.Signature)) { if (!wrongQueries.Contains(query.Name)) { wrongQueries.Add(query.Name); } query.DatabaseSelect.RemoveAt(j); } } for (int j = query.Items.Count - 1; j >= 0; j--) { QueryItemInfo queryItem = query.Items[j]; log.InfoFormat("queryItem.Text:'{0}'", queryItem.Text); if (cryptoProcessor != null && !cryptoProcessor.Verify(queryItem.Text, queryItem.Signature)) { if (!wrongQueries.Contains(query.Name)) { wrongQueries.Add(query.Name); } query.Items.RemoveAt(j); } } } if (query.Items.Count == 0) { queries.RemoveAt(i); } } if ((Settings.WarnAboutUnsignedQuery) && (wrongQueries.Count > 0)) { StringBuilder sb = new StringBuilder(); sb.Append(filename + Environment.NewLine + Environment.NewLine); foreach (string wrongQuery in wrongQueries) { sb.Append(wrongQuery + Environment.NewLine); } MessageBox.Show(sb.ToString(), LocaleManager.GetLocalizedText(LocaleManager.Exceptions, "wrongQueriesSignatures")); } return queries; }
//private void ProcessQueryFilesRootAnnotation(Dictionary<String, List<String>> queriesInQueryFiles, string srcFolder, // CryptoProcessor cryptoProcessor) //{ // this._logger.WriteToLog("Обработка запросов Root Annotation"); // processQueryFilesInner(queriesInQueryFiles, srcFolder, cryptoProcessor); // this._logger.WriteToLog("Обработка запросов Root Annotation"); //} /// <summary> /// Processes query file /// </summary> /// <param name="srcFileName">The source query file</param> /// <param name="dstFileName">The destination query file</param> /// <param name="cryptoProcessor">The crypto processor</param> private void processQueryFile(string srcFileName, string dstFileName, CryptoProcessor cryptoProcessor) { this._logger.WriteToLog( "Start file processing: '{0}' -> '{1}'", srcFileName, dstFileName ); if (File.Exists(srcFileName)) { try { List<QueryInfo> queries = QueriesLoader.LoadFromXml(srcFileName); foreach (QueryInfo query in queries) { this._logger.WriteToLog( "Query processing:{0}-{1}-{2}", query.Id, query.Source, query.Name ); foreach (var itemInfo in query.DatabaseSelect) { this._logger.WriteToLog("Обработка запроса на выборку БД({0}-{1})", itemInfo.MinVersion, itemInfo.MaxVersion); this.SignQueryItem(cryptoProcessor, itemInfo, query); } foreach (var itemInfo in query.GroupSelect) { this._logger.WriteToLog("Обработка запроса на выборку групп({0}-{1})", itemInfo.MinVersion, itemInfo.MaxVersion); this.SignQueryItem(cryptoProcessor, itemInfo, query); } foreach (var itemInfo in query.Items) { this._logger.WriteToLog("Обработка запроса на выборку данных ({0}-{1})", itemInfo.MinVersion, itemInfo.MaxVersion); this.SignQueryItem(cryptoProcessor, itemInfo, query); } this._logger.WriteToLog( "Query has been processed:{0}-{1}-{2}", query.Id, query.Source, query.Name ); } SureDirForFileExists(dstFileName); QueriesLoader.SaveToXml(dstFileName, queries, cryptoProcessor); this._logger.WriteToLog( "File has been SUCESSFULLY processed: {0} -> {1}", srcFileName, dstFileName ); } catch (Exception e) { this._logger.WriteToLog("ERROR: File has not been processed: {0}", srcFileName); this._logger.WriteToLog("ERROR: Query processing error: {0}", e.Message); this._logger.WriteToLog("ERROR: File has NOT been processed: {0} -> {1}", srcFileName, dstFileName); } } else { this._logger.WriteToLog("QueryFile is not found: {0}", srcFileName); } }
/// <summary> /// Processes the XSL template files. /// </summary> /// <summary> /// Processes the XSL template files. /// </summary> /// <param name="srcFolder">The SRC folder.</param> /// <param name="cryptoProcessor">The crypto processor.</param> private void ProcessPostBuildDbTemplateFiles(string srcFolder, CryptoProcessor cryptoProcessor) { string srcFileName = String.Empty; string dstFileName = String.Empty; var systemSettings = SystemSettingsInfo.LoadFrom(Settings.SystemSettingsFile); this._logger.WriteToLog( "{Begin: processing system SQL scripts...." ); // // PostBuildCurrentDb // processing SQL scripts for current SQLite database // this._logger.WriteToLog( "systemSettings.PostBuildCurrentDb:'{0}'", systemSettings.PostBuildCurrentDb ); srcFileName = Path.Combine( srcFolder, String.Empty, String.Empty, systemSettings.PostBuildCurrentDb ); this._logger.WriteToLog( "srcFileName:'{0}'", srcFileName ); dstFileName = Path.Combine( this._settings.DstFolderFull, String.Empty, String.Empty, systemSettings.PostBuildCurrentDb ); this._logger.WriteToLog( "dstFileName:'{0}'", dstFileName ); processQueryFile( srcFileName, dstFileName, cryptoProcessor ); // // PostBuildHistoricDbs // processing SQL scripts for all SQLite historical databases // foreach (var postBuildHistoricDb in systemSettings.PostBuildSQLiteDbs) { this._logger.WriteToLog( "systemSettings.PostBuildHistoricDb:Script'{0}';Alias:{1};Filename:{2}", postBuildHistoricDb.PostBuildScript, postBuildHistoricDb.Alias, postBuildHistoricDb.FileName ); srcFileName = Path.Combine( srcFolder, String.Empty, String.Empty, postBuildHistoricDb.PostBuildScript ); this._logger.WriteToLog( "srcFileName:'{0}'", srcFileName ); dstFileName = Path.Combine( this._settings.DstFolderFull, String.Empty, String.Empty, postBuildHistoricDb.PostBuildScript ); this._logger.WriteToLog( "dstFileName:'{0}'", dstFileName ); processQueryFile( srcFileName, dstFileName, cryptoProcessor ); } this._logger.WriteToLog("}End: processing system SQL scripts"); }
/// <param name="xslTemplateFileNames">The XSL templates.</param> /// <param name="srcFolder">The SRC folder.</param> /// <param name="cryptoProcessor">The crypto processor.</param> private void ProcessXslTemplateFiles(IEnumerable<string> xslTemplateFileNames, string srcFolder, CryptoProcessor cryptoProcessor) { var languageFolders = GetReportLanguages().ToArray(); var systemSettings = SystemSettingsInfo.LoadFrom(Settings.SystemSettingsFile); this._logger.WriteToLog( "start modules processing...." ); foreach (var fileName in xslTemplateFileNames) { try { this._logger.WriteToLog( "Start module file name processing. File:'{0}'", fileName ); foreach (var localeFolder in languageFolders) { var srcFileName = Path.Combine( srcFolder, "Templates", localeFolder, fileName ); if (!File.Exists(srcFileName)) { this._logger.WriteToLog( "ERROR: Module not found. File name: '{0}'", srcFileName ); continue; } string dstFileName = Path.Combine( this._settings.DstFolderFull + @"\" + systemSettings.TemplateDirectory + @"\", "Templates", localeFolder, fileName ); this.SureCopy(srcFileName, dstFileName); new XSLPreparator(new KeyValuePair<string, string>(dstFileName, localeFolder), this._logger) .Prepare(this._settings.AdditionalTemplates); if (AppVersionHelper.IsNotDebug()) { var doc = new XmlDocument(); doc.Load(dstFileName); this._logger.WriteToLog( "EncryptXmlDocument: file name: '{0}'", dstFileName ); cryptoProcessor.EncryptXmlDocument(doc); doc.Save(dstFileName); } } } catch (Exception e) { this._logger.WriteToLog( "ERROR: Module has not been processed. File:'{0}';Error:'{1}'", fileName, e.Message ); } } this._logger.WriteToLog( "Modules processing is completed." ); }
public void ExecuteSign() { var srcFolder = this._settings.SrcFolder; var systemSettings = SystemSettingsInfo.LoadFrom(Settings.SystemSettingsFile); if (!Directory.Exists(this._settings.DstFolderFull)) { Directory.CreateDirectory(this._settings.DstFolderFull); } //var connections = ConnectionsLoader.LoadFromXml(_settings.ConnectionsFileName); var cryptoProcessor = new CryptoProcessor(this._settings.PrivateKeySign, this._settings.PrivateKeyDecrypt); //SignLicenses(connections, cryptoProcessor); //string dstConnectionsFileName = GetDstFileName(_settings.ConnectionsFileName); //ConnectionsLoader.SaveToXml(dstConnectionsFileName, connections); // process ini files for SQLite databases ProcessPostBuildDbTemplateFiles(srcFolder, cryptoProcessor); List<string> xslTemplates; Dictionary<String, List<String>> queriesInQueryFiles; //var treeNodeTemplateFileNames = connections.Select(cnn => cnn.TemplateFileName).Distinct().ToList(); ProcessTreeNodeTemplateFiles(this._settings.TemplateFiles, out xslTemplates, out queriesInQueryFiles, cryptoProcessor); ProcessXslTemplateFiles(xslTemplates, srcFolder+@"\"+systemSettings.TemplateDirectory+@"\", cryptoProcessor); ProcessQueryFiles(queriesInQueryFiles, srcFolder + @"\" + systemSettings.TemplateDirectory + @"\", cryptoProcessor); //ProcessQueryFilesRootAnnotation(queriesInRootAnnotationQueryFiles, srcFolder, cryptoProcessor); }
private void ProcessTreeNodeTemplateFiles( IEnumerable<string> treeNodeTemplateFileNames, out List<string> xslTemplateFiles, out Dictionary<string, List<string>> queriesInQueryFiles, CryptoProcessor cryptoProcessor ) { xslTemplateFiles = new List<string>(); queriesInQueryFiles = new Dictionary<string, List<string>>(); var systemSettings = SystemSettingsInfo.LoadFrom(Settings.SystemSettingsFile); foreach (string templateFileName in treeNodeTemplateFileNames) { string fullTemplateFileName = Path.GetFullPath(templateFileName); if (File.Exists(fullTemplateFileName)) { string dstTemplateFileName = Path.Combine( this._settings.DstFolderFull + @"\" + systemSettings.TemplateDirectory + @"\", Path.GetFileName(templateFileName) ); this.SureCopy(fullTemplateFileName, dstTemplateFileName); XmlDocument doc = new XmlDocument(); doc.Load(dstTemplateFileName); string startupTemplateId = null; Stack<string> startupTemplateInfoIdStack = null; var rootNode = TemplateNodesLoader.LoadFromXml(null, doc, out startupTemplateId, out startupTemplateInfoIdStack); var allNodesInTemplate = ToPlainList(rootNode); foreach (TemplateNodeInfo node in allNodesInTemplate) { //foreach (TemplateNodeLocaleInfo locale in // node.Locales.Where(l => !string.IsNullOrEmpty(l.TemplateFile))) //{ // if (!xslTemplates.ContainsKey(locale.TemplateFile)) // { // xslTemplates.Add(locale.TemplateFile, locale.Language); // } //} if (!string.IsNullOrWhiteSpace(node.XslTemplateFileName) && !xslTemplateFiles.Contains(node.XslTemplateFileName)) { xslTemplateFiles.Add(node.XslTemplateFileName); } var allQueries = node.Queries.Union(node.GroupQueries); foreach (TemplateNodeQueryInfo query in allQueries) { if (!queriesInQueryFiles.ContainsKey(query.QueryFileName)) { queriesInQueryFiles.Add(query.QueryFileName, new List<string>()); } if (!queriesInQueryFiles[query.QueryFileName].Contains(query.QueryName)) { queriesInQueryFiles[query.QueryFileName].Add(query.QueryName); } } foreach (TemplateNodeQueryInfo query in node.ConnectionQueries) { if (!queriesInQueryFiles.ContainsKey(query.QueryFileName)) { queriesInQueryFiles.Add(query.QueryFileName, new List<string>()); } if (!queriesInQueryFiles[query.QueryFileName].Contains(query.QueryName)) { queriesInQueryFiles[query.QueryFileName].Add(query.QueryName); } } } if (AppVersionHelper.IsNotDebug()) { cryptoProcessor.EncryptXmlDocument(doc); doc.Save(dstTemplateFileName); } } else { this._logger.WriteToLog(this.GetText("TemplateTreeFileNotFound") + templateFileName); } } }
private void SignLicenses(IEnumerable<ConnectionGroupInfo> connections, CryptoProcessor cp) { foreach (ConnectionGroupInfo connection in connections) { foreach (InstanceInfo instance in connection.Connections) { if (instance.LicenseInfo == null) { this._logger.WriteToLog(GetText("NoLicenseDataForInstance") + instance.Instance); } else { instance.LicenseInfo.Signature = cp.Sign(instance.GetHash()); } } } }
public void SignLicense(string inFile, string outFile) { var connections = ConnectionsLoader.LoadFromXml(inFile); var cryptoProcessor = new CryptoProcessor(this._settings.PrivateKeySign, this._settings.PrivateKeyDecrypt); SignLicenses(connections, cryptoProcessor); ConnectionsLoader.SaveToXml(outFile, connections); }
/// <summary> /// The validate license. /// </summary> /// <param name="fullSlowCheck">The full slow check.</param> /// <returns> /// The <see cref="LicenseState" />. /// </returns> public LicenseState ValidateLicense(bool fullSlowCheck, bool withCheckConnection = true) { if (this._foundLicenseState != null) { return this._foundLicenseState; } this._foundLicenseState = new LicenseState { Instance = this.Instance }; if (this.LicenseInfo == null) { if (AppVersionHelper.IsNotRelease()) { return this._foundLicenseState; } this._foundLicenseState.AddProblem(LicenseProblemType.LicenseNotDefined, string.Empty); } else { this._foundLicenseState.AddProblems(this.LicenseInfo.IsLicenseInfoCorrect()); DateTime dateTime; if (fullSlowCheck && withCheckConnection) { if (this._serverProperties != null) { dateTime = this._serverProperties.Date; } else { try { ServerProperties props = ServerProperties.Query(this); dateTime = props.Date; this._serverProperties = props; } catch (Exception exc) { log.Error("Exception:", exc); log.ErrorFormat( "Instance:'{0}';Authentication:'{1}';Exception:'{2}'", Instance, Authentication, exc ); dateTime = DateTime.MaxValue; } } } else { dateTime = DateTime.Now; } var buildDateObject = Assembly.GetExecutingAssembly() .GetCustomAttributes(typeof (BuildDateAttribute), false) .FirstOrDefault(); DateTime buildDate = DateTime.MaxValue; if (buildDateObject is BuildDateAttribute) { buildDate = (buildDateObject as BuildDateAttribute).BuildDate; } if (dateTime == DateTime.MaxValue) { this._foundLicenseState.AddProblem(LicenseProblemType.CantConnect, string.Empty); } else if (this._foundLicenseState.IsCorrect && fullSlowCheck && (dateTime > this.LicenseInfo.ExpiryDate)) { this._foundLicenseState.AddProblem(LicenseProblemType.Expired, string.Empty); } else if (buildDate > this.LicenseInfo.BuildExpiryDate) { this._foundLicenseState.AddProblem(LicenseProblemType.BuildExpiryDateNotValid, string.Empty); } else { if (AppVersionHelper.IsNotDebug()) { string hash = this.GetHash(); CryptoProcessor cryptoProcessor = new CryptoProcessor( Program.Model.Settings.SystemSettings.PublicKeyXmlSign, Program.Model.Settings.SystemSettings.PrivateKeyXmlDecrypt ); if (!cryptoProcessor.Verify(hash, this.LicenseInfo.Signature)) { this._foundLicenseState.AddProblem(LicenseProblemType.WrongSignature, string.Empty); } } } } var result = this._foundLicenseState; if (!fullSlowCheck) { this._foundLicenseState = null; } return result; }
public static Template GetTemplateByFile(string strFileName) { try { XmlDocument doc = new XmlDocument(); doc.Load(strFileName); Template retTemplate; if (AppVersionHelper.IsNotDebug()) { var cryptoProcessor = new CryptoProcessor( Program.Model.Settings.SystemSettings.PublicKeyXmlSign, Program.Model.Settings.SystemSettings.PrivateKeyXmlDecrypt); cryptoProcessor.DecryptXmlDocument(doc); } using (var nodeReader = new XmlNodeReader(doc)) { XmlSerializer serializer = new XmlSerializer(typeof(Template)); using (var xmlReader = XmlReader.Create(nodeReader, XmlUtils.GetXmlReaderSettings())) { retTemplate = (Template)serializer.Deserialize(xmlReader); } } return retTemplate; } catch (Exception ex) { log.Error(ex); } return null; }
private void ProcessQueryFiles( Dictionary<String, List<String>> queriesInQueryFiles, string srcFolder, CryptoProcessor cryptoProcessor ) { this._logger.WriteToLog( "Start queries processing..." ); processQueryFilesInner(queriesInQueryFiles, srcFolder, cryptoProcessor); this._logger.WriteToLog( "Queries processing is completed." ); }
public VisualizeData GetVisualizeData( NodeDataProvider dataProvider, GraphicsInfo graphicsInfo ) { XmlDocument xmlData = dataProvider.XmlDocument; MultyQueryResultInfo queriesResult = dataProvider.QueryResult; VisualizeData result = new VisualizeData { NodeLastUpdated = queriesResult.NodeLastUpdated, NodeLastUpdateDuration = queriesResult.NodeLastUpdateDuration }; if (xmlData != null && xmlData.DocumentElement != null) { result.SourceXml = xmlData.FormatXml(); } ConcreteTemplateNodeDefinition nodeDefinition = dataProvider.NodeDefinition; string xslFileName = GetXslFileName(nodeDefinition); if (xslFileName != null && File.Exists(xslFileName)) { XmlDocument xslDoc = new XmlDocument(); xslDoc.Load(xslFileName); ConnectionGroupInfo connectionGroup = nodeDefinition.Connection; if (AppVersionHelper.IsNotDebug() && !connectionGroup.IsExternal) { CryptoProcessor cryptoProcessor = new CryptoProcessor( this._model.Settings.SystemSettings.PublicKeyXmlSign, this._model.Settings.SystemSettings.PrivateKeyXmlDecrypt ); cryptoProcessor.DecryptXmlDocument(xslDoc); } try { XslPreprocessManager preprocessManager = GetManager( dataProvider, graphicsInfo ); List<PreprocessorAreaData> datas; using (preprocessManager.ExecuteXslPreprocessing(xslDoc, out datas)) { } foreach (PreprocessorAreaData preprocessorAreaData in datas) { preprocessorAreaData.CheckPreprocessors(); } result.PreprocessorAreas = datas.ToList(); } catch (Exception ex) { log.ErrorFormat( "nodeDefinition.TemplateNode.Queries(.Name)='{0}';xslFileName='{1}';Exception:'{2}'", nodeDefinition.TemplateNode.Queries.Select(q => q.QueryName).Join(", "), xslFileName, ex ); } } return result; }
//void ReloadConectionGroupInfos() //{ // var filenames = _filesProvider.GetConnectionsFilenames(); // _connections = new List<ConnectionGroupInfo>(); // foreach (var filename in filenames) // { // _connections.AddRange(ConnectionsLoader.LoadFromXml(filename)); // } //} /// <summary> /// Load Template /// </summary> /// <param name="filename">Xml-file name</param> /// <param name="connectionGroup"></param> /// <param name="isExternal">Is opened from user file template</param> /// <returns>Tree template</returns> public TemplateNodeInfo LoadTemplateNodes( string filename, bool isExternal, out string startupTemplateId, out Stack<string> startupTemplateInfoIdStack ) { if (!File.Exists(filename)) { throw new FileNotFoundException("Template needed!"); } var doc = new XmlDocument(); doc.Load(filename); if (AppVersionHelper.IsNotDebug() && !isExternal) { var cryptoProcessor = new CryptoProcessor( this.Settings.SystemSettings.PublicKeyXmlSign, this.Settings.SystemSettings.PrivateKeyXmlDecrypt ); cryptoProcessor.DecryptXmlDocument(doc); } return TemplateNodesLoader.LoadFromXml(this, doc, out startupTemplateId, out startupTemplateInfoIdStack); }