def get_account_info(myAccId):
myAccId = str(myAccId)
account = {}
account['id'] = myAccId
account['name'] = otapi.OTAPI_Wrap_GetAccountWallet_Name(myAccId)
assetId = otapi.OTAPI_Wrap_GetAccountWallet_AssetTypeID(myAccId)
account["balance"] = otapi.OTAPI_Wrap_GetAccountWallet_Balance(myAccId)
account["formattedBalance"] = \
otapi.OTAPI_Wrap_FormatAmount(assetId, account["balance"])
account["nym"] = {}
account["nym"]["id"] = otapi.OTAPI_Wrap_GetAccountWallet_NymID(myAccId)
account["nym"]["name"] = \
otapi.OTAPI_Wrap_GetNym_Name(account["nym"]["id"])
account["server"] = {}
account["server"]["id"] = \
otapi.OTAPI_Wrap_GetAccountWallet_ServerID(myAccId)
account["server"]["name"] = \
otapi.OTAPI_Wrap_GetServer_Name(account["server"]["id"])
account["asset"] = {}
account["asset"]["id"] = assetId
account["asset"]["name"] = otapi.OTAPI_Wrap_GetAssetType_Name(assetId)
return {'account': account}
def refresh(myAccId):
myAccId = str(myAccId)
myNymId = otapi.OTAPI_Wrap_GetAccountWallet_NymID(myAccId)
serverId = otapi.OTAPI_Wrap_GetAccountWallet_ServerID(myAccId)
objEasy = otapi.OT_ME()
result = objEasy.retrieve_account(serverId, myNymId, myAccId, True)
if not result:
return {'error': 'Failed trying to refresh wallet.'}
return {} # OK
def change_account_name(myAccId, name):
myAccId = str(myAccId)
name = str(name)
myNymId = otapi.OTAPI_Wrap_GetAccountWallet_NymID(myAccId)
if not myNymId:
errorMessage = (
"Unable to find NymID based on myAccId\nThe designated asset "
"account must be yours. OT will find the Nym based on the account."
)
return {'error': errorMessage}
result = otapi.OTAPI_Wrap_SetAccountWallet_Name(myAccId, myNymId, name)
if result:
return {} # OK
else:
return {'error': 'Failed trying to set account label to:'+name}
def send_transfer(myAccId, hisAccId, amount, memo):
myAccId = str(myAccId)
hisAccId = str(hisAccId)
amount = str(amount)
memo = str(memo)
myNymId = otapi.OTAPI_Wrap_GetAccountWallet_NymID(myAccId)
if not myNymId:
errorMessage = ("Unable to find NymID (for sender) based on myAccId.\n"
"The designated asset account must be yours."
"OT will find the Nym based on the account.")
return {'error': errorMessage}
myServerId = otapi.OTAPI_Wrap_GetAccountWallet_ServerID(myAccId)
if not myServerId:
errorMessage = ("Unable to find ServerID based on myAccId.\n"
"The designated asset account must be yours. "
"OT will find the Server based on the account.")
return {'error': errorMessage}
hisServerId = otapi.OTAPI_Wrap_GetAccountWallet_ServerID(hisAccId)
if not hisServerId:
print 'hisAcctId is not in the wallet, so I\'m assuming it\'s on the same server as myAccId. (Proceeding.)'
hisServerId = myServerId
if myServerId != hisServerId:
errorMessage = (
"hisAccId is not on the same server as myAccId "
"(he's on " + hisServerId + " but myAccId is on " + myServerId +
"). "
"You must choose either a different sender account or a "
"different recipient account")
return {'error': errorMessage}
assetTypeId = otapi.OTAPI_Wrap_GetAccountWallet_AssetTypeID(myAccId)
assetAmount = otapi.OTAPI_Wrap_StringToAmount(assetTypeId, amount)
objEasy = otapi.OT_ME()
response = objEasy.send_transfer(myServerId, myNymId, myAccId, hisAccId,
assetAmount, memo)
attempt = 'send_transfer'
interpretReply = objEasy.InterpretTransactionMsgReply(
myServerId, myNymId, myAccId, attempt, response)
if int(interpretReply) is not -1:
# Download all the intermediary files
# (account balance, inbox, outbox, etc)
# since they have probably changed from this operation.
retrieved = objEasy.retrieve_account(myServerId, myNymId, myAccId,
True)
print 'Server response (' + attempt + '): SUCCESS sending transfer!'
if retrieved:
print "Success retrieving intermediary files for account."
else:
print "Failed retrieving intermediary files for account."
return {} # OK
else:
errorMessage = (
"Unexpected error. Verify if the accounts really exist.")
return {'error': errorMessage}
def handle_payment_index(myAccId, nIndex, strPaymentType, strInbox):
myNymId = otapi.OTAPI_Wrap_GetAccountWallet_NymID(myAccId)
if not myNymId:
errorMessage = (
"Unable to find NymID based on myAccId\n"
"The designated asset account must be yours. OT will find "
"the Nym based on the account."
)
return {'error': errorMessage}
serverId = otapi.OTAPI_Wrap_GetAccountWallet_ServerID(myAccId)
if not serverId:
errorMessage = (
"Unable to find Server ID based on myAccId.\n"
"The designated asset account must be yours. OT will find "
"the Server based on the account."
)
return {'error': errorMessage}
instrument = ''
if nIndex == -1:
return {'error': "You must specify an index in the payments inbox"}
else: # Use an instrument from the payments inbox, since a valid index was provided.
objEasy = otapi.OT_ME()
# strInbox is optional and avoids having to load it multiple times. This function will just load it itself, if it has to.
instrument = objEasy.get_payment_instrument(serverId, myNymId, nIndex, strInbox)
if not instrument:
errorMessage = (
"Unable to get payment instrument based on index: "+nIndex
)
return {'error': errorMessage}
# By this point, instrument is a valid string (whether we got it from the payments inbox,
# or whether we got it from stdin.)
type = otapi.OTAPI_Wrap_Instrmnt_GetType(instrument)
if not type:
errorMessage = (
"Unable to determine instrument's type. "
"Expected CHEQUE, VOUCHER, INVOICE, or (cash) PURSE."
)
return {'error': errorMessage}
strIndexErrorMsg = ''
if nIndex != -1:
strIndexErrorMsg = 'at index '+nIndex
# If there's a payment type,
# and it's not "ANY", and it's the wrong type,
# then skip this one.
if not strPaymentType and (strPaymentType != 'ANY') and (strPaymentType != type):
if not ((('CHEQUE' == strPaymentType) and ('VOUCHER' == type)) or (('VOUCHER' == strPaymentType) and ('CHEQUE' == type))):
errorMessage = (
"The instrument "+strIndexErrorMsg+"is not a "
""+strPaymentType+". (It's a "+type+". Skipping.)"
)
return {'error': errorMessage}
# in this case we allow it to drop through.
# By this point, we know the invoice has the right asset type for the account
# we're trying to use (to pay it from.)
#
# But we need to make sure the invoice is made out to myNymId (or to no one.)
# Because if it IS endorsed to a Nym, and myNymId is NOT that nym, then the
# transaction will fail. So let's check, before we bother sending it...
strRecipientUserID = otapi.OTAPI_Wrap_Instrmnt_GetRecipientUserID(instrument)
# Not all instruments have a specified recipient. But if they do, let's make
# sure the Nym matches.
if strRecipientUserID and (strRecipientUserID != myNymId):
errorMessage = (
"The instrument "+strIndexErrorMsg+" is endorsed to a "
"specific recipient ("+strRecipientUserID+") and that "
"doesn't match the account's owner Nym ("+myNymId+"). "
"(Skipping.)\nTry specifying a different account"
)
return {'error': errorMessage}
# At this point I know the invoice isn't made out to anyone, or if it is, it's properly
# made out to the owner of the account which I'm trying to use to pay the invoice from.
# So let's pay it! P.S. strRecipientUserID might be NULL, but myNymId is guaranteed
# to be good.
instrumentAssetType = otapi.OTAPI_Wrap_Instrmnt_GetAssetID(instrument)
strAccountAssetID = otapi.OTAPI_Wrap_GetAccountWallet_AssetTypeID(myAccId)
if instrumentAssetType and (strAccountAssetID != instrumentAssetType):
errorMessage = (
"The instrument at index "+nIndex+" has a different "
"asset type than the selected account. (Skipping.)\n"
"Try specifying a different account"
)
return {'error': errorMessage}
tFrom = otapi.OTAPI_Wrap_Instrmnt_GetValidFrom(instrument)
tTo = otapi.OTAPI_Wrap_Instrmnt_GetValidTo(instrument)
tTime = otapi.OTAPI_Wrap_GetTime()
if (tTime < tFrom):
errorMessage = (
"The instrument at index "+nIndex+" is not yet within "
"its valid date range. (Skipping.)"
)
return {'error': errorMessage}
if (tTo > 0) and (tTime > tTo):
print "The instrument at index "+nIndex+" is expired. \
(Moving it to the record box.)"
# Since this instrument is expired, remove it from the payments inbox, and move to record box.
# Note: this harvests
# bSaveCopy = true. (Since it's expired, it'll go into the expired box.)
if (nIndex >= 0) and otapi.OTAPI_Wrap_RecordPayment(serverId, myNymId, true, nIndex, true):
return {'handled': True}
return {'error': "Failed trying to record payment"}
# TODO, IMPORTANT: After the below deposits are completed successfully, the wallet
# will receive a "successful deposit" server reply. When that happens, OT (internally)
# needs to go and see if the deposited item was a payment in the payments inbox. If so,
# it should REMOVE it from that box and move it to the record box.
#
# That's why you don't see me messing with the payments inbox even when these are successful.
# They DO need to be removed from the payments inbox, but just not here in the script. (Rather,
# internally by OT itself.)
if type == 'CHEQUE':
return deposit_cheque(serverId, myAccId, myNymId, instrument, type)
elif type == "VOUCHER":
return deposit_cheque(serverId, myAccId, myNymId, instrument, type)
elif type == "INVOICE":
return deposit_cheque(serverId, myAccId, myNymId, instrument, type)
elif type == "PURSE":
nDepositPurse = deposit_purse(serverId, myAccId, myNymId, instrument, '') # strIndices is left blank in this case
# if nIndex != (-1), go ahead and call RecordPayment on the purse at that index, to
# remove it from payments inbox and move it to the recordbox.
#
if nIndex != -1 and nDepositPurse == 1:
nRecorded = otapi.OTAPI_Wrap_RecordPayment(serverId, myNymId, true, nIndex, true) # bSaveCopy=true.
return nDepositPurse
else:
errorMessage = (
"Skipping this instrument: Expected CHEQUE, "
"VOUCHER, INVOICE, or (cash) PURSE."
)
return {'error': errorMessage}
def accept_from_paymentbox(myAccId, strIndices, strPaymentType):
myAccId = str(myAccId)
strIndices = str(strIndices)
strPaymentType = str(strPaymentType)
myNymId = otapi.OTAPI_Wrap_GetAccountWallet_NymID(myAccId)
if not myNymId:
errorMessage = (
"Unable to find NymID based on myAccId\n"
"The designated asset account must be yours. OT will find "
"the Nym based on the account."
)
return {'error': errorMessage}
serverId = otapi.OTAPI_Wrap_GetAccountWallet_ServerID(myAccId)
if not serverId:
errorMessage = (
"Unable to find Server ID based on myAccId.\n"
"The designated asset account must be yours. OT will find "
"the Server based on the account."
)
return {'error': errorMessage}
# Returns NULL, or an inbox.
strInbox = otapi.OTAPI_Wrap_LoadPaymentInbox(serverId, myNymId)
if not strInbox:
errorMessage = (
"accept_from_paymentbox: "
"otapi.OTAPI_Wrap_LoadPaymentInbox Failed."
)
return {'error': errorMessage}
nCount = otapi.OTAPI_Wrap_Ledger_GetCount(serverId, myNymId, myNymId, strInbox)
if not nCount:
return {'error': "Unable to retrieve size of payments inbox ledger."}
nIndicesCount = otapi.OTAPI_Wrap_NumList_Count(strIndices) if strIndices else 0
# Either we loop through all the instruments and accept them all, or
# we loop through all the instruments and accept the specified indices.
#
# (But either way, we loop through all the instruments.)
#
for i in range(nCount):
# Loop from back to front, so if any are removed, the indices remain accurate subsequently.
j = nCount - i - 1
# - If indices are specified, but the current index is not on
# that list, then continue...
#
# - If NO indices are specified, accept all the ones matching MyAcct's asset type.
#
if nIndicesCount > 0 and not otapi.OTAPI_Wrap_NumList_VerifyQuery(strIndices, j):
continue
nHandled = handle_payment_index(myAccId, j, strPaymentType, strInbox)
return {} # OK
def accept_inbox_items(myAccId, nItemType, strIndices):
myAccId = str(myAccId)
nItemType = int(nItemType)
strIndices = str(strIndices)
myNymId = otapi.OTAPI_Wrap_GetAccountWallet_NymID(myAccId)
if not myNymId:
errorMessage = (
"Unable to find NymID based on the specified account "+myAccId
)
return {'error': errorMessage}
serverId = otapi.OTAPI_Wrap_GetAccountWallet_ServerID(myAccId)
if not serverId:
errorMessage = (
"Unable to find Server ID based on the specified account "+myAccId
)
return {'error': errorMessage}
# User may have already chosen indices (passed in) so we don't want to
# re-download the inbox unless we HAVE to. But if the hash has changed, that's
# one clear-cut case where we _do_ have to. Otherwise our balance agreement
# will fail anyway. So hopefully we can let OT "be smart about it" here instead
# of just forcing it to download every time even when unnecessary.
objEasy = otapi.OT_ME()
result = objEasy.retrieve_account(serverId, myNymId, myAccId, False)
if not result:
return {'error': 'Unable to download the intermediary files.'}
# Make sure we have at least one transaction number (to process the inbox with.)
#
# NOTE: Normally we don't have to do this, because the high-level API is smart
# enough, when sending server transaction requests, to grab new transaction numbers
# if it is running low.
# But in this case, we need the numbers available BEFORE sending the transaction
# request, because the call to otapi.OTAPI_Wrap_Ledger_CreateResponse is where the number
# is first needed, and that call is made long before the server transaction request
# is actually sent.
if not objEasy.make_sure_enough_trans_nums(10, serverId, myNymId):
return {'error': 'Unable to have at least one transaction number'}
# Returns NULL, or an inbox.
strInbox = otapi.OTAPI_Wrap_LoadInbox(serverId, myNymId, myAccId)
if not strInbox:
return {'error': 'otapi.OTAPI_Wrap_LoadInbox: Failed.'}
else:
nCount = otapi.OTAPI_Wrap_Ledger_GetCount(serverId, myNymId, myAccId, strInbox)
if nCount and nCount > 0:
# NOTE!!! DO **NOT** create the response ledger until the FIRST iteration of the below loop that actually
# creates a transaction response! If that "first iteration" never comes (due to receipts being skipped, etc)
# then otapi.OTAPI_Wrap_Transaction_CreateResponse will never get called, and therefore Ledger_CreateResponse should
# also not be called, either. (Nor should otapi.OTAPI_Wrap_Ledger_FinalizeResponse, etc.)
strResponseLEDGER = ''
nIndicesCount = otapi.OTAPI_Wrap_NumList_Count(strIndices) if strIndices else 0
for i in range(nCount):
strTrans = otapi.OTAPI_Wrap_Ledger_GetTransactionByIndex(serverId, myNymId, myAccId, strInbox, i)
# ----------------------------------------------------------
# nItemType == 0 for all, 1 for transfers only, 2 for receipts only.
# strIndices == "" for "all indices"
#
print 'P6'
if nItemType > 0: # 0 means "all", so we don't have to skip anything based on type, if it's 0.
strTransType = otapi.OTAPI_Wrap_Transaction_GetType(serverId, myNymId, myAccId, strTrans)
# incoming transfer
print 'P4'
if strTransType == 'pending' and nItemType != 1:
continue
# receipt
print 'P5'
if strTransType != 'pending' and nItemType != 2:
# if it is NOT an incoming transfer, then it's a receipt. If we're not doing receipts, then skip it.
continue
# ----------------------------------------------------------
# - If NO indices are specified, process them ALL.
#
# - If indices are specified, but the current index is not on
# that list, then continue...
#
if nIndicesCount > 0 and not otapi.OTAPI_Wrap_NumList_VerifyQuery(strIndices, str(i)):
continue
# By this point we know we actually have to call otapi.OTAPI_Wrap_Transaction_CreateResponse
# Therefore, if otapi.OTAPI_Wrap_Ledger_CreateResponse has not yet been called (which it won't
# have been, the first time we hit this in this loop), then we call it here this one
# time, to get things started...
#
print 'P1'
if not strResponseLEDGER:
strResponseLEDGER = otapi.OTAPI_Wrap_Ledger_CreateResponse(serverId, myNymId, myAccId, strInbox)
print 'P2'
if not strResponseLEDGER:
errorMessage = (
"otapi.OTAPI_Wrap_Ledger_CreateResponse "
"returned NULL."
)
return {'error': errorMessage}
# ----------------------------
# By this point, we know the ledger response exists, and we know we have to create
# a transaction response to go inside of it, so let's do that next...
# accept = True (versus rejecting a pending transfer, for example.)
strNEW_ResponseLEDGER = otapi.OTAPI_Wrap_Transaction_CreateResponse(serverId, myNymId, myAccId, strResponseLEDGER, strTrans, True)
print 'P3'
if not strNEW_ResponseLEDGER:
errorMessage = (
"otapi.OTAPI_Wrap_Transaction_CreateResponse "
"returned NULL."
)
return {'error': errorMessage}
strResponseLEDGER = strNEW_ResponseLEDGER
if not strResponseLEDGER:
# This means there were receipts in the box, but they were skipped.
# And after the skipping was done, there were no receipts left.
# So we can't just say "the box is empty" because it's not. But nevertheless,
# we aren't actually processing any of them, so we return 0 AS IF the box
# had been empty. (Because this is not an error condition. Just a "no op".)
logMessage = (
"There were receipts in the box, but they were skipped."
)
return {'log': logMessage}
# -------------------------------------------
# Below this point, we know strResponseLEDGER needs to be sent,
# so let's finalize it.
#
strFinalizedResponse = otapi.OTAPI_Wrap_Ledger_FinalizeResponse(serverId, myNymId, myAccId, strResponseLEDGER)
if not strFinalizedResponse:
errorMessage = (
"otapi.OTAPI_Wrap_Ledger_FinalizeResponse returned NULL."
)
return {'error': errorMessage}
# Server communications are handled here...
strResponse = objEasy.process_inbox(serverId, myNymId, myAccId, strFinalizedResponse)
strAttempt = 'process_inbox'
nInterpretReply = objEasy.InterpretTransactionMsgReply(serverId, myNymId, myAccId, strAttempt, strResponse)
if nInterpretReply == 1:
# Download all the intermediary files (account balance, inbox, outbox, etc)
# since they have probably changed from this operation.
bRetrieved = objEasy.retrieve_account(serverId, myNymId, myAccId, True)
if not bRetrieved:
logMessage = (
"Failed retrieving intermediary files for account."
)
return {'log': logMessage}
return {} # OK
if not nInterpretReply:
return {'error': "Failed accepting inbox items."}
return {'log': 'empty'}
def inbox(myAccId):
myAccId = str(myAccId)
myNymId = otapi.OTAPI_Wrap_GetAccountWallet_NymID(myAccId)
if not myNymId:
errorMessage = (
"Unable to find NymID based on myAccId\nThe designated asset "
"account must be yours. OT will find the Nym based on the account."
)
return {'error': errorMessage}
serverId = otapi.OTAPI_Wrap_GetAccountWallet_ServerID(myAccId)
if not serverId:
errorMessage = (
"Unable to find Server ID based on myAccId.\nThe designated asset "
"account must be yours. OT will find the Server based on "
"the account."
)
return {'error': errorMessage}
inbox = otapi.OTAPI_Wrap_LoadInbox(serverId, myNymId, myAccId)
if not inbox:
errorMessage = (
"Unable to load asset account inbox. ( "+myAccId+" )\n"
"Perhaps it doesn't exist yet?"
)
return {'error': errorMessage}
nCount = otapi.OTAPI_Wrap_Ledger_GetCount(serverId, myNymId, myAccId, inbox)
if nCount and nCount > 0:
payments = []
for i in range(nCount):
trans = otapi.OTAPI_Wrap_Ledger_GetTransactionByIndex(serverId, myNymId, myAccId, inbox, i)
lTransID = otapi.OTAPI_Wrap_Ledger_GetTransactionIDByIndex(serverId, myNymId, myAccId, inbox, i)
lRefNum = otapi.OTAPI_Wrap_Transaction_GetDisplayReferenceToNum(serverId, myNymId, myAccId, trans)
lAmount = otapi.OTAPI_Wrap_Transaction_GetAmount(serverId, myNymId, myAccId, trans)
type = otapi.OTAPI_Wrap_Transaction_GetType(serverId, myNymId, myAccId, trans)
strSenderUserID = otapi.OTAPI_Wrap_Transaction_GetSenderUserID(serverId, myNymId, myAccId, trans)
strSenderAcctID = otapi.OTAPI_Wrap_Transaction_GetSenderAcctID(serverId, myNymId, myAccId, trans)
strRecipientUserID = otapi.OTAPI_Wrap_Transaction_GetRecipientUserID(serverId, myNymId, myAccId, trans)
strRecipientAcctID = otapi.OTAPI_Wrap_Transaction_GetRecipientAcctID(serverId, myNymId, myAccId, trans)
strUserID = strSenderUserID if strSenderUserID else strRecipientUserID
strAcctID = strSenderAcctID if strSenderAcctID else strRecipientAcctID
bUserIDExists = True if strUserID else False
bAcctIDExists = True if strAcctID else False
if bAcctIDExists:
strAssetTypeID = otapi.OTAPI_Wrap_GetAccountWallet_AssetTypeID(strAcctID)
else:
strAssetTypeID = ''
if lAmount:
if strAssetTypeID:
strAmount = otapi.OTAPI_Wrap_FormatAmount(strAssetTypeID, lAmount)
else:
strAmount = lAmount
else:
strAmount = "UNKNOWN_AMOUNT"
payment = {}
payment['index'] = i
payment['formattedAmount'] = strAmount
payment['amount'] = lAmount
payment['status'] = type
payment['transactionId'] = lTransID
payment['ref'] = lRefNum
payment['from'] = {}
payment['from']['id'] = strUserID
payment['from']['accountId'] = strAcctID
payments.append(payment)
return {'inbox': payments}
else:
return {'inbox': []}