DataSetControllerImpl

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val ACCEPT: String

val ACCEPTED: Int

val ACCEPT_CHARSET: String

val ACCEPT_ENCODING: String

val ACCEPT_LANGUAGE: String

val ACCEPT_RANGES: String

val ACCESS_CONTROL_ALLOW_CREDENTIALS: String

val ACCESS_CONTROL_ALLOW_HEADERS: String

val ACCESS_CONTROL_ALLOW_METHODS: String

val ACCESS_CONTROL_ALLOW_ORIGIN: String

val ACCESS_CONTROL_EXPOSE_HEADERS: String

val ACCESS_CONTROL_MAX_AGE: String

val ACCESS_CONTROL_REQUEST_HEADERS: String

val ACCESS_CONTROL_REQUEST_METHOD: String

val AGE: String

val ALLOW: String

val AUTHORIZATION: String

val Accepted: Status

object Accepts

val BAD_GATEWAY: Int

val BAD_REQUEST: Int

val BINARY: String

val BadGateway: Status

val BadRequest: Status

val CACHE_CONTROL: String

val CACHE_MANIFEST: String

val CHUNKED: String

val CONFLICT: Int

val CONNECTION: String

val CONTENT_DISPOSITION: String

val CONTENT_ENCODING: String

val CONTENT_LANGUAGE: String

val CONTENT_LENGTH: String

val CONTENT_LOCATION: String

val CONTENT_MD5: String

val CONTENT_RANGE: String

val CONTENT_TRANSFER_ENCODING: String

val CONTENT_TYPE: String

val CONTINUE: Int

val COOKIE: String

val CREATED: Int

def CSS(implicit codec: Codec): String

val Conflict: Status

val Created: Status

val DATE: String

val ETAG: String

def EVENT_STREAM(implicit codec: Codec): String

val EXPECT: String

val EXPECTATION_FAILED: Int

val EXPIRES: String

val EntityTooLarge: Status

val ExpectationFailed: Status

val FAILED_DEPENDENCY: Int

val FORBIDDEN: Int

val FORM: String

val FORWARDED: String

val FOUND: Int

val FROM: String

val FailedDependency: Status

val Forbidden: Status

def Found(url: String): Result

val GATEWAY_TIMEOUT: Int

val GONE: Int

val GatewayTimeout: Status

val Gone: Status

val HOST: String

def HTML(implicit codec: Codec): String

val HTTP_1_0: String

val HTTP_1_1: String

val HTTP_VERSION_NOT_SUPPORTED: Int

val HttpVersionNotSupported: Status

val IF_MATCH: String

val IF_MODIFIED_SINCE: String

val IF_NONE_MATCH: String

val IF_RANGE: String

val IF_UNMODIFIED_SINCE: String

val INSUFFICIENT_STORAGE: Int

val INTERNAL_SERVER_ERROR: Int

val InsufficientStorage: Status

val InternalServerError: Status

def JAVASCRIPT(implicit codec: Codec): String

val JSON: String

val LAST_MODIFIED: String

val LENGTH_REQUIRED: Int

val LOCATION: String

val LOCKED: Int

val Locked: Status

val MAX_FORWARDS: String

val METHOD_NOT_ALLOWED: Int

val MOVED_PERMANENTLY: Int

val MULTIPLE_CHOICES: Int

val MULTI_STATUS: Int

val MethodNotAllowed: Status

def MovedPermanently(url: String): Result

val MultiStatus: Status

val NON_AUTHORITATIVE_INFORMATION: Int

val NOT_ACCEPTABLE: Int

val NOT_FOUND: Int

val NOT_IMPLEMENTED: Int

val NOT_MODIFIED: Int

val NO_CONTENT: Int

val NoContent: Result

val NonAuthoritativeInformation: Status

val NotAcceptable: Status

val NotFound: Status

val NotImplemented: Status

val NotModified: Result

val OK: Int

val ORIGIN: String

val Ok: Status

val PARTIAL_CONTENT: Int

val PAYMENT_REQUIRED: Int

val PERMANENT_REDIRECT: Int

val PRAGMA: String

val PRECONDITION_FAILED: Int

val PROXY_AUTHENTICATE: String

val PROXY_AUTHENTICATION_REQUIRED: Int

val PROXY_AUTHORIZATION: String

val PartialContent: Status

val PaymentRequired: Status

def PermanentRedirect(url: String): Result

val PreconditionFailed: Status

