queries.graphql

# SPDX-FileCopyrightText: Magenta ApS <https://magenta.dk>
# SPDX-License-Identifier: MPL-2.0

query GetActor {
  me {
    actor {
      uuid
    }
  }
}

query GetOrganization {
  org {
    uuid
  }
}

query GetAddressTimeline($input: AddressFilter!) {
  addresses(filter: $input) {
    objects {
      uuid
      validities {
        address_type {
          uuid
          name
          user_key
        }
        visibility_uuid
        user_key
        value
        uuid
        validity {
          from
          to
        }
        engagement_uuid
      }
    }
  }
}

query AddressTypes {
  facets(filter: { user_keys: "org_unit_address_type" }) {
    objects {
      current {
        user_key
        uuid
        classes {
          uuid
          user_key
          name
        }
      }
    }
  }
}

mutation CreateAddress($input: AddressCreateInput!) {
  address_create(input: $input) {
    uuid
    current {
      validity {
        from
        to
      }
      uuid
      name
      address_type {
        user_key
      }
    }
  }
}

mutation UpdateAddress($input: AddressUpdateInput!) {
  address_update(input: $input) {
    uuid
    current {
      validity {
        from
        to
      }
      uuid
      name
      address_type {
        user_key
      }
    }
  }
}

mutation TerminateAddress($input: AddressTerminateInput!) {
  address_terminate(input: $input) {
    uuid
  }
}

mutation DeleteAddress($addr_uuid: UUID!) {
  address_delete(uuid: $addr_uuid) {
    uuid
  }
}

query GetFacetUuid($user_key: String!) {
  facets(filter: { user_keys: [$user_key] }) {
    objects {
      uuid
    }
  }
}

query GetClass($class_filter: ClassFilter!, $at: DateTime) {
  classes(filter: $class_filter) {
    objects {
      uuid
      current(at: $at) {
        uuid
        user_key
        name
        scope
        parent {
          uuid
          user_key
          scope
        }
        validity {
          from
          to
        }
      }
    }
  }
}

mutation CreateClass($input: ClassCreateInput!) {
  class_create(input: $input) {
    uuid
  }
}

mutation UpdateClass($input: ClassUpdateInput!) {
  class_update(input: $input) {
    uuid
  }
}

query GetUnit($uuid: UUID!) {
  org_units(filter: { uuids: [$uuid] }) {
    objects {
      uuid
    }
  }
}

query GetOrgUnitTimeline($filter: OrganisationUnitFilter!) {
  org_units(filter: $filter) {
    objects {
      validities {
        validity {
          from
          to
        }
        uuid
        user_key
        name
        org_unit_level {
          name
        }
        unit_type_uuid
        org_unit_hierarchy
        time_planning_uuid
        parent_uuid
        addresses {
          uuid
          name
          user_key
          value
          address_type {
            user_key
            name
          }
          visibility {
            uuid
          }
        }
      }
    }
  }
}

query GetParentRoots($input: OrganisationUnitFilter!) {
  org_units(filter: $input) {
    objects {
      uuid
    }
  }
}

query GetOrgUnitUserKeys($input: OrganisationUnitFilter!) {
  org_units(filter: $input) {
    objects {
      uuid
      validities {
        user_key
      }
    }
  }
}

mutation CreateOrgUnit($input: OrganisationUnitCreateInput!) {
  org_unit_create(input: $input) {
    uuid
  }
}

mutation UpdateOrgUnit($input: OrganisationUnitUpdateInput!) {
  org_unit_update(input: $input) {
    uuid
  }
}

mutation TerminateOrgUnit($input: OrganisationUnitTerminateInput!) {
  org_unit_terminate(input: $input) {
    uuid
  }
}

query GetOrgUnitChildren(
  $org_unit: UUID!
  $from_date: DateTime!
  $to_date: DateTime
) {
  org_units(
    filter: {
      parent: { uuids: [$org_unit], from_date: $from_date, to_date: $to_date }
      from_date: $from_date
      to_date: $to_date
    }
  ) {
    objects {
      uuid
    }
  }
}

