def download(request):
    transaction = Transaction(request)
    transaction.set_current_step(Steps.DOWNLOAD)
    if transaction.current_step()['state'] in (State.DONE, State.DISABLED):
        return HttpResponseRedirect(transaction.next_step_url())

    return render(request, 'download.html', {'transaction': transaction})

    def checkUndoInvalidation(self):
        oid = self._storage.new_oid()
        revid = self._dostore(oid, data=MinPO(23))
        revid = self._dostore(oid, revid=revid, data=MinPO(24))
        revid = self._dostore(oid, revid=revid, data=MinPO(25))

        info = self._storage.undoInfo()
        if not info:
            # Preserved this comment, but don't understand it:
            # "Perhaps we have an old storage implementation that
            #  does do the negative nonsense."
            info = self._storage.undoInfo(0, 20)
        tid = info[0]['id']

        # Now start an undo transaction
        t = Transaction()
        t.note('undo1')
        oids = self._begin_undos_vote(t, tid)

        # Make sure this doesn't load invalid data into the cache
        self._storage.load(oid, '')

        self._storage.tpc_finish(t)

        assert len(oids) == 1
        assert oids[0] == oid
        data, revid = self._storage.load(oid, '')
        obj = zodb_unpickle(data)
        assert obj == MinPO(24)

class TestTransaction(unittest.TestCase):
  def setUp(self):
    Transaction.objects = {}

    self.transaction = Transaction(datetime(2014, 10, 4, 20, 0), 33.50)

  def test_initial_attributes(self):
    self.transaction.date        |should| equal_to(datetime(2014, 10, 4, 20, 0))
    self.transaction.month       |should| equal_to(10)
    self.transaction.value       |should| equal_to(33.50)
    self.transaction.id          |should| equal_to(1)

  def test_persistence(self):
    Transaction.objects |should| equal_to({ 1: self.transaction })

  def test_associate_credit_card(self):
    with Stub() as credit_card: credit_card.id >> 1

    self.transaction.associate_credit_card(credit_card)

    self.transaction.credit_card_id |should| equal_to(credit_card.id)

  def test_associate_seller(self):
    with Stub() as seller: seller.id >> 1

    self.transaction.associate_seller(seller)

    self.transaction.seller_id |should| equal_to(seller.id)

 def undo(self, tid, note=None):
     t = Transaction()
     if note is not None:
         t.note(note)
     oids = self._begin_undos_vote(t, tid)
     self._storage.tpc_finish(t)
     return oids

def config(request):
    """ configuration page """
    transaction = Transaction(request)
    transaction.set_current_step(Steps.CONFIG)
    if transaction.current_step()['state'] in (State.DONE, State.DISABLED):
        return HttpResponseRedirect(transaction.next_step_url())

    config = xmlrpc.call('get_config', transaction.modules_list)

    run_config = False
    skip_config = True
    for module in transaction.modules_info:
        if module["has_configuration"]:
            skip_config = False
        if module["has_configuration_script"]:
            run_config = True

    # modules don't have configuration scripts
    if not run_config:
        for module in transaction.modules_list:
            config_end(request, module)
        return render(request, 'config_no.html', {'transaction': transaction})
    # some module have configuration
    elif not skip_config:
        return render(request, 'config.html', {'transaction': transaction, 'config': config})
    else:
        return HttpResponseRedirect(reverse('config_valid'))

def preinst(request):
    """ preinst page """
    transaction = Transaction(request)
    transaction.set_current_step(Steps.PREINST)
    if transaction.current_step()['state'] in (State.DONE, State.DISABLED):
        return HttpResponseRedirect(transaction.next_step_url())

    return render(request, 'preinst.html', {'transaction': transaction})

 def undo(self, tid, note):
     t = Transaction()
     t.note(note)
     self._storage.tpc_begin(t)
     oids = self._storage.undo(tid, t)
     self._storage.tpc_vote(t)
     self._storage.tpc_finish(t)
     return oids

 def all_unknown(self, message, *args, **kwargs):
     __callstack_var_tx__ = Transaction(name=self._transactionName)
     yield self.once.begin(self._transactionName)
     try:
         yield self.all.unknown(message, *args, **kwargs)
         yield __callstack_var_tx__.commit()
     except TransactionException:
         yield __callstack_var_tx__.rollback()

