All perguntas(coding)

Fundo:

Eu tenho um Actor chamado Peer. Dentro da minha aplicação, a Peerrepresenta uma conexão entre o servidor que o criou e outro servidor. É essencialmente um http-client.

Quando a instância é executada pela primeira vez, o PeerManagerconsulta o banco de dados para obter a lista de entradas do servidor. Em seguida, ele cria um Peerator para esse servidor. O estado do Peerdepende de seu RegistrationStatuscampo ( PENDING_OUT , PENDING_IN , REGISTERED , ...)

A Peertem uma função de recebimento padrão que se parece com esta:

  override def receive: Receive = {
    case FirstTick =>
      system.log.info("receive FirstTick")
      timers.startTimerWithFixedDelay(TickKey, Tick, FiniteDuration(2, TimeUnit.SECONDS))
    case Tick =>
      system.log.info("receive Tick")
      // process every state until all are complete
      var statesLeft = false
      
      states = states.sortWith{ (s1, s2) => s1.order > s2.order }

      for (state <- states) {
        if (!state.complete) {
          statesLeft = true
          if (state.waitForPing) {
            context.become(pingService(state))
          } else {
            context.become(state.behavior)
          }
        }
      }

      if (!statesLeft) context.become(pingService(null))
  }

Isso basicamente permite a Peertransição por uma lista de estados, executando o comportamento de cada estado até que ele esteja completo.

Um conjunto de estados pode se parecer com isto:

    case PENDING_OUT =>
        Seq(
          new InitState(0, peer),
          new SessionHandshake(1, peer),
          new WaitMessages(2, peer)
        )

Um exemplo de um dos estados:

class WaitAccept(order: Int, peer: Peer)(implicit system: ActorSystem) extends PeerState(order, false, true) {

  override def behavior: Receive = {
    case Tick =>
      system.log.info("Waiting for accept")
      if (complete) peer.getContext.unbecome()

    case rA@RegistrationAccept(serverID, serverIP, _) =>
      system.log.info(s"Processing RegistrationAccept: ${rA.toProtoString}")
      complete = true
  }
  
}

PeerStatesuperclasse:

abstract case class PeerState(var order: Int, var complete: Boolean, var waitForPing: Boolean) {

  def behavior: Receive // <- must be overridden
  
}

Esse estado faz com que o peer fique sentado esperando por uma mensagem 'RegistrationAccept', gerada quando o usuário clica em 'Aceitar' na página da web.

O problema:

Alguns dos estados (por exemplo, Handshakeo estado que é responsável por trocar chaves de criptografia) enviam httpmensagens para o serverque o Peeré gerado para. Se a instância que recebe a mensagem encontrar um Peercom o solicitado serverID, o PeerManagerencaminhará essa mensagem para o Peerusando askassim:

case peerRequest@PeerRequest(serverID, SessionRequest(sessionRequest), _) =>
      // get the relevant peer for the requested serverID
      val peerEntry = peerMap.get(serverID)
      if (peerEntry.isDefined) {
        // ask the peer Actor for a response to the sessionRequest, block and wait for this response, then send it back to the peerManager

        val peerState = queryPeerState(peerEntry.get)    // <-- the issue

        if (peerState.isInstanceOf[SessionHandshake]) {  // <-- the issue
          try {
            sender() ! Await.result((peerEntry.get ? (self, sessionRequest)).mapTo[PeerResponse.Response], timeout.duration)
          } catch {
            case e: TimeoutException =>
              sender() ! PeerResponse.Response.StatusResponse(HydraStatusCodes.PEER_MANAGER_TIMEOUT.getStatusResponse)
          }
        } else {
          sender() ! PeerResponse.Response.StatusResponse(HydraStatusCodes.PEER_NOT_READY.getStatusResponse)
        }
      } else {
        sender() ! PeerResponse.Response.StatusResponse(HydraStatusCodes.PEER_NOT_READY.getStatusResponse)
      }

O problema ocorre quando a outra instância Peernão está no estado correto para receber a mensagem. Se isso acontecer, eu gostaria de responder com o apropriado HydraStatusCode. A abordagem mais normal para mim é de alguma forma perguntar em Peerque estado ela está antes de encaminhar a mensagem e, se estiver no estado errado, retornar o StatusCode apropriado.

No entanto, para conseguir isso, eu teria que implementar QueryStatecase em todos os lugares em que tenho Receivecomportamento. Isso parece desajeitado e bagunçado e, como um engenheiro habilidoso, não sinto que seja a maneira certa de fazer isso.

Gostaria de implementar isso de alguma forma na PeerStateclasse como comportamento padrão que sempre é chamado para um QueryState, ou de alguma forma permitir que eles PeerManagerchamem uma referência ao Peerobjeto diretamente em vez de ao ActorRef (mas sei que isso não é possível)

Existe alguma outra abordagem para isso ou a maneira mais bagunçada é provavelmente a melhor?

Estou tentando criar uma tabela de auto-referência no MySql usando SqlAlchemy. Recebo o erro TypeError: Additional arguments should be named _, got 'ForeignKey'

Meu código é

from sqlalchemy import (
    create_engine,
    Column,
    Integer,
    String,
    DateTime,
    func,
    Text,
    DECIMAL,
    ForeignKey,
)

# from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, declarative_base, mapped_column, relationship

Base = declarative_base()
class Account(Base):
    __tablename__ = "account"

    id = mapped_column(Integer, primary_key=True)
    name = mapped_column(String(50))
    notes = mapped_column(Text())
    opening_balance = DECIMAL()
    current_balance = DECIMAL()
    parent_id = mapped_column(Integer, ForeignKey="account.id") #error here
    children = relationship("Account")
    created_at = mapped_column(DateTime, default=func.now())
    updated_at = mapped_column(DateTime, default=func.now(), onupdate=func.now())```

the error occurs at the line parent_id = ...
everywhere I look suggests that the code is correct (and I've looked in a lot of places). Co-Pilot told me to put () around "account.id" but PyCharm told me they were redundant. Either way got the error. Tried changing mapped_column to Column, same error.
Havent got a clue what to do!

Eu tenho um objeto com objeto aninhado. Estou tentando exibir em html usando a diretiva ngFor do Angular. Mas obtive o resultado como várias vezes. Abaixo do meu objeto

 productlists = [
    {
      productname: 'orange', price:
        [{ small: 20 }, { medium: 30 }, { large: 40 }], gst: 12
    },
    {
      productname: 'lemon', price:
        [{ small: 40 }, { medium: 80 }, { large: 102 }], gst: 20
    },
    {
      productname: 'apple', price:
        [{ small: 40 }, { medium: 80 }, { large: 102 }], gst: 20
    }

];

O código HTML é

<div style="margin-left: 20rem;">
<div *ngFor="let product of productlists" >

    <p style="color: blue;">Product Name {{product.productname}}</p>

    <div *ngFor="let productprice of product.price">
        Product Price
        <p>Small: {{productprice.small}}</p>
        <p>Medium: {{productprice.medium}}</p>
        <p>Large: {{productprice.large}}</p>
    </div>
    <p>Product GST {{product.gst}}</p>

</div>
</div>

O resultado que obtive foi

Por favor me ajude a exibir corretamente

Eu tenho este código:

#include<stdio.h>
#include<stdlib.h>

typedef struct{
    int data;
    struct node *next;
} NODE;

NODE *head = NULL;

void display_ll(NODE *head){
    if (head == NULL){
        printf("\nList is empty");
    } else{
        for(NODE *curr=head; curr!=NULL; curr=curr->next){
            printf("%d ->", curr->data);
        }
        printf("\b\b  ");
    }
}

int main(void){
    NODE *temp = (NODE *)malloc(sizeof(NODE));
    temp->data = 5;
    temp->next = NULL;
    head = temp;
    display_ll(head);
    return 0;
}

Na linha 15, onde faço curr=curr->nexto forloop, estou recebendo um aviso se compilado usando clang, e um erro se compilado usando gcc:

1. barulho:

   warning: incompatible pointer types assigning to 'NODE *' from 'struct node *' [-Wincompatible-pointer-types]
   

2. gcc:

   error: assignment to ‘NODE *’ from incompatible pointer type ‘struct node *’ [-Wincompatible-pointer-types]`
   