val RANGE: String

val REFERER: String

val REQUESTED_RANGE_NOT_SATISFIABLE: Int

val REQUEST_ENTITY_TOO_LARGE: Int

val REQUEST_TIMEOUT: Int

val REQUEST_URI_TOO_LONG: Int

val RESET_CONTENT: Int

val RETRY_AFTER: String

def Redirect(call: Call, status: Int): Result

def Redirect(call: Call): Result

def Redirect(url: String, queryString: Map[String, Seq[String]], status: Int): Result

def Redirect(url: String, status: Int): Result

val RequestTimeout: Status

val ResetContent: Result

val SEE_OTHER: Int

val SERVER: String

val SERVICE_UNAVAILABLE: Int

val SET_COOKIE: String

val SET_COOKIE2: String

val SWITCHING_PROTOCOLS: Int

def SeeOther(url: String): Result

val ServiceUnavailable: Status

def Status(code: Int): Status

val TE: String

val TEMPORARY_REDIRECT: Int

def TEXT(implicit codec: Codec): String

val TODO: Action[AnyContent]

val TOO_MANY_REQUESTS: Int

val TRAILER: String

val TRANSFER_ENCODING: String

def TemporaryRedirect(url: String): Result

val TooManyRequests: Status

val UNAUTHORIZED: Int

val UNPROCESSABLE_ENTITY: Int

val UNSUPPORTED_MEDIA_TYPE: Int

val UPGRADE: String

val UPGRADE_REQUIRED: Int

val USER_AGENT: String

val USE_PROXY: Int

val Unauthorized: Status

val UnprocessableEntity: Status

val UnsupportedMediaType: Status

val UriTooLong: Status

val VARY: String

val VIA: String

val WARNING: String

val WWW_AUTHENTICATE: String

def XML(implicit codec: Codec): String

val X_FORWARDED_FOR: String

val X_FORWARDED_HOST: String

val X_FORWARDED_PORT: String

val X_FORWARDED_PROTO: String

val X_REQUESTED_WITH: String

final def asInstanceOf[T0]: T0

def authenticationFailed(request: RequestHeader)(implicit ctx: ExecutionContext): Future[Result]

If the user is not logged in and tries to access a protected resource, redirect to login page

def authorizationFailed(request: RequestHeader, user: User, authority: Option[Authority])(implicit context: ExecutionContext): Future[Result]

Only used, if play2-auth authorization is required.

def authorize(user: User, authority: Authority)(implicit ctx: ExecutionContext): Future[Boolean]

Unused.

def calcComparison(fieldName: String, filterOrIds: Seq[FilterOrId]): Action[AnyContent]

def calcCumulativeCount(fieldName: String, groupFieldName: Option[String], filterOrId: FilterOrId): Action[AnyContent]

def calcDistribution(fieldName: String, groupFieldName: Option[String], filterOrId: FilterOrId): Action[AnyContent]

def calcHeatmap(xFieldName: String, yFieldName: String, valueFieldName: Option[String], aggType: Option[server.models.AggType.Value], filterOrId: FilterOrId): Action[AnyContent]

def calcMatthewsCorrelations(filterOrId: FilterOrId): Action[AnyContent]

def calcPearsonCorrelations(filterOrId: FilterOrId): Action[AnyContent]

def calcScatter(xFieldName: String, yFieldName: String, groupOrValueFieldName: Option[String], filterOrId: FilterOrId): Action[AnyContent]

val categoryRepo: CategoryRepo

def clone(): AnyRef

def cluster(mlModelId: BSONObjectID, inputFieldNames: Seq[String], filterId: Option[BSONObjectID], featuresNormalizationType: Option[incal.spark_ml.models.VectorScalerType.Value], pcaDims: Option[Int]): Action[AnyContent]

var configuration: Configuration

def convertNumeric(fieldType: server.models.FieldTypeId.Value): Option[(BigDecimal) ⇒ Date]

def createCategoricalWidget(spec: DistributionWidgetSpec, field: Field, groupField: Option[Field]): (Traversable[(String, Traversable[Count[Any]])]) ⇒ Option[CategoricalCountWidget]

def createGroupNumericCounts[G](groupCounts: Traversable[(Option[G], Traversable[(BigDecimal, Int)])], groupFieldType: FieldType[G], field: Field): Seq[(String, Traversable[Count[_]])]

