DBProcessRepository

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

lazy val api: API

def archive(processId: ProcessId, isArchived: Boolean): DB[XError[Unit]]

final def asInstanceOf[T0]: T0

val attachmentsTable: TableQuery[AttachmentEntity]

def clone(): AnyRef

val commentsTable: TableQuery[CommentEntity]

val dbConfig: DbConfig

def deleteProcess(processId: ProcessId): DB[XError[Unit]]

implicit def deploymentMapper: JdbcType[ProcessActionType] with BaseTypedType[ProcessActionType]

val environmentsTable: TableQuery[EnvironmentsEntity]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fetchLastActionPerProcessQuery: slick.jdbc.JdbcProfile.API.Query[(slick.jdbc.JdbcProfile.API.Rep[Long], (ProcessActionEntity, slick.jdbc.JdbcProfile.API.Rep[Option[CommentEntity]])), (Long, (ProcessActionEntityData, Option[CommentEntityData])), Seq]

def fetchLastDeployedActionPerProcessQuery: slick.jdbc.JdbcProfile.API.Query[(slick.jdbc.JdbcProfile.API.Rep[Long], (ProcessActionEntity, slick.jdbc.JdbcProfile.API.Rep[Option[CommentEntity]])), (Long, (ProcessActionEntityData, Option[CommentEntityData])), Seq]

def fetchLatestProcessesQuery(query: (ProcessEntity) ⇒ slick.jdbc.JdbcProfile.API.Rep[Boolean], lastDeployedActionPerProcess: Seq[(Long, (ProcessActionEntityData, Option[CommentEntityData]))], isDeployed: Option[Boolean])(implicit fetchShape: ProcessShapeFetchStrategy[_], loggedUser: LoggedUser, ec: ExecutionContext): slick.jdbc.JdbcProfile.API.Query[(((slick.jdbc.JdbcProfile.API.Rep[Long], slick.jdbc.JdbcProfile.API.Rep[Option[Timestamp]]), BaseProcessVersionEntity), ProcessEntity), (((Long, Option[Timestamp]), ProcessVersionEntityData), ProcessEntityData), Seq]

def fetchProcessLatestActionsQuery(processId: ProcessId): slick.jdbc.JdbcProfile.API.Query[(ProcessActionEntity, slick.jdbc.JdbcProfile.API.Rep[Option[CommentEntity]]), (ProcessActionEntityData, Option[CommentEntityData]), Seq]

def fetchProcessLatestVersionsQuery(processId: ProcessId)(implicit fetchShape: ProcessShapeFetchStrategy[_]): slick.jdbc.JdbcProfile.API.Query[BaseProcessVersionEntity, ProcessVersionEntityData, Seq]

def fetchTagsPerProcess(implicit fetchShape: ProcessShapeFetchStrategy[_], ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIOAction[Map[Long, List[TagsEntityData]], slick.jdbc.JdbcProfile.API.NoStream, Read]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def latestProcessVersionsNoJsonQuery(processName: ProcessName): slick.jdbc.JdbcProfile.API.Query[BaseProcessVersionEntity, ProcessVersionEntityData, Seq]

lazy val logger: Logger

val modelVersion: ProcessingTypeDataProvider[Int]

final def ne(arg0: AnyRef): Boolean

def newCommentAction(processId: ProcessId, processVersionId: Long, comment: String)(implicit ec: ExecutionContext, loggedUser: LoggedUser): DB[Option[Long]]

def nextIdAction[T <: JdbcProfile](implicit jdbcProfile: T): slick.jdbc.JdbcProfile.API.DBIO[Long]

final def notify(): Unit

final def notifyAll(): Unit

def now: LocalDateTime

val processActionsTable: TableQuery[ProcessActionEntity]

def processTableFilteredByUser(implicit loggedUser: LoggedUser): slick.jdbc.JdbcProfile.API.Query[ProcessEntity, ProcessEntityData, Seq]

implicit def processTypeMapper: JdbcType[ProcessType] with BaseTypedType[ProcessType]

val processVersionsTable: slick.jdbc.JdbcProfile.API.TableQuery[ProcessVersionEntity]

val processVersionsTableNoJson: slick.jdbc.JdbcProfile.API.TableQuery[ProcessVersionEntityNoJson]

def processVersionsTableQuery(implicit fetchShape: ProcessShapeFetchStrategy[_]): slick.jdbc.JdbcProfile.API.TableQuery[BaseProcessVersionEntity]

val processesTable: TableQuery[ProcessEntity]

lazy val profile: JdbcProfile

def renameProcess(process: ProcessIdWithName, newName: String)(implicit loggedUser: LoggedUser): DB[XError[Unit]]

def run[R]: (DB[R]) ⇒ DB[R]

def saveNewProcess(action: CreateProcessAction)(implicit loggedUser: LoggedUser): DB[XError[Option[ProcessVersionEntityData]]]

These action should be done on transaction - move it to ProcessService.createProcess

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

val tagsTable: TableQuery[TagsEntity]

def toString(): String

def updateCategory(processId: ProcessId, category: String)(implicit loggedUser: LoggedUser): DB[XError[Unit]]

def updateProcess(updateProcessAction: UpdateProcessAction)(implicit loggedUser: LoggedUser): DB[XError[ProcessUpdated]]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit