All perguntas(coding)

Tenho duas versões da mesma função usando std::any_ofe std::find_ifpara verificar se intexiste em um vetor (retornado de g.getEdges()).

Entretanto, quando executo repetidamente o std::any_ofvalor de retorno é inconsistente, enquanto std::find_ifé.

Ambas as versões são as seguintes ( g.getEdges()retorna um intvetor, enquanto this->sé um int):

bool Search::marked(const int &v) {
    return std::any_of(begin(g.getEdges(v)), end(g.getEdges(v)), [this](const int &w) { return w == this->s; });
}

bool Search::marked(const int &v) {
    auto it = std::find_if(begin(g.getEdges(v)), end(g.getEdges(v)), [this](const auto &w) { return w == this->s; });
    return it != end(g.getEdges(v));
}

Em ambas as classes, adjo vetor está sendo iterado:

class Graph {
  public:
    Graph() : vertex(0), edges(0) {
      adj = std::make_unique<std::vector<std::vector<int>>>(0);
    }
    const std::vector<int> getEdges(int v) { return (*adj)[v]; }
  // ... rest of public
  private:
    std::shared_ptr<std::vector<std::vector<int>>> adj; // Shared for Search class
}

class Search {
  public:
    Search(Graph &g_, int s_) : g(g_), s(s_) {}
    int count();
    bool marked(const int &v);

  private:
    Graph &g;
    int s;
};

A função gtest que usei para verificar o código:

TEST(searchClassTest, HandlesPositiveInput) {
    // ... init myGraph ...
    Search mySearch(myGraph, 2);  // 2 is s!
    EXPECT_EQ(mySearch.count(), 2);
    EXPECT_EQ(mySearch.marked(1), true);
    EXPECT_EQ(mySearch.marked(3), true);
}

Por que estou obtendo resultados inconsistentes?

Link para o exemplo mínimo reproduzível: https://godbolt.org/z/9TnGq3Wbs

Tenho este select aguardando dados no buffer do socket. Quando há dados no buffer, lanço uma thread e aceito a conexão.

while (!InterruptWaitForConnections) 
{
    const int status = select(ListenSocket+1, &readfds, writefds, exceptfds, timeout);
    if (status == -1) 
    {
        // ERROR: do something
        return false;
    } 
    else if (status > 0) 
    {
        // - The socket buffer has data
        // - Check if it is a valid connection
        // - Reject or accept       
        return true;      
    }
    else if(status == 0)
    {
        //timeout           
    }
}

Gostaria de filtrar as conexões antes de aceitá-las. Quero aceitar apenas conexões vindas do meu cliente.

Se uma conexão vier de outro lugar ou houver lixo no buffer do soquete, eu simplesmente quero limpar o buffer do soquete.

Meu cliente pode estar em IPs diferentes. Então, preciso descobrir uma maneira de reconhecê-lo.

Alguém sabe como posso fazer isso?

Tenho um conjunto de dados (simplificado) que se parece com o exemplo abaixo

Preciso criar uma tabela dinâmica para esta tabela, mas a tabela dinâmica deve conter os valores exclusivos das colunas "Primeiro idioma" e "Segundo idioma" como uma coluna e as pontuações somadas das colunas FLScore e SLScore.

Neste exemplo, o resultado seria algo como:

Eu usei:

=UNIQUE(VSTACK(dtScore[First Language];dtScore[Second Language]))

O resultado está no intervalo M10:M16 (segunda imagem) E

=SUMIFS(dtScore[FLScore];dtScore[First Language];M10)+SUMIFS(dtScore[SLScore];dtScore[Second Language];M10)

para obter a soma total para cada idioma.

Mas preciso transformar os dados de forma que eu possa usá-los em uma tabela dinâmica que também possa filtrar por ano e trimestre.

Tenho pensado em usar as funções GROUPBY, FILTER, HSTACK, VSTACK e lambda para transformar os dados, mas não sei por onde começar e como obter o resultado em uma tabela dinâmica que atenda aos critérios mencionados.

Prefiro não usar VBA, apenas funções do Excel

Alguém pode indicar uma direção?

