TILs - Fueling Curiosity, One Insight at a Time

require 'webmock/webmock_api.rb'

config.before(:each) do
    stub_request(:any, /domain_name/).to_rack(WebmockApi
end

# spec/fixtures/member_api_success.json
[
  {
    "id": 1,
    "name": "John Doe",
    "email": "john.doe@example.com",
    "phone": "123-456-7890",
    "membership_type": "Gold",
    "status": "active"
  },
  {
    "id": 2,
    "name": "Jane Smith",
    "email": "jane.smith@example.com",
    "phone": "987-654-3210",
    "membership_type": "Silver",
    "status": "inactive"
  }
]

class WebmockApi
  SPEC_FIXTURES_PATH = 'spec/fixtures'.freeze
  MEMBERS_SUCCESS = File.read("#{SPEC_FIXTURES_PATH}/members_api_success.json").freeze
  POSTS_SUCCESS = File.read("#{SPEC_FIXTURES_PATH}/posts_api_success.json").freeze
  ERROR = File.read("#{SPEC_FIXTURES_PATH}/error.json").freeze

  def self.call(env)
    new.call(env)
  end

  def call(env)
    action = env['REQUEST_METHOD']
    path = env['PATH_INFO']
    params = env['QUERY_STRING']

    case path
    when '/external_members_api_path'
      params.include?('test_user') ? [ 200, {}, [ MEMBERS_SUCCESS ] ] : [ 500, {}, [ ERROR ] ]
    when '/external_post_api_path'
      params.include?('new_post') ? [ 200, {}, [ POSTS_SUCCESS ] ] : [ 500, {}, [ ERROR ] ]
    end
  end
end

require 'rails_helper'
require 'webmock/rspec'

RSpec.describe "Members", type: :request do
  describe "GET /members_search_path" do
    context "when the members API call is successful" do
      it "returns member details from the API" do
        get "/external_members_api_path", params: { member: "test_user" }

        expect(response).to have_http_status(:ok)
        user = response.parsed_body["member"]
        expect(["id"]).to eq("123456")
        expect(user["name"]).to eq("abc")
      end
    end
    
    context "when the members API call is successful" do
      it "returns error message from the API" do
        get "/external_members_api_path", params: { member: "unknown_user" }

        expect(response).to have_http_status(:ok)
        expect(response).to have_http_status(:internal_server_error)
        error = response.parsed_body["error"]
        expect(error).to eq("Something went wrong")
      end
    end
  end
end

import { WebClient } from "@slack/web-api";

const client = new WebClient("YOUR_SLACK_BOT_TOKEN");

async function sendThreadedMessage(channel: string, parent_ts: string, message: string) {
  try {
    // Post a new message as a reply in the thread
    const response = await client.chat.postMessage({
      channel,
      text: message,
      thread_ts: parent_ts, // This makes it a threaded message
    });
  } catch (error) {
    console.error("Error sending threaded message:", error);
  }
}

// Usage example
sendThreadedMessage("C123456789", "1688852910.123456", "This is a reply in the thread.");

async function sendMessageWithThread(channel: string, message: string, replyMessage: string) {
  try {
    // Send the parent message
    const parentMessage = await client.chat.postMessage({
      channel,
      text: message,
    });

    // Reply to the message in a thread
    await client.chat.postMessage({
      channel,
      text: replyMessage,
      thread_ts: parentMessage.ts,
    });
  } catch (error) {
    console.error("Error sending messages:", error);
  }
}

// Usage example
sendMessageWithThread("C123456789", "This is the main message", "This is a reply in the thread.");

// In your stimulus controller 
updateList() {
  this.listTarget.innerHTML = `
    <div class="flex gap-2">
      <span>${this.name}</span>
      <button>Delete</button>
    </div>
  `
}

// In your view 
<template data-list-target="template">
  <div class="flex gap-2">
    <span data-placeholder="name"></span>
    <button>Delete</button>
  </div>
</template>

// In your Stimulus controller
updateList() {
  const template = this.templateTarget.content.cloneNode(true)
  template.querySelector('[data-placeholder="name"]').textContent = this.name
  this.listTarget.appendChild(template)
}

def set_variant
    browser = Browser.new(request.user_agent)

    if browser.device.mobile?
      request.variant = :mobile
    else
      request.variant = :desktop
    end
  end

app/views/orders/index.html.erb
app/views/orders/index.html+mobile.erb

<%= form_with url: some_path, method: :post do |form| %>
  <%= form.text_field :some_field %>
  <%= form.submit "Submit" %>
<% end %>

<%= form_with model: @record do |form| %>
  <%= form.text_field :name %>
  <%= form.submit %>
<% end %>

aws cognito-idp admin-set-user-password \
    --user-pool-id <pool-id> \
    --username <cognito-username> \
    --password <password> \
    --permanent

const queryClient = new QueryClient(
 defaultOptions: {
  queries: {
   staleTime: 10 * 1000
  }
 }
}

queryClient.setQueryDefaults(
 ['todos','list'],
 {staleTime: 10 * 1000}
) 
//This sets default stale time of 10secs for all the matched queries having keys 'todos' and 'list'

useQuery({
 queryKey: ['todo'],
 staleTime: 10 * 1000,
});

const promises = [
  Promise.resolve(1),
  Promise.reject('Error'),
  Promise.resolve(2),
];

Promise.allSettled(promises).then((results) => {
  results.forEach((result) => {
    if (result.status === 'fulfilled') {
      console.log('Result:', result.value);
    } else {
      console.log('Error:', result.reason);
    }
  });
});

Output :
Result: 1
Error: Error
Result: 2