def createGroupStringCounts[G, T](groupCounts: Traversable[(Option[G], Traversable[(Option[T], Int)])], groupFieldType: FieldType[G], fieldType: FieldType[T]): Seq[(String, Traversable[Count[String]])]

def createNumericCounts(counts: Traversable[(BigDecimal, Int)], convert: Option[(BigDecimal) ⇒ Any] = None): Seq[Count[_]]

def createNumericWidget(spec: DistributionWidgetSpec, field: Field, groupField: Option[Field]): (Traversable[(String, Traversable[Count[Any]])]) ⇒ Option[NumericalCountWidget[Any]]

def createStringCounts[T](counts: Traversable[(Option[T], Int)], fieldType: FieldType[T]): Traversable[Count[String]]

def createTitle(field: Field, groupField: Option[Field]): String

def createWidget(spec: DistributionWidgetSpec, field: Field, groupField: Option[Field]): (Traversable[(String, Traversable[Count[Any]])]) ⇒ Option[Product with Serializable with Widget { val displayOptions: org.ada.server.models.MultiChartDisplayOptions }]

def csvFileName: String

def currentUser(request: Request[_]): Future[Option[User]]

val dataSetId: String

val dataViewRepo: DataViewRepo

var deadbolt: DeadboltActions

val defaultNumericBinCount: Int

val dsa: DataSetAccessor

lazy val entityName: String

def entityNameKey: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exportTableRecordsAsCsv(tableColumnNames: Seq[String], delimiter: String, replaceEolWithSpace: Boolean, eol: Option[String], filter: Seq[FilterCondition], tableColumnsOnly: Boolean, useDisplayValues: Boolean, escapeStringValues: Boolean): Action[AnyContent]

def exportTableRecordsAsJson(tableColumnNames: Seq[String], filter: Seq[FilterCondition], tableColumnsOnly: Boolean, useDisplayValues: Boolean): Action[AnyContent]

def exportToCsv(filename: String, delimiter: String = ",", eol: String = "\n", replacements: Traversable[(String, String)] = Nil, escapeStringValues: Boolean = false)(fieldNames: Traversable[String], orderBy: Option[String] = None, filter: Seq[FilterCondition] = Nil, nameFieldTypeMap: Map[String, FieldType[_]] = Map()): Action[AnyContent]

def exportToJson(filename: String)(orderBy: Option[String], filter: Seq[FilterCondition] = Nil, fieldNames: Traversable[String] = Nil, nameFieldTypeMap: Map[String, FieldType[_]] = Map())(implicit ev: Format[JsObject]): Action[AnyContent]

def exportTranSMARTDataFile(delimiter: String, visitFieldName: Option[String], replaceEolWithSpace: Boolean): Action[AnyContent]

Generate and content of TRANSMART data file and create a download.

def exportTranSMARTMappingFile(delimiter: String, visitFieldName: Option[String], replaceEolWithSpace: Boolean): Action[AnyContent]

Generate content of TRANSMART mapping file and create a download.

def exportViewRecordsAsCsv(dataViewId: BSONObjectID, delimiter: String, replaceEolWithSpace: Boolean, eol: Option[String], filter: Seq[FilterCondition], tableColumnsOnly: Boolean, useDisplayValues: Boolean, escapeStringValues: Boolean): Action[AnyContent]

Generate content of csv export file and create download.

def exportViewRecordsAsJson(dataViewId: BSONObjectID, filter: Seq[FilterCondition], tableColumnsOnly: Boolean, useDisplayValues: Boolean): Action[AnyContent]

Generate content of Json export file and create download.

def fieldLabelMap: Future[Map[String, Option[String]]]

def fieldNameCategoryMap(categories: Traversable[Category]): Future[Map[String, Category]]

val fieldRepo: FieldRepo

val filterRepo: FilterRepo

def filterValueConverters(fieldNames: Traversable[String]): Future[Map[String, (String) ⇒ Option[Any]]]

def finalize(): Unit

def find(page: Int, orderBy: String, conditions: Seq[FilterCondition]): Action[AnyContent]

def findCustom(filterOrId: FilterOrId, orderBy: String, projection: Seq[String], limit: Option[Int], skip: Option[Int]): Action[AnyContent]

def formatId(id: BSONObjectID): String

def generateTable(page: Int, orderBy: String, fieldNames: Seq[String], filterOrId: FilterOrId): Action[AnyContent]

def generateTableWithFilter(page: Int, orderBy: String, fieldNames: Seq[String], filterOrId: FilterOrId): Action[AnyContent]

