All perguntas(coding)

Olá, colegas entusiastas do Excel. Estou tentando referenciar as informações do meu banco de dados e retornar a soma total de dólares do Col M. Os critérios são Entre intervalo de datas, número do cliente e PO# começa com KB... é isso que tenho até agora, mas não está retornando um total

=SUMIFS(Data!K:K,Data!G:G,">="&DATE(2025,3,1),Data!G:G,"<="&DATE(2025,3,31),Data!C:C,"301000",Data!E:E,LEFT("KB",2))

Eu tenho 2 widgets

1 com um assertem seu buildmétodo:

class MyWidget1 extends StatelessWidget {
  const MyWidget1({super.key});

  @override
  Widget build(BuildContext context) {
    assert(false);
    return const Placeholder();
  }
}

1 com um assertretorno de chamada de um botão:

class MyWidget2 extends StatelessWidget {
  const MyWidget2({super.key});

  @override
  Widget build(BuildContext context) {
    return TextButton(
      onPressed: () {
        assert(false);
      },
      child: const Text('button'),
    );
  }
}

Quero um teste que verifique o que asserté lançado. A partir desta questão , tentei:

void main() {
  testWidgets('It should throw an assert error during the build',
      (WidgetTester tester) async {
    await expectLater(
      () => tester.pumpWidget(const MaterialApp(home: MyWidget1())),
      throwsA(isA<AssertionError>()),
    );
  });

  testWidgets('It should throw an assert error on tap',
      (WidgetTester tester) async {
    await tester.pumpWidget(const MaterialApp(
      home: Scaffold(
        body: MyWidget2(),
      ),
    ));
    await expectLater(
      () async {
        await tester.tap(find.byType(TextButton));
        await tester.pumpAndSettle();
      },
      throwsAssertionError,
    );
  });
}

Mas os erros não são detectados pelas expectativas.

Como testar?

Tenho várias pastas de trabalho que utilizam as mesmas macros VBA. As macros são iniciadas a partir de botões nas planilhas e, em seguida, de outras macros dentro do módulo. Se eu fizer uma revisão em uma macro, devo fazê-la em cada pasta de trabalho, tomando cuidado para manter os módulos da pasta de trabalho idênticos. Geralmente faço isso alterando o módulo em uma pasta de trabalho e, em seguida, copio/colo o módulo inteiro nas outras pastas de trabalho. Existe uma maneira de automatizar esse processo?

Ou existe uma abordagem melhor?

Tentei utilizar uma apostila comum para o Módulo, mas não obtive muito sucesso.

Qualquer conselho é bem-vindo. Obrigado

No meu antigo aplicativo Java, eu tinha um menu suspenso na barra de ação que apresentava uma opção de ajuste do tamanho da fonte e do tipo de fonte. Isso usava o PreferenceFragment, que foi descontinuado há muito tempo. Estou procurando um substituto no Kotlin. Tudo o que posso encontrar nos documentos são preferências, que é um subconjunto do banco de dados Room. Quero fornecer um xml de variáveis ​​e usar um gerenciador de preferências para lembrar a escolha. A jornada é: o usuário clica em actionBar para obter um menu suspenso com dois itens, tamanho da fonte e nome da fonte

<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
    <ListPreference
        android:entries="@array/font_size"
        android:entryValues="@array/fvalues"
        android:key="fong"
        android:summary="Click here to choose a font size"
        android:title="Select Font Size" />
    <ListPreference
        android:entries="@array/font_name"
        android:entryValues="@array/font_ttf"
        android:key="fonz"
        android:summary="Click here to change font"
        android:title="Select Font" />
</PreferenceScreen>

Dependendo da sua seleção, você terá uma escolha de recursos

<resources>
    <string-array name="font_size">
        <item>Huge</item>
        <item>Large</item>
        <item>Normal</item>
        <item>Small</item>
        <item>Tiny</item>
    </string-array>

    <string-array name="fvalues">
        <item>28</item>
        <item>24</item>
        <item>20</item>
        <item>16</item>
        <item>12</item>
    </string-array>


    <string-array name="font_name">
        <item>Note</item>
        <item>Flower</item>
    </string-array>

    <string-array name="font_ttf">
        <item>Note_this.ttf</item>
        <item>IndieFlower.ttf</item>
    </string-array>

