paths:
  /userinfo:
    get:
      summary: Get User Info
      description: Retrieve user profile information including person ID
      operationId: GetUserInfo
      parameters: []
      responses:
        '200':
          description: Success
          schema:
            type: object
            properties:
              sub:
                type: string
                description: User ID (Person ID)
                x-ms-summary: Person ID
              name:
                type: string
                description: Full name
                x-ms-summary: Name
              email:
                type: string
                description: Email address
                x-ms-summary: Email
              given_name:
                type: string
                description: First name
                x-ms-summary: First Name
              family_name:
                type: string
                description: Last name
                x-ms-summary: Last Name
              picture:
                type: string
                description: Profile picture URL
                x-ms-summary: Picture
        default:
          description: Error
          schema:
            type: object
  /ugcPosts:
    post:
      summary: Create LinkedIn Post
      description: Post content to LinkedIn. Provide the complete JSON body for the post.
      operationId: CreatePost
      consumes:
        - application/json
      produces:
        - application/json
      parameters:
        - name: Content-Type
          in: header
          required: true
          type: string
          default: application/json
          x-ms-visibility: internal
        - name: X-Restli-Protocol-Version
          in: header
          required: true
          type: string
          default: 2.0.0
          x-ms-visibility: internal
        - name: body
          in: body
          required: true
          schema:
            type: object
            x-ms-visibility: important
            description: LinkedIn post JSON body
            example:
              author: urn:li:person:YOUR_PERSON_ID
              lifecycleState: PUBLISHED
              specificContent:
                com.linkedin.ugc.ShareContent:
                  shareCommentary:
                    text: Your post text here
                  shareMediaCategory: NONE
              visibility:
                com.linkedin.ugc.MemberNetworkVisibility: PUBLIC
      responses:
        '201':
          description: Post created successfully
          schema:
            type: object
            properties:
              id:
                type: string
                description: The URN of the created post
                x-ms-summary: Post ID
        default:
          description: Error
          schema:
            type: object
            properties:
              message:
                type: string
                description: Error message
              status:
                type: integer
                description: HTTP status code
      x-ms-visibility: important
  /ugcPosts/simple:
    post:
      summary: Create LinkedIn Post (Simple)
      description: >-
        Post to LinkedIn with simple input fields - ideal for non-technical
        users. Supports text posts and link sharing with preview cards.
      operationId: CreatePostSimple
      consumes:
        - application/json
      produces:
        - application/json
      parameters:
        - name: Content-Type
          in: header
          required: true
          type: string
          default: application/json
          x-ms-visibility: internal
        - name: X-Restli-Protocol-Version
          in: header
          required: true
          type: string
          default: 2.0.0
          x-ms-visibility: internal
        - name: personId
          in: query
          required: true
          type: string
          description: Your Person ID (the "sub" value from Get User Info, e.g., abc123xyz)
          x-ms-summary: Person ID
        - name: postText
          in: query
          required: true
          type: string
          description: >-
            The text content of your LinkedIn post. URLs in text are
            automatically clickable (e.g., "Check this out:
            https://example.com"). For link preview cards, use Article URL
            below.
          x-ms-summary: Post Text
        - name: articleUrl
          in: query
          required: false
          type: string
          description: >-
            Optional: URL to share with a preview card (image, title,
            description). Leave empty for text-only posts.
            Example: https://example.com/my-article
          x-ms-summary: Article URL (optional)
          x-ms-visibility: advanced
        - name: articleTitle
          in: query
          required: false
          type: string
          description: >-
            Optional: Title for the article preview card. Only used if Article
            URL is provided. Example: "The Future of AI in Business"
          x-ms-summary: Article Title (optional)
          x-ms-visibility: advanced
        - name: articleDescription
          in: query
          required: false
          type: string
          description: >-
            Optional: Description for the article preview card. Only used if
            Article URL is provided.
          x-ms-summary: Article Description (optional)
          x-ms-visibility: advanced
        - name: thumbnailUrl
          in: query
          required: false
          type: string
          description: >-
            Optional: URL des Vorschaubildes für den Post.
            Beispiel: https://beispiel.de/images/bild.png
          x-ms-summary: Thumbnail URL (optional)
          x-ms-visibility: advanced
        - name: visibility
          in: query
          required: false
          type: string
          default: PUBLIC
          enum:
            - PUBLIC
            - CONNECTIONS
          description: Who can see this post
          x-ms-summary: Visibility
        - name: lifecycleState
          in: query
          required: false
          type: string
          default: PUBLISHED
          enum:
            - PUBLISHED
            - DRAFT
          description: Post state
          x-ms-summary: Lifecycle State
          x-ms-visibility: advanced
      responses:
        '201':
          description: Post created successfully
          schema:
            type: object
            properties:
              id:
                type: string
                description: The URN of the created post
                x-ms-summary: Post ID
        default:
          description: Error
          schema:
            type: object
            properties:
              message:
                type: string
                description: Error message
              status:
                type: integer
                description: HTTP status code
      x-ms-visibility: important

using System;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

public class Script : ScriptBase
{
    public override async Task<HttpResponseMessage> ExecuteAsync()
    {
        try
        {
            if (this.Context.OperationId == "CreatePostSimple")
            {
                return await this.HandleCreatePostSimple().ConfigureAwait(false);
            }

            return await this.Context.SendAsync(this.Context.Request, this.CancellationToken).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            var errorResponse = new HttpResponseMessage(HttpStatusCode.InternalServerError)
            {
                Content = new StringContent(
                    JsonConvert.SerializeObject(new { error = "Connector error", message = ex.Message }),
                    Encoding.UTF8,
                    "application/json"
                )
            };
            return errorResponse;
        }
    }

    private async Task<HttpResponseMessage> HandleCreatePostSimple()
    {
        // Query-Parameter auslesen
        var query = HttpUtility.ParseQueryString(this.Context.Request.RequestUri.Query);
        var personId = query.Get("personId");
        var postText = query.Get("postText");
        var articleUrl = query.Get("articleUrl");
        var articleTitle = query.Get("articleTitle");
        var articleDescription = query.Get("articleDescription");
        var thumbnailUrl = query.Get("thumbnailUrl");
        var visibility = query.Get("visibility") ?? "PUBLIC";
        var lifecycleState = query.Get("lifecycleState") ?? "PUBLISHED";

        // Input-Validierung
        if (string.IsNullOrWhiteSpace(personId))
            return CreateErrorResponse(HttpStatusCode.BadRequest, "Person ID is required");

        if (string.IsNullOrWhiteSpace(postText))
            return CreateErrorResponse(HttpStatusCode.BadRequest, "Post text is required");

        if (!System.Text.RegularExpressions.Regex.IsMatch(personId, @"^[a-zA-Z0-9\-_]+$"))
            return CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid Person ID format");

        if (postText.Length > 3000)
            return CreateErrorResponse(HttpStatusCode.BadRequest, "Post text exceeds 3000 character limit");

        if (visibility != "PUBLIC" && visibility != "CONNECTIONS")
            return CreateErrorResponse(HttpStatusCode.BadRequest, "Visibility must be PUBLIC or CONNECTIONS");

        if (lifecycleState != "PUBLISHED" && lifecycleState != "DRAFT")
            return CreateErrorResponse(HttpStatusCode.BadRequest, "Lifecycle state must be PUBLISHED or DRAFT");

        // ShareContent aufbauen
        var shareContent = new JObject
        {
            ["shareCommentary"] = new JObject
            {
                ["text"] = postText
            }
        };

        // Artikel-Link einbauen falls vorhanden
        if (!string.IsNullOrWhiteSpace(articleUrl))
        {
            shareContent["shareMediaCategory"] = "ARTICLE";

            var mediaItem = new JObject
            {
                ["status"] = "READY",
                ["originalUrl"] = articleUrl,
                ["title"] = new JObject { ["text"] = articleTitle ?? "" },
                ["description"] = new JObject { ["text"] = articleDescription ?? "" }
            };

            // Thumbnail einbauen falls vorhanden
            if (!string.IsNullOrWhiteSpace(thumbnailUrl))
            {
                mediaItem["thumbnails"] = new JArray
                {
                    new JObject { ["url"] = thumbnailUrl }
                };
            }

            shareContent["media"] = new JArray { mediaItem };
        }
        else
        {
            shareContent["shareMediaCategory"] = "NONE";
        }

        // Vollständigen Request-Body aufbauen
        var requestBody = new JObject
        {
            ["author"] = $"urn:li:person:{personId}",
            ["lifecycleState"] = lifecycleState,
            ["specificContent"] = new JObject
            {
                ["com.linkedin.ugc.ShareContent"] = shareContent
            },
            ["visibility"] = new JObject
            {
                ["com.linkedin.ugc.MemberNetworkVisibility"] = visibility
            }
        };

        var jsonBody = requestBody.ToString(Newtonsoft.Json.Formatting.None);

        // Request URI anpassen
        var originalUri = this.Context.Request.RequestUri.ToString();
        var baseUri = originalUri.Split('?')[0].Replace("/simple", "");

        try
        {
            this.Context.Request.RequestUri = new Uri(baseUri);
        }
        catch (UriFormatException)
        {
            return CreateErrorResponse(HttpStatusCode.InternalServerError, "Invalid URI format");
        }

        this.Context.Request.Content = new StringContent(jsonBody, Encoding.UTF8, "application/json");

        HttpResponseMessage response;
        try
        {
            response = await this.Context.SendAsync(this.Context.Request, this.CancellationToken).ConfigureAwait(false);
        }
        catch (TaskCanceledException)
        {
            return CreateErrorResponse(HttpStatusCode.RequestTimeout, "Request timed out");
        }
        catch (HttpRequestException ex)
        {
            return CreateErrorResponse(HttpStatusCode.BadGateway, $"LinkedIn API error: {ex.Message}");
        }

        return response;
    }

    private HttpResponseMessage CreateErrorResponse(HttpStatusCode statusCode, string message)
    {
        var errorObject = new JObject
        {
            ["error"] = true,
            ["message"] = message,
            ["status"] = (int)statusCode
        };

        return new HttpResponseMessage(statusCode)
        {
            Content = new StringContent(
                errorObject.ToString(Newtonsoft.Json.Formatting.None),
                Encoding.UTF8,
                "application/json"
            )
        };
    }
}

{
  "author": "urn:li:person:{DEINE_SUB_ID}",
  "lifecycleState": "PUBLISHED",
  "specificContent": {
    "com.linkedin.ugc.ShareContent": {
      "shareCommentary": {
        "text": "Dein Post-Text hier! 🚀"
      },
      "shareMediaCategory": "NONE"
    }
  },
  "visibility": {
    "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"
  }
}