Method to add a transaction to the batch list. The correct batch will
        be determined by the payment dict and the batch will be created if
        not existant. This will also add the payment amount to the respective
        batch total.
769299
def _add_to_batch_list(self, TX, payment):
        
        batch_key = payment.get('execution_date', None)
        if batch_key in self._batches.keys():
            self._batches[batch_key].append(TX['CdtTrfTxInfNode'])
        else:
            self._batches[batch_key] = []
            self._batches[batch_key].append(TX['CdtTrfTxInfNode'])

        if batch_key in self._batch_totals:
            self._batch_totals[batch_key] += payment['amount']
        else:
            self._batch_totals[batch_key] = payment['amount']
1231829
public static void addTxn(TransactionImpl txn)
    {
        if (tc.isEntryEnabled()) Tr.entry(tc, "addTxn", txn);

        final ByteArray key = new ByteArray(txn.getXid().getGlobalTransactionId());

        synchronized (txnTable)
        {
            if (!txnTable.containsKey(key))
            {
                txnTable.put(key, new JCATranWrapperImpl(txn, true, false)); // @LIDB2110C
            }
        }

        if (tc.isEntryEnabled()) Tr.exit(tc, "addTxn");
    }
57782
@Override
    public boolean add(OrderableTransaction txnState) {
        if (m_initiatorData.containsKey(txnState.initiatorHSId) == false) {
            return false;
        }
        boolean retval = super.add(txnState);
        // update the queue state
        if (retval) updateQueueState();
        return retval;
    }
179069
def add(self, item):
        
        check_not_none(item, "item can't be none")
        return self._encode_invoke(transactional_list_add_codec, item=self._to_data(item))
1289456
def batch_update_reimburse(self, openid, reimburse_status, invoice_list):
        
        return self._post(
            'reimburse/updatestatusbatch',
            data={
                'openid': openid,
                'reimburse_status': reimburse_status,
                'invoice_list': invoice_list,
            },
        )
186992
public void addCommitAction(final Runnable action) throws HibernateException
	{
		if (action == null)
			return; // ignore null actions

		addAction(new BaseSessionEventListener()
		{
			@Override
			public void transactionCompletion(final boolean successful)
			{
				if (successful)
					action.run();
			}
		});
	}
745908
def create_payment(self, data):
        
        return OrderPayments(self.client).on(self).create(data)
186511
def group_batchadd(self, buyer_ids, group_ids, session):
        ''''''
        request = TOPRequest('taobao.crm.members.group.batchadd')
        request['buyer_ids'] = buyer_ids
        request['group_ids'] = group_ids
        self.create(self.execute(request, session), fields=['is_success', ])
        return self.is_success
1313889
def apply_transaction(self,
                          transaction: BaseTransaction
                          ) -> Tuple[BaseBlock, Receipt, BaseComputation]:
        
        vm = self.get_vm(self.header)
        base_block = vm.block

        receipt, computation = vm.apply_transaction(base_block.header, transaction)
        header_with_receipt = vm.add_receipt_to_header(base_block.header, receipt)

        # since we are building the block locally, we have to persist all the incremental state
        vm.state.persist()
        new_header = header_with_receipt.copy(state_root=vm.state.state_root)

        transactions = base_block.transactions + (transaction, )
        receipts = base_block.get_receipts(self.chaindb) + (receipt, )

        new_block = vm.set_block_transactions(base_block, new_header, transactions, receipts)

        self.header = new_block.header

        return new_block, receipt, computation
96903
def add_batch(self, datapoints):
        
        num_datapoints_to_add = datapoints.shape[0]
        end_index = self.cur_index + num_datapoints_to_add
        if end_index <= self.num_datapoints:
            self.data[self.cur_index:end_index,...] = datapoints
            self.cur_index = end_index
92640
def send(self, transactions):
        
        txn_signatures = [txn.header_signature for txn in transactions]
        header = BatchHeader(
            signer_public_key=self._identity_signer.get_public_key().as_hex(),
            transaction_ids=txn_signatures
        ).SerializeToString()

        signature = self._identity_signer.sign(header)
        batch = Batch(
            header=header,
            transactions=transactions,
            header_signature=signature)

        self._batch_sender.send(batch)
22173
def _add_batch(x, sample):
    
    added = False
    for batch in sorted(dd.get_batches(sample) or [], key=len, reverse=True):
        if batch and os.path.basename(x["path"]).startswith(("%s-" % batch, "%s.vcf" % batch)):
            x["batch"] = batch
            added = True
            break
    if not added:
        x["batch"] = dd.get_sample_name(sample)
    return x
732257
def payments
      payments ||= lambda {
        obj = Payments.new
        obj.account = self
        obj
      }.call
    end
1078392
def AddTransaction(self, tx):
        
        if BC.Default() is None:
            return False

        if tx.Hash.ToBytes() in self.MemPool.keys():
            return False

        if BC.Default().ContainsTransaction(tx.Hash):
            return False

        if not tx.Verify(self.MemPool.values()):
            logger.error("Verifying tx result... failed")
            return False

        self.MemPool[tx.Hash.ToBytes()] = tx

        return True
388891
void addToCommittedQueue(Session session, Object[] list) {

        synchronized (committedTransactionTimestamps) {

            // add the txList according to commit timestamp
            committedTransactions.addLast(list);

            // get session commit timestamp
            committedTransactionTimestamps.addLast(session.actionTimestamp);
/* debug 190
            if (committedTransactions.size() > 64) {
                System.out.println("******* excessive transaction queue");
            }
// debug 190 */
        }
    }
25066
def notify_batch_pending(self, batch):
        
        txn_ids = {t.header_signature for t in batch.transactions}
        with self._lock:
            self._pending.add(batch.header_signature)
            self._batch_info[batch.header_signature] = txn_ids
            self._update_observers(batch.header_signature,
                                   ClientBatchStatus.PENDING)
137019
public function addPayment(\OxidEsales\PayPalModule\Model\OrderPayment $payment)
    {
        $paymentList = $this->getPaymentList();
        $paymentList->addPayment($payment);
        $this->setPaymentList(null);
    }