public void PutLoots(Player player, int pinCode, IList <KeyValuePair <long, int> > items)
        {
            HasAccess(player, pinCode);

            Zone.CreateBeam(BeamType.loot_bolt, b => b.WithSource(player)
                            .WithTarget(this)
                            .WithState(BeamState.Hit).WithDuration(1000));

            lock (syncObject)
            {
                using (var scope = Db.CreateTransaction())
                {
                    var container = player.GetContainer();
                    Debug.Assert(container != null, "container != null");
                    container.EnlistTransaction();
                    var progressPacketBuilder = new LootContainerProgressInfoPacketBuilder(container, this, items.Count);

                    var b = TransactionLogEvent.Builder().SetTransactionType(TransactionType.PutLoot).SetCharacter(player.Character).SetContainer(Eid);

                    foreach (var kvp in items)
                    {
                        try
                        {
                            var itemEid  = kvp.Key;
                            var quantity = kvp.Value;

                            var tmpItem = container.GetItemOrThrow(itemEid);

                            //robotot lehet
                            if (tmpItem.ED.AttributeFlags.NonStackable)
                            {
                                continue;
                            }

                            if (tmpItem is VolumeWrapperContainer)
                            {
                                continue;
                            }

                            lock (container)
                            {
                                var resultItem = container.RemoveItem(tmpItem, quantity);
                                if (resultItem == null)
                                {
                                    continue;
                                }

                                Repository.Delete(resultItem);
                                b.SetItem(resultItem);
                                player.Character.LogTransaction(b);

                                //sikerult minden mehet bele a kontenerbe
                                AddLoot(LootItemBuilder.Create(resultItem).Build());
                            }
                        }
                        finally
                        {
                            SendPacketToLooters(progressPacketBuilder);
                            progressPacketBuilder.Increase();
                        }
                    }

                    container.Save();

                    Transaction.Current.OnCompleted((c) =>
                    {
                        SendLootListToLooters();
                        container.SendUpdateToOwnerAsync();
                        SendPacketToLooters(progressPacketBuilder);
                    });

                    scope.Complete();
                }
            }
        }
        public void TakeLoots(Player player, int pinCode, IList <KeyValuePair <Guid, int> > items)
        {
            HasAccess(player, pinCode);

            lock (syncObject)
            {
                var takeLootBeamBuilder = Beam.NewBuilder().WithType(BeamType.loot_bolt)
                                          .WithSource(player)
                                          .WithTarget(this)
                                          .WithState(BeamState.Hit)
                                          .WithDuration(TimeSpan.FromSeconds(1));

                Zone.CreateBeam(takeLootBeamBuilder);

                using (var scope = Db.CreateTransaction())
                {
                    var container = player.GetContainer();
                    Debug.Assert(container != null, "container != null");
                    container.EnlistTransaction();
                    var lootedItems = new List <Item>();

                    var progressPacketBuilder = new LootContainerProgressInfoPacketBuilder(container, this, items.Count);

                    foreach (var kvp in items)
                    {
                        try
                        {
                            var lootId = kvp.Key;
                            var reqQty = kvp.Value;

                            var lootItem = _itemRepository.Get(this, lootId);
                            if (lootItem == null)
                            {
                                continue;
                            }

                            if (lootItem.Quantity < reqQty)
                            {
                                reqQty = lootItem.Quantity;
                            }

                            var item = CreateWithRandomEid(lootItem.ItemInfo);
                            item.Owner        = player.Owner;
                            item.Quantity     = reqQty;
                            item.IsRepackaged = lootItem.ItemInfo.IsRepackaged;

                            if (!container.IsEnoughCapacity(item))
                            {
                                continue;
                            }

                            //ha serult akkor legyen serult
                            item.Health = lootItem.ItemInfo.Health;

                            lock (container)
                            {
                                container.AddItem(item, true);
                            }

                            lootItem.Quantity -= reqQty;

                            if (lootItem.Quantity <= 0)
                            {
                                _itemRepository.Delete(this, lootItem);
                            }
                            else
                            {
                                _itemRepository.Update(this, lootItem);
                            }

                            lootedItems.Add(item);
                        }
                        finally
                        {
                            SendPacketToLooters(progressPacketBuilder);
                            progressPacketBuilder.Increase();
                        }
                    }

                    container.Save();

                    Transaction.Current.OnCompleted(c =>
                    {
                        container.SendUpdateToOwnerAsync();

                        OnTakeLoots(player, lootedItems);

                        if (CanRemoveIfEmpty() && _itemRepository.IsEmpty(this))
                        {
                            RemoveFromZone();
                        }
                        else
                        {
                            SendLootListToLooters();
                        }

                        SendPacketToLooters(progressPacketBuilder);
                    });

                    scope.Complete();
                }
            }
        }