diff --git a/signalData/.gitattributes b/signalData/.gitattributes
new file mode 100644
index 000000000..176a458f9
--- /dev/null
+++ b/signalData/.gitattributes
@@ -0,0 +1 @@
+* text=auto
diff --git a/signalData/.gitignore b/signalData/.gitignore
new file mode 100644
index 000000000..32858aad3
--- /dev/null
+++ b/signalData/.gitignore
@@ -0,0 +1,12 @@
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
diff --git a/signalData/LICENSE.txt b/signalData/LICENSE.txt
new file mode 100644
index 000000000..8f71f43fe
--- /dev/null
+++ b/signalData/LICENSE.txt
@@ -0,0 +1,202 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "{}"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright {yyyy} {name of copyright owner}
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
diff --git a/signalData/README.md b/signalData/README.md
new file mode 100644
index 000000000..554d36b83
--- /dev/null
+++ b/signalData/README.md
@@ -0,0 +1,79 @@
+# SignalData
+
+## Basic Setup ##
+
+1. Create a LabKey Assay Project/Folder
+ 1. Hover over the Project or Folder menu, and click **Create Project** or **Create Subfolder**.
+ 1. Provide a Name and select type **Assay**.
+ 1. Click **Next**.
+ 1. Set permissions (optional) and click **Next**.
+ 1. Click **Finish**.
+1. Create a Signal Data Assay Design
+ 1. In the **Assay List** web part, click **New Assay Design**.
+ 1. On the New Assay Design page, select **Signal Data** as the assay type.
+ 1. Click **Next**.
+ 1. Name is the only required field. (Design default values should work fine.)
+ 1. Click the **Save & Close** button.
+
+## Manual Import of Signal Data Results ##
+
+Importing data is a two step process:
+
+1. Upload the metadata file. (An example metadata file is available at: https://github.com/LabKey/signalData/blob/develop/test/sampledata/signaldata/RunsMetadata/datafiles.tsv)
+1. Drag and drop the data files (Example data files are available at: https://github.com/LabKey/signalData/tree/develop/test/sampledata/signaldata/SignalDataAssayData/TestRun001)
+
+### Metadata Upload
+
+1. Go to the folder where you wish to upload results.
+1. Add the **Signal Data Upload** webpart.
+1. Confirm that **File** is selected, and click **Upload TXT, TSV, XLS, XLSX**.
+
+
+
+1. Specify a Run Identifier (required).
+
+
+
+### Data Upload
+
+1. Drag-and-drop any result files you want to import onto the dropzone.
+
+
+
+1. Click the **Save Run** button.
+
+
+
+## View Results ##
+
+To view chromatograms for the results, follow these instructions:
+
+1. Go to the folder where your results reside.
+1. On the **Assay List** webpart, click the name of the Signal Data assay you created.
+1. Select the run(s) you want to look at, using the checkboxes.
+1. Click **View Selected Runs**.
+
+
+
+1. Select the data run(s) you wish to view from the left.
+1. Click the `Overlay Selected` button.
+
+
+
+1. The left selection pane will close, and the overlayed results will be displayed in the center pane.
+
+
+
+1. You can zoom into the graph by entering values in the **Time** and **mV Range** text boxes, or by drawing a new area inside the graph using the mouse.
+
+
+
+Enter values in the right pane to calculate areas under the curves. Select in the name column to highlight different graph lines.
+
+
+
+## Installing the Signal Data Module ##
+
+[Contact us](https://www.labkey.com/company/contact-us) for details on installing the Signal Data module.
+
+
diff --git a/signalData/build.gradle b/signalData/build.gradle
new file mode 100644
index 000000000..405ae2406
--- /dev/null
+++ b/signalData/build.gradle
@@ -0,0 +1,3 @@
+plugins {
+ id 'org.labkey.build.module'
+}
diff --git a/signalData/module.properties b/signalData/module.properties
new file mode 100644
index 000000000..acc479342
--- /dev/null
+++ b/signalData/module.properties
@@ -0,0 +1,7 @@
+ModuleClass: org.labkey.signaldata.SignalDataModule
+Label: signaldata
+Description: A module defining general X/Y plottable assays and tools for working with those assays.
+URL: https://github.com/LabKey/signalData
+License: Apache 2.0
+LicenseURL: http://www.apache.org/licenses/LICENSE-2.0
+ManageVersion: true
diff --git a/signalData/resources/assay/signalData/config.xml b/signalData/resources/assay/signalData/config.xml
new file mode 100644
index 000000000..fd5ee4ae6
--- /dev/null
+++ b/signalData/resources/assay/signalData/config.xml
@@ -0,0 +1,7 @@
+
+ Signal Data
+ X/Y plottable Signal Data
+
+ SignalData
+
+
diff --git a/signalData/resources/assay/signalData/domains/batch.xml b/signalData/resources/assay/signalData/domains/batch.xml
new file mode 100644
index 000000000..1915a5e35
--- /dev/null
+++ b/signalData/resources/assay/signalData/domains/batch.xml
@@ -0,0 +1,19 @@
+
+ Signal Data Assay Batch fields
+
+ XAxis
+ true
+ http://www.w3.org/2001/XMLSchema#string
+ X-Axis Label
+ FixedValue
+ Time (m)
+
+
+ YAxis
+ true
+ http://www.w3.org/2001/XMLSchema#string
+ Y-Axis Label
+ FixedValue
+ mV
+
+
\ No newline at end of file
diff --git a/signalData/resources/assay/signalData/domains/result.xml b/signalData/resources/assay/signalData/domains/result.xml
new file mode 100644
index 000000000..3c859714d
--- /dev/null
+++ b/signalData/resources/assay/signalData/domains/result.xml
@@ -0,0 +1,14 @@
+
+ Signal Data Assay Results
+
+ Name
+ true
+ http://www.w3.org/2001/XMLSchema#string
+
+
+ DataFile
+ true
+ http://cpas.fhcrc.org/exp/xml#fileLink
+ Data File
+
+
diff --git a/signalData/resources/assay/signalData/domains/run.xml b/signalData/resources/assay/signalData/domains/run.xml
new file mode 100644
index 000000000..cebcdfcbd
--- /dev/null
+++ b/signalData/resources/assay/signalData/domains/run.xml
@@ -0,0 +1,8 @@
+
+
+ RunIdentifier
+ true
+ http://www.w3.org/2001/XMLSchema#string
+ Run Identifier
+
+
diff --git a/signalData/resources/assay/signalData/queries/Data.query.xml b/signalData/resources/assay/signalData/queries/Data.query.xml
new file mode 100644
index 000000000..332e31863
--- /dev/null
+++ b/signalData/resources/assay/signalData/queries/Data.query.xml
@@ -0,0 +1,42 @@
+
+
+
+
+
+
+ /signaldata/update.view?protocolId=${Run/Protocol/RowId}&batchId=${Run/Batch/RowId}&runId=${Run/RowId}&rowId=${RowId}&runName=${Run/Name}
+
+ /signaldata/QCView/SignalData.js
+ -
+
LABKEY.SignalData.signalDataSelection(dataRegion, dataRegionName, 'signaldata')
+
+
+
+
+
+
+ SearchSignalDataData
+ RowId
+
+
+
+
+
+
+
diff --git a/signalData/resources/assay/signalData/queries/SearchSignalDataData.sql b/signalData/resources/assay/signalData/queries/SearchSignalDataData.sql
new file mode 100644
index 000000000..f705afa47
--- /dev/null
+++ b/signalData/resources/assay/signalData/queries/SearchSignalDataData.sql
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2016 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+-- noinspection SqlDialectInspectionForFile
+-- noinspection SqlNoDataSourceInspectionForFile
+-- This query is used to define the search criteria as used for the SignalData initial view
+SELECT
+Data.RowId,
+--TODO: Identify search fields
+COALESCE(Data.Name, '') || COALESCE(Data.Run.RunIdentifier, '')AS Search
+FROM Data
\ No newline at end of file
diff --git a/signalData/resources/assay/signalData/views/begin.html b/signalData/resources/assay/signalData/views/begin.html
new file mode 100644
index 000000000..280ee5221
--- /dev/null
+++ b/signalData/resources/assay/signalData/views/begin.html
@@ -0,0 +1,45 @@
+
+
\ No newline at end of file
diff --git a/signalData/resources/assay/signalData/views/begin.view.xml b/signalData/resources/assay/signalData/views/begin.view.xml
new file mode 100644
index 000000000..5fbe3ce56
--- /dev/null
+++ b/signalData/resources/assay/signalData/views/begin.view.xml
@@ -0,0 +1,5 @@
+
+
+
+
diff --git a/signalData/resources/assay/signalData/views/upload.html b/signalData/resources/assay/signalData/views/upload.html
new file mode 100644
index 000000000..3c251b032
--- /dev/null
+++ b/signalData/resources/assay/signalData/views/upload.html
@@ -0,0 +1,9 @@
+
+
\ No newline at end of file
diff --git a/signalData/resources/views/mockSignalDataWatch.html b/signalData/resources/views/mockSignalDataWatch.html
new file mode 100644
index 000000000..7eeded323
--- /dev/null
+++ b/signalData/resources/views/mockSignalDataWatch.html
@@ -0,0 +1,232 @@
+
+
+
diff --git a/signalData/resources/views/mockSignalDataWatch.view.xml b/signalData/resources/views/mockSignalDataWatch.view.xml
new file mode 100644
index 000000000..1e4bca528
--- /dev/null
+++ b/signalData/resources/views/mockSignalDataWatch.view.xml
@@ -0,0 +1,5 @@
+
+
+
+
diff --git a/signalData/resources/views/qc.html b/signalData/resources/views/qc.html
new file mode 100644
index 000000000..d35cdc48a
--- /dev/null
+++ b/signalData/resources/views/qc.html
@@ -0,0 +1,10 @@
+
+
diff --git a/signalData/resources/views/qc.view.xml b/signalData/resources/views/qc.view.xml
new file mode 100644
index 000000000..1f2474cdd
--- /dev/null
+++ b/signalData/resources/views/qc.view.xml
@@ -0,0 +1,14 @@
+
+
+
+
diff --git a/signalData/resources/views/signalDataUpload.html b/signalData/resources/views/signalDataUpload.html
new file mode 100644
index 000000000..91c86d742
--- /dev/null
+++ b/signalData/resources/views/signalDataUpload.html
@@ -0,0 +1,59 @@
+ Signal Data Files
+
+
+ Import (or paste) the results file. Data must include a column that has the signal data filename (case-sensitive).
+ Download Spreadsheet Template
+
+ Enter Run-level data and import the relevant signal data files.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/signalData/resources/views/signalDataUpload.view.xml b/signalData/resources/views/signalDataUpload.view.xml
new file mode 100644
index 000000000..f529f151b
--- /dev/null
+++ b/signalData/resources/views/signalDataUpload.view.xml
@@ -0,0 +1,5 @@
+
+
+
+
\ No newline at end of file
diff --git a/signalData/resources/views/signalDataUpload.webpart.xml b/signalData/resources/views/signalDataUpload.webpart.xml
new file mode 100644
index 000000000..6635cc2fb
--- /dev/null
+++ b/signalData/resources/views/signalDataUpload.webpart.xml
@@ -0,0 +1,6 @@
+
+
+
+
\ No newline at end of file
diff --git a/signalData/resources/views/update.html b/signalData/resources/views/update.html
new file mode 100644
index 000000000..d7b200603
--- /dev/null
+++ b/signalData/resources/views/update.html
@@ -0,0 +1,5 @@
+
+ Update Signal Data result
+
+
\ No newline at end of file
diff --git a/signalData/resources/views/update.view.xml b/signalData/resources/views/update.view.xml
new file mode 100644
index 000000000..b30f54a90
--- /dev/null
+++ b/signalData/resources/views/update.view.xml
@@ -0,0 +1,12 @@
+
+
+
+
diff --git a/signalData/resources/web/signaldata-upload.lib.xml b/signalData/resources/web/signaldata-upload.lib.xml
new file mode 100644
index 000000000..c17acc494
--- /dev/null
+++ b/signalData/resources/web/signaldata-upload.lib.xml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/signalData/resources/web/signaldata/QCView/DataService.js b/signalData/resources/web/signaldata/QCView/DataService.js
new file mode 100644
index 000000000..edaa7cd4f
--- /dev/null
+++ b/signalData/resources/web/signaldata/QCView/DataService.js
@@ -0,0 +1,410 @@
+/*
+ * Copyright (c) 2016-2017 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * Created by Nick Arnold on 9/26/2014.
+ */
+Ext4.define('LABKEY.SignalData.DataService', {
+
+ alternateClassName: ['SignalDataService'],
+
+ singleton: true,
+
+ _ContentCache: {},
+ _PipelineCache: undefined,
+ _AssayTypeCache: {},
+
+ FileContentCache : function(expData /* LABKEY.Exp.Data */, callback, scope) {
+ if (expData instanceof LABKEY.Exp.Data)
+ {
+ var path = expData['pipelinePath'];
+
+ var content = this._ContentCache[path];
+ if (content)
+ {
+ if (Ext4.isFunction(callback))
+ callback.call(scope || this, content, expData);
+ }
+ else
+ {
+ expData.getContent({
+ format: 'jsonTSV',
+ success: function (c)
+ {
+ this._ContentCache[path] = c;
+ if (Ext4.isFunction(callback))
+ callback.call(scope || this, c, expData);
+ },
+ failure: function (error)
+ {
+ alert('Failed to Load File Contents');
+ },
+ scope: this
+ });
+ }
+ }
+ else {
+ console.error('LABKEY.SignalData.QualityControl.FileContentCache: invalid expData object. Must be of type LABKEY.Exp.Data');
+ }
+ },
+
+ /**
+ * Retrieves the data from a file response object
+ * @param datacontent
+ * @param xleft
+ * @param xright
+ * @param mod - if not specified it will not be used
+ * @returns {Array}
+ */
+ getData : function(datacontent, xleft, xright, mod) {
+ var data = [];
+ if (datacontent) {
+ var _data = [...datacontent.sheets[0].data];
+ _data.shift(); // get rid of column headers
+ var newData = [], d, xy;
+
+ //
+ // check modulus
+ //
+ if (!mod || !Ext4.isNumber(mod)) {
+
+ //
+ // check for bounds
+ //
+ if (xleft == 0 && xright == 0) {
+ for (d=0; d < _data.length; d++) {
+ xy = this.getXYRow(_data[d]);
+ xy[0] = parseFloat(xy[0]);
+ xy[1] = parseFloat(xy[1]);
+ newData.push(xy);
+ }
+ }
+ else {
+ //
+ // using bounds
+ //
+ for (d=0; d < _data.length; d++) {
+ xy = this.getXYRow(_data[d]);
+ xy[0] = parseFloat(xy[0]);
+ xy[1] = parseFloat(xy[1]);
+ if (xy[0] > xleft && xy[0] < xright)
+ newData.push(xy);
+ }
+ }
+ }
+ else {
+ //
+ // check for bounds
+ //
+ if (xleft == 0 && xright == 0) {
+ for (d=0; d < _data.length; d++) {
+ if (d%mod == 0) {
+ xy = this.getXYRow(_data[d]);
+ xy[0] = parseFloat(xy[0]);
+ xy[1] = parseFloat(xy[1]);
+ newData.push(xy);
+ }
+ }
+ }
+ else {
+ //
+ // using bounds
+ //
+ for (d=0; d < _data.length; d++) {
+ if (d%mod == 0) {
+ xy = this.getXYRow(_data[d]);
+ xy[0] = parseFloat(xy[0]);
+ xy[1] = parseFloat(xy[1]);
+ if (xy[0] > xleft && xy[0] < xright)
+ newData.push(xy);
+ }
+ }
+ }
+ }
+
+ data = newData;
+ }
+ return data;
+ },
+
+ /**
+ * Helper to return an XY array from the raw input data file. This helps normalize
+ * different data file delimiter types.
+ */
+ getXYRow : function(row) {
+ // space delimited
+ if (row.length === 1)
+ return row[0].split(' ');
+
+ // all others
+ return row;
+ },
+
+ /**
+ * Get the max y value * 110%
+ * @param datacontents
+ * @returns {Number} max y value * 110% rounded to the nearest 10
+ */
+ getMaxHeight : function(datacontents) {
+ var maxY = 0;
+ for (var i = 0; i < datacontents.length; i++)
+ {
+ var datacontent = datacontents[i];
+ if (datacontent)
+ {
+ var _data = datacontent.sheets[0].data;
+ _data.shift(); // get rid of column headers
+ var d, xy, y;
+
+ for (d = 0; d < _data.length; d++)
+ {
+ xy = this.getXYRow(_data[d]);
+ y = parseFloat(xy[1]);
+ if (y > maxY)
+ {
+ maxY = y;
+ }
+ }
+ }
+ }
+ return maxY > 0 ? Math.ceil(maxY * 1.1/10)*10 : 1200;
+ },
+
+ /**
+ * Use this to retrieve all the required information with regards to the given Signal Data assay runIds
+ * @param schema
+ * @param runIds
+ * @param dataNames
+ * @param callback
+ * @param scope
+ */
+ getRun : function(schema, runIds, dataNames, callback, scope) {
+
+ var context = {
+ RunIds: runIds,
+ DataNames: dataNames
+ }, _count = 0;
+
+ var loader = function() {
+ _count++;
+ if (_count == 4) {
+
+ var batchIds = [];
+ for (var i = 0; i < context.RunDefinitions.length; i++) {
+ batchIds.push(context.RunDefinitions[i].Batch.value);
+ }
+
+ LABKEY.Experiment.loadBatches({
+ assayId: context.AssayDefinition.id,
+ batchIds: batchIds,
+ success: function(RunGroups) {
+ //context.batch = RunGroup;
+
+ //
+ // Transform select rows result into a structure the Ext store can accept
+ //
+ var d = [];
+ for (var j = 0; j < RunGroups.length; j++) {
+ var RunGroup = RunGroups[j];
+ var runs = RunGroup.runs;
+ var filteredRuns = [];
+
+ //
+ // Find the associated runs
+ //
+ for (var r=0; r < runs.length; r++) {
+ for (var ind = 0; ind < context.RunIds.length; ind++){
+ if (context.RunIds[ind] == runs[r].id) {
+ filteredRuns.push(runs[r]);
+ break;
+ }
+ }
+ }
+
+ var dataNames = {};
+ if(context.DataNames)
+ context.DataNames.forEach(function(name){
+ dataNames[name] = true;
+ });
+
+ for (var k = 0; k < filteredRuns.length; k++)
+ {
+ var run = filteredRuns[k];
+ var runIdentifier = run.name;
+
+ for (var r = 0; r < run.dataRows.length; r++)
+ {
+ //If DataNames is null, all files should be used.
+ var isValidData = context.DataNames == null || dataNames[run.dataRows[r]['Name']];
+ if (!isValidData) {
+ continue;
+ }
+
+ var name = run.dataRows[r]['Name'].split('.');
+ var fileExt = name[1];
+ name = name[0];
+ var filePath = "";
+ var dataFile = run.dataRows[r]['DataFile'];
+
+ var osDelimiter = '/';
+ var fileName = dataFile.split(osDelimiter).pop(); //Hack to make fileLink and pipe resolve file
+ if (fileName == dataFile) { //Filename wasn't parsed correctly
+ //Check if windows delimiter
+ osDelimiter = '\\';
+ fileName = dataFile.split(osDelimiter).pop();
+ }
+ filePath = context.pipe + osDelimiter + runIdentifier + osDelimiter + fileName;
+
+ //
+ // Link the associated LABKEY.Exp.Data object (the data file)
+ //
+ var ExpDataRun = null;
+ for (var i = 0; i < run.dataInputs.length; i++) {
+ if (run.dataInputs[i].name == fileName) {
+ ExpDataRun = run.dataInputs[i];
+ break;
+ }
+ }
+
+ d.push({
+ name: name,
+ fileExt: fileExt,
+ filePath: filePath,
+ expDataRun: ExpDataRun
+ });
+ }
+ }
+ }
+ context.rawInputs = d;
+
+ if (Ext4.isFunction(callback)) {
+ callback.call(scope || this, context);
+ }
+ },
+ scope: this
+ });
+ }
+ };
+
+ //
+ // Get the associated SignalData configuration
+ //
+ this.getPipelineConfiguration(function(data) {
+ context.pipe = data.webDavURL; loader();
+ }, this);
+
+ //
+ // Get the associated Assay information
+ //
+ this.getAssayDefinition('Signal Data', function(def) {
+ context.AssayDefinition = def; loader();
+ }, this);
+
+ //
+ // Get the associated HPLC Assay information
+ //
+ this.getAssayDefinition('HPLC', function(def) {
+ context.HPLCDefinition = def; loader();
+ }, this);
+
+ //
+ // Get the associated Batch information
+ //
+ this.getBatchDefinition(schema, context.RunIds, function(def) {
+ context.RunDefinitions = def; loader();
+ }, this);
+ },
+
+ getPipelineConfiguration : function(callback, scope) {
+ if (Ext4.isObject(this._PipelineCache)) {
+ if (Ext4.isFunction(callback)) {
+ callback.call(scope || this, Ext4.clone(this._PipelineCache));
+ }
+ }
+ else {
+ Ext4.Ajax.request({
+ url: LABKEY.ActionURL.buildURL('SignalData', 'getSignalDataPipelineContainer.api'),
+ success: function(response) {
+ this._PipelineCache = Ext4.decode(response.responseText);
+ if (Ext4.isFunction(callback)) {
+ callback.call(scope || this, Ext4.clone(this._PipelineCache));
+ }
+ },
+ scope: this
+ });
+ }
+ },
+
+ getAssayDefinition : function(assayType /* String */, callback, scope) {
+ //TODO: can we do this by ID?
+ if (Ext4.isString(assayType)) {
+ if (Ext4.isObject(this._AssayTypeCache[assayType])) {
+ if (Ext4.isFunction(callback)) {
+ callback.call(scope || this, this._AssayTypeCache[assayType]);
+ }
+ }
+ else {
+ LABKEY.Assay.getByType({
+ type: assayType,
+ success: function(defs) {
+ this._AssayTypeCache[assayType] = defs[0];
+ if (Ext4.isFunction(callback)) {
+ callback.call(scope || this, this._AssayTypeCache[assayType]);
+ }
+ },
+ scope: this
+ });
+ }
+ }
+ },
+
+ getBatchDefinition : function(assaySchema /* String */, runIds /* Number */, callback, scope) {
+ LABKEY.Query.selectRows({
+ schemaName: assaySchema,
+ queryName: 'Runs',
+ requiredVersion: 13.2,
+ filterArray: [ LABKEY.Filter.create('RowId', runIds.join(';'), LABKEY.Filter.Types.IN) ],
+ success: function(data) {
+ if (Ext4.isFunction(callback)) {
+ callback.call(scope || this, data.rows); // LABKEY.Query.Row
+ }
+ },
+ scope: this
+ });
+ },
+
+ getDate : function(filePath) {
+ var date;
+
+ if (!Ext4.isEmpty(filePath)) {
+ var path = filePath.split('/');
+
+ var folder = "";
+ if (path.length == 1) {
+ folder = path[0]; // allows for the folder name to be handed in directly
+ }
+ else {
+ folder = path[path.length-2];
+ }
+
+ if (folder.indexOf('20') == 0) {
+ folder = folder.split('_');
+ date = new Date();
+ date.setDate(parseInt(folder[2])); // setDay
+ date.setFullYear(parseInt(folder[0]));
+ date.setMonth(parseInt(folder[1])-1);
+ date.setHours(parseInt(folder[3]));
+ date.setMinutes(parseInt(folder[4]));
+ date.setSeconds(parseInt(folder[5]));
+ }
+ }
+
+ if (!Ext4.isDefined(date)) {
+ Ext4.Msg.alert('Invalid Date requested for:', filePath);
+ }
+
+ return date;
+ }
+});
diff --git a/signalData/resources/web/signaldata/QCView/ProvisionalRun.js b/signalData/resources/web/signaldata/QCView/ProvisionalRun.js
new file mode 100644
index 000000000..9b2aa965e
--- /dev/null
+++ b/signalData/resources/web/signaldata/QCView/ProvisionalRun.js
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2016 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
+ */
+Ext4.define('LABKEY.SignalData.ProvisionalRun', {
+ extend: 'Ext.data.Model',
+ fields: [
+ {name: 'name'},
+ {name: 'fileExt'},
+ {name: 'filePath'},
+ {name: 'expDataRun'}
+ ]
+});
+
+Ext4.define('LABKEY.SignalData.Standard', {
+ extend: 'Ext.data.Model',
+ fields: [
+ {name: 'Key', type: 'int'},
+ {name: 'Name'},
+ {name: 'provisionalRun'}
+ ]
+});
+
+Ext4.define('LABKEY.SignalData.StandardSource', {
+ extend: 'Ext.data.Model',
+ fields: [
+ {name: 'key', type: 'int'},
+ {name: 'expDataRun'},
+ {name: 'standard', type: 'int'}, // lookup to Standard.key
+ {name: 'name'},
+ {name: 'concentration', type: 'float'},
+ {name: 'xleft', type: 'float', defaultValue: ''},
+ {name: 'xright', type: 'float'},
+ {name: 'base', type: 'float'},
+ {name: 'auc', type: 'float'},
+ {name: 'peakMax', type: 'float'},
+ {name: 'peakResponse', type: 'float'},
+ {name: 'filePath'},
+ {name: 'fileName'},
+ {name: 'fileExt'}
+ ]
+});
+
+Ext4.define('LABKEY.SignalData.Sample', {
+ extend: 'LABKEY.SignalData.StandardSource',
+
+ fields: [
+ {name: 'include', type: 'boolean', defaultValue: true}
+ ]
+});
diff --git a/signalData/resources/web/signaldata/QCView/QualityControl.js b/signalData/resources/web/signaldata/QCView/QualityControl.js
new file mode 100644
index 000000000..bbcf40e23
--- /dev/null
+++ b/signalData/resources/web/signaldata/QCView/QualityControl.js
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2016 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
+ */
+Ext4.define('LABKEY.SignalData.QualityControl', {
+ extend: 'Ext.panel.Panel',
+
+ layout: 'card',
+
+ minWidth: 650,
+
+ height: 700,
+
+ initComponent : function() {
+
+ this.items = [];
+
+ this.callParent();
+
+ this.getRunContext(function(context) {
+ this.loadContext(context);
+ }, this);
+ },
+
+ loadContext : function(context) {
+ this.context = context;
+ this.add(this.getSampleCreator());
+ },
+
+ getSampleCreator : function() {
+ if (!this.sampleCreator) {
+ this.sampleCreator = Ext4.create('LABKEY.SignalData.SampleCreator', {
+ context: this.context,
+ scope: this
+ });
+ }
+ return this.sampleCreator;
+ },
+
+ getRunContext : function(callback, scope) {
+ LABKEY.DataRegion.getSelected({
+ selectionKey: LABKEY.ActionURL.getParameter('selectionKey'),
+ success: function(resultSelection) {
+ LABKEY.Query.selectRows({
+ schemaName: LABKEY.ActionURL.getParameter('schemaName'),
+ queryName: 'Data',
+ requiredVersion: 13.2,
+ filterArray: [ LABKEY.Filter.create('RowId', resultSelection.selected.join(';'), LABKEY.Filter.Types.IN) ],
+ success: function(result) {
+ var runNames = [];
+ var dataNames = [];
+ if (result.rows.length > 0) {
+
+ Ext4.each(result.rows, function(row) {
+ runNames.push(row['Run/RunIdentifier'].value);
+ dataNames.push(row['Name'].value);
+ });
+
+ LABKEY.Query.selectRows({
+ schemaName: LABKEY.ActionURL.getParameter('schemaName'),
+ queryName: 'Runs',
+ requiredVersion: 13.2,
+ columns: 'RowId',
+ filterArray: [
+ LABKEY.Filter.create('RunIdentifier', runNames.join(';'), LABKEY.Filter.Types.IN)
+ ],
+ success: function(runs) {
+
+ var runIds = [];
+
+ Ext.each(runs.rows, function(row) {
+ runIds.push(row['RowId'].value);
+ });
+
+ SignalDataService.getRun(LABKEY.ActionURL.getParameter('schemaName'), runIds, dataNames, callback, scope);
+ },
+ scope: this
+ });
+ }
+ },
+ scope: this
+ });
+ },
+ scope: this
+ });
+ }
+});
diff --git a/signalData/resources/web/signaldata/QCView/SampleCreator.js b/signalData/resources/web/signaldata/QCView/SampleCreator.js
new file mode 100644
index 000000000..9a8565408
--- /dev/null
+++ b/signalData/resources/web/signaldata/QCView/SampleCreator.js
@@ -0,0 +1,550 @@
+/*
+ * Copyright (c) 2016 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
+ */
+//TODO: this should be renamed
+Ext4.define('LABKEY.SignalData.SampleCreator', {
+ extend: 'Ext.panel.Panel',
+
+ title: 'SignalData Qualitative Analysis',
+
+ layout: {
+ type: 'border',
+ regionWeights: {
+ west: 20,
+ north: 10,
+ south: -10,
+ east: 20
+ }
+ },
+
+ border: false,
+
+ initComponent: function() {
+
+ this.items = [
+ this.getWest(),
+ this.getNorth(),
+ this.getCenter(),
+ this.getEast()
+ ];
+
+ this.callParent();
+
+ this.curveTask = new Ext4.util.DelayedTask(function() {
+ var xleft = Ext4.getCmp('aucleft').getValue();
+ var xright = Ext4.getCmp('aucright').getValue();
+ this.fireEvent('curvechange', xleft, xright);
+ }, this);
+
+ this.rangeTask = new Ext4.util.DelayedTask(function() {
+ var low = Ext4.getCmp('mvrangelow').getValue();
+ var high = Ext4.getCmp('mvrangehigh').getValue();
+ this.fireEvent('rangechange', low, high);
+ }, this);
+ },
+
+ getWest : function() {
+
+ if (!this.westpanel) {
+ this.westpanel = Ext4.create('Ext.panel.Panel', {
+ region: 'west',
+ title: 'Available Inputs',
+ header: false,
+ id: 'sampleinputs',
+ width: 250,
+ border: false, frame: false,
+ style: 'border-right: 1px solid lightgrey; overflow-x: hidden; overflow-y: auto;',
+ bodyStyle: 'overflow-y: auto;',
+ items: [{
+ itemId: 'inputsgrid',
+ xtype: 'grid',
+ store: {
+ xtype: 'store',
+ model: 'LABKEY.SignalData.ProvisionalRun',
+ data: this.context.rawInputs
+ },
+ columns: [
+ {text: 'Inputs', dataIndex: 'name', width: 205}
+ ],
+ selModel: {
+ selType: 'checkboxmodel',
+ mode: 'MULTI'
+ },
+ hideHeaders: true,
+ listeners: {
+ viewready : function(g) {
+ //
+ // Filter to remove PRE_, POST_, and BLANK tags
+ //
+ g.getStore().filter([{
+ filterFn: function(item) {
+ return item.get('name').indexOf('PRE_') == -1 && item.get('name').indexOf('POST_') == -1;
+ }
+ },{
+ filterFn: function(item) {
+ return item.get('name').indexOf('BLANK') == -1;
+ }
+ }]);
+ },
+ selectionchange: function(g, recs) {
+ this.fireEvent('inputchange', recs);
+ Ext4.getCmp('startqcbtn').setDisabled(recs.length == 0);
+ },
+ scope: this
+ }
+ }],
+ dockedItems: [{
+ xtype: 'toolbar',
+ dock: 'top',
+ items: [{
+ id: 'startqcbtn',
+ text: 'Overlay Selected',
+ disabled: true,
+ handler: function(b) {
+ this.fireEvent('startqc', this.getSelectedInputResults());
+ },
+ scope: this
+ }]
+ }],
+ scope: this
+ });
+
+ this.on('startqc', function() {
+ this.updateZoom(0, 30, 0, 1200);
+ this.westpanel.collapse();
+ }, this);
+ }
+
+ return this.westpanel;
+ },
+
+ getNorth : function() {
+
+ if (!this.northpanel) {
+ var xLabel = this.getXLabel();
+ var yLabel = this.getYLabel();
+
+ this.northpanel = Ext4.create('Ext.panel.Panel', {
+ region: 'north',
+ height: 120,
+ items: [{
+ xtype: 'panel',
+ columnWidth: 0.5,
+ border: false, frame: false,
+ items: [{
+ id: 'sampleform',
+ itemId: 'sampleform',
+ xtype: 'form',
+ border: false, frame: false,
+ padding: '15 10',
+ fieldDefaults: {
+ labelWidth: 150
+ },
+ items: [{
+ xtype: 'fieldcontainer',
+ fieldLabel: xLabel,
+ layout: 'hbox',
+ width: 300,
+ items: [{
+ id: 'aucleft',
+ name: 'aucleft',
+ xtype: 'numberfield',
+ hideTrigger: true,
+ emptyText: 'left',
+ value: 0,
+ flex: 1,
+ listeners: {
+ change: function() {
+ this.curveTask.delay(300);
+ },
+ scope: this
+ }
+ },{
+ xtype: 'splitter'
+ },{
+ id: 'aucright',
+ name: 'aucright',
+ xtype: 'numberfield',
+ hideTrigger: true,
+ emptyText: 'right',
+ value: 30,
+ flex: 1,
+ listeners: {
+ change: function() {
+ this.curveTask.delay(300);
+ },
+ scope: this
+ }
+ }]
+ },{
+ xtype: 'fieldcontainer',
+ fieldLabel: yLabel,
+ layout: 'hbox',
+ width: 300,
+ items: [{
+ id: 'mvrangelow',
+ xtype: 'numberfield',
+ hideTrigger: true,
+ emptyText: 'left',
+ value: 0,
+ flex: 1,
+ listeners: {
+ change: function() {
+ this.rangeTask.delay(300);
+ },
+ scope: this
+ }
+ },{
+ xtype: 'splitter'
+ },{
+ id: 'mvrangehigh',
+ xtype: 'numberfield',
+ hideTrigger: true,
+ emptyText: 'right',
+ value: 1200,
+ flex: 1,
+ listeners: {
+ change: function() {
+ this.rangeTask.delay(300);
+ },
+ scope: this
+ }
+ }]
+ }]
+ }]
+ }]
+ });
+
+
+ this.on('startqc', function(runs) {
+ //
+ // clear the form fields
+ //
+ this.getQCForm().getForm().reset();
+ }, this);
+ }
+ return this.northpanel;
+ },
+
+ getInputsSelectionModel : function() {
+ return this.getWest().getComponent('inputsgrid').getSelectionModel();
+ },
+
+ getSelectedInputResults : function() {
+ return this.getInputsSelectionModel().getSelection();
+ },
+
+ getQCForm : function() {
+ return Ext4.getCmp('sampleform');
+ },
+
+ getCenter : function() {
+
+ if (!this.centerpanel) {
+ var xLabel = this.getXLabel();
+ var yLabel = this.getYLabel();
+
+ this.centerpanel = Ext4.create('Ext.panel.Panel', {
+ region: 'center',
+ border: false, frame: false,
+ dockedItems: [{
+ xtype: 'toolbar',
+ dock: 'top',
+ items: [{
+ text: 'Reset Zoom',
+ handler: function() {
+ this.updateZoom(0, 30, 0, 1200);
+ },
+ scope: this
+ }]
+ }],
+ items: [{
+ id: 'plotarea',
+ xtype: 'spectrum',
+ xLabel: xLabel,
+ yLabel: yLabel,
+ leftBoundField: 'aucleft',
+ rightBoundField: 'aucright',
+ lowBoundField: 'mvrangelow',
+ highBoundField: 'mvrangehigh',
+ listeners: {
+ zoom: this.updateZoom,
+ scope: this
+ }
+ }]
+ });
+
+ this.on('startqc', function(provisionalRuns) {
+ //
+ // load the appropriate content for each selected sample
+ //
+ var received = 0,
+ expected = provisionalRuns.length,
+ allContent = [],
+ contentMap = {};
+
+ var done = function(content, pr) {
+ received++;
+ content.runName = pr.runName;
+ allContent.push(content);
+ contentMap[pr.runName] = content;
+ if (received == expected) {
+ this.allContent = allContent;
+ this.contentMap = contentMap;
+ this.renderPlot(allContent, true);
+ }
+ };
+
+ Ext4.each(provisionalRuns, function(run){
+ var pr = run.get('expDataRun');
+ if (pr) {
+ // use the run name as the key for all data
+ pr.runName = run.get('name');
+ SignalDataService.FileContentCache(pr, done, this);
+ }
+ else {
+ console.error('Failed to load expDataRun from provisional run.');
+ }
+ }, this);
+
+ }, this);
+ }
+
+ return this.centerpanel;
+ },
+
+ getXLabel: function(){
+ return this.getAxisLabel('XAxis');
+ },
+ getYLabel: function(){
+ return this.getAxisLabel('YAxis');
+ },
+
+ getAxisLabel: function(axisField) {
+ var assay = this.context.AssayDefinition;
+ if (assay && assay.domains && assay.domains[assay.name + ' Batch Fields']) {
+ var batchFields = assay.domains[assay.name + ' Batch Fields'];
+ for(var i=0; i< batchFields.length;i++) {
+ var field = batchFields[i];
+ if (field.fieldKey === axisField) {
+ return field.defaultValue;
+ }
+ }
+ }
+ },
+
+ getEast : function() {
+
+ if (!this.eastpanel) {
+
+ var view = Ext4.create('Ext.view.View', {
+ store: {
+ xtype: 'store',
+ model: 'LABKEY.SignalData.Sample'
+ },
+ itemSelector: 'tr.item',
+ autoScroll: true,
+ tpl: new Ext4.XTemplate(
+ '',
+ '',
+ 'Name ',
+ 'Left ',
+ 'Right ',
+ 'Base ',
+ 'Include ',
+ 'Response ',
+ ' ',
+ '',
+ '',
+ '{name} ',
+ '{peakResponse:this.renderPeakResponse} C ',
+ ' ',
+ '
',
+ {
+ renderChecked : function(checked) {
+ var ret = '';
+ if (checked === true) {
+ ret = ' checked="checked" ';
+ }
+ return ret;
+ },
+ renderPeakResponse : function(response) {
+ return response.toFixed(3);
+ }
+ }
+ ),
+ listeners: {
+ viewready: function(v) { this.qcresultview = v; },
+ itemclick: this.onQCResultItemSelect,
+ select: this.bindCalc,
+ scope: this
+ }
+ });
+
+ this.eastpanel = Ext4.create('Ext.panel.Panel', {
+ title: 'Basic integration',
+ region: 'east',
+ autoScroll: true,
+ width: 400,
+ layout: {
+ type: 'vbox',
+ align: 'stretch'
+ },
+ items: [view],
+ dockedItems: [{
+ xtype: 'toolbar',
+ dock: 'top',
+ items: [{
+ // text: 'Calculate',
+ // handler: this.runAnalysis,
+ // scope: this
+ // },{
+ text: 'Clear Highlight',
+ handler: function() {
+ this.highlighted = undefined;
+ this.renderPlot(this.allContent);
+ },
+ scope: this
+ }]
+ }]
+ });
+
+ this.on('startqc', function(runs) {
+
+ var _runs = [];
+ for (var r=0; r < runs.length; r++) {
+ _runs.push(Ext4.clone(runs[r].data));
+ }
+ view.getStore().loadData(_runs);
+
+ }, this);
+ this.on('curvechange', function(xleft, xright) { this.renderPlot(this.allContent); }, this);
+ this.on('rangechange', function(low, high) { this.renderPlot(this.allContent); }, this);
+ }
+
+ return this.eastpanel;
+ },
+
+ /**
+ * Fires whenever a user selects any input for a give QC Result row. Primarily used to check if they clicked
+ * 'C' meaning to copy that rows results as a convenience.
+ */
+ onQCResultItemSelect : function(view, model, z, a, evt) {
+ if (evt.target && Ext4.isString(evt.target.tagName) && evt.target.tagName.toLowerCase() === "button") {
+ this.updateModels();
+ }
+ else {
+ // for some reason, focus is not maintained even after a user clicks an input
+ Ext4.defer(function() { Ext4.get(evt.target).dom.focus(); }, 50);
+ }
+ },
+
+ bindCalc : function(view, sample) {
+ var modelname = sample.get('name');
+
+ if (modelname) {
+ this.highlighted = sample.get('name');
+ this.renderPlot(this.allContent);
+ }
+ },
+
+ updateModels : function(callback, scope, toCopy) {
+ //
+ // Iterate over all QC Results updating their peakResponse based on given values for that row/result
+ //
+ if (Ext4.isDefined(this.qcresultview)) {
+ var view = this.qcresultview;
+ var store = view.getStore();
+ var models = store.getRange();
+
+ var xleft, xright, base, include, response;
+
+ Ext4.each(models, function(model) {
+
+ if (Ext4.isDefined(toCopy)) {
+ xleft = toCopy.get('xleft');
+ xright = toCopy.get('xright');
+ base = toCopy.get('base');
+ }
+ else {
+ xleft = +this._getNodeValue(view, model, 'input[name="xleft"]');
+ xright = +this._getNodeValue(view, model, 'input[name="xright"]');
+ base = +this._getNodeValue(view, model, 'input[name="base"]');
+ }
+
+ include = this._getNode(view, model, 'input[name="include"]');
+ response = this._getNode(view, model, 'span[name="response"]');
+
+ var fileContent = this.contentMap[model.get('name')];
+ var data = SignalDataService.getData(fileContent, xleft, xright, false);
+ var aucPeak = LABKEY.SignalData.Stats.getAUC(data, base);
+ response.update(+aucPeak.auc.toFixed(3));
+
+ model.suspendEvents(true);
+ model.set('xleft', xleft);
+ model.set('xright', xright);
+ model.set('base', base);
+ model.set('auc', aucPeak.auc);
+ model.set('peakResponse', aucPeak.auc);
+ model.set('peakMax', aucPeak.peakMax);
+ model.set('include', include.dom.checked);
+ model.resumeEvents();
+ }, this);
+
+ if (Ext4.isFunction(callback)) {
+ callback.call(scope);
+ }
+ }
+ else {
+ console.error('qcresultview not initialized before update.');
+ }
+ },
+
+ _getNode : function(view, model, selector) {
+ return Ext4.get(Ext4.DomQuery.select(selector, view.getNodeByRecord(model))[0]);
+ },
+
+ _getNodeValue : function(view, model, selector) {
+ return this._getNode(view, model, selector).getValue();
+ },
+
+ renderPlot : function(contents, isStartQC) {
+ if (isStartQC) {
+ var mvHight = SignalDataService.getMaxHeight(contents);
+ var mvHighCmp = Ext4.getCmp('mvrangehigh');
+ mvHighCmp.setValue(mvHight);
+ }
+
+ var spectrumPlot = Ext4.getCmp('plotarea');
+ spectrumPlot.leftRight = [Ext4.getCmp('aucleft').getValue(), Ext4.getCmp('aucright').getValue()];
+ spectrumPlot.lowHigh = [Ext4.getCmp('mvrangelow').getValue(), Ext4.getCmp('mvrangehigh').getValue()];
+ spectrumPlot.setHighlight(this.highlighted);
+ spectrumPlot.renderPlot(contents);
+
+ this.fireEvent('samplesrendered');
+ },
+
+ clearPlot : function() {
+ Ext4.getCmp('plotarea').clearPlot();
+ },
+
+ updateZoom : function(l, r, b, t) {
+ var leftCmp = Ext4.getCmp('aucleft');
+ var rightCmp = Ext4.getCmp('aucright');
+ var mvLowCmp = Ext4.getCmp('mvrangelow');
+ var mvHighCmp = Ext4.getCmp('mvrangehigh');
+ leftCmp.setValue(l);
+ rightCmp.setValue(r);
+ mvLowCmp.setValue(b);
+ mvHighCmp.setValue(t);
+ }
+});
diff --git a/signalData/resources/web/signaldata/QCView/SpectrumPlot.js b/signalData/resources/web/signaldata/QCView/SpectrumPlot.js
new file mode 100644
index 000000000..534d3c34d
--- /dev/null
+++ b/signalData/resources/web/signaldata/QCView/SpectrumPlot.js
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2016 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
+ */
+Ext4.define('LABKEY.SignalData.SpectrumPlot', {
+
+ extend: 'Ext.Component',
+
+ alias: 'widget.spectrum',
+
+ colors: ['#00FE00', '#0100FE', '#FC01FC', '#ff0000'],
+
+ yLabel: '',
+
+ xLabel: '',
+
+ leftRight: [0, 30],
+
+ lowHigh: [0, 1200],
+
+ id: Ext4.id(),
+
+ height: '100%',
+
+ autoEl: {
+ tag: 'div'
+ },
+
+ autoZoom: false,
+
+ highlight: undefined,
+
+ constructor : function(config) {
+ this.callParent([config]);
+ this.addEvents('zoom');
+ },
+
+ clearPlot : function() {
+ Ext4.get(this.id).update('');
+ },
+
+ renderPlot : function(contents) {
+
+ if (!contents) {
+ if (!this._lastContent) {
+ console.error(this.$className + '.renderPlot requires contents be provided at least once');
+ return;
+ }
+ contents = this._lastContent;
+ }
+
+ var layers = [];
+ var colors = this.colors;
+
+ var xleft = this.leftRight[0], xright = this.leftRight[1],
+ low = this.lowHigh[0], high = this.lowHigh[1];
+
+ var c=0, isHighlight = false, useHighlight = (this.highlight ? true : false), color;
+ for (var i=0; i < contents.length; i++) {
+ //
+ // create point layer
+ //
+ color = colors[c%colors.length];
+
+ if (useHighlight) {
+ isHighlight = (this.highlight === contents[i].runName);
+
+ if (!isHighlight) {
+ color = '#A09C9C';
+ }
+ }
+
+ var pointLayer = new LABKEY.vis.Layer({
+ data: SignalDataService.getData(contents[i], xleft, xright, 2),
+ aes: {
+ x: function(r) { return r[0]; },
+ y: function(r) { return r[1]; }
+ },
+ geom: new LABKEY.vis.Geom.Path({
+ color: color
+ })
+ });
+ c++;
+
+ layers.push(pointLayer);
+ }
+
+ this.update('');
+
+ var box = this.getBox();
+
+ var width = box.width;
+ var height = box.height - 30;
+
+ var me = this;
+
+ var plot = new LABKEY.vis.Plot({
+ renderTo: this.id,
+ rendererType: 'd3',
+ width: width,
+ height: height,
+ layers: layers,
+ legendPos: 'none',
+ labels: {
+ x: {value: this.xLabel},
+ y: {value: this.yLabel}
+ },
+ scales: {
+ x: { domain: [xleft, xright] },
+ y: { domain: [low, high] }
+ },
+ brushing: {
+ brush: function() {}, /* required due to bug in brushing API */
+ brushend: function(e, d, extent, ls) {
+ var left = extent[0][0];
+ var right = extent[1][0];
+ var bottom = extent[0][1];
+ var top = extent[1][1];
+ me.updateZoom(left, right, bottom, top);
+ }
+ }
+ });
+
+ this._lastContent = contents;
+ plot.render();
+ },
+
+ setHighlight : function(highlight) {
+ this.highlight = highlight;
+ },
+
+ resetZoom : function() {
+ this.leftRight = [0, 30];
+ this.lowHigh = [0, 1200];
+ if (this._lastContent) {
+ this.renderPlot();
+ }
+ },
+
+ updateZoom : function(left, right, bottom, top) {
+ if (this.autoZoom) {
+ this.leftRight = [left, right];
+ this.lowHigh = [bottom, top];
+ this.renderPlot();
+ }
+ this.fireEvent('zoom', left, right, bottom, top);
+ }
+});
\ No newline at end of file
diff --git a/signalData/resources/web/signaldata/QCView/Stats.js b/signalData/resources/web/signaldata/QCView/Stats.js
new file mode 100644
index 000000000..cb7ea9b48
--- /dev/null
+++ b/signalData/resources/web/signaldata/QCView/Stats.js
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2016 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
+ */
+Ext4.define('LABKEY.SignalData.Stats', {
+
+ singleton: true,
+
+ getAUC : function(data, ybase) {
+ //
+ // Calculate AUC
+ //
+ var sum = 0.0, area = 0.0, peakMax = 0.0;
+ var x1, x0, y1, y0, i;
+
+ for (i = 1; i < data.length; i++)
+ {
+ x0 = data[i - 1][0] * 60;
+ x1 = data[i][0] * 60;
+ y0 = data[i - 1][1] - ybase;
+ y1 = data[i][1] - ybase;
+
+ // only work above the baseline
+ if (y0 >= 0 && y1 >= 0)
+ {
+ peakMax = Math.max(y0, peakMax);
+ area = ((y1 + y0) / 2) * (x1 - x0);
+ sum += area;
+ }
+ }
+
+ return {
+ 'auc': sum,
+ 'peakMax': peakMax
+ };
+ },
+
+ /**
+ * This method utilizes the regression methods provided by
+ * http://tom-alexander.github.com/regression-js/
+ * This library is loaded on the page and provided under window.regression
+ * @param points
+ * @returns {*}
+ */
+ getPolynomialRegression : function(points) {
+
+ if (!Ext4.isFunction(window.regression)) {
+ console.error(this.$className + '.getPolynomialRegression depends on regression.js. Include that library.');
+ return;
+ }
+
+ var doRegression = function(x, terms) {
+ var a = 0, exp = 0, term;
+ for (var i = 0; i < terms.length;i++) {
+ term = terms[i];
+ a += term * Math.pow(x, exp);
+ exp++;
+ }
+ return a;
+ };
+
+ var rSquared = function(data, terms) {
+
+ var xs = [], _x;
+ var ys = [], ystar = [], ysum = 0, _y, _yy;
+
+ var sqrdErrorWithLine = [], SESum = 0;
+
+ // apply equation to calculate ystar
+ var getY = function(x) { return (terms[2] * Math.pow(x, 2)) + (terms[1] * x) + terms[0]; };
+
+ for (var d=0; d < data.length; d++) {
+
+ _x = data[d][0];
+ _y = data[d][1];
+ _yy = getY(_x);
+
+ xs.push(_x);
+ ys.push(_y);
+ ystar.push(_yy);
+ ysum += _y;
+
+ _y = Math.pow((_y - _yy), 2);
+ sqrdErrorWithLine.push(_y);
+ SESum += _y;
+ }
+
+ var yavg = (ysum / ys.length), sqrdMeanY = [], meanYSum = 0;
+
+ for (d=0; d < data.length; d++) {
+ _y = ys[d] - yavg;
+ _y = Math.pow(_y, 2);
+ sqrdMeanY.push(_y);
+ meanYSum += _y;
+ }
+
+ return 1 - (SESum / meanYSum);
+ };
+
+ var stdError = function(data, terms) {
+ var r = 0;
+ var n = data.length;
+ if (n > 2) {
+ var a = 0, xy;
+ for (var i = 0;i < data.length;i++) {
+ xy = data[i];
+ a += Math.pow((doRegression(xy[0], terms) - xy[1]), 2);
+ }
+ r = Math.sqrt(a / (n - 2));
+ }
+ return r;
+ };
+
+ var R = regression('polynomial', points, 2);
+ R.stdError = stdError(Ext4.clone(points), Ext4.clone(R.equation));
+ R.rSquared = rSquared(Ext4.clone(points), Ext4.clone(R.equation));
+ return R;
+ },
+
+ average : function(a) {
+ var r = {mean: 0, variance: 0, deviation: 0}, t = a.length;
+ for(var m, s = 0, l = t; l--; s += a[l]);
+ for(m = r.mean = s / t, l = t, s = 0; l--; s += Math.pow(a[l] - m, 2));
+ return r.deviation = Math.sqrt(r.variance = s / t), r;
+ },
+
+ /**
+ * Quadratic formula returning an array result of two numeric values [x+, x-]
+ */
+ getQuadratic : function(a, b, c) {
+ var inner = Math.pow(b, 2) - (4 * a * c);
+ var sqrtInner = Math.sqrt(inner);
+ var negB = -1 * b;
+ var bottom = 2 * a;
+
+ var x_plus = (negB + sqrtInner) / bottom;
+ var x_minus = (negB - sqrtInner) / bottom;
+
+ return [x_plus, x_minus];
+ }
+});
\ No newline at end of file
diff --git a/signalData/resources/web/signaldata/QCView/regression.js b/signalData/resources/web/signaldata/QCView/regression.js
new file mode 100644
index 000000000..ce9a03f0b
--- /dev/null
+++ b/signalData/resources/web/signaldata/QCView/regression.js
@@ -0,0 +1,210 @@
+/**
+ * @license
+ *
+ * Regression.JS - Regression functions for javascript
+ * http://tom-alexander.github.com/regression-js/
+ *
+ * copyright(c) 2013 Tom Alexander
+ * Licensed under the MIT license.
+ *
+ **/
+
+;(function() {
+ 'use strict';
+
+ var gaussianElimination = function(a, o) {
+ var i = 0, j = 0, k = 0, maxrow = 0, tmp = 0, n = a.length - 1, x = new Array(o);
+ for (i = 0; i < n; i++) {
+ maxrow = i;
+ for (j = i + 1; j < n; j++) {
+ if (Math.abs(a[i][j]) > Math.abs(a[i][maxrow]))
+ maxrow = j;
+ }
+ for (k = i; k < n + 1; k++) {
+ tmp = a[k][i];
+ a[k][i] = a[k][maxrow];
+ a[k][maxrow] = tmp;
+ }
+ for (j = i + 1; j < n; j++) {
+ for (k = n; k >= i; k--) {
+ a[k][j] -= a[k][i] * a[i][j] / a[i][i];
+ }
+ }
+ }
+ for (j = n - 1; j >= 0; j--) {
+ tmp = 0;
+ for (k = j + 1; k < n; k++)
+ tmp += a[k][j] * x[k];
+ x[j] = (a[n][j] - tmp) / a[j][j];
+ }
+ return (x);
+ };
+
+ var methods = {
+ linear: function(data) {
+ var sum = [0, 0, 0, 0, 0], n = 0, results = [];
+
+ for (; n < data.length; n++) {
+ if (data[n][1]) {
+ sum[0] += data[n][0];
+ sum[1] += data[n][1];
+ sum[2] += data[n][0] * data[n][0];
+ sum[3] += data[n][0] * data[n][1];
+ sum[4] += data[n][1] * data[n][1];
+ }
+ }
+
+ var gradient = (n * sum[3] - sum[0] * sum[1]) / (n * sum[2] - sum[0] * sum[0]);
+ var intercept = (sum[1] / n) - (gradient * sum[0]) / n;
+ // var correlation = (n * sum[3] - sum[0] * sum[1]) / Math.sqrt((n * sum[2] - sum[0] * sum[0]) * (n * sum[4] - sum[1] * sum[1]));
+
+ for (var i = 0, len = data.length; i < len; i++) {
+ var coordinate = [data[i][0], data[i][0] * gradient + intercept];
+ results.push(coordinate);
+ }
+
+ var string = 'y = ' + Math.round(gradient*100) / 100 + 'x + ' + Math.round(intercept*100) / 100;
+
+ return {equation: [gradient, intercept], points: results, string: string};
+ },
+
+ exponential: function(data) {
+ var sum = [0, 0, 0, 0, 0, 0], n = 0, results = [];
+
+ for (len = data.length; n < len; n++) {
+ if (data[n][1]) {
+ sum[0] += data[n][0];
+ sum[1] += data[n][1];
+ sum[2] += data[n][0] * data[n][0] * data[n][1];
+ sum[3] += data[n][1] * Math.log(data[n][1]);
+ sum[4] += data[n][0] * data[n][1] * Math.log(data[n][1]);
+ sum[5] += data[n][0] * data[n][1];
+ }
+ }
+
+ var denominator = (sum[1] * sum[2] - sum[5] * sum[5]);
+ var A = Math.pow(Math.E, (sum[2] * sum[3] - sum[5] * sum[4]) / denominator);
+ var B = (sum[1] * sum[4] - sum[5] * sum[3]) / denominator;
+
+ for (var i = 0, len = data.length; i < len; i++) {
+ var coordinate = [data[i][0], A * Math.pow(Math.E, B * data[i][0])];
+ results.push(coordinate);
+ }
+
+ var string = 'y = ' + Math.round(A*100) / 100 + 'e^(' + Math.round(B*100) / 100 + 'x)';
+
+ return {equation: [A, B], points: results, string: string};
+ },
+
+ logarithmic: function(data) {
+ var sum = [0, 0, 0, 0], n = 0, results = [];
+
+ for (len = data.length; n < len; n++) {
+ if (data[n][1]) {
+ sum[0] += Math.log(data[n][0]);
+ sum[1] += data[n][1] * Math.log(data[n][0]);
+ sum[2] += data[n][1];
+ sum[3] += Math.pow(Math.log(data[n][0]), 2);
+ }
+ }
+
+ var B = (n * sum[1] - sum[2] * sum[0]) / (n * sum[3] - sum[0] * sum[0]);
+ var A = (sum[2] - B * sum[0]) / n;
+
+ for (var i = 0, len = data.length; i < len; i++) {
+ var coordinate = [data[i][0], A + B * Math.log(data[i][0])];
+ results.push(coordinate);
+ }
+
+ var string = 'y = ' + Math.round(A*100) / 100 + ' + ' + Math.round(B*100) / 100 + ' ln(x)';
+
+ return {equation: [A, B], points: results, string: string};
+ },
+
+ power: function(data) {
+ var sum = [0, 0, 0, 0], n = 0, results = [];
+
+ for (len = data.length; n < len; n++) {
+ if (data[n][1]) {
+ sum[0] += Math.log(data[n][0]);
+ sum[1] += Math.log(data[n][1]) * Math.log(data[n][0]);
+ sum[2] += Math.log(data[n][1]);
+ sum[3] += Math.pow(Math.log(data[n][0]), 2);
+ }
+ }
+
+ var B = (n * sum[1] - sum[2] * sum[0]) / (n * sum[3] - sum[0] * sum[0]);
+ var A = Math.pow(Math.E, (sum[2] - B * sum[0]) / n);
+
+ for (var i = 0, len = data.length; i < len; i++) {
+ var coordinate = [data[i][0], A * Math.pow(data[i][0] , B)];
+ results.push(coordinate);
+ }
+
+ var string = 'y = ' + Math.round(A*100) / 100 + 'x^' + Math.round(B*100) / 100;
+
+ return {equation: [A, B], points: results, string: string};
+ },
+
+ polynomial: function(data, order) {
+ if(typeof order == 'undefined'){
+ order = 2;
+ }
+ var lhs = [], rhs = [], results = [], a = 0, b = 0, i = 0, k = order + 1;
+
+ for (; i < k; i++) {
+ for (var l = 0, len = data.length; l < len; l++) {
+ if (data[l][1]) {
+ a += Math.pow(data[l][0], i) * data[l][1];
+ }
+ }
+ lhs.push(a), a = 0;
+ var c = [];
+ for (var j = 0; j < k; j++) {
+ for (var l = 0, len = data.length; l < len; l++) {
+ if (data[l][1]) {
+ b += Math.pow(data[l][0], i + j);
+ }
+ }
+ c.push(b), b = 0;
+ }
+ rhs.push(c);
+ }
+ rhs.push(lhs);
+
+ var equation = gaussianElimination(rhs, k);
+
+ for (var i = 0, len = data.length; i < len; i++) {
+ var answer = 0;
+ for (var w = 0; w < equation.length; w++) {
+ answer += equation[w] * Math.pow(data[i][0], w);
+ }
+ results.push([data[i][0], answer]);
+ }
+
+ var string = 'y = ';
+
+ for(var i = equation.length-1; i >= 0; i--){
+ if(i > 1) string += Math.round(equation[i]*100) / 100 + 'x^' + i + ' + ';
+ else if (i == 1) string += Math.round(equation[i]*100) / 100 + 'x' + ' + ';
+ else string += Math.round(equation[i]*100) / 100;
+ }
+
+ return {equation: equation, points: results, string: string};
+ }
+ };
+
+ var regression = (function(method, data, order) {
+
+ if (typeof method == 'string') {
+ return methods[method](data, order);
+ }
+ });
+
+ if (typeof exports !== 'undefined') {
+ module.exports = regression;
+ } else {
+ window.regression = regression;
+ }
+
+}());
\ No newline at end of file
diff --git a/signalData/resources/web/signaldata/QCView/signaldata.js b/signalData/resources/web/signaldata/QCView/signaldata.js
new file mode 100644
index 000000000..62a203436
--- /dev/null
+++ b/signalData/resources/web/signaldata/QCView/signaldata.js
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2016 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
+ */
+if (!LABKEY.SignalData) {
+ LABKEY.SignalData = {};
+}
+
+LABKEY.SignalData.signalDataSelection = function(dataRegion, dataRegionName) {
+ var qcViewProvider = LABKEY.getModuleProperty('signaldata', 'QCViewProviderModule') || 'signaldata';
+ window.location = LABKEY.ActionURL.buildURL(qcViewProvider, 'qc', null, {
+ selectionKey: dataRegion.selectionKey,
+ queryName: dataRegion.queryName,
+ schemaName: dataRegion.schemaName,
+ rowId: LABKEY.ActionURL.getParameter('rowId')
+ });
+};
\ No newline at end of file
diff --git a/signalData/resources/web/signaldata/ResultUpdate/resultupdate.js b/signalData/resources/web/signaldata/ResultUpdate/resultupdate.js
new file mode 100644
index 000000000..2c4f95710
--- /dev/null
+++ b/signalData/resources/web/signaldata/ResultUpdate/resultupdate.js
@@ -0,0 +1,359 @@
+/*
+ * Copyright (c) 2016-2019 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * Created by iansigmon on 8/26/16.
+ */
+Ext4.ns('LABKEY.SignalData');
+
+var getAssay = function() {
+ LABKEY.Assay.getById({
+ id:LABKEY.ActionURL.getParameter('protocolId'),
+ success:function(def) {
+ getResultData(def[0]);
+ }
+ });
+};
+
+var loadBatch = function(callback, scope){
+ LABKEY.Experiment.loadBatch({
+ assayId: LABKEY.ActionURL.getParameter('protocolId'),
+ batchId: LABKEY.ActionURL.getParameter('batchId'),
+ success: function(result) {
+ callback.call(scope || this, result);
+ }
+ });
+};
+
+var getResultData = function(assay) {
+ LABKEY.Query.selectRows({
+ schemaName: assay.protocolSchemaName,
+ queryName: 'data',
+ requiredVersion: 13.2,
+ filterArray: [LABKEY.Filter.create('RowId', LABKEY.ActionURL.getParameter('rowId'))],
+ success: function(results){
+ if (results.length > 0) {
+ init(assay, results.getRow(0));
+ }
+ else {
+ // Use an ExtJS alert instead of a raw browser alert to avoid alarming the crawler
+ Ext4.Msg.alert('Error', 'Row not found');
+ }
+ },
+ scope: this
+ });
+};
+
+var getFileInputFromExtFileField = function(field) {
+ return document.getElementById(field.button.fileInputEl.id);
+};
+
+var init = function(assay, row){
+
+ var assay = assay;
+ var row = row;
+ var saveRun = function(form, dataFiles) {
+ if(!dataFiles) {
+ var updateRow = setRunFields(form, dataFiles);
+ updateRunResult(updateRow, dataFiles);
+ }
+ else {
+ var file = dataFiles[0];
+ LABKEY.Ajax.request({
+ url: LABKEY.ActionURL.buildURL('SignalData', 'getSignalDataResource.api'),
+ method: 'POST',
+ params: {path: decodeURIComponent(file.internalId), test: true},
+ success: function (response) {
+ var fileResource = Ext4.decode(response.responseText);
+ var updatedRow = setRunFields(form, fileResource);
+ updateRunResult(updatedRow, fileResource);
+ },
+ scope: this
+ });
+ }
+ };
+
+ var updateRunResult = function(updatedRow, file) {
+ LABKEY.Query.updateRows({
+ schemaName: assay.protocolSchemaName,
+ queryName: 'data',
+ rows: [updatedRow],
+ success: function (rowResults, request, options) {
+ if (!file) {
+ //No file to save, return to grid
+ navToReturnURL();
+ }
+ else {
+ //Save file
+ updateRunInputs(updatedRow, file);
+ }
+ },
+ failure: function(response){
+ //TODO: Do more here
+ alert("Failed to update data");
+ }
+ });
+ };
+
+ var updateRunInputs = function(updatedRow, dataFile) {
+ var callback = function(batch) {
+ var runId = LABKEY.ActionURL.getParameter('runId');
+ for (var i = 0; batch && i < batch.runs.length; i++) {
+
+ //Find run to add input to.
+ var run = batch.runs[i];
+ if (runId == run.id) {
+ run.dataInputs.push({
+ dataFileURL: dataFile.DataFileUrl
+ });
+
+ //save updated batch with new input object
+ LABKEY.Experiment.saveBatch({
+ assayId: assay.id,
+ batch: batch,
+ success: function (batch, response) {
+ navToReturnURL();
+ },
+ scope: this
+ });
+
+ return;
+ }
+ }
+
+ alert("Could not find run to update");
+ };
+
+ //Get fresh batch object
+ loadBatch(callback, this);
+ };
+
+ var setRunFields = function(form, dataFiles) {
+ var newRow = {
+ RowId: LABKEY.ActionURL.getParameter('rowId')
+ };
+
+ if (dataFiles)
+ newRow.DataFile = decodeURI(dataFiles['DataFileUrl']).replace( new RegExp('^file:/+'), '/');
+
+
+ var fieldValues = form.getForm().getFieldValues(true);
+ Object.keys(fieldValues).forEach(function(key){
+ newRow[key] = fieldValues[key];
+ });
+
+ return newRow;
+ };
+
+ var getConfigs = function(fields) {
+ if (!fields || fields.length == 0)
+ return [];
+
+ var configs = [];
+ Ext4.each(fields, function(metaField) {
+ var config = getExtConfig(metaField);
+ configs.push(config);
+ });
+
+ return configs;
+ };
+
+ var fileFields = [];
+ var getExtConfig = function(meta) {
+ var config;
+ if (meta.inputType === 'file' || meta.fieldKey === 'DataFile') {
+ var dataFile = row.get(meta.fieldKey);
+ config =
+ {
+ xtype:'fieldcontainer',
+ fieldLabel: meta.name,
+ name: meta.fieldKey,
+ border:false,
+ items:[{
+ xtype:'fieldcontainer',
+ tpl: '',
+ data:{
+ file:
+ {
+ url: dataFile.url,
+ hasDisplayValue: dataFile.displayValue,
+ displayValue: dataFile.displayValue || (dataFile.value + " (unavailable) ")
+ },
+ fieldKey: meta.fieldKey
+ },
+ listeners:{
+ render: function(field) {
+ field.up().template = field;
+ }
+ }
+ }, {
+ xtype: 'fileuploadfield',
+ buttonText: "Choose a File",
+ id: meta.name + 'File',
+ width: 350,
+ hidden: true,
+ listeners:{
+ render: function(field) {
+ fileFields.push(field);
+ field.up().fileField = field;
+ }
+ }
+ }],
+ listeners:{
+ render: function(field){
+ // attach listeners to all of the delete span buttons
+ var selection = Ext4.select('a[class^="removeFile"]', this.getEl());
+ if (selection) {
+ Ext4.each(selection.elements, function (el) {
+ Ext4.EventManager.addListener(el, 'click', this.removeFile, this);
+ }, this);
+ }
+ }
+ },
+ removeFile: function() {
+ this.template.hide();
+ this.fileField.show();
+ }
+ };
+ } else {
+ setLookupConfig(meta);
+ config = LABKEY.ext4.Util.getFormEditorConfig(meta);
+ config.value = row.get(meta.name).value;
+ }
+
+ return Ext4.apply(config, {
+ id: config.name,
+ validateOnBlur: false,
+ labelCls: 'labkey-form-label',
+ formBind: true
+
+ });
+ };
+
+ var setLookupConfig = function(meta) {
+ // the getDefaultEditorConfig code in util.js expects a lookup object, so create one here
+ // if our metadata has lookup information
+ if (meta.lookupQuery && meta.lookupSchema && !meta.lookup) {
+ meta.lookup = {
+ container: meta.lookupContainer,
+ schemaName: meta.lookupSchema,
+ queryName: meta.lookupQuery
+ };
+ }
+ };
+
+ var resolvePipeline = function (callback, scope) {
+ if (Ext4.isFunction(callback)) {
+ Ext4.Ajax.request({
+ url: LABKEY.ActionURL.buildURL('SignalData', 'getSignalDataPipelineContainer.api'),
+ method: 'GET',
+ success: function (response) {
+ var context = Ext4.decode(response.responseText);
+ if (Ext4.isObject(context) && !Ext4.isEmpty(context.containerPath) && !Ext4.isEmpty(context.webDavURL)) {
+ callback.call(scope || this, context);
+ }
+ else {
+ Ext4.Msg.alert('Error', 'Failed to load the pipeline context for Signal Data');
+ }
+ },
+ failure: function (error, response) {
+ Ext4.Msg.alert('Error', 'Failed to load the pipeline context for Signal Data');
+ }
+ });
+ }
+ };
+
+ var getResultFieldConfigs = function(){
+ var resultFields = assay.domains[assay.name + ' Result Fields'];
+ return getConfigs(resultFields);
+ };
+
+ var form = Ext4.create('Ext.form.Panel', {
+ renderTo: 'update',
+ border:false,
+ items: getResultFieldConfigs(),
+ bodyStyle: 'background-color: transparent;',
+ buttons: [{
+ xtype: 'button',
+ text: 'Cancel',
+ handler: function () {
+ window.location = LABKEY.ActionURL.getReturnUrl();
+ }
+ }, {
+ xtype: 'button',
+ text: 'Save',
+ handler: function () {
+ //Generate a form to upload files with
+ var uploadForm;
+
+ //For each file field in the main form add files to uploader
+ fileFields.forEach(function(field) {
+ var fileInput = getFileInputFromExtFileField(field);
+ Object.keys(fileInput.files).forEach(function(key) {
+ var fileToUpload = fileInput.files[key];
+ uploadForm = uploadForm || new FormData();
+ uploadForm.append(fileToUpload.name, fileToUpload);
+ });
+ });
+
+ if (uploadForm) {
+ LABKEY.Ajax.request({
+ url: form.url + '?overwrite=t',
+ method: 'POST',
+ form: uploadForm,
+ header:false,
+ success: function (response, operation) {
+ var results;
+ if (response.responseXML != null) {
+ var reader = new Ext4.data.reader.Xml({
+ record: '>response',
+ root: 'multistatus',
+ type: 'xml',
+ model: 'File.data.webdav.XMLResponse'
+ });
+
+ results = reader.read(response.responseXML.documentElement);
+ }
+
+ saveRun(form, results ? results.records : null);
+ },
+ failure: function (response, operation) {
+ //TODO: Do something...
+ }
+ });
+ }
+ else {
+ saveRun(form);
+ }
+ }
+ }],
+ buttonAlign: 'left'
+ });
+
+ resolvePipeline(function (context) {
+ this.fileSystem = Ext4.create('File.system.Webdav', {
+ rootPath: context['webDavURL'],
+ rootOffset: LABKEY.ActionURL.getParameter('runName'),
+ rootName: 'fileset'
+ });
+
+ this.url = this.fileSystem.getAbsoluteURL();
+ }, form);
+
+ var navToReturnURL = function(){
+ window.location = LABKEY.ActionURL.getReturnUrl();
+ };
+};
+
+getAssay();
diff --git a/signalData/resources/web/signaldata/UploadView/UploadLog.js b/signalData/resources/web/signaldata/UploadView/UploadLog.js
new file mode 100644
index 000000000..1e2b50231
--- /dev/null
+++ b/signalData/resources/web/signaldata/UploadView/UploadLog.js
@@ -0,0 +1,417 @@
+/*
+ * Copyright (c) 2016-2019 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+Ext4.ns('LABKEY.SignalData');
+
+Ext4.define('LABKEY.SignalData.UploadLog', {
+
+ extend: 'Ext.panel.Panel',
+
+ modelClass: 'LABKEY.SignalData.model.Uploads',
+
+ UPLOAD_TIME: 'uploadTime',
+ DATA_FILE: 'DataFile',
+ FILE_URL: 'DataFileURL',
+ FILENAME: 'FileName',
+ constructor: function (config) {
+ if (!Ext4.ModelManager.isRegistered(this.modelClass)) {
+ Ext4.define(this.modelClass, {
+ extend: 'Ext.data.Model',
+ fields: this.getFields(config.resultFields),
+ publishMessage: function (message) {
+ var oldMsgs = this.get("messages");
+ oldMsgs.push(message);
+ this.setCommit("messages", oldMsgs);
+ },
+
+ setCommit: function (fieldName, newValue) {
+ this.set(fieldName, newValue);
+ this.commit();
+ }
+ });
+ }
+
+ this.items = [this.getGrid(config.results, config.resultFields)];
+ this.callParent([config]);
+ this.addEvents('removefile');
+ },
+
+ initComponent: function () {
+ this.callParent();
+
+ this.resolvePipeline(function (context) {
+ this.fileSystem = Ext4.create('File.system.Webdav', {
+ rootPath: context['webDavURL'],
+ rootName: 'fileset'
+ });
+
+ this.createWorkingFolder();
+ }, this);
+ },
+
+ getFields: function (resultFields) {
+ if (!this.fields) {
+ var fields = [];
+ resultFields.forEach(function (field) {
+ fields.push({
+ name: field.name,
+ type: 'string'
+ });
+ });
+
+ this.fields = fields.concat([
+ {name: this.FILE_URL, type: 'string'},
+ {
+ name: 'messages',
+ convert: function (raw) {
+ var value = [];
+
+ if (Ext4.isArray(raw)) {
+ value = raw;
+ }
+ else if (!Ext4.isEmpty(raw)) {
+ value.push(raw);
+ }
+
+ return value;
+ }
+ },
+ {name: this.UPLOAD_TIME, type: 'date'},
+ {name: 'progress', type: 'int'},
+ {name: 'file', type:'file'}
+ ]);
+ }
+
+ return this.fields;
+ },
+
+ getGrid: function (results, assayResultFields) {
+ if (!this._grid) {
+ this._grid = Ext4.create('Ext.grid.Panel', {
+ height: 300,
+ store: this.getStore(results),
+ columns: this.getColumns(assayResultFields),
+ invalidateScrollerOnRefresh: false,
+ plugins: [
+ Ext4.create('Ext.grid.plugin.CellEditing', {
+ clicksToEdit: 1
+ })
+ ],
+ flex: 1
+ });
+ }
+
+ return this._grid;
+ },
+
+ getColumns: function (assayResultFields) {
+ if (!this.columns) {
+
+ var columns = [];
+ assayResultFields.forEach(function (field) {
+ columns.push({
+ text: field.label,
+ dataIndex: field.fieldKey,
+ type: field.jsonType,
+ //TODO: create toggle option to enable editing?
+ //TODO: Instead make click open file chooser and associate selected file to row
+ editor: {
+ xtype: 'textfield'
+ }
+ });
+ });
+
+ this.columns = columns.concat([{
+ text: 'Upload Time',
+ dataIndex: this.UPLOAD_TIME,
+ renderer: Ext4.util.Format.dateRenderer('m/d/y g:i')
+ , width: 150
+ }, {
+ text: 'Upload Progress',
+ width: 150,
+ dataIndex: 'progress',
+ sortable: true,
+ renderer: function (v, m, r) {
+ var calcValue = v / 100;
+ var pbRenderer = (function () {
+ var b = new Ext4.ProgressBar({height: 15});
+ return function (val) {
+ b.updateProgress(val);
+ return Ext4.DomHelper.markup(b.getRenderTree());
+ };
+ })();
+
+ return pbRenderer(calcValue);
+ }
+ }, {
+ xtype: 'actioncolumn',
+ width: 20,
+ items: [{
+ iconCls: 'iconDelete',
+ tooltip: 'Remove uploaded file',
+ handler: function (grid, rowIndex, colIndex) {
+ var store = grid.getStore();
+ var row = store.getAt(rowIndex);
+ var fileName = row.get(this.DATA_FILE);
+ var me = this;
+
+ //Delete File
+ this.fileSystem.deletePath({
+ path: this.fileSystem.concatPaths(this.getFullWorkingPath(), fileName),
+ isFile: true,
+ success: function () {
+ row.set('progress', 0);
+ row.set(me.UPLOAD_TIME, '');
+ store.sync();
+ me.fireEvent('removefile', fileName, store.getCount());
+ }
+ });
+ },
+ scope: this
+ }]
+ }]);
+ }
+
+ return this.columns;
+ },
+
+ getStore: function (data) {
+ if (!this._store) {
+ var store = Ext4.create('Ext.data.Store', {
+ model: this.modelClass,
+ autoSync: true,
+ proxy: {
+ type: 'sessionstorage',
+ id: 'pSizeProxy'
+ }
+ });
+
+ this.loadData(store, data);
+
+ this._store = store;
+ // let the user see the most recent uploads at the top
+ this._store.sort(this.UPLOAD_TIME, 'DESC');
+ }
+
+ return this._store;
+ },
+ loadData: function (store, content) {
+ // Use 1st sheet
+ var sheet = content.sheets[0];
+ var data = sheet.data;
+
+ //remove headers
+ var headers = data.shift();
+
+ data.forEach(function (dataRow) {
+ var rowConfig = {};
+ for (var i = 0; i < dataRow.length; i++) {
+ rowConfig[headers[i].value] = dataRow[i].value;
+ }
+
+ store.add(this.getModelInstance(rowConfig));
+ }, this);
+ },
+
+ getModelInstance: function (config) {
+ return Ext4.create(this.modelClass, config);
+ },
+
+ /**
+ * Moves files from temp folder to target folder
+ * Assumes: assay container as base.
+ *
+ * @param tempFolderName
+ * @param targetFolder
+ */
+ commitRun: function (targetDirectory, callback, scope, runProperties) {
+ if (Ext4.isFunction(callback)) {
+ var me = this;
+ var destination = this.fileSystem.concatPaths(this.fileSystem.getBaseURL(), targetDirectory);
+ this.fileSystem.renamePath({
+ source: this.getWorkingPath(),
+ destination: destination,
+ isFile: false,
+ success: function () {
+ me.resolveFileResources(targetDirectory, callback, scope, runProperties);
+ }
+ });
+ }
+ },
+
+ resolveFileResources: function (targetDirectory, callback, callbackScope, runProperties) {
+ var fileUri = this.fileSystem.concatPaths(this.fileSystem.getAbsoluteURL(), targetDirectory);
+ LABKEY.Ajax.request({
+ url: fileUri,
+ method: 'GET',
+ params: {method: 'JSON'},
+ success: function (response) {
+ var json = Ext4.decode(response.responseText);
+ if (Ext4.isDefined(json) && Ext4.isArray(json.files)) {
+ if (!Ext4.isEmpty(json.files)) {
+ this.resolveDataFileURL(json.files, callback, callbackScope, runProperties);
+ }
+ }
+ },
+ failure: function () {
+ }
+ , scope: this
+ }, this);
+ },
+
+ /**
+ * will append a 'dataFileURL' property to all files resolved as resources
+ */
+ resolveDataFileURL: function (files, callback, scope, runProperties) {
+ if (Ext4.isFunction(callback)) {
+
+ var received = 0;
+ var newFiles = [];
+
+ var me = this;
+
+ function done(file, results) {
+
+ var store = me.getStore();
+ var idx = store.find(me.DATA_FILE, file.text);
+ var process = store.getAt(idx);
+
+ //Set upload time
+ process.set(me.FILENAME, results[me.DATA_FILE]);
+ process.set(me.FILE_URL, results['DataFileUrl']);
+ process.set('file', file);
+ newFiles.push(file);
+ received++;
+
+ if (received == files.length) {
+ callback.call(scope || me, newFiles, runProperties);
+ }
+ }
+
+ //TODO: This should be refactored to use a single ajax call for the array
+ files.forEach(function (file) {
+ LABKEY.Ajax.request({
+ url: LABKEY.ActionURL.buildURL('SignalData', 'getSignalDataResource.api'),
+ method: 'POST',
+ params: {path: decodeURIComponent(file.id), test: true},
+ success: function (response) {
+ done(file, Ext4.decode(response.responseText));
+ },
+ scope: this
+ });
+ }, this);
+ }
+ },
+
+ resolvePipeline: function (callback, scope) {
+ if (Ext4.isFunction(callback)) {
+ Ext4.Ajax.request({
+ url: LABKEY.ActionURL.buildURL('SignalData', 'getSignalDataPipelineContainer.api'),
+ method: 'GET',
+ success: function (response) {
+ var context = Ext4.decode(response.responseText);
+ if (Ext4.isObject(context) && !Ext4.isEmpty(context.containerPath) && !Ext4.isEmpty(context.webDavURL)) {
+ callback.call(scope || this, context);
+ }
+ else {
+ Ext4.Msg.alert('Error', 'Failed to load the pipeline context for Signal Data');
+ }
+ },
+ failure: function (error, response) {
+ Ext4.Msg.alert('Error', 'Failed to load the pipeline context for Signal Data');
+ }
+ });
+ }
+ },
+
+ //TODO: this should probably just be an action
+ createWorkingFolder: function () {
+ this.checkOrCreateBaseFolder();
+ },
+
+ //Check if working folder exists
+ checkOrCreateBaseFolder: function () {
+ var targetURL = this.fileSystem.getBaseURL();
+
+ LABKEY.Ajax.request({
+ url: this.fileSystem.getURI(targetURL),
+ method: 'GET',
+ params: {method: 'JSON'},
+ success: function (response) {
+ //directory exists
+ this.checkOrCreateTempFolder();
+ },
+ failure: function (b, xhr) {
+ this.createFolder(targetURL, this.checkOrCreateTempFolder, this);
+ },
+ scope: this
+ }, this);
+ },
+
+ //Check if working folder exists
+ checkOrCreateTempFolder: function () {
+ var targetURL = this.fileSystem.concatPaths(this.fileSystem.getBaseURL(), 'Temp');
+
+ LABKEY.Ajax.request({
+ url: this.fileSystem.getURI(targetURL),
+ method: 'GET',
+ params: {method: 'JSON'},
+ success: function (response) {
+ //directory exists
+ this.checkOrCreateWorkingFolder();
+ },
+ failure: function (b, xhr) {
+ this.createFolder(targetURL, this.checkOrCreateWorkingFolder, this);
+ },
+ scope: this
+ }, this);
+ },
+
+ //Check if working folder exists
+ checkOrCreateWorkingFolder: function () {
+ var targetURL = this.getWorkingPath();
+
+ LABKEY.Ajax.request({
+ url: this.fileSystem.getURI(targetURL),
+ method: 'GET',
+ params: {method: 'JSON'},
+ success: function (response) {
+ },
+ failure: function (b, xhr) {
+ this.createFolder(targetURL, null, this);
+ },
+ scope: this
+ }, this);
+ },
+
+ createFolder: function (targetDir, callback, scope, options) {
+ //Working directory not found, create it.
+ scope.fileSystem.createDirectory({
+ path: scope.fileSystem.getURI(targetDir),
+ success: function () {
+ if (callback)
+ callback.call(scope, options);
+ },
+ failure: function () {
+ Ext4.Msg.alert("Error", "Couldn't generate working directory");
+ },
+ scope: scope
+ }, scope);
+ },
+
+ getWorkingPath: function () {
+ return this.fileSystem.concatPaths(this.fileSystem.getBaseURL(), 'Temp/' + this.workingDirectory);
+ },
+ getFullWorkingPath: function () {
+ return this.fileSystem.getURI(this.getWorkingPath());
+ },
+ workingDirectory: '',
+ containsFile: function(file) {
+ var store = this.getStore();
+ var idx = store.find(this.DATA_FILE, file.name);
+ return store.getAt(idx);
+ }
+});
diff --git a/signalData/resources/web/signaldata/UploadView/uploadResultDataForm.js b/signalData/resources/web/signaldata/UploadView/uploadResultDataForm.js
new file mode 100644
index 000000000..e969dc4f0
--- /dev/null
+++ b/signalData/resources/web/signaldata/UploadView/uploadResultDataForm.js
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2016-2018 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * Created by iansigmon on 8/8/16.
+ */
+Ext4.ns('LABKEY.SignalData');
+
+LABKEY.SignalData.initializeUploadForm = function(metadataFormElId, metadataFileId, metadataTSVId, nextButtonElId, renderToId, templateDivId) {
+
+ var assayType = 'Signal Data';
+ var assay;
+
+ var loadAssay = function(cb, scope) {
+ if (LABKEY.page && LABKEY.page.assay) {
+ assay = LABKEY.page.assay;
+ cb.call(scope || this);
+ }
+ else {
+ //TODO: may need to rework this for webpart...
+ LABKEY.Assay.getById({
+ id: LABKEY.ActionURL.getParameter("rowId"),
+ success: function(definitions) {
+ if (definitions.length == 0) {
+ var link = LABKEY.Utils.textLink({
+ text: 'New assay design',
+ href: LABKEY.ActionURL.buildURL('assay', 'chooseAssayType')
+ });
+ Ext4.get(renderToId).update('To get started, create a "' + assayType + '" assay. ' + link);
+ }
+ else if (definitions.length == 1) {
+ assay = definitions[0];
+ cb.call(scope || this);
+ }
+ else {
+ // In the future could present a dropdown allowing the user to switch between active assay design
+ Ext4.get(renderToId).update('This webpart does not currently support multiple "' + assayType + '" assays in the same folder.');
+ }
+ }
+ });
+ }
+ };
+
+ var formSubmitted = function (data) {
+ var run = new LABKEY.Exp.Run();
+ run.name = data.name;
+ run.dataInputs = [ data ];
+
+ if (!data.content)
+ {
+ data.getContent({
+ format: 'jsonTSVExtended',
+ success: function (content) {
+ data.content = content;
+ LABKEY.SignalData.initializeDataFileUploadForm(metadataFormElId, renderToId, assay, run, content);
+ document.getElementById(metadataFormElId).style.display = 'none';
+ },
+ failure: function (error, format) {
+ }
+ });
+ }
+ };
+
+ var formFailed = function (form, action) {
+ alert('Upload failed!');
+ };
+
+ LABKEY.SignalData.disableFileUpload = function() {
+ tsvForm.setVisible(true);
+ fileForm.setVisible(false);
+
+ activeForm = tsvForm;
+ };
+
+ LABKEY.SignalData.enableFileUpload = function() {
+ tsvForm.setVisible(false);
+ fileForm.setVisible(true);
+
+ activeForm = fileForm;
+ };
+
+
+ var activeForm;
+ var fileForm;
+ var tsvForm;
+ loadAssay(function() {
+ //Load the rowId into the template link
+ var templateLink = document.getElementById(templateDivId);
+ templateLink.setAttribute('href', LABKEY.ActionURL.buildURL("assay", "template", LABKEY.ActionURL.getContainer(),
+ {rowId: assay.id}));
+
+ fileForm = Ext4.create('Ext.form.Panel',{
+ renderTo: metadataFileId,
+ border: false,
+ bodyStyle: 'background-color: transparent;',
+ fileUpload: true,
+ url: LABKEY.ActionURL.buildURL("assay", "assayFileUpload", LABKEY.ActionURL.getContainer(), { protocolId: assay.id }),
+ flex:1,
+ items: [{
+ xtype: 'filefield',
+ id: 'file',
+ width: 400,
+ buttonConfig: {
+ text: 'Upload txt, tsv, xls, xlsx'
+ }
+ }, {
+ xtype: 'hidden',
+ name: 'X-LABKEY-CSRF',
+ value: LABKEY.CSRF
+ }],
+ listeners: {
+ actioncomplete : function (form, action) {
+ var data = new LABKEY.Exp.Data(action.result);
+ formSubmitted(data);
+ },
+ actionfailed: formFailed
+ }
+ });
+
+ tsvForm = Ext4.create('Ext.form.Panel',{
+ renderTo: metadataTSVId,
+ border: false,
+ bodyStyle: 'background-color: transparent;',
+ getTsvInput: function(){
+ return Ext4.getCmp('tsv').value;
+ },
+ items: [{
+ xtype: 'textarea',
+ id: 'tsv',
+ height: 300,
+ minHeight: 300,
+ width: 400,
+ minWidth:150
+ }, {
+ xtype: 'hidden',
+ name: 'X-LABKEY-CSRF',
+ value: LABKEY.CSRF
+ }],
+ submit:function(){
+ LABKEY.Ajax.request({
+ url: LABKEY.ActionURL.buildURL("assay", "assayFileUpload", LABKEY.ActionURL.getContainer()),
+ params: { protocolId: assay.id, fileName: metadataTSVId + '.txt', fileContent: this.getTsvInput() },
+ success: function(response) {
+ var data = new LABKEY.Exp.Data(Ext.util.JSON.decode(response.responseText));
+ formSubmitted(data);
+ },
+ failure: formFailed
+ });
+ },
+ scope: this
+ });
+
+ Ext4.create('Ext.button.Button', {
+ xtype: 'button',
+ renderTo: nextButtonElId,
+ text: 'next',
+ handler: function () {
+ activeForm.submit();
+ }
+ });
+
+ LABKEY.SignalData.enableFileUpload();
+ });
+};
diff --git a/signalData/resources/web/signaldata/UploadView/uploadResultFiles.js b/signalData/resources/web/signaldata/UploadView/uploadResultFiles.js
new file mode 100644
index 000000000..a08939bb4
--- /dev/null
+++ b/signalData/resources/web/signaldata/UploadView/uploadResultFiles.js
@@ -0,0 +1,413 @@
+/*
+ * Copyright (c) 2016 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * Created by iansigmon on 1/20/16.
+ */
+Ext4.ns('LABKEY.SignalData');
+
+LABKEY.SignalData.initializeDataFileUploadForm = function (metadataFormId, elementId, assay, loadedRun, resultFileContents) {
+
+ var hideOverlay = true;
+
+ var setWorkingDirectory = function() {
+ var dir = 'TEMP_SignalData_' + getRunFolderName();
+ sessionStorage.signalDataWorkingDirectory = dir;
+ return dir;
+ };
+
+ var getTempFolderName = function() {
+ if (!sessionStorage.signalDataWorkingDirectory)
+ setWorkingDirectory();
+ return sessionStorage.signalDataWorkingDirectory;
+ };
+
+ var runFolder;
+ var getRunFolderName = function() {
+ if (!runFolder) {
+ var now = new Date();
+ var parts = [now.getFullYear(), now.getMonth() + 1 /*javascript uses 0 based month*/,
+ now.getDate(), now.getHours(),now.getMinutes(),now.getSeconds()];
+ runFolder = parts.join('_');
+ }
+ return runFolder;
+ };
+
+ var uploadLog = Ext4.create('LABKEY.SignalData.UploadLog', {
+ region: 'center',
+ workingDirectory: getTempFolderName(),
+ flex: 2,
+ results: resultFileContents,
+ resultFields: assay.domains[assay.name + ' Result Fields'],
+ listeners: {
+ removefile: function(name, count) {
+ if (count == 0) {
+ hideOverlay = false;
+ LABKEY.internal.FileDrop.showDropzones();
+ }
+ }
+ }
+ });
+
+ var clearCachedReports = function(cleanUpFiles, callback, scope) {
+ uploadLog.getStore().removeAll();
+ uploadLog.getStore().sync();
+ form.getForm().reset();
+
+ dropzone.removeAllFiles(true);
+ LABKEY.internal.FileDrop.showDropzones();
+
+ if (cleanUpFiles) {
+ //delete contents of working folder
+ uploadLog.fileSystem.deletePath({
+ path: uploadLog.getFullWorkingPath(),
+ isFile: false,
+ success: callback,
+ scope: scope
+ });
+ } else {
+ callback.call(scope || this);
+ }
+ };
+
+ var dropzone; var form;
+ var init = function() {
+ Ext4.QuickTips.init();
+
+ var _assayForm;
+ var getAssayForm = function() {
+
+ if (!_assayForm) {
+ _assayForm = Ext4.create('Ext.form.Panel', {
+ region: 'west',
+ title: 'Run Fields',
+ cls: 'signaldata-run-form',
+ border: false,
+ layout: 'vbox',
+ shrinkWrap: true,
+ shrinkWrapDock: true,
+ buttonAlign: 'center',
+ collapsible: false,
+ width: '25%',
+ minWidth: 300,
+ minHeight: 300,
+ flex: 1,
+ items: getAssayFormFields(),
+ buttons: [
+ {
+ //Add a reset button
+ xtype: 'button',
+ text: 'Clear Run',
+ cls: 'labkey-button',
+ handler: function () {
+ Ext4.Msg.show({
+ title: 'Clear Run',
+ msg: 'Are you sure you want to clear these results?',
+ icon: Ext4.window.MessageBox.INFO,
+ buttons: Ext4.Msg.YESNO,
+ fn: function(btn) {
+ if (btn == 'yes') {
+ clearCachedReports(true, function() {
+ uploadLog.workingDirectory = setWorkingDirectory();
+ //Recreate working dir
+ uploadLog.checkOrCreateWorkingFolder(uploadLog.getWorkingPath(), uploadLog);
+ document.getElementById(metadataFormId).style.display = '';
+ LABKEY.internal.FileDrop.hideDropzones();
+ document.getElementById(elementId).innerHTML = ""; //Clear this form.
+ }, this);
+ }
+ }
+ });
+ }
+ }, {
+ //Add a Save button
+ xtype: 'button',
+ text: 'Save Run',
+ cls: 'labkey-button',
+ formBind: true,
+ handler: function () {
+ var form = this.up('form').getForm();
+ closeRun(form);
+ }
+ }
+ ]
+ });
+ }
+
+ return _assayForm;
+ };
+
+ var dropInit = function(){
+ dropzone = LABKEY.internal.FileDrop.registerDropzone({
+ url: LABKEY.ActionURL.buildURL("assay", "assayFileUpload"),
+ uploadMultiple: false,
+ maxFiles: 5000,
+ // Allow uploads of 100GB files
+ maxFilesize: 100*(1024*1024),
+ previewsContainer: false,
+
+ peer: function() {
+ // Get the grid component from the outer Browser component
+ var grid = uploadLog.getGrid();
+ return grid ? grid.el : uploadLog.ownerCt.el;
+ },
+
+ /**
+ * If the user is allowed to drop
+ * @param file
+ * @param done
+ */
+ accept: function(file, done) {
+ // Filter out folder drag-drop on unsupported browsers (Firefox)
+ // See: https://github.com/enyo/dropzone/issues/528
+ if ( (!file.type && file.size == 0 && file.fullPath == undefined)) {
+ done("Drag-and-drop upload of folders is not supported by your browser. Please consider using Google Chrome or an external WebDAV client.");
+ return;
+ }
+
+ //Hide dropzone overlay
+ LABKEY.internal.FileDrop.hideDropzones();
+ hideOverlay = true;
+
+ done();
+ },
+
+ init: function() {
+ this.on('addedfile', function (file) {
+ if (!uploadLog.containsFile(file)) {
+ dropzone.removeFile(file);
+ Ext4.Msg.show({msg: file.name + ' not uploaded'});
+ }
+ });
+
+ this.on('processing', function (file) {
+ var cwd = uploadLog.getFullWorkingPath();
+ if (cwd) {
+ // Folder the file will be POSTed into
+ var uri = uploadLog.fileSystem.concatPaths(cwd, file.name);
+ this.options.url = uploadLog.fileSystem.getParentPath(uri);
+ }
+
+ //get modelInstance from store that matches file.name
+ var store = uploadLog.getStore();
+ var idx = store.find('DataFile', file.name);
+ var process = store.getAt(idx);
+
+ //Set upload time
+ process.set(uploadLog.UPLOAD_TIME, new Date());
+ file.workingId = process.get('id');
+ uploadLog.getStore().sync();
+
+ //Update in-progress tracker
+ processingCounter.value++;
+ form.isValid();
+ });
+
+ //Update file progress bar
+ this.on('uploadprogress',function(file, progress, bytesSent){
+ var model = uploadLog.getStore().getById(file.workingId);
+ if (model)
+ model.set('progress', progress);
+ });
+
+ //Update in-progress tracker
+ this.on('success', function(file, response, evt) {
+ processingCounter.value--;
+ form.isValid();
+ });
+ },
+ show: !(uploadLog.getStore().getCount() > 0)
+ });
+
+ dropzone.uploadPanel = uploadLog;
+ dropzone.form = form;
+ };
+
+ form = Ext4.create('Ext.form.Panel', {
+ renderTo: elementId,
+ tempFolder: getTempFolderName(),
+ layout: 'border',
+ height: 300,
+ minHeight: 300,
+ border: false,
+ bodyStyle: 'background-color: transparent;',
+ items: [
+ getAssayForm(),
+ uploadLog
+ ],
+ listeners: {
+ actioncomplete: function (_form, action, eOpts) {
+ var process = uploadLog.getModelInstance({
+ uploadTime: new Date(),
+ fileName: action.result.name
+ });
+
+ uploadLog.getStore().add(process);
+ uploadLog.getStore().sync();
+ },
+ actionfailed: function (_form, action, eOpts) {
+ LABKEY.Utils.alert('Server Failed', 'Failed to create run.');
+ }
+ }
+ });
+
+ window.onbeforeunload = function(){
+ if(form.isDirty() || uploadLog.getStore().getCount() > 0) {
+ return 'Unsaved changes will be lost. Continue?';
+ }
+ };
+
+ window.onunload = function(){
+ clearCachedReports(true);
+ };
+
+ dropInit();
+
+ Ext4.EventManager.onWindowResize(function(w, h) {
+ LABKEY.ext4.Util.resizeToViewport(this, w, this.getHeight(), 20, 35);
+ if (!hideOverlay && dropzone) {
+ LABKEY.internal.FileDrop.hideDropzones();
+ LABKEY.internal.FileDrop.showDropzones();
+ }
+ }, form);
+ };
+
+ var processingCounter = Ext4.create('Ext.form.field.Hidden', {
+ xtype:'hidden',
+ validate: function(){
+ return this.value === 0;
+ },
+ validateOnChange:true,
+ value: 0
+ });
+
+ var getAssayFormFields = function() {
+
+ var batchFields = assay.domains[assay.name + ' Batch Fields'];
+ var runFields = assay.domains[assay.name + ' Run Fields'];
+
+ var configs = getConfigs(runFields);
+
+ configs.push(processingCounter);
+
+ return configs;
+ };
+
+ var showNoFilesError = function() {
+ LABKEY.Utils.alert('No Files', 'Please add run result file(s)');
+ };
+
+ var getConfigs = function(fields) {
+ if (!fields || fields.length == 0)
+ return [];
+
+ var configs = [];
+ Ext4.each(fields, function(metaField) {
+ configs.push(getExtConfig(metaField));
+ });
+
+ return configs;
+ };
+
+ var getExtConfig = function(meta) {
+ setLookupConfig(meta);
+ var config = LABKEY.ext4.Util.getFormEditorConfig(meta);
+
+ return Ext4.apply(config, {
+ id: config.name,
+ validateOnBlur: false
+ });
+ };
+
+ var setLookupConfig = function(meta) {
+ // the getDefaultEditorConfig code in util.js expects a lookup object, so create one here
+ // if our metadata has lookup information
+ if (meta.lookupQuery && meta.lookupSchema && !meta.lookup) {
+ meta.lookup = {
+ container : meta.lookupContainer,
+ schemaName : meta.lookupSchema,
+ queryName : meta.lookupQuery
+ };
+ }
+ };
+
+ var closeRun = function(form) {
+ var fieldValues = form.getFieldValues();
+ var runFolder = getRunFolderName();
+
+ uploadLog.commitRun(runFolder, generateAndSaveRun, this, fieldValues);
+ };
+
+ function saveRun(run) {
+ LABKEY.Experiment.saveBatch({
+ assayId: assay.id,
+ batch: {
+ batchProtocolId: assay.id,
+ runs: [{
+ name: run.name,
+ properties: run.properties,
+ dataRows: run.dataRows,
+ dataInputs: run.dataInputs
+ }]
+ },
+ success: function() {
+ clearCachedReports(false, function() {
+ let returnUrl = LABKEY.ActionURL.getReturnUrl();
+ if (returnUrl) {
+ if (window.location.hash)
+ returnUrl = returnUrl.concat(window.location.hash);
+ }
+ else {
+ returnUrl = LABKEY.ActionURL.buildURL('assay', 'assayBegin', null, {rowId: assay.id});
+ }
+ uploadLog.workingDirectory = setWorkingDirectory();
+ window.location = returnUrl;
+ },this);
+ },
+ failure: function(response){
+ //TODO: Should probably do something here...
+ }
+ }, this);
+ }
+
+ var generateAndSaveRun = function(files, fieldValues) {
+
+ var dataRows = [];
+ var dataInputs = [];
+
+ var rows = uploadLog.getStore().getRange();
+
+ var runFolder = getRunFolderName();
+ rows.forEach(function (row){
+ var dataRow = {};
+ row.fields.eachKey(function(key){
+ dataRow[key] = row.get(key);
+ });
+
+ if(row.get('file')) {
+ dataRow[uploadLog.DATA_FILE] = decodeURI(dataRow[uploadLog.FILE_URL]).replace('file:','');
+
+ dataInputs.push({
+ name: row.get(uploadLog.DATA_FILE), //This is how DataFile will be looked up in Chromatogram
+ dataFileURL: row.get(uploadLog.FILE_URL)
+ });
+ }
+
+ dataRows.push(dataRow);
+
+ }, this);
+
+ var run = new LABKEY.Exp.Run({
+ name: runFolder,
+ properties: fieldValues,
+ dataRows: dataRows,
+ dataInputs: dataInputs
+ });
+
+ saveRun(run);
+ };
+
+ init();
+};
\ No newline at end of file
diff --git a/signalData/resources/web/signaldata/signaldata.css b/signalData/resources/web/signaldata/signaldata.css
new file mode 100644
index 000000000..1c58c5f89
--- /dev/null
+++ b/signalData/resources/web/signaldata/signaldata.css
@@ -0,0 +1,19 @@
+
+.signaldata-run-form {
+ margin: 0 5px 0 0;
+ border-style: solid;
+ border-width: 0 1px 1px 1px;
+}
+
+.signaldata-run-form .x4-panel-body {
+ padding: 10px;
+}
+
+.signaldata-run-form .x4-toolbar .x4-box-target a {
+ margin-bottom: 20px;
+}
+
+.signaldata-upload-target {
+ display:block;
+ overflow:auto;
+}
\ No newline at end of file
diff --git a/signalData/src/org/labkey/signaldata/SignalDataController.java b/signalData/src/org/labkey/signaldata/SignalDataController.java
new file mode 100644
index 000000000..80db85f3b
--- /dev/null
+++ b/signalData/src/org/labkey/signaldata/SignalDataController.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2016-2019 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.labkey.signaldata;
+
+import org.labkey.api.action.ApiResponse;
+import org.labkey.api.action.ApiSimpleResponse;
+import org.labkey.api.action.MutatingApiAction;
+import org.labkey.api.action.ReadOnlyApiAction;
+import org.labkey.api.action.SpringActionController;
+import org.labkey.api.data.Container;
+import org.labkey.api.data.RuntimeSQLException;
+import org.labkey.api.data.TableInfo;
+import org.labkey.api.exp.api.ExpData;
+import org.labkey.api.exp.api.ExperimentService;
+import org.labkey.api.exp.query.ExpDataTable;
+import org.labkey.api.exp.query.ExpSchema;
+import org.labkey.api.files.FileContentService;
+import org.labkey.api.pipeline.PipeRoot;
+import org.labkey.api.pipeline.PipelineService;
+import org.labkey.api.query.QueryUpdateService;
+import org.labkey.api.security.RequiresPermission;
+import org.labkey.api.security.permissions.ReadPermission;
+import org.labkey.api.util.FileUtil;
+import org.labkey.api.util.UnexpectedException;
+import org.labkey.api.webdav.WebdavResource;
+import org.labkey.api.webdav.WebdavService;
+import org.labkey.signaldata.assay.SignalDataAssayDataHandler;
+import org.springframework.validation.BindException;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.sql.SQLException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import static org.labkey.api.files.FileContentService.UPLOADED_FILE;
+
+public class SignalDataController extends SpringActionController
+{
+ private static final DefaultActionResolver _actionResolver = new DefaultActionResolver(SignalDataController.class);
+ static final String NAME = "signaldata";
+
+ public SignalDataController()
+ {
+ setActionResolver(_actionResolver);
+ }
+
+
+ /**
+ * Meant to mimic PipelineController.getPipelineContainerAction but with the incorporated SignalData path context
+ */
+ @RequiresPermission(ReadPermission.class)
+ public class getSignalDataPipelineContainerAction extends ReadOnlyApiAction
+ {
+ @Override
+ public ApiResponse execute(Object form, BindException errors) throws Exception
+ {
+ ApiSimpleResponse resp = new ApiSimpleResponse();
+ PipeRoot root = PipelineService.get().findPipelineRoot(getContainer());
+
+ String containerPath = null;
+ URI webdavURL = null;
+
+ if (null != root)
+ {
+ containerPath = root.getContainer().getPath();
+ webdavURL = root.getWebdavURL();
+ if (!SignalDataAssayDataHandler.NAMESPACE.isEmpty())
+ webdavURL = webdavURL.resolve(SignalDataAssayDataHandler.NAMESPACE);
+
+ //Create folder if needed
+ File sdFileRoot = new File(root.getRootPath(), SignalDataAssayDataHandler.NAMESPACE);
+ if(!sdFileRoot.exists())
+ sdFileRoot.mkdirs();
+ }
+
+ resp.put("containerPath", containerPath);
+ resp.put("webDavURL", Objects.toString(webdavURL, null));
+
+ return resp;
+ }
+ }
+
+ public static class SignalDataResourceForm
+ {
+ public String _path;
+ public boolean _test = false;
+
+ public String getPath()
+ {
+ return _path;
+ }
+
+ public void setPath(String path)
+ {
+ _path = path;
+ }
+
+ public boolean isTest()
+ {
+ return _test;
+ }
+
+ public void setTest(boolean test)
+ {
+ _test = test;
+ }
+ }
+
+
+ @RequiresPermission(ReadPermission.class)
+ public class getSignalDataResourceAction extends MutatingApiAction
+ {
+ @Override
+ public ApiResponse execute(SignalDataResourceForm form, BindException errors)
+ {
+ String path = form.getPath();
+ WebdavResource resource = WebdavService.get().lookup(path);
+ Map props = new HashMap<>();
+ Container c = getContainer();
+
+ if (null != resource)
+ {
+ FileContentService svc = FileContentService.get();
+ ExpData data = svc.getDataObject(resource, c);
+
+ if (form.isTest() && data == null)
+ {
+ // Generate the data to help the test, replicating what DavController would do for us
+ File file = resource.getFile();
+ if (null != file)
+ {
+ data = ExperimentService.get().createData(c, UPLOADED_FILE);
+ data.setName(file.getName());
+ data.setDataFileURI(file.toURI());
+
+ int scale = ExperimentService.get().getTinfoData().getColumn("DataFileURL").getScale();
+ String dataFileURL = data.getDataFileUrl();
+ if (dataFileURL == null || dataFileURL.length() <= scale)
+ {
+ data.save(getUser());
+ }
+ else
+ {
+ // If the path is too long to store, bail out without creating an exp.data row
+ }
+ }
+ }
+
+ if (null != data)
+ {
+ TableInfo ti = ExpSchema.TableType.Data.createTable(new ExpSchema(getUser(), c), ExpSchema.TableType.Data.toString(), null);
+ QueryUpdateService qus = ti.getUpdateService();
+
+ try
+ {
+ File canonicalFile = FileUtil.getAbsoluteCaseSensitiveFile(resource.getFile());
+ String url = canonicalFile.toURI().toURL().toString();
+ Map keys = Collections.singletonMap(ExpDataTable.Column.DataFileUrl.name(), url);
+ List> rows = qus.getRows(getUser(), c, Collections.singletonList(keys));
+
+ if (rows.size() == 1)
+ {
+ for (Map.Entry entry : rows.get(0).entrySet())
+ {
+ Object value = entry.getValue();
+
+ if (null != value)
+ {
+ props.put(entry.getKey(), String.valueOf(value));
+ }
+ }
+ }
+ }
+ catch (MalformedURLException e)
+ {
+ throw UnexpectedException.wrap(e);
+ }
+ catch (SQLException e)
+ {
+ throw new RuntimeSQLException(e);
+ }
+ catch (RuntimeException re)
+ {
+ throw re;
+ }
+ catch (Exception e)
+ {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ return new ApiSimpleResponse(props);
+ }
+ }
+}
\ No newline at end of file
diff --git a/signalData/src/org/labkey/signaldata/SignalDataModule.java b/signalData/src/org/labkey/signaldata/SignalDataModule.java
new file mode 100644
index 000000000..a0a4a0b0c
--- /dev/null
+++ b/signalData/src/org/labkey/signaldata/SignalDataModule.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2016 LabKey Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.labkey.signaldata;
+
+import org.jetbrains.annotations.NotNull;
+import org.labkey.api.data.Container;
+import org.labkey.api.module.CodeOnlyModule;
+import org.labkey.api.module.ModuleContext;
+import org.labkey.api.module.ModuleProperty;
+import org.labkey.api.view.WebPartFactory;
+
+import java.util.Collection;
+import java.util.Collections;
+
+public class SignalDataModule extends CodeOnlyModule
+{
+ public static final String NAME = "SignalData";
+ public static final String QC_PROVIDER_PROPERTY_NAME = "QCViewProviderModule";
+
+ SignalDataModule()
+ {
+ super();
+
+ ModuleProperty qcViewProperty;
+ qcViewProperty = new ModuleProperty(this, QC_PROVIDER_PROPERTY_NAME);
+ qcViewProperty.setDescription("Name of module that will provide the QC view");
+ qcViewProperty.setCanSetPerContainer(true);
+ qcViewProperty.setDefaultValue("signaldata");
+ addModuleProperty(qcViewProperty);
+ }
+
+ @Override
+ public String getName()
+ {
+ return NAME;
+ }
+
+ @Override
+ @NotNull
+ protected Collection createWebPartFactories()
+ {
+ return Collections.emptyList();
+ }
+
+ @Override
+ protected void init()
+ {
+ addController(SignalDataController.NAME, SignalDataController.class);
+ }
+
+ @Override
+ public void doStartup(ModuleContext moduleContext)
+ {
+ }
+
+ @Override
+ @NotNull
+ public Collection