Timofey Melentev's questions

Resolver中存在突变：

@InputType()
class TurnInput {
  @Field(() => [Letter])
  word: [Letter]; // также пробовал Letter[] и просто [{}]

  @Field(() => Int)
  gameId: number

  @Field(() => Boolean)
  confirmed: boolean
}

@Mutation(() => Game)
async makeTurn(
  @Arg("input") input: TurnInput,
  @Ctx() { req }: MyContext
) { ... }

启动时会报错：

CannotDetermineGraphQLTypeError：无法确定 'TurnInput' 类的 'word' 的 GraphQL 输入类型。用作其 TS 类型或显式类型的值是用适当的装饰器装饰还是适当的输入值？

有没有办法将您类型的对象数组传递给参数？也就是说，会有这样的东西：

word: [
  {id: 1, char: 's'},
  {id: 2, char:'a'},
  {id: 3, char: 'n'},
  {id: 4, char: 'd'}
]

我想实现多对多连接（我使用 type-graphql、graphql、typeorm），我需要创建一个游戏，同时将它放在玩家的游戏数组中：

@ObjectType()
@Entity()
export class User extends BaseEntity {
  ...

  @ManyToMany(() => Game, game => game.players, { cascade: true }) @JoinTable()
  games: Game[];
}

@ObjectType()
@Entity()
export class Game extends BaseEntity {
  
  // От этих p1id и p2id хочу отказаться, чтобы можно было ссылаться на связь с User
  @Field(() => Int, {nullable: false})
  @Column()
  p1id: number;

  @Field(() => Int, {nullable: true, defaultValue: 0})
  @Column({nullable: true, default: 0})
  p2id: number;

  ...

  @ManyToMany(() => User, user => user.games)
  players: User[]  
}

为此，解析器中有以下功能：

  @Mutation(() => Game)
  async createGame(@Ctx() { req }: MyContext) {
    const initialWord = await generateRandomWord();
    const currUser = await User.findOne({ id: req.session.userId });

    if (currUser) {
      let userGames = [];
      if (currUser.games !== undefined) {
        currUser.games.map((i) => userGames.push(i));
      }      
      const game = await getConnection()
        .createQueryBuilder()
        .insert()
        .into(Game)
        .values({
          status: false,
          initialWord,
          p1id: req.session.userId,
        })
        .returning("*")
        .execute();
      const res = game.raw[0] as Game;
      userGames.push(res);                
      await getConnection()
      .createQueryBuilder()
      .update(User)
      .set({games: userGames as Game[]})
      .where("id = :id", {id: req.session.userId})
      .execute();      
      return game.raw[0] as Game;
    }
    throw new UnauthorizedError();
  }

我不明白为什么它在被问到时显示以下内容：

query failed: UPDATE "user" SET "userId" = $1, "updatedAt" = CURRENT_TIMESTAMP WHERE "id" = $2 -- PARAMETERS: [null,1]
[0] error: error: столбец "userId" в таблице "user" не существует

这个 userId 在请求中来自哪里？为什么它没有更新您需要的内容？

每次启动项目，需要在三个终端执行两条命令：

1: cd server -> yarn watch
2: cd server -> yarn dev
3: cd web -> yarn dev

如何实现自动化，以便通过一个按钮启动三个终端窗口？VS Code 中是否有任何宏可以执行此操作？

我考虑过创建*.bat一个文件并单独运行三个 PowerShell 窗口，但它们不会显示在 VS Code 中。

我应该使用这个：

private IMediator _mediator;
protected IMediator Mediator => _mediator ??= HttpContext.RequestServices.GetService<IMediator>();

然后打电话Mediator.Send(...)？

或者是否有必要创建一个控制器实例，在其中调用所需的命令/请求？或者完全是别的什么？

到目前为止，我对 TypeScript 并不熟悉，但我还没有遇到过任何语言的这个，我在 ASP.NET Core + React-Redux + TS 样板中看到了这段代码。请解释为什么需要在声明的描述中声明一个相同类型的静态字段？

import { AxiosResponse } from 'axios';
import { BaseService } from './base.service';
import { IAuthUser, ICredentials } from '../store/auth/types';

