private void btnOk_Click(object sender, EventArgs e)
		{
			if (!ValidateForm())
			{
				return;
			}

			ConnectionGroupInfo group = PrepareGroupResult();
			this._resultConnection    = new ConnectionData(this._model, group);

			group.ReadGroupIdFrom(this._storage.ConnectionGroupDirectory);

			long? groupId    = group.Identity;
			long? templateId = this._storage.TemplateDirectory.GetId(group);
			if (groupId != null && templateId != null)
			{
				SaveLastConnection(
					groupId.Value,
					templateId.Value);
			}

			DialogResult = DialogResult.OK;
		}
		internal IEnumerable<ConcreteTemplateNodeDefinition> GetCurrentTree(out ConnectionData connectionData)
		{
			connectionData = GetSelectedConnection();
			var selectedConnectionData = connectionData;

			var selectedConnectionNode = treeTemplate.Nodes.OfType<TreeNode>().FirstOrDefault(
				n => (n.Tag is ConcreteTemplateNodeDefinition) &&
					((ConcreteTemplateNodeDefinition)n.Tag).IsRoot &&
					GetConnectionDataForTreeNode(n) == selectedConnectionData);

			if (selectedConnectionNode != null)
			{
				return GetConcreteTemplateNodeDefinitions(selectedConnectionNode);
			}

			return null;
		}
		public void AppendConnectionData(ConnectionData connection)
		{
			this._connections.Add(connection);
			treeTemplate.ContextMenuStrip = null;
			NewFillTemplateTreeView(true);
		}
		public void OpenConnection(ConnectionData connectionData)
		{
			AppendConnectionData(connectionData);

			TreeIsVisible = !this._isDisableNavigationPanel;
		}
		private static TreeNode CreateConnectionNode(TreeNodeCollection nodes, ConnectionData connection, TemplateNodeInfo rootNode)
		{
			Debug.Assert(rootNode.Parent == null);
			Debug.Assert(rootNode.IsInstance);

			var iconName = connection.IsLiveConnection
				? ApplicationResources.ConnectionNodeImageRefName
				: ApplicationResources.RawDataNodeImageRefName;

			TreeNode newNode = new TreeNode
			{
				Tag              = new ConcreteTemplateNodeDefinition(rootNode, connection.ConnectionGroup),
				Text             = connection.Title,
				ImageKey         = iconName,
				SelectedImageKey = iconName,
			};

			nodes.Add(newNode);

			return newNode;
		}
		private void SaveSrcData(
			string                          currentDb,
			string                          reportDb,
			ISerializationCancellationToken canceller
		)
		{
			ConnectionData connectionData;
			StorageManager backupStorageManager = new StorageManager(
				this._model, false, currentDb, null, reportDb);

			backupStorageManager.InitializeDataBases();

			CheckCancellation(canceller);

			IEnumerable<ConcreteTemplateNodeDefinition> nodes =
				this._connectionTabControl.GetCurrentTree(out connectionData);

			if (nodes != null)
			{
				IList<ConcreteTemplateNodeDefinition> nodeList = nodes as IList<ConcreteTemplateNodeDefinition> ?? nodes.ToList();

				if (nodeList.Any())
				{
					ConnectionGroupInfo sourceConnection = connectionData.ConnectionGroup;
					ConnectionGroupInfo destConnection   = sourceConnection.CopyXmlContent();

					destConnection.Identity = backupStorageManager.CurrentStorage.ConnectionGroupDirectory.GetId(destConnection);

					Dictionary<TemplateNodeInfo, TemplateNodeInfo> clonesDict = new Dictionary<TemplateNodeInfo, TemplateNodeInfo>();

					ConnectionData destConnectionData = new ConnectionData(this._model, destConnection);
					TemplateNodeInfo nodesRoot        = nodeList.First().TemplateNode.GetRootPatent();
					TemplateNodeInfo clonedNodesRoot  = nodesRoot.CloneNotSavedTree(clonesDict, destConnectionData);

					CheckCancellation(canceller);

					backupStorageManager.CurrentStorage.NodeInstances.SaveTree(clonedNodesRoot);

					CheckCancellation(canceller);

					foreach (ConcreteTemplateNodeDefinition concreteTemplateNode in nodeList)
					{
						CheckCancellation(canceller);

						MultyQueryResultInfo queriesResult = this._model.DefaultVaultProcessor.ReadCurrentResult(
							sourceConnection,
							concreteTemplateNode
						);

						CheckCancellation(canceller);

						TemplateNodeInfo templateNode = concreteTemplateNode.TemplateNode;

						if (queriesResult != null)
						{
							backupStorageManager.SerializeData(
								clonesDict[templateNode],
								queriesResult
							);
						}
					}
				}
			}
		}
		public void CloseConnection(ConnectionData connection)
		{
			if (connection != null)
			{
				if (!this._connections.Remove(connection))
				{
					throw new ArgumentException();
				}

				this._model.DeassociateVaultProcessor(connection.ConnectionGroup);

				NewFillTemplateTreeView(false);
			}
		}
		public TemplateNodeInfo CloneNotSavedTree(
			Dictionary<TemplateNodeInfo, TemplateNodeInfo> originalsAndClones,
			ConnectionData                                 connectionData,
			TemplateNodeInfo                               parent = null
		)
		{
			TemplateNodeInfo clone = (TemplateNodeInfo) MemberwiseClone();

			clone._templateNodeId     = null;
			clone.Parent     = parent;
			clone.Connection = connectionData;
			clone.Childs     = new List<TemplateNodeInfo>(
				Childs.Select(
					ch => ch.CloneNotSavedTree(
						originalsAndClones,
						connectionData,
						clone
					)
				)
			);

			originalsAndClones.Add(this, clone);

			return clone;
		}
		public TreeTaskThreadCounter(ConnectionData connection)
		{
			this._connectionHashCode = connection.GetHashCode();
		}
