Teacher tool: Initial validation logic

pxtblocks/code-validation/evaluationResult.ts

@@ -1,5 +1,5 @@
 namespace pxt.blocks {
   export interface EvaluationResult {
-    passed: boolean;
+   blockIdResults: pxt.Map<boolean>;
   }
 }

pxtblocks/code-validation/rubricCriteria.ts

@@ -23,6 +23,55 @@ namespace pxt.blocks {
         }
     }
 
+    function blockSetToRequiredBlockCounts(blockSet: BlockSet): pxt.Map<number> {
+        const requiredBlockCounts: pxt.Map<number> = {};
+        blockSet.blocks.forEach((block) => {
+            requiredBlockCounts[block] = blockSet.count;
+        });
+        return requiredBlockCounts;
+    }
+
+    export function validateProject(usedBlocks: Blockly.Block[], rubric: string): EvaluationResult {
+        const rubricData = parseRubric(rubric);
+        const finalResult: pxt.Map<boolean> = {};
+        rubricData.criteria.forEach((criteria: RubricCriteria) => {
+            (criteria as BlockCheckCriteria).blockRequirements.forEach((blockSet) => {
+                const result = validateBlockSet(usedBlocks, blockSet);
+                Object.keys(result).forEach((blockId) => {
+                    finalResult[blockId] = result[blockId];
+                });
+            });
+        });
+        return { blockIdResults: finalResult } as EvaluationResult;
+    }
+
+
+    function validateBlockSet(usedBlocks: Blockly.Block[], blockSet: BlockSet): pxt.Map<boolean> {
+        const requiredBlockCounts = blockSetToRequiredBlockCounts(blockSet);
+        const blockResults: pxt.Map<boolean> = {};
+        Object.keys(requiredBlockCounts).forEach((blockId) => {
+            blockResults[blockId] = true;
+        });
+        const {
+            missingBlocks,
+            disabledBlocks,
+            insufficientBlocks
+        } = pxt.blocks.validateBlocksExist({
+            usedBlocks: usedBlocks,
+            requiredBlockCounts: requiredBlockCounts,
+        });
+        missingBlocks.forEach((blockId) => {
+            blockResults[blockId] = false;
+        });
+        disabledBlocks.forEach((blockId) => {
+            blockResults[blockId] = false;
+        });
+        insufficientBlocks.forEach((blockId) => {
+            blockResults[blockId] = false;
+        });
+        return blockResults;
+    }
+
     export abstract class RubricCriteria {
         displayText: string;
         abstract criteriaId: string;

pxteditor/editor.ts

@@ -335,6 +335,7 @@ namespace pxt.editor {
         blocksScreenshotAsync(pixelDensity?: number, encodeBlocks?: boolean): Promise<string>;
         renderBlocksAsync(req: EditorMessageRenderBlocksRequest): Promise<EditorMessageRenderBlocksResponse>;
         renderPythonAsync(req: EditorMessageRenderPythonRequest): Promise<EditorMessageRenderPythonResponse>;
+        getBlocks(): Blockly.Block[];
 
         toggleHighContrast(): void;
         setHighContrast(on: boolean): void;

pxteditor/editorcontroller.ts

@@ -548,9 +548,9 @@ namespace pxt.editor {
                                     const evalmsg = data as EditorMessageRunEvalRequest;
                                     const rubric = evalmsg.rubric;
                                     return Promise.resolve()
-                                        .then(() => (
-                                            // TODO : call into evaluation function.
-                                            { passed: true } as pxt.blocks.EvaluationResult))
+                                        .then(() => {
+                                            const blocks = projectView.getBlocks();
+                                            return pxt.blocks.validateProject(blocks, rubric)})
                                         .then (results => {
                                             resp = results;
                                         });

teachertool/src/App.tsx

@@ -35,9 +35,11 @@ function App() {
     return (
         <div className="app-container">
             <HeaderBar />
-            <DebugInput />
-            <EvalResultDisplay />
-            <MakeCodeFrame />
+            <div className="inner-app-container">
+                <DebugInput />
+                <EvalResultDisplay />
+                <MakeCodeFrame />
+            </div>
             <Notifications />
         </div>
     );

teachertool/src/components/EvalResultDisplay.tsx

@@ -14,8 +14,15 @@ const EvalResultDisplay: React.FC<IProps> = ({}) => {
                 <div className="eval-results-container">
                     <h3>{lf("Project: {0}", teacherTool.projectMetadata.name)}</h3>
                     {teacherTool.currentEvalResult === undefined && <div className="common-spinner" />}
-                    {teacherTool.currentEvalResult?.passed === true && <h4 className="positive-text">Passed!</h4>}
-                    {teacherTool.currentEvalResult?.passed === false && <h4 className="negative-text">Failed!</h4>}
+                    {Object.keys(teacherTool.currentEvalResult?.blockIdResults ?? {}).map((id) => {
+                        const result = teacherTool.currentEvalResult?.blockIdResults[id];
+                        return (
+                            <div className="result-block-id" key={id}>
+                                <p className="block-id-label">{id}:</p>
+                                <p className={result ? "positive-text" : "negative-text"}>{result ? "passed" : "failed"}</p>
+                            </div>
+                        );
+                    })}
                 </div>
             )}
         </>

teachertool/src/teacherTool.css

@@ -76,6 +76,13 @@ code {
     overflow: auto;
 }
 
+.inner-app-container {
+    display: flex;
+    flex-direction: column;
+    min-height: 100%;
+    width: 100%;
+}
+
 .noclick {
     pointer-events: none;
     cursor: default;
@@ -397,6 +404,22 @@ code {
     border-bottom: 1px solid #ddd;
     margin: 1rem 0;
     padding: 1rem;
+    overflow: auto;
+}
+
+.result-block-id {
+    display: flex;
+    padding-left: .5rem;
+    margin: .2rem 0;
+}
+
+.result-block-id p {
+    margin: 0;
+}
+
+.block-id-label {
+    font-weight: 700;
+    padding-right: .5rem;
 }
 
 .positive-text {

webapp/src/app.tsx

@@ -4038,6 +4038,15 @@ export class ProjectView
             });
     }
 
+    getBlocks(): Blockly.Block[] {
+        if (!this.isBlocksActive()) {
+            console.error("Trying to get blocks from a non-blocks editor.");
+            throw new Error("Trying to get blocks from a non-blocks editor.");
+        }
+
+        return this.blocksEditor.editor.getAllBlocks(false);
+    }
+
     launchFullEditor() {
         Util.assert(pxt.shell.isSandboxMode());