/**
 * Auth API abstraction layer communication via Axios (typescript singleton pattern)
 */
class AuthService extends BaseService {
  private static _authService: AuthService; // вот эта строка
  private static _controllerName: string = 'Auth';

  private constructor(controllerName: string) {
    super(controllerName);
  }

  public static get Instance(): AuthService {
    return this._authService || (this._authService = new this(this._controllerName));
  }

  public async logoutAsync(): Promise<AxiosResponse> {
    return await this.$http.post('Logout');
  }

  public async loginAsync(credentials: ICredentials): Promise<IAuthUser> {
    const { data } = await this.$http.post<IAuthUser>('Login', credentials);
    return data;
  }
}

export const AuthApi = AuthService.Instance;

我最近开始使用 Redux，一切似乎都解决了。现在我又制作了一个组件，添加了更多reducers，action，然后调用combinedReducers，但由于某种原因发生了错误：this.props.books 未定义。我试图从 mapStateToProps 调用 console.log，据我了解，应用程序甚至没有进入它。有什么问题？

import React, { Component } from 'react';
import { Spinner, Row, Col, Container } from 'reactstrap';
import store from '../store/Store';
import { connect } from 'react-redux';
import getBooks from '../actions/ContentActions';
export class Books extends Component {
    constructor(props) {
        super(props);
        this.state = {
            isFetching: true
        }
        this.fetchData = this.fetchData.bind(this);
    }
    async componentDidMount() {
        await this.fetchData(); // Получаю книги из API, чтобы занести их в store
    }

    async fetchData() {
        var data = {
            first: 1,
            last: 9
        }
        var response = await fetch('contentRequests/getBooksInRange', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify(data)
        })
            var result = await response.json();
        store.dispatch(getBooks(result)); // Вызываю экшн, который добавляет в store массив books, который приходит в result
        console.log(this.props);
        this.setState({isFetching:false });
    }

    render() {
        console.log(this.props);
        if (this.state.isFetching) {
            return (
                <Spinner animation="grow" variant="dark" />
            );
        }
//На этом месте возникает ошибка
        if (this.props.books !== null || this.props.books !== undefined) {
            var bookTitles = this.props.books.map((b) => <div><b>{b.bookTitle} ({b.publishYear})</b></div>);
            var bookAuthors = this.props.books.map((a) => <div>{a.authorName}</div>);
            var bookDescription = this.props.books.map((d) => <div>{d.description}</div>);
            var books = [];
            for (var i = 0; i < this.props.books.length; i++) {
                books.push(
                    <Col key={'book_' + i} md={4}>
                        {bookTitles[i]}
                        {bookAuthors[i]}
                        {bookDescription[i]}
                    </Col>);
            }
            return (
                <Container>
                    <h1>Каталог книг</h1>
                    <Row>
                        {books}
                    </Row>
                </Container>
            );
        }                

    }
}

const mapStateToProps = state => {
    console.log(state.books.books); // ничего в консоль не выводится
    return {
        books: state.books.books        
    }
}

export default connect(mapStateToProps, { getBooks })(Books); // Нужно ли тут передавать action в аргумент?

为代码写注释，以便您可以快速了解正在发生的事情

还会出现错误：Can't perform a React state update on an unmounted component.

减速器：

import { GET_BOOKS } from '../constants/ActionTypes';

export default function getBooksReducer(state = { books: [] }, action) {
    switch (action.type) {
        case GET_BOOKS:
            return Object.assign({}, state,
                {
                    books: action.books
                });
        default:
            return state;
    }
}

行动：

export const GET_BOOKS = 'GET_BOOKS';
export default function getBooks(books) {
    return {
        type: GET_BOOKS,
        books: books
    }
}

结合：

import { combineReducers } from 'redux'
import getBooksReducer from './ContentReducers';
import loginAccountReducer from './AccountReducers';

export default combineReducers({
    books: getBooksReducer,
    account: loginAccountReducer
})

店铺：

import { createStore } from 'redux';
import reducer from '../reducers/CombinedReducer';

const store = createStore(reducer);
export default store;