Atualização : Embora eu tenha usado a solução PQ, por ser a mais adequada às minhas necessidades, não parei de experimentar. Consegui usar o PIVOTBY para ter uma matriz por idioma, pontuação e anos como colunas.

A fórmula parece

=PIVOTBY(VSTACK(dtScore[First Language];dtScore[Second Language]);VSTACK(dtScore[Year];dtScore[Year]);VSTACK(dtScore[FLScore];dtScore[SLScore]);SUM) 

Uma observação: vou usar VSTACK também para o parâmetro colunas. Embora a coluna seja a mesma (dtScore[Ano]). Se eu apenas inserir dtScore[Ano], a fórmula gera um erro #Value, indicando que há um número inconsistente de linhas.

O resultado do PIVOTBY

Encontrei uma ocorrência estranha ao trabalhar com Ngrx Store e Angular. Basicamente, o objetivo da minha tarefa é mostrado neste exemplo com cerca de 10 mil entradas em Person[]:

Meu objetivo é mostrar certas pessoas com sobrenomes específicos. Esta é a primeira revisão que fiz, que é bem lenta:

export const selectPerson = createSelector(
  selectCitizensState,
  (citizensState: CitizensState): Person[] => citizensState.people ?? []
);

export const selectPeopleWithSurname = createSelector(
  selectPerson,
  selectSelectedSurnames,
  (people: Person[], surnames: string[]) => {
    if (surnames.length === 0) {
      return people;
    }
    return people.filter((person) => surnames.includes(person.surname));
  }
);

Eu criei isso por acidente e é muito mais rápido que o código acima:

export const selectPerson = createSelector(
  selectCitizensState,
  (citizensState: CitizensState): Person[] => [...(citizensState.people ?? [])]
);

Por que isso acontece? Estou apenas criando uma cópia superficial da propriedade store. Imagino que tenha algo a ver com a detecção de alterações do Ngrx ou algo assim, mas não tenho certeza.

Meu objetivo é adicionar um recurso ao existente TreeTableViewonde clicar no nó de divulgação de um grupo com Alta tecla pressionada deve expandir apenas o grupo associado, mas com todos os seus filhos (subgrupos) recolhidos, independentemente de terem sido expandidos anteriormente.

Sem que a Alttecla seja mantida pressionada, o nó de divulgação deve apenas acionar o comportamento "padrão".

Por exemplo, vamos supor que o usuário tenha a seguinte hierarquia de nós:

ROOT
-> GROUP_1
----> GROUP_1_1
--------> CHILD_1_1_1
--------> CHILD_1_1_2
--------> CHILD_1_1_3
----> GROUP_1_2
--------> CHILD_1_2_1
--------> CHILD_1_2_2
-> GROUP_2
-> GROUP_3
-> ...

Quando o usuário mantém pressionada a Alttecla e clica no nó de divulgação ao lado ROOTpara expandi-lo, espera-se que o sistema mostre. É essencial que os grupos GROUP_1_1e GROUP_1_2sejam recolhidos.

ROOT
-> GROUP_1
-> GROUP_2
-> GROUP_3
-> ...

A diferença entre esse comportamento e o padrão é que se o usuário mantiver a Alttecla pressionada e clicar no nó de divulgação ao lado, ROOTo sistema deverá garantir que tudo dentro dele seja recolhido no final.

Estou procurando funções como CellBehaviorBase#doSelecte TreeTableCellBehavior#handleDisclosureNode, mas até agora não consegui encontrar nenhuma dica de como conseguir o que quero.

Exemplo mínimo para meus testes. O objetivo é ter a possibilidade de expandir o grupo raiz ("Carros") com todos os subgrupos recolhidos quando ALTpressionado:

import javafx.application.Application;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.scene.Scene;
import javafx.scene.control.TreeItem;
import javafx.scene.control.TreeTableColumn;
import javafx.scene.control.TreeTableView;
import javafx.scene.layout.Pane;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class HelloApplication extends Application {
    @Override
    public void start(Stage stage) {
        Pane rootNode = new VBox();
        Scene scene = new Scene(rootNode, 400, 300);
        stage.setTitle("TreeTableView Demo");
        stage.setScene(scene);

        TreeTableView<Car> treeTableView = new TreeTableView<>();

        TreeTableColumn<Car, String> treeTableColumn1 = new TreeTableColumn<>("Brand");
        treeTableColumn1.setPrefWidth(120);
        TreeTableColumn<Car, String> treeTableColumn2 = new TreeTableColumn<>("Model");
        treeTableColumn2.setPrefWidth(120);

        treeTableColumn1.setCellValueFactory(param -> param.getValue().getValue().brandProperty());
        treeTableColumn2.setCellValueFactory(param -> param.getValue().getValue().modelProperty());

        treeTableView.getColumns().add(treeTableColumn1);
        treeTableView.getColumns().add(treeTableColumn2);

        TreeItem<Car> mercedes1 = new TreeItem<>(new Car("Mercedes", "SL500"));
        TreeItem<Car> mercedes2 = new TreeItem<>(new Car("Mercedes", "SL500 AMG"));
        TreeItem<Car> mercedes3 = new TreeItem<>(new Car("Mercedes", "CLA 200"));

        TreeItem<Car> mercedes = new TreeItem<>(new Car("Mercedes", "..."));
        mercedes.getChildren().add(mercedes1);
        mercedes.getChildren().add(mercedes2);

        TreeItem<Car> audi1 = new TreeItem<>(new Car("Audi", "A1"));
        TreeItem<Car> audi2 = new TreeItem<>(new Car("Audi", "A5"));
        TreeItem<Car> audi3 = new TreeItem<>(new Car("Audi", "A7"));

        TreeItem<Car> audi = new TreeItem<>(new Car("Audi", "..."));
        audi.getChildren().add(audi1);
        audi.getChildren().add(audi2);
        audi.getChildren().add(audi3);

        TreeItem<Car> cars = new TreeItem<>(new Car("Cars", "..."));
        cars.getChildren().add(audi);
        cars.getChildren().add(mercedes);

        treeTableView.setRoot(cars);

        rootNode.getChildren().add(treeTableView);

        stage.show();
    }

    public static void main(String[] args) {
        launch();
    }
}

class Car {
    private StringProperty brand = new SimpleStringProperty();
    private StringProperty model = new SimpleStringProperty();

    public Car(String brand, String model) {
        this.brand.set(brand);
        this.model.set(model);
    }

    public String getBrand() {
        return brand.get();
    }

    public StringProperty brandProperty() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand.set(brand);
    }

    public String getModel() {
        return model.get();
    }

    public StringProperty modelProperty() {
        return model;
    }

    public void setModel(String model) {
        this.model.set(model);
    }
}

Recentemente, voltei a me interessar por áudio gerado, mas estou com um pouco de dificuldade. Tenho seguido este tutorial e convertido para Swift:

https://gist.github.com/gcatlin/0dd61f19d40804173d015c01a80461b8

No entanto, quando reproduzo por áudio, tudo o que obtenho são alguns efeitos de ruído branco bastante desagradáveis, em vez do tom puro que eu esperava. Aqui está o código que estou usando para criar a unidade de tom:

private func createToneUnit() throws {
    // Configure the search parameters to find the default playback output unit
    var outputDesc = AudioComponentDescription()
    outputDesc.componentType = kAudioUnitType_Output
    outputDesc.componentSubType = kAudioUnitSubType_RemoteIO
    outputDesc.componentManufacturer = kAudioUnitManufacturer_Apple
    outputDesc.componentFlags = 0
    outputDesc.componentFlagsMask = 0
    
    // Get the default playback output unit
    guard let output = AudioComponentFindNext(nil, &outputDesc) else {
        throw AudioError.cannotFindOutput
    }
    
    // Create a new unit based on this that we'll use for output
    var error = AudioComponentInstanceNew(output, &toneUnit)
    guard let toneUnit = toneUnit, error == noErr else {
        throw AudioError.cannotCreateComponent
    }
    
    // Set our tone rendering function on the unit
    var callback = AURenderCallbackStruct()
    callback.inputProcRefCon = UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())
    callback.inputProc = {
        (userData, actionFlags, timeStamp, busNumber, frameCount, data) -> OSStatus in
        let _self = Unmanaged<MainViewController>.fromOpaque(userData).takeUnretainedValue()
        return _self.renderTone(actionFlags: actionFlags, timeStamp: timeStamp, busNumber: busNumber, frameCount: frameCount, data: data)
    }
    
    error = AudioUnitSetProperty(
        toneUnit,
        kAudioUnitProperty_SetRenderCallback,
        kAudioUnitScope_Input,
        0,
        &callback,
        UInt32(MemoryLayout.size(ofValue: callback))
    )
    
    guard error == noErr else {
        throw AudioError.cannotSetCallback
    }
            
    // Set the format to 32 bit, single channel, floating point, linear PCM
    var streamFormat = AudioStreamBasicDescription()
    streamFormat.mSampleRate = sampleRate
    streamFormat.mFormatID = kAudioFormatLinearPCM
    streamFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked
    streamFormat.mFramesPerPacket = 1
    streamFormat.mChannelsPerFrame = 1
    streamFormat.mBitsPerChannel = 16
    streamFormat.mBytesPerFrame = streamFormat.mChannelsPerFrame * streamFormat.mBitsPerChannel / 8
    streamFormat.mBytesPerPacket = streamFormat.mBytesPerFrame * streamFormat.mFramesPerPacket
    
    error = AudioUnitSetProperty(
        toneUnit,
        kAudioUnitProperty_StreamFormat,
        kAudioUnitScope_Input,
        0,
        &streamFormat,
        UInt32(MemoryLayout<AudioStreamBasicDescription>.size)
    )
    
    guard error == noErr else {
        throw AudioError.cannotSetStreamFormat
    }
}

E aqui está a função render:

func renderTone(
    actionFlags: UnsafeMutablePointer<AudioUnitRenderActionFlags>,
    timeStamp: UnsafePointer<AudioTimeStamp>,
    busNumber: UInt32,
    frameCount: UInt32,
    data: UnsafeMutablePointer<AudioBufferList>?
) -> OSStatus {
    // Get buffer
    let bufferList = UnsafeMutableAudioBufferListPointer(data!)
    let increment = MainViewController.fullCycle * frequency / sampleRate
    
    // Generate samples
    for buffer in bufferList {
        for frame in 0 ..< frameCount {
            if let audioData = buffer.mData?.assumingMemoryBound(to: Float64.self) {
                audioData[Int(frame)] = sin(theta) * amplitude
            }
            
            // Note: this would NOT work for a stereo output
            theta += increment
            while theta > MainViewController.fullCycle {
                theta -= MainViewController.fullCycle
            }
        }
    }
    
    return noErr;
}

Alguém vê algo obviamente ruim nisso? Eu realmente preferiria usar Swift em vez de Obj C, mas não consigo encontrar um exemplo prático de como fazer isso, apenas alguns exemplos parciais (reconhecidamente úteis) sobre como configurar coisas que não executam nenhuma renderização de tom.

Descobri um rxjscomportamento estranho que continua me incomodando e não consigo nem imaginar uma solução para esse problema.

Preciso criar um Observablefrom Subjectque emita um erro se o valor consumido for null, ou emita um valor. E então emita Subjectum nullvalor from . Tudo funciona como esperado, mas o subscriberof Observablecontinua consumindo o erro que foi emitido após a primeira assinatura, mesmo com o first()operador.

Como isso é possível?

import { Subject, throwError, of } from 'rxjs';
import { switchMap, tap, first } from 'rxjs/operators';

var subj$ = new Subject();

var obs$ = subj$.asObservable().pipe(
  switchMap((v) => {
    if (!v) {
      return throwError(() => 'ERROR');
    }

    return of(v);
  })
);

obs$
  .pipe(
    first(),
    tap({
      next(v) {
        console.log('obs$', v);
      },
      error(err) {
        console.error('obs$ error', err);
      },
    }),
    tap(() => subj$.next(null))
  )
  .subscribe();

subj$.next('VALUE');

// obs$ VALUE
// obs$ error ERROR <- ???
// ERROR <- ???

https://stackblitz.com/edit/stackblitz-starters-sdx1oqzx?file=index.js

Exemplo do mundo real:

import { Observable, BehaviorSubject, zip, throwError, of } from 'rxjs';
import { first, switchMap, tap } from 'rxjs/operators';

