ReportingAPI

<back to all web services

PostLinkReportRequest

Requires Authentication
The following routes are available for this service:
POST/v4/report/links
import 'package:servicestack/servicestack.dart';

// @DataContract
class Item implements IConvertible
{
    // @DataMember(Name="id")
    String? id;

    // @DataMember(Name="displayName")
    String? displayName;

    Item({this.id,this.displayName});
    Item.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        displayName = json['displayName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'displayName': displayName
    };

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

// @DataContract
class ReportData implements IConvertible
{
    // @DataMember(Name="id")
    String? id;

    // @DataMember(Name="item")
    Item? item;

    // @DataMember(Name="totalClicks")
    int? totalClicks;

    // @DataMember(Name="clicks")
    int? clicks;

    // @DataMember(Name="junkClicks")
    int? junkClicks;

    // @DataMember(Name="spiderClicks")
    int? spiderClicks;

    // @DataMember(Name="dateUtc")
    DateTime? dateUtc;

    ReportData({this.id,this.item,this.totalClicks,this.clicks,this.junkClicks,this.spiderClicks,this.dateUtc});
    ReportData.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        item = JsonConverters.fromJson(json['item'],'Item',context!);
        totalClicks = json['totalClicks'];
        clicks = json['actualClicks'];
        junkClicks = json['junkClicks'];
        spiderClicks = json['spiderClicks'];
        dateUtc = JsonConverters.fromJson(json['dateUtc'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'item': JsonConverters.toJson(item,'Item',context!),
        'totalClicks': totalClicks,
        'clicks': clicks,
        'junkClicks': junkClicks,
        'spiderClicks': spiderClicks,
        'dateUtc': JsonConverters.toJson(dateUtc,'DateTime',context!)
    };

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

// @DataContract
class Error implements IConvertible
{
    // @DataMember(Name="code")
    String? code;

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

    fromMap(Map<String, dynamic> json) {
        code = json['code'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'code': code
    };

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

enum GroupBy
{
    Default,
    Retailer,
    Date,
}

enum ReportType
{
    ShortUrl,
    Group,
    User,
}

// @DataContract
class ReportRequest implements IConvertible
{
    // @DataMember(Name="items")
    List<String>? items;

    // @DataMember(Name="groupBy")
    List<GroupBy>? groupBy;

    // @DataMember(Name="attribute")
    String? attribute;

    // @DataMember(Name="type")
    ReportType? type;

    // @DataMember(Name="fromStartUtcInclusive")
    DateTime? fromStartUtcInclusive;

    // @DataMember(Name="fromEndUtcInclusive")
    DateTime? fromEndUtcInclusive;

    // @DataMember(Name="retailers")
    List<String>? retailers;

    ReportRequest({this.items,this.groupBy,this.attribute,this.type,this.fromStartUtcInclusive,this.fromEndUtcInclusive,this.retailers});
    ReportRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        items = JsonConverters.fromJson(json['items'],'List<String>',context!);
        groupBy = JsonConverters.fromJson(json['groupBy'],'List<GroupBy>',context!);
        attribute = json['attribute'];
        type = JsonConverters.fromJson(json['type'],'ReportType',context!);
        fromStartUtcInclusive = JsonConverters.fromJson(json['fromStartUtcInclusive'],'DateTime',context!);
        fromEndUtcInclusive = JsonConverters.fromJson(json['fromEndUtcInclusive'],'DateTime',context!);
        retailers = JsonConverters.fromJson(json['retailers'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'items': JsonConverters.toJson(items,'List<String>',context!),
        'groupBy': JsonConverters.toJson(groupBy,'List<GroupBy>',context!),
        'attribute': attribute,
        'type': JsonConverters.toJson(type,'ReportType',context!),
        'fromStartUtcInclusive': JsonConverters.toJson(fromStartUtcInclusive,'DateTime',context!),
        'fromEndUtcInclusive': JsonConverters.toJson(fromEndUtcInclusive,'DateTime',context!),
        'retailers': JsonConverters.toJson(retailers,'List<String>',context!)
    };

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

// @DataContract
class Report implements IConvertible
{
    // @DataMember(Name="data")
    List<ReportData>? data;

    // @DataMember(Name="executionTimeMs")
    int? executionTimeMs;

    // @DataMember(Name="totalItems")
    int? totalItems;

    // @DataMember(Name="errors")
    List<Error>? errors;

    // @DataMember(Name="request")
    ReportRequest? request;

    // @DataMember(Name="totalClicks")
    int? totalClicks;

    Report({this.data,this.executionTimeMs,this.totalItems,this.errors,this.request,this.totalClicks});
    Report.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        data = JsonConverters.fromJson(json['data'],'List<ReportData>',context!);
        executionTimeMs = json['executionTimeMs'];
        totalItems = json['totalItems'];
        errors = JsonConverters.fromJson(json['errors'],'List<Error>',context!);
        request = JsonConverters.fromJson(json['request'],'ReportRequest',context!);
        totalClicks = json['totalClicks'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'data': JsonConverters.toJson(data,'List<ReportData>',context!),
        'executionTimeMs': executionTimeMs,
        'totalItems': totalItems,
        'errors': JsonConverters.toJson(errors,'List<Error>',context!),
        'request': JsonConverters.toJson(request,'ReportRequest',context!),
        'totalClicks': totalClicks
    };

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

// @DataContract
class PostLinkReportResponse implements IPostLinkReportResponse, IConvertible
{
    // @DataMember(Name="reports")
    List<Report>? reports;

    // @DataMember(Name="responseStatus")
    ResponseStatus? responseStatus;

    PostLinkReportResponse({this.reports,this.responseStatus});
    PostLinkReportResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        reports = JsonConverters.fromJson(json['reports'],'List<Report>',context!);
        responseStatus = JsonConverters.fromJson(json['responseStatus'],'ResponseStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'reports': JsonConverters.toJson(reports,'List<Report>',context!),
        'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!)
    };

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

// @DataContract
class PostLinkReportRequest implements IPostLinkReportRequest, IConvertible
{
    // @DataMember(Name="reports")
    List<ReportRequest>? reports;

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

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

    Map<String, dynamic> toJson() => {
        'reports': JsonConverters.toJson(reports,'List<ReportRequest>',context!)
    };

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

TypeContext _ctx = TypeContext(library: 'reporting_api_zane.dev.platform.georiot.com', types: <String, TypeInfo> {
    'Item': TypeInfo(TypeOf.Class, create:() => Item()),
    'ReportData': TypeInfo(TypeOf.Class, create:() => ReportData()),
    'Error': TypeInfo(TypeOf.Class, create:() => Error()),
    'GroupBy': TypeInfo(TypeOf.Enum, enumValues:GroupBy.values),
    'ReportType': TypeInfo(TypeOf.Enum, enumValues:ReportType.values),
    'ReportRequest': TypeInfo(TypeOf.Class, create:() => ReportRequest()),
    'List<GroupBy>': TypeInfo(TypeOf.Class, create:() => <GroupBy>[]),
    'Report': TypeInfo(TypeOf.Class, create:() => Report()),
    'List<ReportData>': TypeInfo(TypeOf.Class, create:() => <ReportData>[]),
    'List<Error>': TypeInfo(TypeOf.Class, create:() => <Error>[]),
    'PostLinkReportResponse': TypeInfo(TypeOf.Class, create:() => PostLinkReportResponse()),
    'List<Report>': TypeInfo(TypeOf.Class, create:() => <Report>[]),
    'PostLinkReportRequest': TypeInfo(TypeOf.Class, create:() => PostLinkReportRequest()),
    'List<ReportRequest>': TypeInfo(TypeOf.Class, create:() => <ReportRequest>[]),
});

Dart PostLinkReportRequest 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 /v4/report/links HTTP/1.1 
Host: reporting-api-zane.dev.platform.georiot.com 
Accept: text/jsv
Content-Type: text/jsv
Content-Length: length

{
	
}

HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length

{
	responseStatus: 
	{
		errorCode: String,
		message: String,
		stackTrace: String,
		errors: 
		[
			{
				errorCode: String,
				fieldName: String,
				message: String,
				meta: 
				{
					String: String
				}
			}
		],
		meta: 
		{
			String: String
		}
	}
}