query GetOrgUnit($filter: OrganisationUnitFilter!) {
  org_units(filter: $filter) {
    objects {
      uuid
      validities {
        name
        user_key
        children {
          uuid
        }
        validity {
          from
          to
        }
      }
    }
  }
}

query GetPerson($cpr: CPR!) {
  employees(filter: { cpr_numbers: [$cpr], from_date: null, to_date: null }) {
    objects {
      uuid
    }
  }
}

query GetPersonCpr($uuid: UUID!) {
  employees(filter: { uuids: [$uuid], from_date: null, to_date: null }) {
    objects {
      validities {
        cpr_number
      }
    }
  }
}

query GetPersonTimeline($filter: EmployeeFilter) {
  employees(filter: $filter) {
    objects {
      uuid
      validities {
        cpr_number
        given_name
        surname
        validity {
          from
          to
        }
      }
    }
  }
}

mutation CreatePerson($input: EmployeeCreateInput!) {
  employee_create(input: $input) {
    uuid
  }
}

mutation UpdatePerson($input: EmployeeUpdateInput!) {
  employee_update(input: $input) {
    uuid
  }
}

mutation CreateEngagement($input: EngagementCreateInput!) {
  engagement_create(input: $input) {
    uuid
  }
}

query GetEngagements($cursor: Cursor, $limit: int, $input: EngagementFilter!) {
  engagements(cursor: $cursor, limit: $limit, filter: $input) {
    page_info {
      next_cursor
    }
    objects {
      uuid
      validities {
        user_key
        validity {
          from
          to
        }
        person {
          cpr_number
        }
        engagement_type_uuid
      }
    }
  }
}

query GetEngagementUuids($filter: EngagementFilter!) {
  engagements(filter: $filter) {
    objects {
      uuid
    }
  }
}

query GetEngagementTimeline($filter: EngagementFilter!) {
  engagements(filter: $filter) {
    objects {
      uuid
      validities {
        user_key
        primary_uuid
        validity {
          from
          to
        }
        extension_1
        extension_2
        extension_3
        extension_4
        extension_5
        extension_6
        extension_7
        extension_8
        extension_9
        extension_10
        employee_uuid
        org_unit_uuid
        engagement_type_uuid
        job_function_uuid
      }
    }
  }
}

query GetManagerTimeline($filter: ManagerFilter!) {
  managers(filter: $filter) {
    objects {
      uuid
      validities {
        user_key
        validity {
          from
          to
        }
        engagement_response {
          uuid
        }
        org_unit_uuid
        employee_uuid
        manager_type_uuid
        manager_level_uuid
        responsibility_uuids
      }
    }
  }
}

query GetManagers($filter: ManagerFilter!) {
  managers(filter: $filter) {
    objects {
      uuid
    }
  }
}

query GetManagerEngagement($uuid: UUID!) {
  managers(filter: { uuids: [$uuid], from_date: null, to_date: null }) {
    objects {
      validities {
        engagement_response {
          uuid
        }
      }
    }
  }
}

mutation UpdateEngagement($input: EngagementUpdateInput!) {
  engagement_update(input: $input) {
    uuid
  }
}

mutation TerminateEngagement($input: EngagementTerminateInput!) {
  engagement_terminate(input: $input) {
    uuid
  }
}

mutation RefreshEngagements(
  $cursor: Cursor
  $limit: int
  $filter: EngagementFilter
  $owner: UUID!
  $priority: int
) {
  engagement_refresh(
    cursor: $cursor
    limit: $limit
    filter: $filter
    owner: $owner
    priority: $priority
  ) {
    objects
    page_info {
      next_cursor
    }
  }
}

query GetLeave($filter: LeaveFilter!) {
  leaves(filter: $filter) {
    objects {
      uuid
      validities {
        user_key
        employee_uuid
        engagement_uuid
        leave_type_uuid
        validity {
          from
          to
        }
      }
    }
  }
}