def end(request):
    transaction = Transaction(request)
    transaction.set_current_step(Steps.END)

    for module in transaction.modules_list:
        xmlrpc.call("end_config", module, 0, "")

    return render(request, "end.html", {"transaction": transaction})

def medias_auth(request):
    """ media auth page """
    transaction = Transaction(request)
    transaction.set_current_step(Steps.MEDIAS_AUTH)
    if transaction.current_step()['state'] in (State.DONE, State.DISABLED):
        return HttpResponseRedirect(transaction.next_step_url())

    return render(request, 'media_auth.html', {'transaction': transaction})

 def signtransaction(self, tx, privkey=None):
     """Sign a transaction. The wallet keys will be used unless a private key is provided."""
     t = Transaction(tx)
     if privkey:
         pubkey = lbrycrd.public_key_from_private_key(privkey)
         t.sign({pubkey:privkey})
     else:
         self.wallet.sign_transaction(t, self._password)
     return t.as_dict()

def end(request):
    transaction = Transaction(request)
    transaction.set_current_step(Steps.END)

    for module in transaction.modules_list:
        xmlrpc.call('end_config', module, 0, "")

    return render(request, 'end.html',
                  {'transaction': transaction})

	def transfer_required_deposits(self):
		from transaction import Transaction
		
		transaction = Transaction()
		value = round(float(self.r*self.get_account("D")), 4)
		transaction.this_transaction("rD",  self.identifier,  -3,  value,  self.rb,  0,  -1)
		self.accounts.append(transaction)
		
		return  -1.0*value

    def __init__(self, size, manager):
        Transaction.__init__(self)
        self._trManager = manager
        self._size = size
        self._flush_count = 0
        self._endpoint = 'https://example.com'
        self._api_key = 'a' * 32

        self.is_flushable = False

	def decode_transaction(self, document):
			assert document["_type"] == "transaction"
			transaction = Transaction(document['_id'], document["time"])
			transaction.value_in = document['value_in']
			transaction.value_out = document['value_out']
			transaction.addressesValue_receving = document['addressesValue_receving']
			transaction.addressesValue_sending = document['addressesValue_sending']
	
			return transaction

def prepare(request):
    """ prepare the transaction """
    if request.method == "POST":
        modules = []
        for module, value in request.POST.items():
            modules.append(module)
        transaction = Transaction(request, modules)
        return HttpResponseRedirect(transaction.first_step_url())
    else:
        return HttpResponseRedirect(reverse('sections'))

 def gettransaction(self, txid, deserialized=False):
     """Retrieve a transaction. """
     tx = self.wallet.transactions.get(txid) if self.wallet else None
     if tx is None and self.network:
         raw = self.network.synchronous_get(('blockchain.transaction.get', [txid]))
         if raw:
             tx = Transaction(raw)
         else:
             raise BaseException("Unknown transaction")
     return tx.deserialize() if deserialized else tx

def install(request):
    """ install page """
    transaction = Transaction(request)
    transaction.set_current_step(Steps.INSTALL)
    if transaction.current_step()['state'] in (State.DONE, State.DISABLED):
        return HttpResponseRedirect(transaction.next_step_url())

    # launch modules install
    xmlrpc.call('install_modules', transaction.modules_list)
    return render(request, 'install.html', {'transaction': transaction})

    def __init__(self, data):
        self._data = data

        # Call after data has been set (size is computed in Transaction's init)
        Transaction.__init__(self)

        # Insert the transaction in the Manager
        self._trManager.append(self)
        logging.debug("Created transaction %d" % self.get_id())
        self._trManager.flush()

 def signtransaction(self, tx, privkey=None):
     """Sign a transaction. The wallet keys will be used unless a private key is provided."""
     t = Transaction(tx)
     t.deserialize()
     if privkey:
         pubkey = bitcoin.public_key_from_private_key(privkey)
         t.sign({pubkey:privkey})
     else:
         self.wallet.sign_transaction(t, self.password)
     return t