PaySecure Pinless Web Services 2023:07:03:07

<back to all web services

ClientTokenizeACHRequest

The following routes are available for this service:
POST/ClientTokenizeACH
import 'package:servicestack/servicestack.dart';

// @DataContract
class InOutTimes implements IConvertible
{
    InOutTimes();
    InOutTimes.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    getTypeName() => "InOutTimes";
    TypeContext? context = _ctx;
}

// @DataContract
class RequestTimestamps implements IConvertible
{
    // @DataMember(EmitDefaultValue=false)
    InOutTimes? AppLayer;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? ParentLookup;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? RetryLookup;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? GetCardData;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? CardTokenize;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? CardEncrypt;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? DBInsert;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? BackendProcess;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? DBUpdate;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? ParentUpdate;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? Network;

    RequestTimestamps({this.AppLayer,this.ParentLookup,this.RetryLookup,this.GetCardData,this.CardTokenize,this.CardEncrypt,this.DBInsert,this.BackendProcess,this.DBUpdate,this.ParentUpdate,this.Network});
    RequestTimestamps.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        AppLayer = JsonConverters.fromJson(json['AppLayer'],'InOutTimes',context!);
        ParentLookup = JsonConverters.fromJson(json['ParentLookup'],'InOutTimes',context!);
        RetryLookup = JsonConverters.fromJson(json['RetryLookup'],'InOutTimes',context!);
        GetCardData = JsonConverters.fromJson(json['GetCardData'],'InOutTimes',context!);
        CardTokenize = JsonConverters.fromJson(json['CardTokenize'],'InOutTimes',context!);
        CardEncrypt = JsonConverters.fromJson(json['CardEncrypt'],'InOutTimes',context!);
        DBInsert = JsonConverters.fromJson(json['DBInsert'],'InOutTimes',context!);
        BackendProcess = JsonConverters.fromJson(json['BackendProcess'],'InOutTimes',context!);
        DBUpdate = JsonConverters.fromJson(json['DBUpdate'],'InOutTimes',context!);
        ParentUpdate = JsonConverters.fromJson(json['ParentUpdate'],'InOutTimes',context!);
        Network = JsonConverters.fromJson(json['Network'],'InOutTimes',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'AppLayer': JsonConverters.toJson(AppLayer,'InOutTimes',context!),
        'ParentLookup': JsonConverters.toJson(ParentLookup,'InOutTimes',context!),
        'RetryLookup': JsonConverters.toJson(RetryLookup,'InOutTimes',context!),
        'GetCardData': JsonConverters.toJson(GetCardData,'InOutTimes',context!),
        'CardTokenize': JsonConverters.toJson(CardTokenize,'InOutTimes',context!),
        'CardEncrypt': JsonConverters.toJson(CardEncrypt,'InOutTimes',context!),
        'DBInsert': JsonConverters.toJson(DBInsert,'InOutTimes',context!),
        'BackendProcess': JsonConverters.toJson(BackendProcess,'InOutTimes',context!),
        'DBUpdate': JsonConverters.toJson(DBUpdate,'InOutTimes',context!),
        'ParentUpdate': JsonConverters.toJson(ParentUpdate,'InOutTimes',context!),
        'Network': JsonConverters.toJson(Network,'InOutTimes',context!)
    };

    getTypeName() => "RequestTimestamps";
    TypeContext? context = _ctx;
}

// @DataContract
class PaysecureResponseInternal implements IConvertible
{
    // @DataMember(EmitDefaultValue=false)
    RequestTimestamps? Timestamps;

    PaysecureResponseInternal({this.Timestamps});
    PaysecureResponseInternal.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Timestamps = JsonConverters.fromJson(json['Timestamps'],'RequestTimestamps',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Timestamps': JsonConverters.toJson(Timestamps,'RequestTimestamps',context!)
    };

    getTypeName() => "PaysecureResponseInternal";
    TypeContext? context = _ctx;
}

// @DataContract
class ClientTokenizeACH extends PaysecureResponseInternal implements IConvertible
{
    // @DataMember
    String? SessionToken;

    // @DataMember
    String? ResponseCode;

    // @DataMember
    String? ErrorMessage;

    // @DataMember
    String? ErrorCode;

    ClientTokenizeACH({this.SessionToken,this.ResponseCode,this.ErrorMessage,this.ErrorCode});
    ClientTokenizeACH.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        SessionToken = json['SessionToken'];
        ResponseCode = json['ResponseCode'];
        ErrorMessage = json['ErrorMessage'];
        ErrorCode = json['ErrorCode'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'SessionToken': SessionToken,
        'ResponseCode': ResponseCode,
        'ErrorMessage': ErrorMessage,
        'ErrorCode': ErrorCode
    });

    getTypeName() => "ClientTokenizeACH";
    TypeContext? context = _ctx;
}

class BillingDescriptor implements IConvertible
{
    String? Address;
    String? City;
    String? State;
    String? Zip;
    String? Country;

