NarrativeService.spec

/*
A KBase module: NarrativeService
*/

module NarrativeService {

    /* @range [0,1] */
    typedef int boolean;

    /*
        A time in the format YYYY-MM-DDThh:mm:ssZ, where Z is either the
        character Z (representing the UTC timezone) or the difference
        in time to UTC in the format +/-HHMM, eg:
            2012-12-17T23:24:06-0500 (EST time)
            2013-04-03T08:56:32+0000 (UTC time)
            2013-04-03T08:56:32Z (UTC time)
    */
    typedef string timestamp;

    /* Represents the permissions a user or users have to a workspace:

        'a' - administrator. All operations allowed.
        'w' - read/write.
        'r' - read.
        'n' - no permissions.
    */
    typedef string permission;

    /* The lock status of a workspace.
        One of 'unlocked', 'locked', or 'published'.
    */
    typedef string lock_status;

    /* Information about an object, including user provided metadata.

        obj_id objid - the numerical id of the object.
        obj_name name - the name of the object.
        type_string type - the type of the object.
        timestamp save_date - the save date of the object.
        obj_ver ver - the version of the object.
        username saved_by - the user that saved or copied the object.
        ws_id wsid - the workspace containing the object.
        ws_name workspace - the workspace containing the object.
        string chsum - the md5 checksum of the object.
        int size - the size of the object in bytes.
        usermeta meta - arbitrary user-supplied metadata about
            the object.
    */
    typedef tuple<int objid, string name, string type,
        timestamp save_date, int version, string saved_by,
        int wsid, string workspace, string chsum, int size,
        mapping<string, string> meta> object_info;

    /* Information about a workspace.

        ws_id id - the numerical ID of the workspace.
        ws_name workspace - name of the workspace.
        username owner - name of the user who owns (e.g. created) this workspace.
        timestamp moddate - date when the workspace was last modified.
        int max_objid - the maximum object ID appearing in this workspace.
            Since cloning a workspace preserves object IDs, this number may be
            greater than the number of objects in a newly cloned workspace.
        permission user_permission - permissions for the authenticated user of
            this workspace.
        permission globalread - whether this workspace is globally readable.
        lock_status lockstat - the status of the workspace lock.
        usermeta metadata - arbitrary user-supplied metadata about
            the workspace.

    */
    typedef tuple<int id, string workspace, string owner, string moddate,
        int max_objid, string user_permission, string globalread,
        string lockstat, mapping<string, string> metadata> workspace_info;

    typedef structure {
        list<object_info> set_items_info;
    } SetItems;

    /*
        ref - reference to any DataPalette container pointing to given object,
        refs - list of references to all DataPalette containers pointing to
            given object.
    */
    typedef structure {
        string ref;
        list<string> refs;
    } DataPaletteInfo;

    /*
        object_info - workspace info for object (including set object),
        set_items - optional property listing info for items of set object,
        dp_info - optional data-palette info (defined for items stored in
            DataPalette object).
    */
    typedef structure {
        object_info object_info;
        SetItems set_items;
        DataPaletteInfo dp_info;
    } ListItem;

    /*
        ws_name/ws_id/workspaces - alternative way of defining workspaces (in
            case of 'workspaces' each string could be workspace name or ID
            converted into string).
        types - optional filter field, limiting output list to set of types.
        includeMetadata - if 1, includes object metadata, if 0, does not. Default 0.
    */
    typedef structure {
        string ws_name;
        int ws_id;
        list<string> workspaces;
        list<string> types;
        boolean includeMetadata;
    } ListObjectsWithSetsParams;

    /*
        data_palette_refs - mapping from workspace Id to reference to DataPalette
            container existing in given workspace.
    */
    typedef structure {
        list<ListItem> data;
        mapping<string ws_text_id, string ws_ref> data_palette_refs;
    } ListObjectsWithSetsOutput;

    funcdef list_objects_with_sets(ListObjectsWithSetsParams params)
        returns (ListObjectsWithSetsOutput) authentication required;

    /*
        workspaceId - optional workspace ID, if not specified then
            property from workspaceRef object info is used.
    */
    typedef structure {
        string workspaceRef;
        int workspaceId;
        string newName;
    } CopyNarrativeParams;

    typedef structure {
        int newWsId;
        int newNarId;
    } CopyNarrativeOutput;

    funcdef copy_narrative(CopyNarrativeParams params)
        returns (CopyNarrativeOutput) authentication required;


