public void AttachConnection(PBSConnection connection)
        {
            connection.InsertToDb();

            Transaction.Current.OnCommited(() =>
            {
                Logger.Info("connection added to " + _pbsObject.ED.Name + " " + (connection.IsOutgoing ? "OUTGOING" : "INCOMING"));
                OnConnectionCreated(connection);
            });
        }
        private void DeleteConnectionFromDb(PBSConnection connection)
        {
            if (connection == null)
            {
                return;
            }

            _connections = null;

            connection.DeleteFromDb();

            Transaction.Current.OnCommited(() =>
            {
                Logger.Info("connection removed from " + _pbsObject.ED.Name + " " + (connection.IsOutgoing ? "OUTGOING" : "INCOMING"));
                OnConnectionDeleted(connection);
            });
        }
 protected virtual void OnConnectionDeleted(PBSConnection connection)
 {
     _connections = null;
     ConnectionDeleted?.Invoke(connection);
 }
        /// <summary>
        /// Make connection by request
        /// </summary>
        /// <param name="targetNode"></param>
        /// <param name="character"></param>
        public void MakeConnection(IPBSObject targetNode, Character character)
        {
            //source pbsObject access check
            _pbsObject.CheckAccessAndThrowIfFailed(character);

            //--- transmit radius check
            targetNode.ThrowIfEqual(_pbsObject, ErrorCodes.WTFErrorMedicalAttentionSuggested);

            var targetUnit = ((Unit)targetNode);

            targetUnit.CurrentPosition.IsInRangeOf2D(_pbsObject.CurrentPosition, _pbsObject.GetTransmitRadius()).ThrowIfFalse(ErrorCodes.TargetOutOfTransmitRadius);


            //check pair--------------------------
            _pbsObject.ConnectionHandler.CheckNewConnection(targetNode, true);
            targetNode.ConnectionHandler.CheckNewConnection(_pbsObject, false);


            //-------check networks and owners
            var  changeOwner = false;
            long newOwner    = 0L;

            var sourceNetwork = NetworkNodes.ToArray();

            IPBSObject[] targetNetwork = null;
            var          dockingBaseInSourceNetwork = false;
            var          dockingBaseInTargetNetwork = false;

            var isSameNetwork = sourceNetwork.Any(p => p.GetHashCode() == targetNode.GetHashCode());

            if (!isSameNetwork)
            {
                //they are in different networks

                targetNetwork = targetNode.ConnectionHandler.NetworkNodes.ToArray();

                var sourceDockingBase = sourceNetwork.FirstOrDefault(n => n is PBSDockingBase) as PBSDockingBase;
                var targetDockingBase = targetNetwork.FirstOrDefault(n => n is PBSDockingBase) as PBSDockingBase;

                dockingBaseInSourceNetwork = sourceDockingBase != null;
                dockingBaseInTargetNetwork = targetDockingBase != null;

                //check nodes in networks
                if (dockingBaseInSourceNetwork)
                {
                    IsAnyNodeOutsideOfNetworkRange(sourceNetwork, sourceDockingBase).ThrowIfTrue(ErrorCodes.SomeNodeAreOutsideOfNetworkRange);
                    IsAnyNodeOutsideOfNetworkRange(targetNetwork, sourceDockingBase).ThrowIfTrue(ErrorCodes.SomeNodeAreOutsideOfNetworkRange);
                }

                var sumUsage = sourceNetwork.Concat(targetNetwork).Where(n => !(n is PBSDockingBase)).Sum(n => n.GetBandwidthUsage());

                //both networks have docking bases -> nono
                (dockingBaseInSourceNetwork && dockingBaseInTargetNetwork).ThrowIfTrue(ErrorCodes.BasesInBothNetworks);

                if (dockingBaseInSourceNetwork || dockingBaseInTargetNetwork)
                {
                    //there must be a docking base in one of the two
                    changeOwner = true;

                    //-------------------------------------- number of nodes check
                    int bandwidthCapacity;
                    if (dockingBaseInSourceNetwork)
                    {
                        bandwidthCapacity = sourceDockingBase.GetBandwidthCapacity;
                    }
                    else
                    {
                        bandwidthCapacity = targetDockingBase.GetBandwidthCapacity;
                    }

                    sumUsage.ThrowIfGreater(bandwidthCapacity, ErrorCodes.TooManyNodesOutOfCpu);

                    //------------------------------------------ new owner select
                    if (dockingBaseInSourceNetwork)
                    {
                        newOwner = _pbsObject.Owner;
                    }
                    else
                    {
                        newOwner = targetUnit.Owner;
                    }
                }
                else
                {
                    //no docking base

                    sumUsage.ThrowIfGreater(CPU_POWER_IN_NETWORK_WITHOUT_BASE, ErrorCodes.TooManyNodesOutOfCpu);

                    _pbsObject.Owner.ThrowIfNotEqual(targetUnit.Owner, ErrorCodes.OwnerMismatch);
                }
            }



            if (changeOwner)
            {
                if (newOwner == 0)
                {
                    //lekezeletlen resz %%%
                    Debug.Assert(false, " nincs megirva");
                }
                else
                {
                    if (dockingBaseInSourceNetwork)
                    {
                        foreach (var n in targetNetwork)
                        {
                            n.TakeOver(newOwner);
                        }
                    }

                    if (dockingBaseInTargetNetwork)
                    {
                        foreach (var n in sourceNetwork)
                        {
                            n.TakeOver(newOwner);
                        }
                    }
                }
            }


            //-----------------------------do actual work

            var outConnection = new PBSConnection(targetNode, _pbsObject, true);

            AttachConnection(outConnection);

            var inConnection = new PBSConnection(_pbsObject, targetNode, false);

            targetNode.ConnectionHandler.AttachConnection(inConnection);

            Transaction.Current.OnCommited(() =>
            {
                var pbsBase = NetworkNodes.FirstOrDefault(o => o is PBSDockingBase);
                if (pbsBase == null)
                {
                    return;
                }

                _pbsObject.ReinforceHandler.ForceDailyOffset(pbsBase.ReinforceHandler.ReinforceOffsetHours); //this node

                foreach (var node in NetworkNodes)
                {
                    if (node.Equals(_pbsObject))
                    {
                        continue;
                    }
                    if (node.Equals(pbsBase))
                    {
                        continue;
                    }

                    //all reinforcable nodes in the network
                    node.ReinforceHandler.ForceDailyOffset(pbsBase.ReinforceHandler.ReinforceOffsetHours);
                }
            });
        }