    BillingDescriptor({this.Address,this.City,this.State,this.Zip,this.Country});
    BillingDescriptor.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Address = json['Address'];
        City = json['City'];
        State = json['State'];
        Zip = json['Zip'];
        Country = json['Country'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Address': Address,
        'City': City,
        'State': State,
        'Zip': Zip,
        'Country': Country
    };

    getTypeName() => "BillingDescriptor";
    TypeContext? context = _ctx;
}

// @DataContract
class ClientTokenizeACHRequest implements IConvertible
{
    // @DataMember
    String? Version;

    // @DataMember
    String? KeyId;

    // @DataMember
    String? FirstName;

    // @DataMember
    String? LastName;

    // @DataMember
    String? Email;

    // @DataMember
    String? PhoneType;

    // @DataMember
    String? PhoneNumber;

    // @DataMember
    String? RoutingNumber;

    // @DataMember
    String? EncryptedAccountNumber;

    // @DataMember
    BillingDescriptor? BillingDetails;

    // @DataMember
    bool? VerifyACH;

    ClientTokenizeACHRequest({this.Version,this.KeyId,this.FirstName,this.LastName,this.Email,this.PhoneType,this.PhoneNumber,this.RoutingNumber,this.EncryptedAccountNumber,this.BillingDetails,this.VerifyACH});
    ClientTokenizeACHRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Version = json['Version'];
        KeyId = json['KeyId'];
        FirstName = json['FirstName'];
        LastName = json['LastName'];
        Email = json['Email'];
        PhoneType = json['PhoneType'];
        PhoneNumber = json['PhoneNumber'];
        RoutingNumber = json['RoutingNumber'];
        EncryptedAccountNumber = json['EncryptedAccountNumber'];
        BillingDetails = JsonConverters.fromJson(json['BillingDetails'],'BillingDescriptor',context!);
        VerifyACH = json['VerifyACH'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Version': Version,
        'KeyId': KeyId,
        'FirstName': FirstName,
        'LastName': LastName,
        'Email': Email,
        'PhoneType': PhoneType,
        'PhoneNumber': PhoneNumber,
        'RoutingNumber': RoutingNumber,
        'EncryptedAccountNumber': EncryptedAccountNumber,
        'BillingDetails': JsonConverters.toJson(BillingDetails,'BillingDescriptor',context!),
        'VerifyACH': VerifyACH
    };

    getTypeName() => "ClientTokenizeACHRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.paysecure.acculynk.net', types: <String, TypeInfo> {
    'InOutTimes': TypeInfo(TypeOf.Class, create:() => InOutTimes()),
    'RequestTimestamps': TypeInfo(TypeOf.Class, create:() => RequestTimestamps()),
    'PaysecureResponseInternal': TypeInfo(TypeOf.Class, create:() => PaysecureResponseInternal()),
    'ClientTokenizeACH': TypeInfo(TypeOf.Class, create:() => ClientTokenizeACH()),
    'BillingDescriptor': TypeInfo(TypeOf.Class, create:() => BillingDescriptor()),
    'ClientTokenizeACHRequest': TypeInfo(TypeOf.Class, create:() => ClientTokenizeACHRequest()),
});

Dart ClientTokenizeACHRequest DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .jsv suffix or ?format=jsv

HTTP + JSV

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

POST /ClientTokenizeACH HTTP/1.1 
Host: api.paysecure.acculynk.net 
Accept: text/jsv
Content-Type: text/jsv
Content-Length: length

{
	Version: String,
	KeyId: String,
	FirstName: String,
	LastName: String,
	Email: String,
	PhoneType: String,
	PhoneNumber: String,
	RoutingNumber: String,
	EncryptedAccountNumber: String,
	BillingDetails: 
	{
		Address: String,
		City: String,
		State: String,
		Zip: String,
		Country: String
	},
	VerifyACH: False
}
HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length

{
	SessionToken: String,
	ResponseCode: String,
	ErrorMessage: String,
	ErrorCode: String,
	Timestamps: 
	{
		AppLayer: 
		{
			InTime: 0001-01-01,
			OutTime: 0001-01-01
		},
		ParentLookup: 
		{
			InTime: 0001-01-01,
			OutTime: 0001-01-01
		},
		RetryLookup: 
		{
			InTime: 0001-01-01,
			OutTime: 0001-01-01
		},
		GetCardData: 
		{
			InTime: 0001-01-01,
			OutTime: 0001-01-01
		},
		CardTokenize: 
		{
			InTime: 0001-01-01,
			OutTime: 0001-01-01
		},
		CardEncrypt: 
		{
			InTime: 0001-01-01,
			OutTime: 0001-01-01
		},
		DBInsert: 
		{
			InTime: 0001-01-01,
			OutTime: 0001-01-01
		},
		BackendProcess: 
		{
			InTime: 0001-01-01,
			OutTime: 0001-01-01
		},
		DBUpdate: 
		{
			InTime: 0001-01-01,
			OutTime: 0001-01-01
		},
		ParentUpdate: 
		{
			InTime: 0001-01-01,
			OutTime: 0001-01-01
		},
		Network: 
		{
			InTime: 0001-01-01,
			OutTime: 0001-01-01
		}
	}
}