    /* Restructured workspace object info 'data' tuple:
        id: data[0],
        name: data[1],
        type: data[2],
        save_date: data[3],
        version: data[4],
        saved_by: data[5],
        wsid: data[6],
        ws: data[7],
        checksum: data[8],
        size: data[9],
        metadata: data[10],
        ref: data[6] + '/' + data[0] + '/' + data[4],
        obj_id: 'ws.' + data[6] + '.obj.' + data[0],
        typeModule: type[0],
        typeName: type[1],
        typeMajorVersion: type[2],
        typeMinorVersion: type[3],
        saveDateMs: ServiceUtils.iso8601ToMillisSinceEpoch(data[3])
    */
    typedef structure {
        int id;
        string name;
        string type;
        string save_date;
        int version;
        string saved_by;
        int wsid;
        string ws;
        string checksum;
        int size;
        mapping<string,string> metadata;
        string ref;
        string obj_id;
        string typeModule;
        string typeName;
        string typeMajorVersion;
        string typeMinorVersion;
        int saveDateMs;
    } ObjectInfo;

    /* Restructured workspace info 'wsInfo' tuple:
        id: wsInfo[0],
        name: wsInfo[1],
        owner: wsInfo[2],
        moddate: wsInfo[3],
        object_count: wsInfo[4],
        user_permission: wsInfo[5],
        globalread: wsInfo[6],
        lockstat: wsInfo[7],
        metadata: wsInfo[8],
        modDateMs: ServiceUtils.iso8601ToMillisSinceEpoch(wsInfo[3])
    */
    typedef structure {
        int id;
        string name;
        string owner;
        timestamp moddate;
        int object_count;
        permission user_permission;
        permission globalread;
        lock_status lockstat;
        mapping<string,string> metadata;
        int modDateMs;
    } WorkspaceInfo;

    typedef tuple<int step_pos, string key, string value> AppParam;

    /*
        app - name of app (optional, either app or method may be defined)
        method - name of method (optional, either app or method may be defined)
        appparam - parameters of app/method packed into string in format:
            "step_pos,param_name,param_value(;...)*" (alternative to appData)
        appData - parameters of app/method in unpacked form (alternative to appparam)
        markdown - markdown text for cell of 'markdown' type (optional)
        copydata - packed import data in format "import(;...)*" (alternative to importData)
        importData - import data in unpacked form (alternative to copydata)
        includeIntroCell - if 1, adds an introductory markdown cell at the top (optional, default 0)
        title - name of the new narrative (optional, if a string besides 'Untitled', this will
                mark the narrative as not temporary, so it will appear in the dashboard)
    */
    typedef structure {
        string app;
        string method;
        string appparam;
        list<AppParam> appData;
        string markdown;
        string copydata;
        list<string> importData;
        boolean includeIntroCell;
        string title;
    } CreateNewNarrativeParams;

    typedef structure {
        WorkspaceInfo workspaceInfo;
        ObjectInfo narrativeInfo;
    } CreateNewNarrativeOutput;

    funcdef create_new_narrative(CreateNewNarrativeParams params)
        returns (CreateNewNarrativeOutput) authentication required;


    /*
        ref - workspace reference to source object,
        target_ws_id/target_ws_name - alternative ways to define target workspace,
        target_name - optional target object name (if not set then source object
            name is used).
    */
    typedef structure {
        string ref;
        int target_ws_id;
        string target_ws_name;
        string target_name;
    } CopyObjectParams;

    /*
        info - workspace info of created object
    */
    typedef structure {
        ObjectInfo info;
    } CopyObjectOutput;

    funcdef copy_object(CopyObjectParams params)
        returns (CopyObjectOutput) authentication required;


    /*
        workspaces - list of items where each one is workspace name of textual ID.
    */
    typedef structure {
        list<string> workspaces;
    } ListAvailableTypesParams;

    /*
        type_stat - number of objects by type
    */
    typedef structure {
        mapping<string, int> type_stat;
    } ListAvailableTypesOutput;

    funcdef list_available_types(ListAvailableTypesParams params)
        returns (ListAvailableTypesOutput) authentication required;




    /* ********************************** */
    /* Listing Narratives / Naratorials (plus Narratorial Management) */

    typedef structure { } ListNarratorialParams;

    /* info for a narratorial */
    typedef structure {
        workspace_info ws;
        object_info nar;
    } Narratorial;

    typedef structure {
        list <Narratorial> narratorials;
    } NarratorialList;

    funcdef list_narratorials(ListNarratorialParams params)
        returns (NarratorialList) authentication optional;




    typedef structure {
        workspace_info ws;
        object_info nar;
    } Narrative;