</resources

Quando o usuário seleciona um nome e tamanho de fonte, eles são usados ​​em todo o aplicativo.

Este é o código actionBar

   public boolean onOptionsItemSelected(MenuItem item) {        
        int itemId = item.getItemId();

        if (itemId == R.id.action_settings) {
            Intent p = new Intent("app.sticky_notes.PREFS");
            startActivity(p);
        }
        return false;
    }

Que chama essa classe, que apresentou ao usuário um segundo menu. Então, ele salva as preferências escolhidas.

public class Prefs extends PreferenceActivity
{
    @Override public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        getFragmentManager().beginTransaction().replace(android.R.id.content, new Pref_frag()).commit();
    }

    public static class Pref_frag extends PreferenceFragment
    {
        @Override public void onCreate(Bundle savedInstanceState)
        {
            super.onCreate(savedInstanceState);

            addPreferencesFromResource(R.xml.prefs);
        }
    }
}

Em seguida, chamo o gerenciador de preferências para obter as opções armazenadas

    public int get_font_size() {
        SharedPreferences get_prefs = PreferenceManager.getDefaultSharedPreferences(this);
        String font_string = get_prefs.getString("fong", "24");

        font_size = Integer.parseInt(font_string);

        return font_size;
    }

    public String get_font_name() {
        SharedPreferences get_prefs = PreferenceManager.getDefaultSharedPreferences(this);
        font_name = get_prefs.getString("fonz", "Note_this.ttf");

        return font_name;
    }

Em kotlin, até onde eu sei, nada disso é possível. Todas as sharedPreferences apontam de volta para preferences, que é uma versão do banco de dados Room que é usado para armazenar a entrada do usuário. Eu quero o menu suspenso->configurações->menu de valores de configurações para que o usuário possa clicar em um botão de opção.

Não quero nenhuma entrada do usuário além da escolha do tamanho e tipo da fonte.

Devo estar esquecendo de alguma coisa. Alguém pode me indicar um exemplo prático?

Criei um Artifacts Feed com escopo organizacional no Azure DevOps e publiquei vários pacotes npm nele. Como usuário/administrador do projeto, posso ver tudo: o repositório, os artefatos, etc., então tudo está funcionando aqui.

Agora, acabei de adicionar um novo usuário à organização no DevOps. Este usuário não tem nenhuma permissão para ver projetos, mas quero permitir acesso ao feed de escopo organizacional no qual configurei permissões de Leitura para este usuário.

O problema é: quando esse usuário efetua login no DevOps, não há nenhum menu de artefatos visível...

Tenho pesquisado em muitos wikis e fóruns, mas não consegui encontrar uma resposta. Espero que alguém possa me apontar a direção certa aqui...

Código Ts do controlador do gadget:

import { Request, Response, NextFunction } from 'express';
import { Status } from '@prisma/client'
import prisma from '../utils/prisma.client';
import { AppError } from '../utils/error.handler';

// Generate random codename for gadgets
const generateCodename = (): string => {
  const adjectives = ['Mighty', 'Silent', 'Phantom', 'Shadow', 'Stealth', 'Covert', 'Invisible', 'Deadly', 'Rapid', 'Quantum'];
  const nouns = ['Eagle', 'Panther', 'Cobra', 'Viper', 'Falcon', 'Wolf', 'Hawk', 'Tiger', 'Raven', 'Phoenix'];
  
  const randomAdjective = adjectives[Math.floor(Math.random() * adjectives.length)];
  const randomNoun = nouns[Math.floor(Math.random() * nouns.length)];
  
  return `The ${randomAdjective} ${randomNoun}`;
};

// Generate random mission success probability
const generateMissionProbability = (): number => {
  return Math.floor(Math.random() * 100);
};