Eu imaginei uma solução alternativa onde escrevemos a estrutura como typedef struct node {...} NODE;e funciona. Mas eu quero saber se há alguma correção para isso sem essa redefinição de struct.

Estou com dificuldade em entender o Jasmine Spies para serviços com dependências injetadas no construtor

Tenho um serviço de conta com o Constructor

constructor(private readonly api: ApiService,private readonly authorityService: AuthorityService) {}

No serviço Conta, tenho um método que usa o authorityService (definido no construtor) para verificar uma permissão antes de retornar um valor

  public async getAccount(): Promise<Account | null> {
    if (this.authorityService.hasAuthority(Authority.PERM_ACCOUNT_READ)) {
      this.account = await this.api.get<Account>('/admin/rest/account');
      return this.account;
    }
    return null;
  }

O que estou tentando fazer é fornecer testes unitários para o método getAccount. O que eu quero é garantir que quando authorityService.hasAuthority(Authority.PERM_ACCOUNT_READ) retorne true ou false

No meu teste, configurei o seguinte no meu arquivo .spec.ts

stub do authService

class  authorityServiceStub{
  hasAuthority(str: string): boolean {
    return false;
  }
}

então no meu bloco describe eu tenho o seguinte

fdescribe('AccountService', () => {
  let service: AccountService;
  let httpTestingController:HttpTestingController
  let authorityServiceDependency:AuthorityService;

  /**
   * Sets up the testing module before each test case.
   */
   beforeEach(waitForAsync(() => {

    TestBed.configureTestingModule({
      imports: [],
      providers: [provideHttpClient(),
        provideHttpClientTesting(),
        AccountService,{
          provide: AuthorityService,
          useClass: authorityServiceStub
        }
        ],
    })

    service = TestBed.inject(AccountService);
    authorityServiceDependency = TestBed.inject(AuthorityService);
    httpTestingController = TestBed.inject(HttpTestingController);
  }));

no meu primeiro teste onde quero garantir se a permissão é falsa, meu objeto Account de getAccount() em nulo

  it('should return null if not permissions and not forced', async() => {
    spyOn(authorityServiceDependency, 'hasAuthority').withArgs(Authority.PERM_ACCOUNT_READ).and.returnValue(false);
    const account = await service.getAccount();
    expect(account).toBeNull();
    expect(authorityServiceDependency.hasAuthority).toHaveBeenCalledWith(Authority.PERM_ACCOUNT_READ);
    const req = httpTestingController.match((request) =>
      request.url.includes("/admin/rest/account")
    );
  });

Este teste passa

mas no outro caso onde eu quero testar quando a permissão está definida e validar se a conta não é nula eu tenho o seguinte

  it('should return the account if the permissions are set', async() => {
    const accountData = {firstName: 'Test',lastName:"tester"} as Account;
    spyOn(authorityServiceDependency, 'hasAuthority').withArgs(Authority.PERM_ACCOUNT_READ).and.returnValue(true);
    spyOn(service, 'getAccount').and.returnValue(Promise.resolve(accountData));
    service.getAccount().then((account) => {
       expect(account).not.toBeNull();
       expect(account?.firstName).toEqual("Test");
       expect(account?.lastName).toEqual("tester");
       expect(service.getAccount).toHaveBeenCalled();

     });
    expect(authorityServiceDependency.hasAuthority).toHaveBeenCalledWith(Authority.PERM_ACCOUNT_READ);
    const req = httpTestingController.match((request) =>
      request.url.includes("/admin/rest/account")
    );
  });

a expectativaexpect(authorityServiceDependency.hasAuthority).toHaveBeenCalledWith(Authority.PERM_ACCOUNT_READ);

está falhando com a mensagem

Esperava-se que o spy hasAuthority tivesse sido chamado com: [ 'PERM_ACCOUNT_READ' ], mas ele nunca foi chamado. em UserContext. (src/app/core/services/account/account.service.spec.ts:86:53) em Generator.next () em asyncGeneratorStep (node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js:3:1) em _next (node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js:17:1)

Eu sei que é algo que estou fazendo incorretamente, mas pela minha vida eu não consigo fazer isso funcionar como eu quero. Não está claro se configurar a classe simulada no meu teste é a abordagem correta... parece desajeitado, mas eu li essa abordagem em algum lugar na internet e parece fazer sentido, mas estou meio fora do meu elemento aqui e apreciaria qualquer insight/orientação

Eu tenho dados

col1
[{value -> Apple, key -> Fruit}, {value -> White, key -> Colour}]
[{value -> Mango, key -> Fruit}, {value -> Black, key -> Colour}]

e eu queria extrair um valor

value -> White
value -> Black

select col1, instr('key -> Colour' in col1), substr(col1, instr('key -> Colour')
from 
(SELECT '[{value -> Apple, key -> Fruit}, {value -> White, key -> Colour}]' as col1 from dual
union all
SELECT '[{value -> Mango, key -> Fruit}, {value -> Black, key -> Colour}]' as col1 from dual
) tbl;

Tentei usar posição e substring, mas não consegui. Qualquer sugestão seria apreciada.

Basicamente, preciso procurar uma chave de valor -> Cor e extrair o valor por substring reversa até { que me dará o valor valor -> Branco e valor -> Preto

No momento tenho o seguinte código:

#include <iterator>
#include <vector>
struct bar{};
struct details {};
struct foo {
    details det;
    std::vector<bar> data;
};

template <std::input_iterator Iter>
foo create_foo(const details& details, Iter begin, Iter end) {
    return foo {
        .det = details,
        .data = {begin, end}
    };
}

int main() {

    std::vector<bar> bars = {bar{},bar{},bar{}};
    create_foo({}, bars.begin(), bars.end());
    return 0;
}

Demonstração do Godbolt

foo::dataé um Container para bars. Seu construtor recebe dois Iteradores.

Quero restringir os iteradores de entrada para serem iteradores de contêineres contendo barapenas, por exemplo, um std::vector<bar>::iteratorou umstd::list<bar>::iterator

Como eu conseguiria isso com conceitos?

Tenho 5 gatilhos gcp cloudbuild. Quero adicionar um usuário que pode editar um gatilho específico.

Do IAM, adicionei o usuário e concedi a função de editor de build de nuvem e da condição do IAM, adicionei condições como visto em anexo. No entanto, o usuário ainda não pode editar o gatilho especificado. (ps sem condição, o usuário pode editar todos os gatilhos).

1. Tenho o nome do gatilho na projects/{PROJECT_ID}/locations/{LOCATION}/triggers/{TRIGGER_ID} sintaxe. Como meus gatilhos são globais, substituo {LOCATION} por global.

Tenho um botão simples com um drawable à esquerda:

<Button
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:id="@+id/color_primary"
   android:onClick="onClick"
   android:text="@string/primary"
   android:drawableLeft="@drawable/solid_color"
   android:drawablePadding="3dp"
   />

Para alterar a cor do desenho eu uso este código:

public void setColorOnButton( int id, int color){
    Button btn = findViewById( id );
    for( Drawable drawable : btn.getCompoundDrawables()) {
        if( drawable != null){
            drawable.setColorFilter(new PorterDuffColorFilter( 0xff000000|color, PorterDuff.Mode.SRC_IN));
        }
    }
}

Funciona bem.

Mas agora eu quero oferecer suporte a idiomas "da direita para a esquerda" e uso este atributo: android:drawableStarte setColorOnButtonnão funciona: btn.getCompoundDrawables()retorna nulos.

O que está errado?

Estou tentando depurar um aplicativo que não consegue rodar e suspeito que o problema seja a versão do node. Ele roda bem localmente e o código mínimo reproduzível depois é muito pequeno.

A documentação diz:

az webapp config appsettings list --name <app-name> --resource-group <resource-group-name> --query "[?name=='WEBSITE_NODE_DEFAULT_VERSION'].value"

No entanto, isso mostrará o valor da variável de ambiente que eu mesmo configurei, não a versão real que foi escolhida para o aplicativo da web. Por exemplo, se eu escrever "23.7.0", o comando imprimirá, mas o aplicativo da web nunca será executado com essa versão, pois parece que o Azure ainda não oferece suporte a ela (verificado executando az webapp list-runtimes)