query getUserInfo { 
    user{ 
        id
        email
        role
        organization{ 
            id
            name
        } 
        projects{ 
            id
            name
        }
    }
}

query byProjects($project_id: ID!) { 
    projects(where: {id_contains: $project_id}) { 
        members{ 
            user{ 
                email
                id
                role
            }
        }
    }
}

# Pass API key as a header to make a graphql query
curl 'https://api.labelbox.com/graphql' \
   -H 'Authorization: Bearer <API_KEY_HERE>' \
   -H 'content-type: application/json' \
   -d '{"query":"[QUERY HERE]"}'

# Pass API key as a header to request a mask for an annotated object
curl 'https://api.labelbox.com/masks/feature/:id' \
   -H 'Authorization: Bearer <API_KEY_HERE>'   

# Passing API key as a query parameter to request a mask for an annotated object
curl 'https://api.labelbox.com/masks/feature/:id?token=<API_KEY_HERE>'

query GetAnnotationCount {
    annotationCounts (where: {startDate: "2021-02-08", endDate: "2021-02-09"}, orderBy: CREATION_DATE_ASC){
        image
        video
        text
        creationDate
        updateTime
    }
}

mutation addAssetInfo {
    createAssetMetadata(
        data: {
            dataRowId:"<DATAROW-ID>",
            metaValue:"https://firebasestorage.googleapis.com/v0/b/labelbox-193903.appspot.com/o/cjhk4p9dyf5va0702liitudpz%2Fd3ffab29-d6be-4d69-b006-89a828679d29%2Fleft_small-pen-test-site_1_1537524039648.jpg?alt=media&token=66e84e55-97e8-46a6-9ab8-685f1e950581",
            metaType: IMAGE
        }
    ) {
    id
    }
}

query getMetadataId {
    dataRow (where: {id: "<DATAROW_ID>"}) {
        id
        metadata {
            id
        }
    }
}

mutation updateAssetInfo {
    updateAssetMetadata(
        where:{
            id:"<METADATA-ID>"
        },
        data:{
            metaValue:"https://storage.googleapis.com/labelbox-sample-datasets/nlp/lorem-ipsum.txt",
            metaType: TEXT
        }
    ){
        id
    }
}

query getMetadataId {
    dataRow (where: {id: "<DATAROW_ID>"}) {
        id
        metadata {
            id
        }
    }
}

mutation removeAssetInfo {
  deleteAssetMetadata(
    where:{
      id:"<METADATA-ID>"
    }
  ){
    id
  }
}

mutation {
    createBulkImportRequest(data: {
        projectId: "<PROJECT_ID>",
        name: "import_job_1",
        fileUrl: "https://foobar.com/test2file"
    }) {
    id
  }
}

query {
    bulkImportRequest(where: {
        projectId: "<PROJECT_ID>",
        name: "import_job_1"
    }) {
        state
        statusFileUrl
        errorFileUrl
    }
}

query ListAllImportRequests {
    bulkImportRequests (
        where: { projectId:"ckg2izcjx5qm10736kqg128yq" } 
        skip: 5 
        first: 100
    ) {
        id
        name
    }
}

mutation DeleteBulkImportRequest {
    deleteBulkImportRequest(where: {id: "<IMPORT_REQUEST_ID>"}) {
        id
        name
    }
}

mutation AppendRowsToDataset { 
    appendRowsToDataset( 
        data:{ 
            datasetId:"<DATASET_ID>", 
            jsonFileUrl:"<URL_TO_JSON_FILE>" 
        } 
    ){ 
        accepted 
    }
}

mutation CreateDataRow { 
    createDataRow( 
        data: { 
            externalId: "<EXTERNAL_ID>", 
            rowData: "<ASSET_URL>", 
            dataset: { 
                connect: { 
                    id: "<DATASET_ID>" 
                } 
            },
        } 
    ){ 
        id 
    }
}

query GetDataRows {
    datasets (where: {id: "<DATASET_ID>"}) { 
        name 
        id 
        dataRows { 
            id 
            externalId 
        } 
    }
}

query GetDataRowsByProject { 
    project (where: {id: "<PROJECT_ID>"}) { 
        datasets { 
            dataRows (first: 100){ 
                id 
                rowData 
                externalId 
            }     
        } 
    }
}