Пример #10
0
		public TemplateNodeInfo InstatiateStaticTree(ConnectionData connection, TemplateNodeInfo parent, Int64? id)
		{
			//Debug.Assert(parent == null || parent.IsInstance);
			//Debug.Assert(!this.IsInstance);

			var nodeInstance = this.IsInstance ? this : this.Instantiate(connection, null, parent);

			if (id != null)
			{
				nodeInstance.AssignTemplateId(id.Value);
			}

			nodeInstance.UpdateChildren(NodeUpdatingSource.LocallyOnly, null);

			foreach (var child in nodeInstance.Childs)
			{
				child.InstatiateStaticTree(connection, nodeInstance, null);
			}

			return nodeInstance;
		}
Пример #11
0
		private static IEnumerable<TemplateNodeInfo> InstantiateStaticNodes(
			IEnumerable<TemplateNodeInfo> templateNodes,
			ConnectionData                connection,
			TemplateNodeInfo              parent
		)
		{
			Debug.Assert(templateNodes.All(t => !t.IsInstance));
			Debug.Assert(parent.IsInstance);

			foreach (TemplateNodeInfo templateNode in templateNodes.Where(n => !n.NeedDataRowToBeInstantiated))
			{
				yield return templateNode.Instantiate(connection, null, parent);
			}
		}
Пример #12
0
		public TemplateNodeInfo Instantiate(ConnectionData connection, string defaultDatabaseAttribute, TemplateNodeInfo parent)
		{
			Debug.Assert(!IsInstance);

			TemplateNodeInfo result = (TemplateNodeInfo)MemberwiseClone();

			result.Template                      = this;
			result.Attributes                    = new NodeAttirbutes(result);
			result.Childs                        = new List<TemplateNodeInfo>();
			result.Connection                    = connection;
			result.ReplicationSourceQuery        = null;
			result._defaultDatabaseAttributeName = defaultDatabaseAttribute;

			result.Queries = Queries.Select(q => q.Clone()).ToList();
			result.ConnectionQueries = ConnectionQueries.Select(q => q.Clone()).ToList();
			result.GroupQueries = GroupQueries.Select(q => q.Clone()).ToList();

			result.Parent = parent;

			return result;
		}