type User {
  id: number,
  name: string
}

class AuthService {
  private isAuthenticatedSource = new BehaviorSubject<boolean>(false);
  private userSource = new BehaviorSubject<User | null>(null);

  isAuthenticated$: Observable<boolean> = this.isAuthenticatedSource.asObservable();

  user$: Observable<User> = zip(
    this.isAuthenticatedSource.asObservable(),
    this.userSource.asObservable(),
  ).pipe(
    switchMap(([ isAuthenticated, user ]) => {
      if (!isAuthenticated || !user) {
        return throwError(() => 'Unauthenticated.');
      }

      return of(user);
    })
  );

  constructor(private socketService: SocketService) {}

  authenticate(user: User) {
    this.isAuthenticatedSource.next(true);
    this.userSource.next(user);

    return this.socketService.emit('join', user);
  }

  // consumes the error from second emission
  deauthenticate() {
    return this.user$.pipe(
      first(),
      switchMap((user: User) => this.socketService.emit('leave', user)),
      tap(() => {
        this.isAuthenticatedSource.next(false);
        this.userSource.next(null);
      })
    );
  }
}

class SocketService {
  socket = {
    emit(event: string, data: any, ack: (res: any) => any) {
      return { event, data, ack };
    }
  }

  emit<T>(event: string, data: any): Observable<T> {
    return new Observable<T>(subscriber => {
      this.socket.emit(event, data, (res) => {
        subscriber.next(res);
        subscriber.complete();
      })
    });
  }
}

Usando Vite, TypeScript e React. Enfrentando um problema com a importação automática de .d.tsarquivos personalizados no VS Code.

As importações manuais funcionam bem, o .d.tsarquivo é detectado pelo TypeScript. Problema com o VS Code que não detecta importações automáticas para o formato Button.d.ts. O VS Code consegue detectar o .d.tsarquivo e importá-lo automaticamente se eu renomeá-lo para index.d.ts.

Estrutura de pastas:

src/
  ├── components/
  │    ├── Button/
  │    │    ├── Button.tsx
  │    │    └── Button.d.ts

Button.d.ts:

export type TypeButton = {className?:string}

Button.tsx:

import type {TypeButton} from "./Button.d"
const Button = ({className=""}:TypeButton) =>{
    return <button className={className}></button>
}
export default Button

package.json:

{
  "name": "made-you-look",
  "private": true,
  "version": "0.0.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "tsc -b && vite build",
    "lint": "eslint .",
    "preview": "vite preview"
  },
  "dependencies": {
    "react": "^19.0.0",
    "react-dom": "^19.0.0"
  },
  "devDependencies": {
    "@eslint/js": "^9.21.0",
    "@types/react": "^19.0.10",
    "@types/react-dom": "^19.0.4",
    "@vitejs/plugin-react-swc": "^3.8.0",
    "eslint": "^9.21.0",
    "eslint-plugin-react-hooks": "^5.1.0",
    "eslint-plugin-react-refresh": "^0.4.19",
    "globals": "^15.15.0",
    "typescript": "~5.7.2",
    "typescript-eslint": "^8.24.1",
    "vite": "^6.2.0"
  }
}

tsconfig.json:

{
    "compilerOptions": {
        "baseUrl": "./",
        "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
        "target": "ES2020",
        "useDefineForClassFields": true,
        "lib": ["ES2020", "DOM", "DOM.Iterable"],
        "module": "ESNext",
        "skipLibCheck": true,

        /* Bundler mode */
        "moduleResolution": "bundler",
        "allowImportingTsExtensions": true,
        "isolatedModules": true,
        "moduleDetection": "force",
        "noEmit": true,
        "jsx": "react-jsx",

        /* Linting */
        "strict": true,
        "noUnusedLocals": true,
        "noUnusedParameters": true,
        "noFallthroughCasesInSwitch": true,
        "noUncheckedSideEffectImports": true,
        "declaration": true
    },
    "include": ["src"]
}

Tenho um problema simples, porém complexo. Tenho um formulário reativo e quero definir a validação programaticamente.

    this.boatForm.get('boatType').setValidators(Validators.required);
    this.boatForm.updateValueAndValidity();

    this.boatForm.get('boatType').updateValueAndValidity();
    this.#logger.debug(
        '/n', 'value:', this.boatForm.get('boatType').value,
        '/n', 'valid:', this.boatForm.get('boatType').valid
    )