mutation UpdateDataRow { 
    updateDataRow( 
        where:{id: "<DATAROW_ID>"} 
        data:{
            externalId: "<NEW_FILENAME>",
            rowData: "<NEW_ASSET_URL>"
        } 
    ){ 
    id
}

mutation DeleteDataRows { 
    deleteDataRows (where:{ 
        dataRowIds: ["<DATA_ROW_ID>"] 
    }){ 
        id 
        deleted 
    }
}

mutation CreateDataset { 
    createDataset ( 
        data: { 
            name: "dataset name", 
            projects: {
                connect: {
                    id: "ck6cib5zmmy3g0842s3bdkl6t"
                }
            } 
        } 
    ) { 
        id 
    }
}

mutation AttachDataset{ 
    updateProject( 
        where:{ 
            id:"ck6cib5zmmy3g0842s3bdkl6t" 
        }, 
        data:{ 
            datasets:{ 
                connect:{ 
                    id: "ck52rvx4ombr80853k1ccx1s2" 
                } 
            } 
        } 
    ){ 
        id 
    } 
}

query GetDataset { 
    dataset (where: {id: "ck7us46zn1ial0807z9esamua"}) { 
        name 
        description 
        projects { 
            id
        } 
        createdAt 
        createdBy { 
            id 
        } 
        rowCount 
    }
}

mutation UpdateDataset { 
    updateDataset ( 
        where: { 
            id: "ck52rvx4ombr80853k1ccx1s2"
        }, 
        data: { 
            name: "new name", 
            description: "new description" 
        } 
    ) { 
        id 
    }
}

mutation UpdateDataset { 
    updateDataset ( 
        where: { 
            id: "ck52rvx4ombr80853k1ccx1s2" 
        }, 
        data: { 
            deleted: true 
        } 
    ) { 
        id 
    }
}

mutation CreateIntegration {
    createAwsIamIntegration(data: { 
      name: "AWS IAM Integration" 
      roleArn: "arn:aws:iam::<AWS_ACCOUNT_ID>:role/<ROLE_NAME>"
    }) {
	id
    }
}

mutation CheckIntegration {
  validateIamIntegration (where: {id: "<INTEGRATION_ID>"}){
    valid
    checks { 
      name
      success
    }
  }
}

mutation UpdateIntegration {
    updateAwsIamIntegration(
        data: { 
            roleArn: "arn:aws:iam::<ACCOUNT_ID>:role/<ROLE_NAME>"
            name: "<NEW_INTEGRATION_NAME>"
        },
	where: { 
            id: "<INTEGRATION_ID>" 
        }) {
            id
        }
}

mutation SetSignerForDataset {
    setSignerForDataset(
	data: { signerId: "<INTEGRATION_ID>" },
	where: { id: "<DATASET_ID>" }) {
	    id
	    signer {
		id
	}
    }
}

mutation ValidateDataset {
  validateDataset (where: {id: "<DATASET_ID>"}){
    valid
    checks {
      name
      success
    }
  }
}

mutation SetLabelingParameterOverrides {
    project(where: { id: "<PROJECT_ID>" }) {
        setLabelingParameterOverrides(data: [
            { 
                dataRow: { id: "<DATA_ROW_ID>" }, 
                priority: 1, 
                numLabels: 2 
            },
            { 
                dataRow: { id: "<DATA_ROW_ID>" }, 
                priority: 2, 
                numLabels: 3 
            }
        ]) {
            success
        }
    }
}

query PullLabelingParameters {
    project(where:{id:"<PROJECT_ID>"}){
        labelingParameterOverrides{
            id
            priority
        }
    }
}

mutation UnsetLabelingParameterOverrides {
    project(where: { id: "<PROJECT_ID>" }) {
        unsetLabelingParameterOverrides(data: [
            { 
                dataRowId: "<DATA_ROW_ID>" 
            },
            { 
                dataRowId: "<DATA_ROW_ID>" 
            }
        ]) {
            success
        }
    }
}

mutation UnsetAllParameterOverrides {
    project(where: {id: "<PROJECT_ID>"}) {
        unsetAllLabelingParameterOverrides {
            success
            deletedCount
        }
    }
}

query getLabelById { 
    label(where: {id: "<LABEL_ID>"}) { 
        label 
    }
}

query getLabelsFromProject {
    projects (where: {id: "<PROJECT_ID>"}) { 
        id 
        name 
        labels (first: 10) { 
            id 
            createdBy { 
                email 
            } 
            label 
        } 
    }
}

query APIGetPageOfLabels { 
    project (where:{id: "<PROJECT_ID>"}) { 
        labels (first: 5){ 
            id 
            label 
            createdBy { 
                id 
                email
            } 
            type { 
                id 
                name
            } 
            secondsToLabel 
            agreement 
            dataRow { 
                id 
                rowData 
            } 
        } 
    }
}

mutation BulkExportLabels { 
    exportLabels (data:{ 
        projectId: "<PROJECT_ID>" 
    }){ 
        downloadUrl 
        createdAt 
        shouldPoll 
    }
}

mutation DeleteLabels { 
    deleteLabels ( 
        labelIds:["LABEL_ID>"] 
    ){ 
        id 
        deleted 
    }
}

mutation BulkDeleteLabels (
    $projectId: ID!,
    $makeTemplates: Boolean = true,
    $labelsWhere: WhereBulkLabelDelete,
    $first: PageSize,
    $skip: Int ) {
    project (where: {id: $projectId}) {
        bulkDeleteLabels (
            where: $labelsWhere,
            makeTemplates: $makeTemplates,
            waitForQueue: true,
            first: $first,
            skip: $skip
        ) {
            count
        }
    }
}

mutation AddUserToProject { 
    addUserToProject ( 
        data: { 
            email: "<USER_EMAIL>", 
            projectId: "<PROJECT_ID>", 
            roleId: "<ROLE-ID>" 
        } 
    ) { 
        user { email } 
        project { name } 
        role { name } 
    }
}

mutation MakeNewUserAdmin { 
    addMembersToOrganization( 
        data: { 
            emails: ["sample1@email.com", "sample2@email.com"], 
            orgRoleId: "cjlvi91a41aab0714677xp87h",
            projectRoles: []
        } 
    ) {
      newUserId
      existingUserEmail
      existingUserInviteSent
    }
}

query GetAvailableRoles { 
    roles (
        first: 10
        skip: 1
    ){ 
        name 
        id
    	permissions
    }
}

query getUserProjects { 
    users ( where: {email:"<USER-EMAIL>"}) {
        id 
        projects { 
            name 
            id 
        } 
    }
}

mutation RemoveMemberFromProject {
    setProjectMembership (data: {
        userId:"<USER_ID>"
     	roleId: "cjmb6xy80f5vz0780u3mw2rj4"
     	projectId:"<PROJECT_ID>"
    }) {
        id  
    }
}

query getOntology { 
    project (where: {id: "<PROJECT_ID>"}) { 
        ontology { 
            normalized 
        } 
    }
}

mutation cloneOntologyFromProject {
    project (where: {id: "<PROJECT_ID>"}) {
        cloneOntology (ontologyId: "<TARGET_ONTOLOGY_ID>"){
            id
            name
        }
    }
}

query connectableOntologies {
    project(where: { id: "<PROJECT_ID>" }) {
        connectableOntologies {
            id
            name
        }
    }
}

mutation connectOntologyToProject {
    project(where: {id: "<PROJECT_ID>"}) {
        connectOntology(ontologyId: "<TARGET_ONTOLOGY_ID>"){
            id
            name
        }
    }
}

mutation RenameOntology {
    ontology(where: { id: "<PROJECT_ID>" }) {
        update(data: {
            name: "<NEW_NAME>"
        }) {
            id
            name
        }
    }
}

mutation {
    createProject(data:{
        name: "<PROJECT_NAME>"
    }){
        id
    }
}

mutation UpsertReviewQueue(
    $projectId: ID!,
    $quotaFactor: Float!) {
    upsertReviewQueue(where: {
        project: {
            id: $projectId
        }
    },
     data: {quotaFactor: $quotaFactor}) {
        id
    }
}

mutation DeleteReviewQueue($projectId: ID!) {
    deleteReviewQueue(where: {
        project: {
            id: $projectId
        }
    }) {
        id
    }
}

mutation CreateWebhook {
    createWebhook(data:{
        project:{
            id:"<PROJECT_ID>"
        },
        url:"<HTTP_URL>",
        secret:"example_secret",
        topics:{
            set:[
                LABEL_CREATED,
                LABEL_UPDATED,
                LABEL_DELETED
            ]
        }
    }){
        id
    }
}

mutation UpdateWebhook {
    updateWebhook(where:{
        id:"<WEBHOOK_ID>"
    },
    data:{
        url:"<PRODUCTION_URL>"
    }){
        id
    }
}

mutation RemoveWebhook {
    updateWebhook(
        data:{
            status: INACTIVE
        }
        where:{
            id:"<WEBHOOK_ID>"
        }
    ){
        id
    }
}