// Get all gadgets with optional status filter
export const getAllGadgets = async (req: Request, res: Response, next: NextFunction) => {
  try {
    const { status } = req.query;
    
    const whereClause = status ? { status: status as Status } : {};
    
    const gadgets = await prisma.gadget.findMany({
      where: whereClause
    });
    
    const gadgetsWithProbability = gadgets.map(gadget => ({
      ...gadget,
      missionSuccessProbability: generateMissionProbability()
    }));
    
    res.status(200).json({
      status: 'success',
      results: gadgetsWithProbability.length,
      data: {
        gadgets: gadgetsWithProbability
      }
    });
  } catch (error) {
    next(error);
  }
};

// Create a new gadget
export const createGadget = async (req: Request, res: Response, next: NextFunction) => {
  try {
    const { status } = req.body;
    
    const gadget = await prisma.gadget.create({
      data: {
        name: generateCodename(),
        status: status || 'Available'
      }
    });
    
    res.status(201).json({
      status: 'success',
      data: {
        gadget
      }
    });
  } catch (error) {
    next(error);
  }
};

// Update a gadget
export const updateGadget = async (req: Request, res: Response, next: NextFunction) => {
  try {
    const { id } = req.params;
    const { name, status } = req.body;
    
    const gadget = await prisma.gadget.findUnique({
      where: { id }
    });
    
    if (!gadget) {
      return next(new AppError('No gadget found with that ID', 404));
    }
    
    const updatedGadget = await prisma.gadget.update({
      where: { id },
      data: {
        name,
        status
      }
    });
    
    res.status(200).json({
      status: 'success',
      data: {
        gadget: updatedGadget
      }
    });
  } catch (error) {
    next(error);
  }
};

// Decommission a gadget (soft delete)
export const decommissionGadget = async (req: Request, res: Response, next: NextFunction) => {
  try {
    const { id } = req.params;
    
    const gadget = await prisma.gadget.findUnique({
      where: { id }
    });
    
    if (!gadget) {
      return next(new AppError('No gadget found with that ID', 404));
    }
    
    const decommissionedGadget = await prisma.gadget.update({
      where: { id },
      data: {
        status: 'Decommissioned',
        decomissionedAt: new Date()
      }
    });
    
    res.status(200).json({
      status: 'success',
      data: {
        gadget: decommissionedGadget
      }
    });
  } catch (error) {
    next(error);
  }
};

// Trigger self-destruct sequence for a gadget
export const selfDestructGadget = async (req: Request, res: Response, next: NextFunction) => {
  try {
    const { id } = req.params;
    
    const gadget = await prisma.gadget.findUnique({
      where: { id }
    });
    
    if (!gadget) {
      return next(new AppError('No gadget found with that ID', 404));
    }
    
    // Generate confirmation code
    const confirmationCode = Math.floor(100000 + Math.random() * 900000);
    
    const updatedGadget = await prisma.gadget.update({
      where: { id },
      data: {
        status: 'Destroyed',
        selfDestruct: new Date()
      }
    });
    
    res.status(200).json({
      status: 'success',
      confirmationCode,
      message: 'Self-destruct sequence initiated',
      data: {
        gadget: updatedGadget
      }
    });
  } catch (error) {
    next(error);
  }
};

The Gadgets Routes : 
router.get('/', getAllGadgets);
router.post('/', createGadget);
router.patch('/:id', updateGadget);
router.delete('/:id', decommissionGadget);
router.post('/:id/self-destruct', selfDestructGadget);

Mesmo que eu não tenha nenhum erro no roteamento, ainda estou recebendo o erro:
throw new TypeError( Missing parameter name at ${i}: ${DEBUG_URL}); ^ TypeError: Nome do parâmetro ausente em 1: https://git.new/pathToRegexpError

Provavelmente tentei de tudo, GPT, V0, StackOverFlow, mas as soluções não funcionaram.

Aqui está o package.json:

{
  "name": "pg_imp",
  "version": "1.0.0",
  "main": "dist/index.js",
  "scripts": {
    "start": "node dist/index.js",
    "dev": "ts-node-dev --respawn --transpile-only src/index.ts",
    "build": "tsc",
    "prisma:generate": "prisma generate",
    "prisma:migrate": "prisma migrate dev --name init"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "devDependencies": {
    "@types/bcrypt": "^5.0.2",
    "@types/cors": "^2.8.17",
    "@types/express": "^5.0.1",
    "@types/jsonwebtoken": "^9.0.9",
    "@types/uuid": "^10.0.0",
    "prisma": "^6.5.0",
    "ts-node-dev": "^2.0.0",
    "typescript": "^5.8.2"
  },
  "dependencies": {
    "@prisma/client": "^6.5.0",
    "bcrypt": "^5.1.1",
    "cors": "^2.8.5",
    "dotenv": "^16.4.7",
    "express": "^5.1.0",
    "express-validator": "^7.2.1",
    "helmet": "^8.1.0",
    "jsonwebtoken": "^9.0.2",
    "pg": "^8.14.1",
    "uuid": "^11.1.0"
  }
}

Alguém pode me dizer como consertar o bug! Não consigo consertar isso há 48 horas (problema de habilidade)

Tentei fazer o downgrade da versão Express para 4 porque alguns disseram que o Express vr:5 estava causando o erro, mas isso não ajudou.

Verifiquei todas as rotas e endpoints da API, mas isso também não ajudou.

Rotas de gadgets:

// src/routes/gadget.routes.ts
import { Router } from 'express';
import { 
  getAllGadgets, 
  createGadget, 
  updateGadget, 
  decommissionGadget, 
  selfDestructGadget 
} from '../controllers/gadget.controller';
import { protect } from '../middleware/auth.middleware';

const router = Router();

// Apply authentication middleware to all routes
router.use(protect);

// Routes
router.get('/', getAllGadgets);
router.post('/', createGadget);
router.patch('/:id', updateGadget);
router.delete('/:id', decommissionGadget);
router.post('/:id/self-destruct', selfDestructGadget);

export default router;

aplicativo.ts:

import express, { Request, Response, NextFunction } from 'express';
import cors from 'cors';
import helmet from 'helmet';
import authRoutes from './routes/auth.routes';
import gadgetRoutes from './routes/gadget.routes';
import { AppError, handleError } from './utils/error.handler';

const app = express();

// Middleware
app.use(helmet());
app.use(cors());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Routes
app.use('/api/auth', authRoutes);
app.use('/api/gadgets', gadgetRoutes);

// Health check route
app.get('/health', (req, res) => {
  res.status(200).json({ status: 'success', message: 'API is running' });
});

// Handle undefined routes
app.all('*', (req, res, next) => {
  next(new AppError(`Can't find ${req.originalUrl} on this server!`, 404));
});

// Global error handler
app.use((err: any, req: Request, res: Response, next: NextFunction) => {
  handleError(err, res);
});

export default app;

auth_routes.ts :

import { Router } from 'express';
import { body } from 'express-validator';
import { register, login } from '../controllers/auth.controller';
import { validate } from '../middleware/validate.middleware';

const router = Router();

// Validation rules
const registerValidation = [
  body('username')
    .notEmpty().withMessage('Username is required')
    .isLength({ min: 3 }).withMessage('Username must be at least 3 characters long'),
  body('password')
    .notEmpty().withMessage('Password is required')
    .isLength({ min: 6 }).withMessage('Password must be at least 6 characters long')
];

const loginValidation = [
  body('username').notEmpty().withMessage('Username is required'),
  body('password').notEmpty().withMessage('Password is required')
];

// Routes
router.post('/register', validate(registerValidation), register);
router.post('/login', validate(loginValidation), login);

export default router;

Auth_Middlewaree.ts:

import { Request, Response, NextFunction } from 'express';
import jwt from 'jsonwebtoken';
import { AppError } from '../utils/error.handler';
import prisma from '../utils/prisma.client';

interface JwtPayload {
  id: string;
}

declare global {
  namespace Express {
    interface Request {
      user?: {
        id: string;
      };
    }
  }
}

export const protect = async (req: Request, res: Response, next: NextFunction) => {
  try {
    // 1) Get token and check if it exists
    let token;
    if (req.headers.authorization && req.headers.authorization.startsWith('Bearer')) {
      token = req.headers.authorization.split(' ')[1];
    }

    if (!token) {
      return next(new AppError('You are not logged in. Please log in to get access', 401));
    }

    // 2) Verify token
    const decoded = jwt.verify(token, process.env.JWT_SECRET as string) as JwtPayload;

    // 3) Check if user still exists
    const user = await prisma.user.findUnique({
      where: { id: decoded.id }
    });

    if (!user) {
      return next(new AppError('The user belonging to this token no longer exists', 401));
    }

    // 4) Grant access to protected route
    req.user = { id: user.id };
    next();
  } catch (error) {
    next(new AppError('Invalid token. Please log in again', 401));
  }
};

Estou dando uma olhada em visualizações de rede em Python. Tenho um dataframe como o seguinte:

| user | nodes    |
| -----| ---------|
| A    | [0, 1, 3]|
| B    | [1, 2, 4]|
| C    | [0, 3]   |
|...   |          |

Existe uma maneira de plotar facilmente um gráfico de rede (NetworkX?) a partir de dados que contenham a lista de nós em cada linha? A presença de um nó em uma linha aumentaria a proeminência desse nó no gráfico (ou a proeminência/peso da aresta no relacionamento entre dois nós).

Suponho que alguma transformação seria necessária para colocar os dados no formato apropriado para que o NetworkX (ou similar) pudesse criar os relacionamentos do gráfico.

Obrigado!

Estou tentando criar um widget de cartão no Flutter que tem quatro linhas de conteúdo:

• Linha com um único widget de texto, alinhado à esquerda Linha com quatro contêineres quadrados, espaçados uniformemente Linha com dois contêineres retangulares, espaçados uniformemente e alinhados com quadrados Linha com um único ícone, alinhado à direita

Estou perto, mas não consigo fazer o alinhamento dos quadrados/retângulos direito. Eu tentei MainAxisAlignment.spaceAround, MainAxisAlignment.spaceBetweene MainAxisAlignment.spaceEvenlynenhum deles está certo.

A fileira de quadrados está próxima, mas não consigo descobrir como alinhar os dois retângulos abaixo dela (ou seja, cada retângulo deve ter a largura de dois quadrados + o espaço que os separa).

Estou usando a combinação errada de MainAxisAlignment.whatever? Preciso usar algo mais complexo, como MediaQuery.of(context)size.width+ algumas fórmulas funky?

Este é o cerne de um problema do Tensorflow .

Considere o seguinte código:

class Option;

class Base
{
public:
  explicit Base(Option opt);
};

class Derived : public Base
{
public:
  using Base::Base;
  explicit Derived(const Option &opt);
};

Derived
doit(const Option &opt)
{
  return Derived(opt);
}

Quando compilado com versões do GCC até 14.2, ele falha assim:

<source>: In function 'Derived doit(const Option&)':
<source>:19:21: error: call of overloaded 'Derived(const Option&)' is ambiguous
   19 |   return Derived(opt);
      |                     ^
<source>:6:12: note: candidate: 'Base::Base(Option)'
    6 |   explicit Base(Option opt);
      |            ^~~~
<source>:12:15: note:   inherited here
   12 |   using Base::Base;
      |               ^~~~
<source>:13:12: note: candidate: 'Derived::Derived(const Option&)'
   13 |   explicit Derived(const Option &opt);
      |            ^~~~~~~
<source>:9:7: note: candidate: 'constexpr Derived::Derived(const Derived&)'
    9 | class Derived : public Base
      |       ^~~~~~~
<source>:9:7: note: candidate: 'constexpr Derived::Derived(Derived&&)'
Compiler returned: 1

O Clang aceita esse código sem reclamar.

Exemplo ao vivo em Golbolt

Isso parece ser um bug no Clang (por permitir uma chamada ambígua) ou no GCC (por não permitir uma chamada não ambígua). Mas não tenho certeza de qual. Então, essa chamada é ambígua ou não?

Preciso classificar a coluna com "Data de criação do arquivo", mas se a coluna "Tipo de arquivo" == FyleType.DIRECTORY, essa linha deve estar no topo. Ou seja, a primeira classificação deve ser por tipo e, depois, por data.

Minha JTable:

Eu tentei usar

TableRowSorter<FileTableModel> tableRowSorter = new TableRowSorter<>(tableModel);
tableRowSorter.setComparator(2, ((o1, o2) -> {}

Comparador, mas ele só obtém o valor da célula atual e não consigo obter o tipo de arquivo porque a data não é única