All perguntas(coding)

Encontro alguns problemas ao tentar escrever um teste.

Tenho um componente que inclui apenas um SignalStore

import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
import { FormulaireStore } from './store/formulaire-store';

@Component({
  selector: 'app-formulaire',
  imports: [],
  providers: [FormulaireStore],
  template: `
    <p>formulaire works!</p>
    @if(store.context(); as ctx) {
    <p>context : {{ ctx.informations }}</p>
    }
  `,
  styleUrl: './formulaire.component.scss',
  changeDetection: ChangeDetectionStrategy.OnPush,
})
export class FormulaireComponent {
  readonly store = inject(FormulaireStore);
}

import { inject } from '@angular/core';
import {
  patchState,
  signalStore,
  withHooks,
  withMethods,
  withProps,
  withState,
} from '@ngrx/signals';
import { rxMethod } from '@ngrx/signals/rxjs-interop';
import { pipe, switchMap, tap } from 'rxjs';
import { FormsService } from '../../services/form.service';

export interface FormulaireContexte {
  informations: string;
}

type FormulaireState = {
  context: Partial<FormulaireContexte> | undefined;
};

const initialState: FormulaireState = {
  context: undefined,
};

export const FormulaireStore = signalStore(
  withState<FormulaireState>(initialState),
  withProps(() => ({
    _formService: inject(FormsService),
  })),
  withMethods((store) => {
    return {
      _getContext: rxMethod<void>(
        pipe(
          switchMap(() => {
            return store._formService.getContext();
          }),
          tap((context) => {
            patchState(store, {
              context,
            });
          })
        )
      ),
    };
  }),
  withHooks(({ _getContext }) => {
    return {
      onInit() {
        _getContext();
      },
    };
  })
);

e o serviço usado pelo SignalStore

