我正在为我们的 Rails 应用程序整合一个 gem，以便通过 Entra ID 使用 SAML 单点登录/注销。我对需要实现的最后一点有一些疑问：ID 提供商发起的单点注销请求...

我正在为我们的 Rails 应用程序整合一个 gem，以便通过 Entra ID 使用 SAML 单点登录/注销。我对需要实现的最后一点有一些疑问：ID 提供商发起的单点注销请求。

我们在服务提供商（Rails 应用程序）中使用 Active Record Session Store，默认情况下，创建的表存储会话 ID 和会话数据。但是 IdP 无法知道每个 SP 的会话 ID，对吗？我唯一需要参考的信息是 IdP 注销请求中的名称 ID（与会话关联的用户名）？实际上，我也需要将名称 ID 存储在会话表中，通过 IdP 注销请求中的名称 ID 找到相应的会话，然后删除该会话？

我现在遇到的问题是，当 IdP 注销请求进入时，会话不会被删除。我认为这是因为 Active Record Session Store 中间件没有为该请求获取正确的会话。而是在表中添加了一个新会话。

切线相关的是，SLO 是否可以使用 cookie 存储？

我使用 dto 在 nestjs typeorm 中通过 post 对象接收数据 @Post(':userId/charge-amount') @HttpCode(HttpStatus.OK) async chargeUser( @Body() chargeAmountDTO : ChargeAmountDTO...

我使用 dto 在 nestjs typeorm 中通过 post 接收对象数据

@Post(':userId/charge-amount')
    @HttpCode(HttpStatus.OK)
    async chargeUser(
      @Body() chargeAmountDTO : ChargeAmountDTO,
      @Param('userId') userId: number
    ) {
      
  
      console.log(chargeAmountDTO);
    }

它像这样返回 chargeAmountDTO: { '{\r\n \'amount\' :\'2000\'\r\n}': '' }为什么它不将其返回到 json 对象请帮帮我

这是我的 ChargeAmountDTO

export class ChargeAmountDTO{
    amount : number
}

dto 不返回 json

我使用 nextjsi 时不断收到错误 OverwriteModelError：编译后无法覆盖 AddOnsDatabase 模型。为了修复此错误，我使用 OR 运算符来检查模型是否已存在

我正在使用 nextjs

我一直收到错误

OverwriteModelError: Cannot overwrite AddOnsDatabase model once compiled.

为了修复此错误，我使用 OR 运算符来检查模型是否已存在

import mongoose from "mongoose";

const AddOnsDatabaseSchema = new mongoose.Schema({
  name: String,
  limit: String,
  required: Boolean,
});

const AddOnsDatabase =
  mongoose.model("AddOnsDatabase") ||
  mongoose.model("AddOnsDatabase", AddOnsDatabaseSchema);
export default AddOnsDatabase;

这修复了错误，但弄乱了打字稿，就像我使用时一样

const AddOnsDatabase = mongoose.model("AddOnsDatabase", AddOnsDatabaseSchema);

并像这样使用该模型：

"use server";
import { connectDB } from "@/lib/mongodb";
import AddOnsDatabase from "@/models/AddOnsDatabase";
import { DBAddon } from "@/types/temp";
export async function GetAddOns(): Promise<DBAddon[]> {
  await connectDB();
  const addons = await AddOnsDatabase.find().lean();
  console.log(addons);
  if (!addons) return [];
  const addonsToReturn = addons.map((addon) => {
    return {
      id: addon._id ? addon._id.toString() : "",
      name: addon.name ? addon.name : "",
      limit: addon.limit ? addon.limit : "",
      required: addon.required ? addon.required : false,
    };
  });
  return addonsToReturn;
}

addons 会有这种类型

const addons: (FlattenMaps<{
    name?: string | null | undefined;
    limit?: string | null | undefined;
    required?: boolean | null | undefined;
}> & {
    _id: Types.ObjectId;
})[]

但使用 OR 运算符后 const AddOnsDatabase = mongoose.model("AddOnsDatabase") || mongoose.model("AddOnsDatabase", AddOnsDatabaseSchema);

addons 有类型

const addons: (FlattenMaps<any> & Required<{
    _id: unknown;
}>)[]

请帮我找到一种方法来避免出现该错误并使用 Model.findById() 自动推断类型

我已经尝试过上述方法

说，我有一个 api 调用，它接受自 Unix 时间戳以来的输入。fetchData = (since?) => { const now = Math.floor(Date.now() / 1000); // 当前 Unix 时间戳（以秒为单位）如果...

Unix 时间戳的 since 输入

  fetchData = (since?) => {
    const now = Math.floor(Date.now() / 1000); // Current Unix timestamp in seconds
    if (since) {
        //handle logic
        console.log(since)
    }
    return of({ since: now });
  };

现在我想创建一个无限循环，在每次调用中，fetchData 的输入值是前一个间隔的返回值。我尝试使用以下代码：

fetchData().pipe(
    expand((response: any) => {
      const { since } = response;
      return fetchData(since);
    }),
    delay(3000),
    repeat(),
  );

我不知道为什么 console.log 一直给出相同的值。我做错了什么？

在 rails 中我如何记住用户登录时离开的页面。当同一个用户回来时，他会登陆同一页面。我是 rails 新手，不确定如何解决这个问题。有没有什么精华...

在 Rails 中，如何记住用户登录时离开的页面。

当同一个用户回来时，他会进入同一页面。

我是 Rails 的新手，不确定如何解决这个问题。

有没有什么 gem 可以实现这个功能？

谢谢

好吧，我检查了你的演示，查看了控制台日志，但输出不是我想要的。它们应该是这样的：``` {since: 1721700772} {since: 1721700775} {since: 1721700778} ```

你可以这样做：

import { repeat, of, delay } from 'rxjs';

const someInputValue = 5;

const fetchData = (since: any = null) => {
const now = Math.floor(Date.now() / 1000); // Current Unix timestamp in seconds
  if (since) {
    //handle logic
    console.log(since);
  }
  return of({ since: now });
};

const delayed = fetchData(someInputValue).pipe(delay(3000));
const repeated = delayed.pipe(repeat());

repeated.subscribe(console.log);

Stackblitz 演示

您没有从该函数返回任何内容。请澄清您的问题。如果您希望在

我稍微修改了 fetchData 并使用 map 来解决问题：

const fetchData = (since) => {
  const now = Math.floor(Date.now() / 1000); // Current Unix timestamp in seconds
  console.log(since, now)
  return now
};

interval(3000)
    .pipe(
      startWith(Math.floor(Date.now() / 1000)),
      scan((prev) => this.fetchData(prev)),
    )
    subscribe();

@manaclan pairwise 将旧值和新值分组，因此你可以选择你想要的 stackblitz

尝试了您的解决方案，但这不是我想要实现的。每个间隔，fetchData 的 since 参数应该是上一个间隔中 fetchData() 调用的结果

您可以使用 interval 创建无限循环，然后切换到内部 fetchData 来 switchMap 获取所需的结果。

import './style.css';

import { interval, of, switchMap } from 'rxjs';

const fetchData = (since: any = null) => {
  const now = Math.floor(Date.now() / 1000); // Current Unix timestamp in seconds
  if (since) {
    //handle logic
    console.log(since);
  }
  return of({ since: now });
};

interval(3000)
  .pipe(switchMap(() => fetchData()))
  .subscribe(console.log);

Stackblitz 演示

您可以将用户访问的最后一个页面存储在 Cookie 中。浏览器每次发出请求时都会发送 Cookie。

1. 用户首次导航到你网站的某个页面
2. 在 Rails 端，将用户访问的路径存储在 cookie 中（假设 last_visited_path )
3. 下次用户访问您的网站时，读取不应为空的 cookie 值，并将用户重定向到该路径。

这里的问题是，您如何决定是否应该重定向用户或允许他们访问请求的页面。因为您可能只想在他们通过链接访问您的网站时重定向他们，但是一旦他们已经进入您的网站，您就应该允许他们导航到他们想要的页面，而不是总是将他们重定向到 1 个页面。要解决这个问题，您可以检查 Referrer 标头：如果它存在并且是您的网站域（即请求是从您的网站发出的），则不要重定向，否则重定向。

你不知道吗？这是一个网页，而不是原生应用，你的用户可能不希望或不期望它以这种方式工作。如果你真的想知道，请阅读有关 cookie 的内容。

您可以使用 contain_exactly 匹配器。只需将其应用于预期响应即可，如下所示

expected_response = {
  id: 10,
  status: 'ok',
  data: contain_exactly(
    { id: 1 },
    { id: 2 },
  ),
}

response = {
  status: 'ok',
  data: [
    { id: 2 },
    { id: 1 },
  ],
  id: 10,
}

expect(response).to match expected_response

或者应用 match_array 。在上面的例子中，它看起来像 match_array([{id: 1}, {id: 2}])

两个匹配器都忽略数组顺序

Rspec 有 match_array() （contain_exactly() 的别名），它忽略数组的顺序

说得好。我原本希望有某种“内置”的 RSpec 匹配器可以做到这一点，但如果我找不到，我就会这样做。

如果顺序对您来说不重要，我会以 expected_response 相同的方式对 response 和

expected_response[:data] = expected_response[:data].sort_by{|x| x[:id]}
response[:data] = response[:data].sort_by{|x| x[:id]}
expect(response).to match(expected_response)

当使用 match 匹配器 contain_exactly :

let(:expected) do
  {
    data: contain_exactly(1, 2, 3)
  }
end

it 'matches' do
  expect({ data: [2, 3, 1] }).to match(expected)
end