Subscriber and Wallet Data

{
	ACS_CUST_ID = <CCS_ACCT_REFERENCE.ACS_CUST_ID>
	ACS_CUST_NAME = <ACS_CUSTOMER.NAME>
	ACCT_REF_ID = <CCS_ACCT_REFERENCE.ACCT_REF_ID>
	CLI = <CCS_ACCT_REFERENCE.CLI>
	ACCOUNT_NUMBER = <CCS_ACCT_REFERENCE.ACCOUNT_NUMBER>
	primary [OPTIONAL] = {
	    BE_ACCT_ID = <CCS_ACCT.BE_ACCT_ID>
	    BE_ACCT_ENGINE_ID = <CCS_ACCT.BE_ACCT_ENGINE_ID>
		ACCOUNT_NUMBER = <CCS_ACCT.ACCOUNT_NUMBER>
		ACCT_CURRENCY_ID = <CCS_ACCT.CURRENCY_ID>
	    ACCT_TYPE_ID = <CCS_ACCT_TYPE.ID>
	    ACCT_TYPE_NAME = <CCS_ACCT_TYPE.NAME>
	    WALLET_TYPE_ID = <CCS_WALLET_TYPE.ID>
	    WALLET_TYPE_NAME = <CCS_WALLET_TYPE.NAME>
	}
	secondary [OPTIONAL] = {
	    <same fields as primary>
	}
}

local cli = '12345'
local pcs
local s = ccs.subscriber_for_cli (cli)
if (s) then
	-- subscriber exists; get information for their service provider
	pcs = ccs.customer.periodic_charges (s.ACS_CUST_ID)
else
	error ("Subscriber " .. cli .. " does not exist!")
end

local sub = ccs.subscriber ()
if (s.secondary) then
	-- logical subscriber has secondary wallet
end

{
	ID = <wallet ID>
	TYPE_ID = <wallet type ID for customer>
	PRODUCT_ID = <product type ID for the active wallet>
	CATEGORY = <Primary|Secondary>
}

local w = ccs.wallet.get ()
if (w and w.CATEGORY == 'Secondary') then
	-- logical subscriber is using their secondary wallet
end

{
	PRIMARY = <wallet type name>
	SECONDARY = <wallet type name>
}

local ws = ccs.wallets.get ('12345')
if (w and w.PRIMARY == 'Primary') then
	-- quelle surprise
end

{
	EXPIRY = <wallet expiry date (epoch) or nil>	
	LAST_ACCESSED = <wallet last access date or nil>
	ACTIVATION_DATE = <wallet activation date (epoch) or nil>
	MAX_CONCURRENT = <wallet maximum concurrent accesses>
	NUM_BALANCES = <number of balances in the wallet>
	USER_CURRENCY_ID = <wallet user currency ID>
	SYS_CURRENCY_ID = <wallet system currency ID>
	STATE = <wallet state (single character)>
	BALANCES = {
		<balance ID> = {
			ID = <balance ID>
			UNIT = <balance unit type ID>
			MAX_CREDIT = <balance maximum credit or nil>
			EXPIRY = <balance expiry date (epoch) or nil>	
			SYSTEM_VAL = <total balance amount in system currency (littles)>	
			USER_VAL = <total balance amount in system currency (littles)>	
			SYSTEM_VAL_UNRES = <unreserved SYSTEM_VAL>	
			USER_VAL_UNRES = <unreserved USER_VAL>
			LIMIT_TYPE = <limit type, one of LIMITED_POSTPAID, POSTPAID, PREPAID,
				SINGLE_USE_PREPAID, or UNKNOWN>	
		}
		<balance ID> = ...
	}
}

local acs_cust_id = ncc.engine.acs_customer ()
local wi = ccs.wallet.info ()
for k, v in pairs (wi) do
	if (k == 'BALANCES') then
		for bk, bv in pairs (v) do
			bname = ccs.customer.balance_type_name_for_id (acs_cust_id, bk)
			for bkx, bvx in pairs (bv) do
				if (bkx == 'LIMIT_TYPE') then
					ncc.debug ("Subscriber's " .. bname .. " limit type is " .. bvx)
				end
			end
		end
	end
end

{
	...
	BALANCES = {
		<balance ID> = {
			...
			BUCKETS = {
				<bucket ID> = {
					ID = <bucket ID>
					VAL = <bucket value in system currency (littles)>
					EXPIRY = <bucket expiry date (epoch) or nil>
					REF = <subscriber reference or nil>
					START = <bucket start date (epoch) or nil>
				}
				<bucket ID> = ...
			}
		}
		<balance ID> = ...
	}
}