如何从另一个登录组件重新渲染 NavMenu 组件？我知道不可能从一个组件更改某些特定其他组件的状态？有什么办法吗？

    export class Login extends Component {
    constructor(props) {
        ....
    }

    ...

    async login() {
        var data = {
            login: this.state.login,
            password: this.state.password
        }
        await fetch('sendrequest/login', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify(data),
        })
            .catch(error => console.log(error));


    }

    ...

    render() {
        return (
            <Col lg={3}>
                <form>
                    <input type="email" id="emailInput" onChange={this.onChangeLogin} name="passwordInput" placeholder="E-Mail" />
                    <input type="password" id="passwordInput" onChange={this.onChangePassword} name="passwordInput" placeholder="Password" />
                    <Button className="btn btn-primary" onClick={this.login} >Log in</Button>
                </form>
                <Button className="btn btn-primary" onClick={this.refreshToken}>Refresh Token</Button>
            </Col>
        )
    }
}

导航栏本身如下所示：

...

export class NavMenu extends Component {
    static displayName = NavMenu.name;

    async componentDidMount() {
        await this.getProfileData();
    }

    constructor(props) {
        ....
        this.state = {
            collapsed: true,
            firstName: ""
        };        
    }

    ...


    async getProfileData() {
        await fetch('sendrequest/getProfileData', {
            method: "POST",
            headers: {
                'Content-Type': "application/json"
            }
        })
            .then(response => response.json())
            .then(result => this.setState({
                firstName: result.firstName
            }));
    }

    async logout(e) {
        e.preventDefault();
        await fetch('sendrequest/logout', {
            method: "POST",
            headers: {
                'Content-Type': "application/json"
            }
        });
        this.setState({ firstName: undefined });

    }

    render() {
        var loginMenu = <NavLink tag={Link} className="text-dark" to="/login">Log in</NavLink>;
        if (this.state.firstName != null && this.state.firstName != undefined) {
            loginMenu = <React.Fragment><NavItem><NavLink tag={Link} className="text-dark" to="/profile">{this.state.firstName}</NavLink></NavItem>
                <NavItem><NavLink tag={Link} className="text-dark" to="/profle" onClick={this.logout}>Logout</NavLink></NavItem></React.Fragment>;

        }
        return (
            <header>
                <Navbar className="navbar-expand-sm navbar-toggleable-sm ng-white border-bottom box-shadow mb-3" light>
                    <Container>
                        <NavbarBrand tag={Link} to="/">LibraryClient</NavbarBrand>
                        <NavbarToggler onClick={this.toggleNavbar} className="mr-2" />
                        <Collapse className="d-sm-inline-flex flex-sm-row-reverse" isOpen={!this.state.collapsed} navbar>
                            <ul className="navbar-nav flex-grow">
                                <NavItem>
                                    <NavLink tag={Link} className="text-dark" to="/">Home</NavLink>
                                </NavItem>
                                <NavItem>
                                    <NavLink tag={Link} className="text-dark" to="/counter">Counter</NavLink>
                                </NavItem>
                                <NavItem>
                                    <NavLink tag={Link} className="text-dark" to="/fetch-data">Fetch data</NavLink>
                                </NavItem>
                                {loginMenu}
                            </ul>
                        </Collapse>
                    </Container>
                </Navbar>
            </header>
        );
    }
}

有两种型号：