O valor do controle boatType é nulo. Portanto, espero que o log mostre:

valor: válido: falso

E... acontece mesmo.

Mas eu tenho vários controles naquele formulário, então, em vez de aplicar updateValueAndValidity() a cada controle individualmente, quero executar:

    this.boatForm.get('boatType').setValidators(Validators.required);
    // Set other validators on other controls on the same form
    this.boatForm.updateValueAndValidity();

    this.#logger.debug(
        '\n', 'value', this.boatForm.get('boatType').value,
        '\n', 'valid', this.boatForm.get('boatType').valid
    )

Mas agora eu entendo:

valor: válido: verdadeiro

A solução alternativa que implementamos é chamar um método:

static updateFormControlValidators(form: FormGroup): void {
    // Iterate over each control in the form group

    Object.keys(form.controls).forEach(controlName => {
        const control = form.get(controlName);

        // Call updateValueAndValidity to re-evaluate the validity of each control
        if (control) {
            control.updateValueAndValidity();
        }
    });
}

Mas a questão é:

form.updateValueAndValidity() deve realizar a mesma coisa?

Estou tentando criar um API Gateway com lambda e anexar o autorizador a ele. A criação da API e do lambda funciona perfeitamente, mas quando adiciono a seção do autorizador, recebo o seguinte erro:

Erro: Falha ao criar o changeset para a pilha: dev-device-management-api-stack, por exemplo: Waiter ChangeSetCreateComplete falhou: Waiter encontrou uma falha de terminal. Estado: Para a expressão "Status", correspondemos ao caminho esperado: "FAILED". Status: FAILED. Motivo: Valores 'null' não são permitidos em modelos em [/Resources/DeviceManagementApi/Type/Body/securityDefinitions/JwtAuthorizer/x-amazon-apigateway-authorizer/authorizerUri/Fn::Sub/1/ FunctionArn ].

Não consegui entender o erro e o motivo. Alguém ajuda?

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Parameters:
  EnvironmentStackName:
    Type: String
    AllowedValues:
      - dev
      - prod

Resources:
  DeviceManagementApi:
    Type: AWS::Serverless::Api
    Properties:
      Name: !Sub "${EnvironmentStackName}-device-management"
      StageName: "api"
      EndpointConfiguration: REGIONAL
      Auth:
        Authorizers:
          JwtAuthorizer:
            AuthorizationScopes:
              - scope
            IdentitySource: $request.header.Authorization
            JwtConfiguration:
              audience:
                - "my-audience"
              issuer: "https://issuer.clerk.accounts.dev"

  GetAllLocationsLambda:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: !Sub "${EnvironmentStackName}-lambda-locations-get-all"
      Handler: app.lambda_handler
      Runtime: python3.12
      CodeUri: src/location/get-all/
      MemorySize: 128
      Timeout: 10
      Role: !GetAtt DeviceApiLambdaExecutionRole.Arn
      Environment:
        Variables:
          STACK_NAME: !Ref EnvironmentStackName
      Events:
        GetAllLocationsApiEvent:
          Type: Api
          Properties:
            Path: /locations
            Method: GET
            RestApiId: !Ref DeviceManagementApi
#            Auth:
#              Authorizer: MyOauth2Authorizer
  
  DeviceApiLambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub "${EnvironmentStackName}-lambda-device-api-execution-role"
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: "sts:AssumeRole"
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      Policies:
        - PolicyName: LambdaDynamoDBReadAccess
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Effect: Allow
                Action:
                  - dynamodb:Scan
                  - dynamodb:GetItem
                  - dynamodb:PutItem
                  - dynamodb:BatchGetItem
                  - dynamodb:BatchWriteItem
                  - dynamodb:ConditionCheckItem
                  - dynamodb:PutItem
                  - dynamodb:DescribeTable
                  - dynamodb:DeleteItem
                  - dynamodb:GetItem
                  - dynamodb:Scan
                  - dynamodb:Query
                  - dynamodb:UpdateItem
                Resource: "*"