Пример #13
0
		public TemplateNodeInfo Instantiate(ConnectionData connection, DataRow row, TemplateNodeQueryInfo replicationSourceQuery, TemplateNodeInfo parent)
		{
			Debug.Assert(!IsInstance);
			Debug.Assert(NeedDataRowToBeInstantiated);

			var result = (TemplateNodeInfo)MemberwiseClone();
			result.Childs = new List<TemplateNodeInfo>();

			result.Template = this;

			result.Attributes = new NodeAttirbutes(result, row);
			result.Connection = connection;

			result.ReplicationSourceQuery = replicationSourceQuery;

			result.Queries = Queries.Select(q => q.Clone()).ToList();
			result.ConnectionQueries = ConnectionQueries.Select(q => q.Clone()).ToList();
			result.GroupQueries = GroupQueries.Select(q => q.Clone()).ToList();

			result.Parent = parent;
			result.Id = null;
			result.Name = Name + result.Id;

			result.OnAttributesChanged();

			return result;
		}
Пример #14
0
		public void SetConnectionData(ConnectionData connection)
		{
			this.Connection = connection;
		}
Пример #15
0
 public void AppendConnectionData(ConnectionData connection)
 {
     this._connections.Add(connection);
     treeTemplate.ContextMenuStrip = null;
     NewFillTemplateTreeView(true);
 }
Пример #16
0
        private void NewFillTemplateTreeView(bool boolDoNotClearNodes)
        {
            string templateName = null;

            using (new WaitCursor())
            {
                treeTemplate.BeginUpdate();

                try
                {
                    var wasState = SaveTreeState(treeTemplate);

                    if (!boolDoNotClearNodes)
                    {
                        treeTemplate.Nodes.Clear();
                    }

                    foreach (var cnn in Connections)
                    {
                        if (cnn.RootInstance != null && boolDoNotClearNodes)
                        {
                            continue;
                        }

                        cnn.RootInstance      = cnn.RootOfTemplate.Instantiate(cnn, null, null);
                        cnn.RootInstance.Name = cnn.Title;

                        var rootNode = CreateConnectionNode(treeTemplate.Nodes, cnn, cnn.RootInstance);

                        if (cnn.ConnectionGroup != null)
                        {
                            CurrentStorage db = this._model.GetVaultProcessor(cnn.ConnectionGroup).CurrentStorage;

                            cnn.ConnectionGroup.ReadGroupIdFrom(db.ConnectionGroupDirectory);

                            Int64?templateId = db.TemplateDirectory.GetId(cnn.ConnectionGroup);

                            if (!db.NodeInstances.TryLoadRoodId(cnn.RootInstance, cnn.ConnectionGroup.Identity, templateId))
                            {
                                db.NodeInstances.Save(cnn.RootInstance);
                            }

                            ConnectionData connectionData = cnn;

                            Action selectTask = () =>
                            {
                                if (!string.IsNullOrEmpty(connectionData.StartupTemplateId))
                                {
                                    var selectFunction = new Action(() =>
                                    {
                                        rootNode.TreeView.SelectedNode = FindChildNode(
                                            rootNode.Nodes,
                                            connectionData.StartupTemplateId
                                            );
                                    });

                                    ExpandNodeToLoadTemplate(
                                        connectionData.StartupTemplateInfoIdStack,
                                        rootNode.Nodes,
                                        connectionData.StartupTemplateId,
                                        selectFunction
                                        );
                                }
                            };

                            TaskManager.BeginRefreshTask(rootNode, false, NodeUpdatingSource.FromServerIfNotSavedLocally, () =>
                            {
                                this.SafeInvoke(rootNode.Expand);
                                this.SafeInvoke(selectTask);
                            }
                                                         );
                        }
                    }

                    ApplyTreeState(treeTemplate, wasState);
                }
                finally
                {
                    treeTemplate.EndUpdate();
                }

                tmSchedulerTimer.Start();

                var connection = Connections.FirstOrDefault();

                if (connection != null)
                {
                    var localeitem = connection.RootInstance.GetLocale(false);

                    if (localeitem != null)
                    {
                        templateName = localeitem.Text;
                    }
                }

                OnTreeSelectionChanged(templateName);

                if (TreeContainsOnlyOneReportNode(treeTemplate.Nodes))
                {
                    treeTemplate.Hide();
                }
            }
        }