mutation CreateLeave($input: LeaveCreateInput!) {
  leave_create(input: $input) {
    uuid
  }
}

mutation UpdateLeave($input: LeaveUpdateInput!) {
  leave_update(input: $input) {
    uuid
  }
}

mutation TerminateLeave($input: LeaveTerminateInput!) {
  leave_terminate(input: $input) {
    uuid
  }
}

mutation DeleteOrgFunction($uuid: UUID!) {
  engagement_delete(uuid: $uuid) {
    uuid
  }
}

query GetAssociationTimeline($input: AssociationFilter!) {
  associations(filter: $input) {
    objects {
      uuid
      validities {
        user_key
        employee_uuid
        org_unit_uuid
        validity {
          from
          to
        }
      }
    }
  }
}

mutation CreateAssociation($input: AssociationCreateInput!) {
  association_create(input: $input) {
    uuid
  }
}

mutation UpdateAssociation($input: AssociationUpdateInput!) {
  association_update(input: $input) {
    uuid
  }
}

mutation TerminateAssociation($input: AssociationTerminateInput!) {
  association_terminate(input: $input) {
    uuid
  }
}

query GetRelatedUnits($filter: RelatedUnitFilter!) {
  related_units(filter: $filter) {
    objects {
      validities {
        uuid
        validity {
          from
          to
        }
        org_unit_uuids
      }
    }
  }
}

query GetEvents($filter: FullEventFilter!) {
  events(filter: $filter) {
    objects {
      subject
      priority
    }
  }
}

mutation SendEvent($input: EventSendInput!) {
  event_send(input: $input)
}

mutation _Testing_UpdateRelatedUnits($input: RelatedUnitsUpdateInput!) {
  related_units_update(input: $input) {
    uuid
  }
}

mutation _Testing_CreateEmployee(
  $uuid: UUID!
  $given_name: String!
  $surname: String!
) {
  employee_create(
    input: { uuid: $uuid, given_name: $given_name, surname: $surname }
  ) {
    uuid
  }
}

mutation _Testing_CreateOrgUnit(
  $uuid: UUID!
  $name: String!
  $user_key: String!
  $from_date: DateTime!
  $org_unit_type: UUID!
  $org_unit_level: UUID
  $parent: UUID
) {
  org_unit_create(
    input: {
      uuid: $uuid
      name: $name
      user_key: $user_key
      validity: { from: $from_date }
      org_unit_type: $org_unit_type
      org_unit_level: $org_unit_level
      parent: $parent
    }
  ) {
    uuid
  }
}

query _Testing_GetOrgUnit($uuid: UUID!) {
  org_units(filter: { uuids: [$uuid] }) {
    objects {
      current {
        validity {
          from
          to
        }
        uuid
        user_key
        name
        parent {
          uuid
          name
        }
        org_unit_level {
          uuid
          user_key
          name
        }
      }
    }
  }
}

mutation _Testing_CreateEngagement(
  $from_date: DateTime!
  $org_unit: UUID!
  $engagement_type: UUID!
  $job_function: UUID!
  $person: UUID!
) {
  engagement_create(
    input: {
      validity: { from: $from_date }
      org_unit: $org_unit
      engagement_type: $engagement_type
      job_function: $job_function
      person: $person
    }
  ) {
    uuid
  }
}

query _Testing_GetOrgUnitAddress($org_unit: UUID!, $addr_type: UUID!) {
  org_units(filter: { uuids: [$org_unit] }) {
    objects {
      current {
        addresses(filter: { address_types: [$addr_type] }) {
          value
          user_key
        }
      }
    }
  }
}

mutation _Testing_CreateManager($input: ManagerCreateInput!) {
  manager_create(input: $input) {
    uuid
  }
}

mutation _Testing_UpdateManager($input: ManagerUpdateInput!) {
  manager_update(input: $input) {
    uuid
  }
}