name: Greet first time contributor

on:
  issues:
    types: [opened]
  pull_request_target:
    types: [opened, closed]

jobs:
  check_for_first_interaction:
    runs-on: ubuntu-22.04
    if: github.repository == 'zephyrproject-rtos/zephyr'

    steps:
      - uses: actions/checkout@v4
      - uses: zephyrproject-rtos/action-first-interaction@v1.1.1-zephyr-5
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}

          issue-message: >
            Hi @${{github.event.issue.user.login}}! We appreciate you submitting your first issue
            for our open-source project. 🌟


            Even though I'm a bot, I can assure you that the whole community is genuinely grateful
            for your time and effort. 🤖💙

          pr-opened-message: >
            Hello @${{ github.event.pull_request.user.login }}, and thank you very much for your
            first pull request to the Zephyr project!

            Our Continuous Integration pipeline will execute a series of checks on your Pull Request
            commit messages and code, and you are expected to address any failures by updating the PR.
            Please take a look at [our commit message guidelines](https://docs.zephyrproject.org/latest/contribute/guidelines.html#commit-message-guidelines)
            to find out how to format your commit messages, and at [our contribution workflow](https://docs.zephyrproject.org/latest/contribute/guidelines.html#contribution-workflow)
            to understand how to update your Pull Request.
            If you haven't already, please make sure to review the project's [Contributor
            Expectations](https://docs.zephyrproject.org/latest/contribute/contributor_expectations.html)
            and update (by amending and force-pushing the commits) your pull request if necessary.

            If you are stuck or need help please join us on [Discord](https://chat.zephyrproject.org/)
            and ask your question there. Additionally, you can [escalate the review](https://docs.zephyrproject.org/latest/contribute/contributor_expectations.html#pr-review-escalation)
            when applicable. 😊

          pr-merged-message: >
            Hi @${{ github.event.pull_request.user.login }}!

            Congratulations on getting your very first Zephyr pull request merged 🎉🥳. This is a
            fantastic achievement, and we're thrilled to have you as part of our community!


            To celebrate this milestone and showcase your contribution, we'd love to award you the
            Zephyr Technical Contributor badge. If you're interested, please claim your badge by
            filling out this form: [Claim Your Zephyr Badge](https://forms.gle/oCw9iAPLhUsHTapc8).


            Thank you for your valuable input, and we look forward to seeing more of your
            contributions in the future! 🪁