import { HttpClient } from '@angular/common/http';
import { inject, Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { FormulaireContexte } from '../formulaire/store/formulaire-store';

@Injectable({ providedIn: 'root' })
export class FormsService {
  readonly #client = inject(HttpClient);

  getContext(): Observable<FormulaireContexte> {
    return this.#client.get<FormulaireContexte>(`/api/forms/context`);
  }
}

Portanto, estou tentando escrever um teste para interagir com a IU

import { TestBed } from '@angular/core/testing';
import { provideHttpClient } from '@angular/common/http';
import { FormulaireComponent } from './formulaire.component';
import { provideRouter } from '@angular/router';

import {
  HttpTestingController,
  provideHttpClientTesting,
} from '@angular/common/http/testing';
import { RouterTestingHarness } from '@angular/router/testing';

describe('FormulaireComponent', () => {
  const setup = async () => {
    TestBed.configureTestingModule({
      providers: [
        provideRouter([
          {
            path: 'formulaire',
            pathMatch: 'full',
            component: FormulaireComponent,
          },
        ]),
        provideHttpClient(),
        provideHttpClientTesting(),
      ],
    });

    const httpCtrl = TestBed.inject(HttpTestingController);

    const harness = await RouterTestingHarness.create('formulaire');
    harness.fixture.autoDetectChanges(true);

    httpCtrl
      .match((req) => Boolean(req.url.match(`/api/forms/context`)))[0]
      .flush({ informations: 'mocked informations' });
    httpCtrl.verify();

    return harness;
  };

  it('should create', async () => {
    const harness = await setup();

    //! This line is needed to see changes
    harness.detectChanges();

    debugger;

    expect(1).toBe(1);
  });
});

mas parece que preciso dessa linha específica

    //! This line is needed to see changes
    harness.detectChanges();

para entrar na condição @if do modelo.

o comportamento estranho é que se não chamar httpClient no serviço

  getContext(): Observable<FormulaireContexte> {
    //return this.#client.get<FormulaireContexte>(`/api/forms/context`);
    return of({ informations: 'informations from of operator' });
  }

Ele funciona sem a necessidade de

harness.detectChanges();

Não entendi o comportamento aqui, preciso de alguns conselhos para entendê-lo

Como posso adicionar um controle de bússola ao meu mapa? Costumava haver uma função chamada addControlCompassem leaflet.extras, eu acredito, mas não existe mais. Alguém sabe como adicionar uma bússola ou uma seta indicando north up?

library(leaflet)
library(leaflet.extras)

# Create a basic Leaflet map
map <- leaflet() %>%
  addTiles() %>%
  setView(lng = -121.2722, lat = 38.1341, zoom = 10)  

# Add a scale bar and compass to the map
map <- map %>%
  addScaleBar(position = "bottomleft", options = scaleBarOptions(maxWidth = 100, metric = TRUE, imperial = FALSE)) %>%
  addControlCompass(position = "topright", options = compassOptions())
  map

Estou realmente impressionado com a elegância e facilidade com que serdeconsigo serde_jsonanalisar mensagens:

{"msg_type": "asauce", "aaa": 3, "bbb": 14}
{"msg_type": "csyrup", "ccc": 10, "ddd": 20}

// this works!
#[derive(serde::Deserialize, PartialEq, Debug)]
struct AppleSauce {
    aaa: u8,
    bbb: u8,
}

#[derive(serde::Deserialize, PartialEq, Debug)]
struct ChocolateSyrup {
    ccc: u8,
    ddd: u8,
}

#[derive(serde::Deserialize, PartialEq, Debug)]
#[serde(tag = "msg_type")]
enum Sauce {
    #[serde(rename = "asauce")]
    AppleSauce(AppleSauce),
    #[serde(rename = "csyrup")]
    ChocolateSyrup(ChocolateSyrup),
}

#[test]
fn deserialise_inner_applesauce() {
    let json = r#"{"msg_type": "asauce", "aaa": 3, "bbb": 14}"#;
    let expected = AppleSauce { aaa: 3, bbb: 14 };
    let sauce: Sauce = serde_json::from_str(json).unwrap();
    assert_eq!(sauce, Sauce::AppleSauce(expected));
}

Entretanto, minhas mensagens têm uma chave pai, da qual gostaria de me livrar:

{"boilerplate": {"msg_type": "asauce", "aaa": 3, "bbb": 14}}
{"boilerplate": {"msg_type": "csyrup", "ccc": 10, "ddd": 20}}

No momento implementei um from_strmétodo:

impl Sauce {
    pub fn from_str(msg: &str) -> Option<Sauce> {
        let outer: serde_json::Value = serde_json::from_str(msg).ok()?;
        let inner = &outer["boilerplate"];
        serde_json::from_value(inner.clone()).ok()
    }
}

#[test]
fn deserialise_boilerplate_applesauce_with_helper_method() {
    let json = r#"{"boilerplate": {"msg_type": "asauce", "aaa": 3, "bbb": 14}}"#;
    let expected = AppleSauce { aaa: 3, bbb: 14 };
    let sauce = Sauce::from_str(json).unwrap(); // not serde_json::from_str :(
    assert_eq!(sauce, Sauce::AppleSauce(expected));
}

Existe uma maneira de eliminar a chave pai com um atributo serde e eliminar o from_strmétodo personalizado?

Só preciso desserializar essas mensagens (mas pelo que vejo no serde, ele provavelmente seria serializado também de graça).

Tenho um processo que precisa mover intermitentemente alguns arquivos de um diretório para outro. Antes de mover os arquivos, preciso garantir que um usuário não esteja adicionando arquivos ao diretório no momento - se estiver, quero esperar até que nenhum arquivo novo tenha sido adicionado ao diretório por N segundos antes de continuar o processo (o valor de N realmente não importa aqui).

Minha ideia original era usar um FileSystemWatcherpara capturar eventos de criação de arquivo, usar o .Throttle()método de Rx para obter o último evento gerado dentro do período de tempo especificado e usar o resultado disso para desabilitar um loop de atraso infinito. O problema é que esse método apenas esperará para sempre se um usuário nunca fizer nenhuma alteração no diretório. De alguma forma, preciso que isso espere pelo menos N segundos e, se não houver nenhuma alteração dentro desse período de tempo, continue. Se houver uma alteração dentro desse período de tempo, espere até que N segundos tenham se passado desde a última alteração.

Aqui está o que tenho até agora:

Console.WriteLine("start");

// wait to ensure no changes are being made to the directory
await Task.Run(async () =>
{
    var watcher = new FileSystemWatcher("D:\\Users\\mwcjk1\\source\\repos\\RandomTestAppNet8\\RandomTestAppNet8\\");
    watcher.EnableRaisingEvents = true;

    watcher.Created += (o, a) => { Console.WriteLine("file changed!"); };

    var subject = Observable.FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(
        ev => watcher.Created += ev,
        ev => watcher.Created -= ev
        );

    bool done = false;

    // wait for 7 seconds after the last file creation
    var disposable = subject.Throttle(TimeSpan.FromSeconds(7)).Subscribe(events => { done = true; });

    Console.WriteLine("Set up observer");

    while (!done)
    {
        await Task.Delay(1000);
        //Console.WriteLine("Waited 1 sec");
    }

    disposable.Dispose();
});

// Continue with the rest of the method execution
Console.WriteLine("done!");

Eu também não gosto do Task.Delay()loop - parece que deveria haver uma maneira muito mais elegante de fazer isso ( .Throttle()parece tão perto de funcionar sozinho!), mas não consegui descobrir.

Qualquer conselho é muito apreciado, obrigado!

Estou trabalhando em um elemento de UI que contém uma série de caixas de valor. Quando uma dessas caixas de valor é clicada, ela mostra conteúdo oculto. Além disso, quando uma caixa de valor é clicada, a outra caixa de valor selecionada anteriormente volta ao seu estado inicial. Como visto aqui:

Eu fiz uma implementação funcional disso. No entanto , é um pouco bagunçado e estou preocupado que se tornará difícil de gerenciar se eu tiver vários elementos de UI como esses dentro de um aplicativo grande.

Minha implementação:

library(shiny)
library(bslib)
library(shinyjs)


# Module UI
cont_box_ui <- function(id) {
  ns <- NS(id)
  # Value box wrapped in a div for JavaScript tracking
  div(id = ns("expand_box"),
      value_box(
        title = "Click me",
        value = "10",
        theme = value_box_theme(bg = "white"),
        # Hidden UI content
        hidden(div(id = ns("expanded_content"),
                   tags$p("This is additional information."),
                   actionButton("btn", "Click me")
        ))
      )
  )
}



cont_box_server <- function(id) {
  moduleServer(id, function(input, output, session) {
      # Add on.click function which 
      runjs(sprintf("
      document.getElementById('%s-expand_box').addEventListener('click', function() {
        Shiny.setInputValue('last_clicked', %s);

      });
    ", id, id))
  })
  
  
}

ui <- page_sidebar(
  sidebar = sidebar(
    useShinyjs(), 
    # Add value box UIs
    cont_box_ui(1),
    cont_box_ui(2),
    cont_box_ui(3)
  ),
  mainPanel()
)

server <- function(input, output, session) {
  # Add value box servers
  cont_box_server(1)
  cont_box_server(2)
  cont_box_server(3)

  # Observe for when a value box is clicked
  observeEvent(input$last_clicked, {
    # Store ids of all show/hide panels
    panels <- c("1-expanded_content", "2-expanded_content", "3-expanded_content")
    
    # Store ids of panels which should be collapsed (even though it's just one)
    collapse <- panels[panels != sprintf("%s-expanded_content", input$last_clicked)]
    
    # Store id of panel to expand
    expand <- sprintf("%s-expanded_content", input$last_clicked)

    # Hide all panels except the one which was clicked
    for(this_panel in collapse){
      shinyjs::hide(this_panel)
    }
    
    # Show hidden content of clicked panel
    shinyjs::show(expand)
  })
  
}

shinyApp(ui, server)

• Não gosto que, na minha implementação, eu itero sobre cada caixa de valor diferente daquela que foi clicada para ocultá-las, embora eu só precise ocultar a caixa de valor clicada anteriormente. Pode haver uma maneira de evitar isso?

• Gostaria de conter todo o código necessário para essa funcionalidade de mostrar/ocultar dentro do servidor/UI do módulo, sem a necessidade de um observeEvent()dentro do servidor principal para mostrar/ocultar elementos. Isso é possível?

Meu único objetivo aqui é simplificar essa implementação para reduzir a carga mental quando ela for usada em um grande aplicativo Shiny.

Tenho 2 tabelas:

comments_table

`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`media_id` int(11) unsigned DEFAULT NULL,
`user_id` int(11) unsigned DEFAULT NULL,//user who commented
`title` varchar(300) DEFAULT NULL,
`url` varchar(300) DEFAULT NULL,
`c_date` datetime,
`comment` longtext DEFAULT NULL,
PRIMARY KEY (`id`),
INDEX `media_id` (`media_id`)

id         comment    user_id
1         foo             1
2         bla             2  
3         something       7 

votes_table

`comment_id` int(11) unsigned DEFAULT NULL,
`user_id` int(11) unsigned DEFAULT NULL,//user who voted
`vote` tinyint(1) DEFAULT 0,
INDEX `comment_id` (`comment_id`)

comment_id user_id vote
1         2       1
2         4       -1  
3         7       0
3         1       1
2         1       1 

Tenho 2 dúvidas (obter todos os comentários):

$comments = $wpdb->get_results($wpdb->prepare("SELECT ct.id, ct.comment, ct.user_id, ct.user_display_name, ct.avatar, ct.c_date, SUM(DISTINCT vt.vote) AS vote
                    FROM $comments_table as ct 
                    LEFT JOIN $votes_table vt on ct.id = vt.comment_id 
                    WHERE ct.media_id=%d 
                    GROUP BY ct.id
                    ORDER BY ct.c_date DESC", $media_id), ARRAY_A);

Obter comentários onde o usuário votou:

$user_votes = $wpdb->get_results($wpdb->prepare("SELECT vote, comment_id
                    FROM $votes_table
                    WHERE user_id=%d", $user_id), ARRAY_A);

Isso funciona como esperado. Há como fazer isso em uma consulta? (por motivos de desempenho)

Por exemplo, adicione aos resultados user_vote = votes_table.vote a comment_table.id votes_table.user_id votado.

O código (partes irrelevantes removidas)

void mpz_choose_ui(mpz_t rop,ul a,ul b){
    mpz_clear(rop);
    mpz_init(rop);
}

causa um segfault mesmo que o mpz_t rop seja limpo antes do init, o gdb mostra

0x00007ffff7da2c95 in __GI___libc_free (mem=0xffffffffffffffff) at malloc.c:3453
3453      if (chunk_is_mmapped (p))                       /* release mmapped memory. */

Parece que algo foi mapeado mesmo que mpz_clear tenha sido executado antes.

o exemplo mínimo reproduzível é

void mpz_example(mpz_t rop){
    mpz_clear(rop);
    mpz_init(rop);
}
void example(){
    mpq_t tmp;
    mpz_t tmp2;
    mpz_t tmp3;
    mpz_example(tmp3);
}
int main(void)
{
    mpq_t rop;

    mpq_init(rop);
    example();
    return 0;
}

isso cheira a uso depois de free ou algo assim, mas tudo é limpo e então inicializado

sim, elas precisam ser 3 funções separadas por algum motivo

tmp e tmp2 também precisam estar lá por algum motivo

Tenho um programa onde um usuário pode escrever (anexar) em um arquivo de texto escolhido para armazenar informações. Cada linha deve ter dois números e uma sequência de data (AAAA-MM-DD). Existem vários arquivos de texto diferentes nos quais o programa pode escrever, digamos "foo.txt", "bar.txt", "stroustrup.txt", e o conteúdo do arquivo pode ser parecido com este:

-18 30  2025-02-12
0   0   2025-02-01
-23 36  2025-02-27

Agora eu gostaria de adicionar uma espécie de função "desfazer", que exclui a última linha de um arquivo de texto escolhido, caso o usuário insira algo errado, por exemplo undo(const string& filename).

Eu sei que uma possibilidade é usar getline(file,string) continuamente, até chegar ao fim do arquivo, e escrever tudo, exceto a última entrada, em um novo arquivo, criando assim uma cópia com a linha final omitida. No entanto, sinto que deveria haver uma maneira melhor de fazer isso. Como 1. Eu teria que criar um novo arquivo, com um novo nome, para cada chamada do meu undo. E reescrever um arquivo inteiro apenas para me livrar de uma linha - uma que está sempre no final - parece um desperdício.

Usar funções seek() também é inapropriado, já que o objetivo é excluir entradas errôneas. Não posso pesquisar razoavelmente por uma string específica (já que o usuário pode inserir qualquer string boba no arquivo .txt antes de tentar desfazer).

Existe uma maneira organizada de fazer isso, ou seja, substituir a linha final por um espaço vazio ou "\n", sem precisar copiar e reescrever todo o outro conteúdo?

Eu uso go_router em combinação com flutter navigation api. Aqui estão minhas rotas:

• rota de casa
• objetos-rota
• objeto-rota

De casa, eu chamaria Navigator.push() para chegar aos objetos e context.push() para chegar ao objeto.

Eu não tenho rotas filhas ainda, eu sei. Não é o ponto aqui, eu acho. Eu recebo uma notificação push que deve navegar para object-route. Funciona bem, mas se object-route já estiver aberto, ele o abre novamente. Então, quando eu clico em voltar, eu volto para object-route.

Devo verificar o caminho no redirecionamento para evitar tela duplicada ou estou usando go_router errado?

Estou usando context.push() quando a notificação é tocada.

Figuras referenciadas abaixo Sou novo em R e RStudio, e acabei usando o pacote tableHTML porque parece uma boa opção para formatar meu dataframe. Tenho um dataframe (tibia_outliers_shortable) listando apenas os valores outliers baixos e altos para cada uma das várias variáveis ​​em muitos assuntos, recortados aqui para uma variável em 9 assuntos. Quero alterar a cor de fundo das células com valores abaixo do "corte outlier baixo" para azul claro, e a cor de fundo das células com valores acima do "corte outlier alto" para vermelho.

Quando uso add_css_conditional_column() para alterar o fundo de células com valores altos, ele perde a célula com os valores mais altos - veja a Figura 1.

Se eu então executar o mesmo comando tableHTML() mas adicionar outra chamada para add_css_conditional_column() para destacar células com valores baixos, ele formata as células vazias (talvez as trate como zeros?) e também formata a célula de maior valor! Veja a Fig. 2.

patients <- c('PatNo 869','PatNo 885','PatNo 888','PatNo 1005','PatNo 1007','PatNo 1016','PatNo 1028','PatNo 1043','PatNo 1044')
vals = rbind("",427.3,978.3,"",423.2,967.4,"",1042.9,"")
tibia_outliers_shorter <- data.frame(vals,row.names = patients)
colnames(tibia_outliers_shorter) <- 'TotalArea'
lowhigh <- cbind(467.7,904.6) # These are the values determining which values are low vs. high outliers

# First attempt: Change background color of cells with high values to red
library(tableHTML)
tableHTML(tibia_outliers_shorter, caption = 'Outlier summary') %>%
  add_css_caption(css = list(c('color','font-size'),c('darkblue','12px'))) %>%
  add_css_conditional_column(conditional = ">", value = lowhigh[2], css = list('background-color','red'), columns = c("TotalArea")) %>%
  tableHTML_to_image()

# Second attempt: Add this argument to same tableHTML command, for cell with low values
  add_css_conditional_column(conditional = "<", value = lowhigh[1], css = list('background-color','lightblue'), columns = c("TotalArea")) %>%