    typedef structure {
        list <Narrative> narratives;
    } NarrativeList;

    /* List narratives
        type parameter indicates which narratives to return.
        Supported options are for now 'mine', 'public', or 'shared'
    */
    typedef structure {
        string type;
    } ListNarrativeParams;

    funcdef list_narratives(ListNarrativeParams params)
        returns (NarrativeList) authentication optional;


    /*
        ws field is a string, but properly interpreted whether it is a workspace
        name or ID
    */
    typedef structure {
        string ws;
        string description;
    } SetNarratorialParams;

    typedef structure { } SetNarratorialResult;

    /*
        Allows a user to create a Narratorial given a WS they own. Right now
        anyone can do this, but we may restrict in the future to users that
        have a particular role.  Run simply as:
            ns.set_narratorial({'ws':'MyWsName'}) or,
            ns.set_narratorial({'ws':'4231'})
    */
    funcdef set_narratorial(SetNarratorialParams params)
        returns (SetNarratorialResult) authentication required;

    typedef structure {
        string ws;
    } RemoveNarratorialParams;

    typedef structure { } RemoveNarratorialResult;

    funcdef remove_narratorial(RemoveNarratorialParams params)
        returns (RemoveNarratorialResult) authentication required;

    /*
        This first version only takes a single UPA as input and attempts to find the report that made it.
    */
    typedef structure {
        string upa;
    } FindObjectReportParams;

    /*
        report_upas: the UPAs for the report object. If empty list, then no report is available. But there might be more than one...
        object_upa: the UPA for the object that this report references. If the originally passed object
                    was copied, then this will be the source of that copy that has a referencing report.
        copy_inaccessible: 1 if this object was copied, and the user can't see the source, so no report's available.
        error: if an error occurred while looking up (found an unavailable copy, or the report is not accessible),
               this will have a sensible string, more or less. Optional.
    */
    typedef structure {
        list<string> report_upas;
        string object_upa;
        boolean copy_inaccessible;
        string error;
    } FindObjectReportOutput;
    /*
        find_object_report searches for a referencing report. All reports (if made properly) reference the objects
        that were created at the same time. To find that report, we search back up the reference chain.

        If the object in question was a copy, then there is no referencing report. We might still want to see it,
        though! If the original object is accessible, we'll continue the search from that object, and mark the
        associated object UPA in the return value.
    */
    funcdef find_object_report(FindObjectReportParams params) returns (FindObjectReportOutput) authentication required;

    /*
        ws_id: The workspace id containing the narrative to share
        share_level: The level of sharing requested - one of "r" (read), "w" (write), "a" (admin)
        user: The user to be shared with
    */
    typedef structure {
        int ws_id;
        string share_level;
        string user;
    } RequestNarrativeShareInput;

    /*
        ok: 0 if the request failed, 1 if the request succeeded.
        error (optional): if a failure happened during the request, this has a reason why. Not present if it succeeded.
    */
    typedef structure {
        boolean ok;
        string error;
    } RequestNarrativeShareOutput;

    /*
        This sends a notification to the admins of a workspace (or anyone with share privileges) that a
        user would like access to it.

        If a request has already been made, this will fail and return with the string "a request has already been made"
    */
    funcdef request_narrative_share(RequestNarrativeShareInput params) returns (RequestNarrativeShareOutput) authentication required;

    typedef structure {
        string tag;
        string user_id;
    } GetAppInfoInput;

    typedef structure {
        string description;
        string id;
        string name;
        string parent_ids;
        string tooltip;
        string ver;
    } CategoryInfo;

    /*
        favorite is optional - if the app is one of the user's favorites, this will be the timestamp when it was made a favorite.
    */
    typedef structure {
        string app_type;
        list<string> authors;
        list<string> categories;
        string git_commit_hash;
        string id;
        list<string> input_types;
        string module_name;
        string name;
        string namespace;
        list<string> output_types;
        string subtitle;
        string tooltip;
        string ver;
        int favorite;
    } AppInfo;

    typedef structure {
        mapping<string, string> module_versions;
        mapping<string, CategoryInfo> categories;
        mapping<string, mapping<string, AppInfo>> app_infos;
    } AllAppInfo;

    /*
        This returns all app info from the KBase catalog, formatted in a way to make life easy for the
        Narrative APPS panel on startup.
    */
    funcdef get_all_app_info(GetAppInfoInput input) returns (AllAppInfo output);

    /*
        This returns ignored app categories used in Narrative Apps Panel.
    */
    funcdef get_ignore_categories() returns (mapping<string, int> ignore_categories);
};