def generateTranSMARTDataFile(dataFilename: String, delimiter: String, keyFieldName: String, orderBy: Option[String], visitFieldName: Option[String], replaceEolWithSpace: Boolean): Future[String]

Generate content of TRANSMART data file for download.

def generateTranSMARTMappingFile(dataFilename: String, delimiter: String, keyFieldName: String, orderBy: Option[String], visitFieldName: Option[String], replaceEolWithSpace: Boolean): Future[String]

Generate the content of TRANSMART mapping file for downnload.

def get(id: BSONObjectID): Action[AnyContent]

def getCategoriesWithFieldsAsTreeNodes(filterOrId: FilterOrId): Action[AnyContent]

final def getClass(): Class[_]

def getClusterization: Action[AnyContent]

def getComparison(filterOrIds: Seq[FilterOrId]): Action[AnyContent]

def getCumulativeCount(filterOrId: FilterOrId): Action[AnyContent]

def getDefaultView: Action[AnyContent]

def getDistribution(filterOrId: FilterOrId): Action[AnyContent]

def getField(fieldName: String): Action[AnyContent]

def getFieldNamesAndLabels(fieldTypeIds: Seq[server.models.FieldTypeId.Value]): Action[AnyContent]

def getFieldTypeWithAllowedValues(fieldName: String): Action[AnyContent]

def getFieldValue(id: BSONObjectID, fieldName: String): Action[AnyContent]

def getFields(fieldTypeIds: Seq[server.models.FieldTypeId.Value]): Action[AnyContent]

def getFractalis(fieldNameOption: Option[String]): Action[AnyContent]

def getFutureCount(filter: Seq[FilterCondition]): Future[Int]

def getFutureItems(page: Option[Int], orderBy: String, filter: Seq[FilterCondition], projection: Seq[String], limit: Option[Int]): Future[Traversable[JsObject]]

def getFutureItemsAndCount(page: Option[Int], orderBy: String, filter: Seq[FilterCondition], projection: Seq[String], limit: Option[Int]): Future[(Traversable[JsObject], Int)]

def getFutureItemsAndCount(page: Int, orderBy: String, filter: Seq[FilterCondition]): Future[(Traversable[JsObject], Int)]

def getFutureItemsForCriteria(page: Option[Int], orderBy: String, criteria: Seq[Criterion[Any]], projection: Seq[String], limit: Option[Int]): Future[Traversable[JsObject]]

def getHeatmap(filterOrId: FilterOrId): Action[AnyContent]

def getIndependenceTest(filterOrId: FilterOrId): Action[AnyContent]

def getListViewData(page: Page[JsObject], conditions: Seq[FilterCondition]): (Request[_]) ⇒ Future[(String, Page[JsObject], Seq[FilterCondition], Map[String, String], Seq[String])]

def getMatthewsCorrelations(filterOrId: FilterOrId): Action[AnyContent]

def getNewFilter: Action[AnyContent]

def getNewFilterViewElementsAndWidgetsCallback(dataViewId: BSONObjectID, tableOrder: String, totalCount: Int): Action[AnyContent]

def getPearsonCorrelations(filterOrId: FilterOrId): Action[AnyContent]

def getScatter(filterOrId: FilterOrId): Action[AnyContent]

def getSeriesProcessingSpec: Action[AnyContent]

def getSeriesTransformationSpec: Action[AnyContent]

def getShowViewData(id: BSONObjectID, item: JsObject): (Request[_]) ⇒ Future[DataSetShowViewDataHolder]

def getTable(filterOrId: FilterOrId): Action[AnyContent]

def getView(dataViewId: BSONObjectID, tablePages: Seq[PageOrder], filterOrIds: Seq[FilterOrId], filterChanged: Boolean): Action[AnyContent]

def getViewElementsAndWidgetsCallback(dataViewId: BSONObjectID, tableOrder: String, filterOrId: FilterOrId, oldCountDiff: Option[Int]): Action[AnyContent]

def getWidgets: Action[AnyContent]

def goHome: Result

def handleBusinessException(message: String, e: Throwable, useReferrer: Boolean)(implicit request: Request[_]): Result

def handleExceptions(functionName: String, extraMessage: Option[String] = None)(implicit request: Request[_]): PartialFunction[Throwable, Result]