local extendedWalletInfo = ccs.wallet.extended_info ()
local balance = ccs.wallet.get_balance (extendedWalletInfo, 123)
local bucket = nil
if (balance) then
	for k, v in pairs (balance) do
		if (type (v) == 'table' and k == "BUCKETS") then
			for bk, bv in pairs (v) do
				if (type (bv) == 'table') then
					bucket = bv
					break;
				end
			end
			if (bucket) then break end
		end
	end
end

{
	LAST_ACCESSED = <wallet last access date or nil>
	ACTIVATION_DATE = <wallet activation date or nil>
	STATE = <wallet state (single character) or nil>
	CREATE_EDR = <0 = no, anything else = yes>
}

local wu = { }
wu.STATE = 'S'
wu.LAST_ACCESSED = os.time () - 86400	
	-- note that this will be reset by any other action
wu.ACTIVATION_DATE = os.time () - (86400/3)
wu.CREATE_EDR = 1
ncc.debug ("Sending wallet update as:")
ncc.debug (wu)
local r = ccs.wallet.update (wu)
if r then
	-- wallet updated successfully
end

{
	START_DATE = <wallet start date (epoch) or nil>
	STATE = <wallet state (single character) or nil>
	BALANCES = {
		<balance ID> = {
			ID = <balance ID, mandatory>
			SYSTEM_VAL = <total balance amount
						in system currency (littles), mandatory>	
			BUCKET_ID = <ID to assign bucket, optional)>
			SUB_REF = <subscriber reference, optional>
			BUCKET_EXP = <bucket expiry date (epoch), optional>
			BUCKET_START = <bucket start date (epoch), optional>
		}
		-- OR
		<balance ID> = <total balance amount
						in system currency (littles)>
		-- (other fields defaulted in this syntax)
	}
	EXTRA_INFORMATION = <TAG=VALUE, pipe-separated>
}

-- simple addition of $10.00 to logical subscriber
local wu = { BALANCES = { ['147'] = 1000 } }
ccs.wallet.extended_update (wu)

-- using values as returned by wallet info
local delta = 2000
wu =  {
	MAX_CONCURRENT = 15,
	EXPIRY = 1473849547,
	USER_CURRENCY_ID = 1,
	BALANCES = {
		[147] = {
			ID = 147,
			BUCKET_EXP = 1418501215,
			SYSTEM_VAL = delta
		}
	},
	NUM_BALANCES = 6,
	EXTRA_INFORMATION = "FOO=BAR|RHU=BARB",
	SYS_CURRENCY_ID = 1,
	LAST_ACCESSED = 1415907954,
	ACTIVATION_DATE = 1415831938,
	STATE = 'A'
}
ncc.debug ("Doing extended wallet update with:")
ncc.debug (wu)
local r = ccs.wallet.extended_update (wu)
if not r then
	-- wallet extended update failed
end

{
	FILLED = <true|false, added by this function for speed>
	SUBSCRIBER = <subscriber definition from ccs.subscriber ()>
	EXTENDED_WI = <wallet information from ccs.wallet.extended_info ()>
	WALLET = <wallet information from ccs.wallet.get ()>
	PERIODIC_CHARGES = <periodic charge information for SUBSCRIBER.ACS_CUST_ID
						from ccs.customer.periodic_charges ()>
}

local l = ccs.wallet.fill_lookup_info ()
-- perhaps modify information here
local wu = { BALANCES = { ['147'] = 1000 } }
ccs.wallet.extended_update (wu, l)

{
	ID = <balance ID>
	-- other balance fields
	BUCKETS (if present in wallet information) = {
		<bucket ID> = {
		ID = <bucket ID>
		-- other bucket fields
	}
}

local extendedWalletInfo = ccs.wallet.extended_info ()
local balance = ccs.wallet.get_balance (extendedWalletInfo, pc.BALANCE_TYPE_ID)
local bucket = nil
if (balance) then
	for id, b in pairs (balance) do
		if (type (b) == 'table') then
			bucket = b
			break
		end
	end
end

{
	ID = <bucket ID>
	-- other bucket fields
}

local extendedWalletInfo = ccs.wallet.extended_info ()
local balance = ccs.wallet.get_balance (extendedWalletInfo, pc.BALANCE_TYPE_ID)
local bucket = ccs.wallet.get_bucket (balance, 123)