public class User : IEntity
{
    public int Id { get; set; }
    public string Login { get; set; }
    public string Password { get; set; }
    public string PhoneNumber { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Role { get; set; } = "user";
    public List<RefreshToken> RefreshTokens { get; set; }
}

public class RefreshToken : IEntity
{       
    [Key]
    public int Id { get; set; }
    public string Token { get; set; }
    public DateTimeOffset Expiration { get; set; }
    [ForeignKey("UserId")]
    public int UserId { get; set; }
    public User User { get; set; }
}

即使导航属性在那里，FK 也在那里，当我尝试查看 _context.Users.RefreshTokens 时，那里什么也没有。我不明白，对吗？为什么然后为空？

更新：

显然请求中包含的内容不够多，所以我尝试添加它，但看起来很糟糕，您能建议如何修复它吗？或者最好不要这样做，放弃导航属性，只在令牌表中进行搜索Where(p => p.UserId == user.Id)？

var userTokens = _libraryContext.Users.Where(p => p.Login == username)
    .Include(p => p.RefreshTokens);
var savedRefreshToken = userTokens.Select(p => p.RefreshTokens)
    .Select(t => t.Where(p => p.Token == requestModel.OldRefreshToken)
    .FirstOrDefault()
    .FirstOrDefault()
    .Token;

这两个FirstOrDefault()在这里是因为第一个之后它返回IEnumerable<RefreshToken>，第二个之后它直接返回RefreshToken。

有一个常规的 ASP.NET Core MVC 应用程序，其中添加了 Identity，通过服务（存储库模式）、一个 EmailSender 实现和几个控制器处理数据库实体，这些控制器简单地从数据库和注册页面路由到多个模型的视图（身份）。我是否正确理解整个服务器部分（使用数据库，包括邮件和注册）应该放在同一解决方案中的一个单独的新项目中，并且不包含视图，而只包含 API？两个独立的项目应该如何相互沟通？请求是否只是通过 fetch 从客户端发送到已发布 API 中方法的 url？也就是说，例如，我访问 somesite.com/phones，进入一个页面，该页面应该包含使用 fetch('somesite2api.com/getPhones' 获取的数据库中的数据 )? 如果这一切已经在某处描述过，请至少给出正确的名称以便谷歌搜索，因为我什至无法正常表述。我刚刚用HttpClient找到了一些东西，但我不明白是不是它？

今天我在这个项目上工作，部署了它和数据库，一切都很好。然后我添加了 Identity，一个新的数据库，通过 SendGrid 邮件确认，再次部署它，现在它没有加载任何东西，只是一个 500 错误。同时，在工作室中一切正常。可能是什么原因？如果有必要，我会把github上的项目扔掉，但是我以为没人会去看和搜索，但是如果我列出的有一些已知问题怎么办？

我做一个项目只是为了学习，我在那里创建了 CommentService 类，其中包含使用数据库的方法（为了将来缩短代码）：

public class CommentService : IDatabaseService<Comment>
{
    private readonly ILogger<CommentService> _logger;
    private readonly DatabaseContext _db;
    public CommentService(ILogger<CommentService> logger, DatabaseContext context)
    {
        _logger = logger;
        _db = context;
    }

    public async void AddEntity(Comment entity)
    {
        _db.Comments.Add(entity);
        await _db.SaveChangesAsync();
    }

    public async Task<List<Comment>> GetAllEntitiesAsync()
    {
        return await _db.Comments.ToListAsync();
    }

    public async Task<List<Comment>> GetAllCommentsByPostId(int postId)
    {
        return await _db.Comments.Where(p => p.PostId == postId).ToListAsync();
    }

    public async Task<Comment> GetEntityByIdAsync(int id)
    {
        return await _db.Comments.FindAsync(id);
    }

    public async void RemoveEntityById(int id)
    {
        _db.Comments.Remove(await GetEntityByIdAsync(id));
        await _db.SaveChangesAsync();
    }

    public void Dispose()
    {
        _db.Dispose();
    }
}

问题是：这种方法是否正确？我的意思是从这里的另一个类传递数据库上下文的构造函数，然后调用 Dispose？还是在每种方法中使用更好using(DatabaseContext _db = new DatabaseContext())？据我了解，两者都暗示 Dispose，并且需要它以便您可以在不同类中使用上下文并且没有冲突，但哪个更正确并且是否有必要？

当你点击一个元素时，它周围有一个虚线边框，如何去除它？是否有一些 CSS 属性对此负责，或者它是浏览器 (Firefox) 的一个功能？

我有一个图像库，其中所有图像都根据此模板非常粗略地呈现

import image1 from './images/image1';
    <...>    
    render(){
        return(
        
             <img src={image1} alt="" />
        );
    }

也就是说，图像不是从服务器加载的，而是通过导入从文件夹中加载的。问题是当我去这个画廊时，起初我看到的只是一个没有这些图片的布局，然后它们加载了两秒钟，然后一切都很好。我需要在它们加载时，不显示页面，但可以看到某种微调器。我看到了他们在 fetch 发生时放置它的示例，但我没有。可能吗？或者至少以某种方式制作动画，使图像随着透明度的变化逐渐出现？

一般是如何实现的？

我翻遍了很多页面，他们写了如何使用项目文件夹中的图片，我这样做了，例如：

    import {img} from './images/logo.jpg';
    ...
    <img src={img} alt="logo" />

但是图片没有显示出来。问题是什么？我也试过用 require('') 但也不管用。

根据示例编写以下代码fetch：

import React, { Component} from 'react';
import { Container, Col, Row } from 'reactstrap';
import './Blog.css';


export class Blog extends Component {
    render() {
        return (
            <Container>
                <PostMaker id={4} />
                <PostMaker id={5} />
                <PostMaker id={9} />
            </Container>
        );
    }
}

export class PostMaker extends Component {
    constructor(props) {
        super(props);
        this.state = { id: 0, data: [] };

    }
    componentDidMount() {        
        const url = 'api/article/makenewpost/?id=' + this.props.id;
        fetch(url, {
            method: "GET",
            headers: {
                "Content-Type":"application/json"
            },
        }).then((response) => { this.setState({id: this.props.id, data:response})})       
    }    



    render() {             

        return (<Container>
            <Row>
                <Col xs={12} className="title">
                    <h2>{this.state.data[0].title}</h2>
                </Col>
            </Row>
            <Row>
                <Col xs={12} className="body">
                    <p>{this.state.data[0].body}</p>
                </Col>
            </Row>
        </Container>);

    }

}

抛出异常：

TypeError: Cannot read property 'title' of undefined

为什么会这样？render以前发生过fetch吗？如何正确更改代码？

如果您需要来自控制器的方法：

public IActionResult MakeNewPost(int id)
{
    var articles = _context.Post.Where(p => p.Id == id).Select(p => p);
    var title = articles.Select(p => p.Title).First();
    var body = articles.Select(p => p.Body).First();

    List<Post> posts = new List<Post>{
           new Post
            {
                Title = title,
                Body = body,
            }};


    return Json(posts.ToArray());
}

我决定为在线商店创建临时帐户。即您可以使用注册时指定的登录名和密码注册并登录永久账户，也可以不注册直接将商品放入购物篮。为此，我在第一次访问该站点时创建了一个 Guid 字符串，该字符串作为 UnauthenticatedID 写入 cookie。可以简单地将购物篮中的产品与此 Guid 链接，但存在根据用户表中用户的 (int)Id 的绑定，因此创建这些相同的帐户以免创建新列。帐户（如 cookie 本身）的到期日期 = 自注册之日起 14 天。所以问题是：如何更好地实现对过期帐户及其删除的自动每日检查？如果不清楚我怀疑什么，我可以添加一些东西

有这个代码：

<div class="row">
    <div class="col-4">
        <form asp-action="Login" asp-controller="Account" asp-anti-forgery="true">
            <div class="validation" asp-validation-summary="ModelOnly"></div>

            <div class="input-group">

                <div class="input-group-prepend">
                    <span class="input-group-text" id="basic-addon1">E-mail</span>
                </div>
                <input class="form-control" type="text" asp-for="Email" />

                <span asp-validation-for="Email" />


            </div>

            <div class="input-group">
                <div class="input-group-prepend">
                    <span id="basic-addon1" class="input-group-text">Пароль</span>
                </div>
                <input class="form-control" asp-for="Password" />
                <span asp-validation-for="Password" />
            </div>
            <div class="form-group">
                <input type="submit" value="Войти" class="btn" />
            </div>
        </form>
    </div>
    <div class="flex-row ml-auto"><img style="width:35rem;" src="~/images/soldier.png" /></div>
</div> 

起初一切都很好：

但是如果validation.js 突然起作用了，那么结果是这样的：

我想将警告向下移动，但我不明白要使用哪些属性。尝试了以下方法：

display:block, flex, inline-block white-space:normal 但这无济于事

有这个代码：

public class CategoriesController : Controller
{
    private readonly WarhammerContext _context;

    public CategoriesController(WarhammerContext context)
    {
        _context = context;

    }
    public IActionResult Index()
    {
        return View();
    }
    public IActionResult ProductListing()
    {

        var listingContext = _context.Product.Include(p => p.ProductFraction).Include(p => p.ProductType);            
        Dictionary<int, string> productImages = GetImagesByIds(listingContext.Select(p => p.Id));      
        foreach(var productId in productImages.Keys)
        {
            listingContext.Where(p => p.Id == productId).FirstOrDefault().ImageSource = productImages[productId];
        }
        ProductsViewModel pvm = new ProductsViewModel { ImageSources = productImages, Products = listingContext };

        return View(pvm);
    }


    public Dictionary<int, string> GetImagesByIds(IEnumerable<int> productIds) =>          
            _context.ProductImage.Where(p => productIds.Contains(p.Id)).ToDictionary(key => key.ProductId, value => value.ImageSource);




}

引发此异常：“在前一个操作完成之前，在此上下文上启动了第二个操作。不保证任何实例成员都是线程安全的。”

试图这样做：

        {
            using (var context = new WarhammerContext())
            {
                return context.ProductImage.Where(p => productIds.Contains(p.Id)).ToDictionary(key => key.ProductId, value => value.ImageSource);
            }
        }

但随后在 ProductListing 中，productImages 字典变为空。它在调试器中给出错误，因为它已被释放。如何解决问题？

我也尝试制作 AddTransient，但它也没有帮助

有一个 ProductSize 尺寸模型，其中有属性：

public int Id {get; set;}
public int S {get; set;}
public int M {get; set;}
public int L {get; set;}
public int ProductId {get;set;}
public Product Product {get; set;}

大小存储一个 Int 值，该值指示存在一种或另一种大小的数量。我想创建一个仅显示值大于零的维度的下拉列表。好吧，或者，作为一种选择，将有所有值，但根据相同的逻辑启用\禁用。但是为此我仍然需要获取非零值的列的名称。这样做的正确方法是什么？

一开始，我存储bool而不是int，写了这个可怕的方法（但最后我什至没有尝试，因为我决定从头重做整个数据库）

var product = db.Products.FirstOrDefault(p => p.Id == productId);
var availableSizes = from s in db.ProductSizes where (s.Id == productId) select s;
List<string> Sizes = new List<string>();
foreach (var s in availableSizes)
{
    if(s.S == true)
    {
        Sizes.Add("S");
    }
    if(s.M == true)
    {
        Sizes.Add("M");
    }
    if (s.L == true)
    {
        Sizes.Add("L");
    }
    if (s.Xl == true)
    {
        Sizes.Add("XL");
    }
    if (s.Xxl == true)
    {
        Sizes.Add("XXL");
    }
}
return Sizes;

在学习C#的阶段面临以下问题。有一个数组包含两个类字段和一个指向类本身的链接。

public void AddAllItems()
{
    allItems[0, 0] = Blade.itemName;
    allItems[0, 1] = Blade.cost;
    allItems[0, 2] = new Blade();            
}

我需要迭代其中的元素，因为我知道对类的引用将在哪里（第二个索引），所以我想调用Build()这个类的方法。
我该怎么做？
allItems[i, 2].Build()，当然，不起作用，因为据我所知，他事先并不知道这将是一个类参考。
我到底做错了什么，我该怎么办？

public void Sell(string itemName)
{
    if (inventory.Contains(itemName))
    {
        for (int i = 0; i < allItems.Length; i++)
        {
            if (allItems[i, 0].ToString() == itemName)
            {
                allItems[i, 2].Build();
                purse += (int)allItems[i, 1] / 2;
                Console.WriteLine($"Great! You've sold {itemName} for {(int)allItems[i, 1]}!");                                                
                Console.WriteLine($"Your money: {purse}\n");
                break;
            }
        }
    }
    else
    {
        Console.WriteLine("You don't have this in your inventory!\n");
    }
}