def handleExceptionsWithErrorCodes(functionName: String, extraMessage: Option[String] = None)(implicit request: Request[_]): PartialFunction[Throwable, Result]

def handleExceptionsWithId(functionName: String, id: BSONObjectID)(implicit request: Request[_]): PartialFunction[Throwable, Result]

def handleFatalException(functionName: String, extraMessage: Option[String], e: Throwable): Result

def handleFindExceptions(implicit request: Request[_]): PartialFunction[Throwable, Result]

def handleGetExceptions(id: BSONObjectID)(implicit request: Request[_]): PartialFunction[Throwable, Result]

def handleListAllExceptions(implicit request: Request[_]): PartialFunction[Throwable, Result]

def handleTimeoutException(functionName: String, extraMessage: Option[String], useReferrer: Boolean)(implicit request: Request[_]): Result

def hashCode(): Int

val homeCall: Call

lazy val idContainer: AsyncIdContainer[Id]

val idTag: ClassTag[Id]

A ClassTag is used to retrieve an id from the Cache API.

final def isInstanceOf[T0]: Boolean

def jsonFileName: String

def listAll(orderBy: String): Action[AnyContent]

def listView: (WebContext) ⇒ ((String, Page[JsObject], Seq[FilterCondition], Map[String, String], Seq[String])) ⇒ play.twirl.api.HtmlFormat.Appendable

def listViewColumns: Option[Seq[String]]

def listViewWithContext(data: ListViewData)(implicit context: WebContext): Html

def loginSucceeded(request: RequestHeader)(implicit ctx: ExecutionContext): Future[Result]

Where to redirect the user after a successful login.

def logoutSucceeded(request: RequestHeader)(implicit ctx: ExecutionContext): Future[Result]

Where to redirect the user after logging out

val maxIntCountsForZeroPadding: Int

var messagesApi: MessagesApi

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val pageLimit: Int

def prepareIntCounts(longUniqueCounts: Traversable[(Option[Long], Int)]): Seq[Count[Long]]

def referrerOrHome(useReferrer: Boolean)(implicit request: Request[_]): Result

object render

def repo: JsonCrudRepo

implicit def request2flash(implicit request: RequestHeader): Flash

implicit def request2lang(implicit request: RequestHeader): Lang

implicit def request2session(implicit request: RequestHeader): Session

def resolveUser(id: Id)(implicit ctx: ExecutionContext): Future[Option[User]]

A function that returns a User object from an Id.

def result[T](future: Future[T]): T

def rootCategoryTree(categories: Traversable[Category]): Category

val router: DataSetRouter

def runSeriesProcessing: Action[AnyContent]

def runSeriesTransformation: Action[AnyContent]

val sessionTimeoutInSeconds: Int

The session timeout in seconds

def showView: (WebContext) ⇒ (ShowViewData) ⇒ play.twirl.api.HtmlFormat.Appendable

def showViewWithContext(data: ShowViewData)(implicit context: WebContext): Html

def sortCountSeries(binCount: Option[Int]): (Traversable[(String, Traversable[Count[Any]])]) ⇒ Seq[(String, Seq[Count[String]])]

final def synchronized[T0](arg0: ⇒ T0): T0

def testIndependence(filterOrId: FilterOrId): Action[AnyContent]

val timeout: FiniteDuration

def toCriteria(filter: Seq[FilterCondition]): Future[Seq[Criterion[Any]]]

def toGroupStringValues[G, T](groupCounts: Traversable[(Option[G], Traversable[T])], groupFieldType: FieldType[G]): Seq[(String, Traversable[T])]

def toJson(items: Traversable[JsObject]): JsValue

def toJson(item: JsObject): JsValue

def toSort(fieldName: String): Seq[Sort]

def toString(): String

lazy val tokenAccessor: CookieTokenAccessor

(Optional) You can custom SessionID Token handler.

def tranSMARTDataFileName: String

def tranSMARTMappingFileName: String

val userManager: UserManager

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

implicit def webContext(implicit request: AuthenticatedRequest[_]): WebContext

var webJarAssets: WebJarAssets

def withCharset(mimeType: String)(implicit codec: Codec): String

val TOO_MANY_REQUEST: Int

val TooManyRequest: Status

final lazy val cookieDomainOption: Option[String]

final lazy val cookieHttpOnlyOption: Boolean

final lazy val cookieName: String

final lazy val cookiePathOption: String

final lazy val cookieSecureOption: Boolean

final lazy val isTransientCookie: Boolean