Dev2.5.17 all+server transl

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/WhiteboardKeyUtil.scala

@@ -4,9 +4,11 @@ object WhiteboardKeyUtil {
   val TEXT_TYPE = "text";
   val PENCIL_TYPE = "pencil";
   val RECTANGLE_TYPE = "rectangle";
+  val ERASER_TYPE = "eraser";
   val ELLIPSE_TYPE = "ellipse";
   val TRIANGLE_TYPE = "triangle";
   val LINE_TYPE = "line";
+  val MARKER_TYPE = "marker";
   val DRAW_START_STATUS = "DRAW_START";
   val DRAW_UPDATE_STATUS = "DRAW_UPDATE";
   val DRAW_END_STATUS = "DRAW_END";

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/WhiteboardModel.scala

@@ -11,7 +11,9 @@ import org.bigbluebutton.SystemConfiguration
 
 class WhiteboardModel extends SystemConfiguration {
   private var _whiteboards = new HashMap[String, Whiteboard]()
-
+  private var SYNCUPDATE = false
+  private var SIMPLEPEN = true
+
   private def saveWhiteboard(wb: Whiteboard) {
     _whiteboards += wb.id -> wb
   }
@@ -58,6 +60,7 @@ class WhiteboardModel extends SystemConfiguration {
 
     //not empty and head id equals annotation id
     if (!usersAnnotations.isEmpty && usersAnnotations.head.id == annotation.id) {
+      // never comes here since 2.3, but now we use this again for the synchronized update
       val rtnAnnotation = annotation.copy(position = usersAnnotations.head.position)
       val newAnnotationsMap = wb.annotationsMap + (userId -> (rtnAnnotation :: usersAnnotations.tail))
       //println("Annotation has position [" + usersAnnotations.head.position + "]")
@@ -90,8 +93,10 @@ class WhiteboardModel extends SystemConfiguration {
         }
       }) //newPoints = a.asInstanceOf[ArrayList[Float]])
       val updatedAnnotationData = annotation.annotationInfo + ("points" -> (oldPoints ::: newPoints))
-      val updatedAnnotation = annotation.copy(position = oldAnnotation.position, annotationInfo = updatedAnnotationData)
-
+
+      val newPosition = wb.annotationCount
+      val updatedAnnotation = annotation.copy(position = newPosition, annotationInfo = updatedAnnotationData)
+
       val newAnnotationsMap = wb.annotationsMap + (userId -> (updatedAnnotation :: usersAnnotations.tail))
       //println("Annotation has position [" + usersAnnotations.head.position + "]")
       val newWb = wb.copy(annotationsMap = newAnnotationsMap)
@@ -104,7 +109,7 @@ class WhiteboardModel extends SystemConfiguration {
     }
   }
 
-  def endAnnotationPencil(wbId: String, userId: String, annotation: AnnotationVO, drawEndOnly: Boolean): AnnotationVO = {
+  def endAnnotationPencil(wbId: String, userId: String, annotation: AnnotationVO): AnnotationVO = {
     var rtnAnnotation: AnnotationVO = annotation
 
     val wb = getWhiteboard(wbId)
@@ -146,28 +151,43 @@ class WhiteboardModel extends SystemConfiguration {
 
       //val oldPointsJava: java.util.List[java.lang.Float] = oldPoints.asJava.asInstanceOf[java.util.List[java.lang.Float]]
       //println("****class = " + oldPointsJava.getClass())
-      val pathData = BezierWrapper.lineSimplifyAndCurve((oldPoints ::: newPoints).asJava.asInstanceOf[java.util.List[java.lang.Float]], dimensions(0), dimensions(1))
-      //println("Path data: pointssize " + pathData.points.size() + " commandssize " + pathData.commands.size())
-
-      val updatedAnnotationData = annotation.annotationInfo + ("points" -> pathData.points.asScala.toList) + ("commands" -> pathData.commands.asScala.toList)
-      //println("oldAnnotation value = " + oldAnnotationOption.getOrElse("Empty"))
-
-      var newPosition: Int = wb.annotationCount
+
+      var updatedAnnotationData: Map[String, Any] = Map[String, Any]()
+      if (!SYNCUPDATE || (SYNCUPDATE && SIMPLEPEN)) {
+        val pathData = BezierWrapper.lineSimplifyAndCurve((oldPoints ::: newPoints).asJava.asInstanceOf[java.util.List[java.lang.Float]], dimensions(0), dimensions(1))
+        //println("Path data: pointssize " + pathData.points.size() + " commandssize " + pathData.commands.size())
+        updatedAnnotationData = annotation.annotationInfo + ("points" -> pathData.points.asScala.toList) + ("commands" -> pathData.commands.asScala.toList)
+        //println("oldAnnotation value = " + oldAnnotationOption.getOrElse("Empty"))
+      } else {
+        updatedAnnotationData = annotation.annotationInfo + ("points" -> (oldPoints ::: newPoints))
+      }
 
+      var newPosition: Int = oldAnnotationOption match {
+        case Some(annotation) => annotation.position
+        case None             => wb.annotationCount
+      }
+      //if (SYNCUPDATE) {
+        newPosition = wb.annotationCount
+      //}
       val updatedAnnotation = annotation.copy(position = newPosition, annotationInfo = updatedAnnotationData)
 
+      val updateExists = !usersAnnotations.isEmpty && usersAnnotations.head.id == annotation.id
       var newUsersAnnotations: List[AnnotationVO] = oldAnnotationOption match {
         //As part of the whiteboard improvments for the HTML5 client it no longer sends
         //DRAW_START and DRAW_UPDATE events (#9019). Client now sends drawEndOnly in the
         //SendWhiteboardAnnotationPubMsg so akka knows not to expect usersAnnotations to be accumulating.
-        case Some(annotation) if (drawEndOnly == true) => usersAnnotations
-        case Some(annotation)                          => usersAnnotations.tail
-        case None                                      => usersAnnotations
+        //With #14012, DRAW_UPDATE can happen when the synchronised update option is turned on,
+        // and we don't need the argument drawEndOnly anymore.
+         case Some(annotation) if (updateExists) => usersAnnotations.tail
+         case _                                  => usersAnnotations
       }
 
       val newAnnotationsMap = wb.annotationsMap + (userId -> (updatedAnnotation :: newUsersAnnotations))
       //println("Annotation has position [" + usersAnnotations.head.position + "]")
-      val newWb = wb.copy(annotationCount = wb.annotationCount + 1, annotationsMap = newAnnotationsMap)
+      //var newWb = wb.copy(annotationsMap = newAnnotationsMap)
+      //if (SYNCUPDATE) {
+        val newWb = wb.copy(annotationCount = wb.annotationCount + 1, annotationsMap = newAnnotationsMap)
+      //}
       //println("Updating annotation on page [" + wb.id + "]. After numAnnotations=[" + getAnnotationsByUserId(wb, userId).length + "].")
       saveWhiteboard(newWb)
 
@@ -232,18 +252,132 @@ class WhiteboardModel extends SystemConfiguration {
     }
     last
   }
-
+
+  def removeWhiteboardAnnotations(wbId: String, selectedAnnotations: Array[Map[String, String]], userId: String): List[AnnotationVO] = {
+    var lasts: List[AnnotationVO] = List[AnnotationVO]()
+    val wb = getWhiteboard(wbId)
+    if (wb.annotationsMap.nonEmpty) {
+      var newWb = getWhiteboard("dummy")
+      for ((uid, annotation) <- wb.annotationsMap) {
+        if (!wb.multiUser.contains(userId) || userId == uid) {
+          for (a <- selectedAnnotations) {
+            val elemRM = annotation.filter(_.id == a("id"))
+            lasts = lasts ++ elemRM
+          }
+          newWb = removeSpecificAnnotations(wb, uid, annotation, lasts)
+        }
+      }
+      saveWhiteboard(newWb)
+    }
+    lasts
+  }
+
+  def moveWhiteboardAnnotations(wbId: String, selectedAnnotations: Array[Map[String, String]], offset: Map[String, Float], userId: String): List[AnnotationVO] = {
+    var allMovedAnnotations: List[AnnotationVO] = List[AnnotationVO]()
+    val wb = getWhiteboard(wbId)
+    if (wb.annotationsMap.nonEmpty) {
+      var newAnnotationsMap = wb.annotationsMap
+      for ((uid, annotations) <- wb.annotationsMap) {
+        if (!(wb.multiUser.contains(userId) && userId != uid)) { // don't allow changing the drawings of others in case of multiUser mode
+          var newAnnotations = List(annotations: _*)
+          for (a <- selectedAnnotations) {
+            val oldAnnotation = annotations.find(_.id == a("id")).getOrElse(null)
+            if (oldAnnotation != null) {
+              var updatedAnnotationData = oldAnnotation.annotationInfo
+              if (oldAnnotation.annotationType == "text") {
+                var x: Double = 0
+                var y: Double = 0
+                oldAnnotation.annotationInfo.get("x").foreach(a => {
+                  a match {
+                    case a2: Double => x = a2.asInstanceOf[Double]
+                  }
+                })
+                oldAnnotation.annotationInfo.get("y").foreach(a => {
+                  a match {
+                    case a2: Double => y = a2.asInstanceOf[Double]
+                  }
+                })
+                updatedAnnotationData = oldAnnotation.annotationInfo + ("x" -> (x + offset("x").toString.toDouble), "y" -> (y + offset("y").toString.toDouble))
+              } else {
+                var oldPoints: List[Float] = List[Float]()
+                oldAnnotation.annotationInfo.get("points").foreach(a => {
+                  a match {
+                    case a2: List[_] => oldPoints = a2.asInstanceOf[List[Float]]
+                  }
+                })
+                val newPoints = oldPoints.zipWithIndex.map {
+                  case (a) =>
+                    if (a._2 % 2 == 0) {
+                      a._1.toString.toFloat + offset("x").toString.toFloat
+                    } else {
+                      a._1.toString.toFloat + offset("y").toString.toFloat
+                    }
+                }
+                updatedAnnotationData = oldAnnotation.annotationInfo + ("points" -> (newPoints))
+              }
+              val updatedAnnotation = oldAnnotation.copy(annotationInfo = updatedAnnotationData)
+              newAnnotations = newAnnotations.map(an => if (an.id == a("id")) updatedAnnotation else an)
+              allMovedAnnotations = allMovedAnnotations :+ updatedAnnotation
+            }
+          }
+          newAnnotationsMap = newAnnotationsMap + (uid -> newAnnotations)
+        }
+      }
+      val newWb = wb.copy(annotationsMap = newAnnotationsMap)
+      saveWhiteboard(newWb)
+    }
+    allMovedAnnotations
+  }
+
+  def reorderWhiteboardAnnotations(wbId: String, selectedAnnotations: Array[Map[String, String]], order: Array[Map[String, String]], userId: String) = {
+    val wb = getWhiteboard(wbId)
+
+    if (wb.annotationsMap.nonEmpty) {
+      var newAnnotationsMap = wb.annotationsMap
+      var id2position: Map[String, String] = Map[String, String]()
+      for (o <- order) {
+        id2position = id2position + (o("id") -> o("position"))
+      }
+
+      for ((uid, annotations) <- wb.annotationsMap) {
+        val newAnnotations = annotations.map(an => an.copy(annotationInfo = an.annotationInfo + ("position" -> (id2position(an.id)))))
+        newAnnotationsMap = newAnnotationsMap + (uid -> newAnnotations)
+      }
+
+      val newWb = wb.copy(annotationsMap = newAnnotationsMap)
+      saveWhiteboard(newWb)
+    }
+  }
+
   private def removeHeadAnnotation(wb: Whiteboard, key: String, list: List[AnnotationVO]): Whiteboard = {
     val newAnnotationsMap = if (list.tail == Nil) wb.annotationsMap - key else wb.annotationsMap + (key -> list.tail)
     wb.copy(annotationsMap = newAnnotationsMap)
   }
 
+  private def removeSpecificAnnotations(wb: Whiteboard, key: String, list: List[AnnotationVO], listRemoved: List[AnnotationVO]): Whiteboard = {
+    var newList = list
+    for (a <- listRemoved) {
+      newList = newList.filterNot(_ == a)
+    }
+    val newAnnotationsMap = if (newList == Nil) wb.annotationsMap - key else wb.annotationsMap + (key -> newList)
+    wb.copy(annotationsMap = newAnnotationsMap)
+  }
+
   def modifyWhiteboardAccess(wbId: String, multiUser: Array[String]) {
     val wb = getWhiteboard(wbId)
     val newWb = wb.copy(multiUser = multiUser, oldMultiUser = wb.multiUser, changedModeOn = System.currentTimeMillis())
     saveWhiteboard(newWb)
   }
 
+  def modifyWBMode(mId: String, wbMode: Map[String, Boolean]) {
+    if (wbMode.isDefinedAt("synchronizeWBUpdate")) {
+      SYNCUPDATE = wbMode.get("synchronizeWBUpdate").get
+    }
+    if (wbMode.isDefinedAt("simplifyPencil")) {
+      SIMPLEPEN = wbMode.get("simplifyPencil").get
+    }
+  }
+
   def getWhiteboardAccess(wbId: String): Array[String] = getWhiteboard(wbId).multiUser
 
   def isNonEjectionGracePeriodOver(wbId: String, userId: String): Boolean = {

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/caption/CaptionApp2x.scala

@@ -46,7 +46,7 @@ class CaptionApp2x(implicit val context: ActorContext) extends RightsManagementT
     }
 
     if (permissionFailed(PermissionCheck.MOD_LEVEL, PermissionCheck.VIEWER_LEVEL, liveMeeting.users2x, msg.header.userId)
-      && isUserCaptionOwner(liveMeeting, msg.header.userId, msg.body.name)) {
+      /*&& isUserCaptionOwner(liveMeeting, msg.header.userId, msg.body.name)*/) {
       val meetingId = liveMeeting.props.meetingProp.intId
       val reason = "No permission to edit caption history in meeting."
       PermissionCheck.ejectUserForFailedPermission(meetingId, msg.header.userId, reason, bus.outGW, liveMeeting)

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/pads/PadUpdatePubMsgHdlr.scala

@@ -21,11 +21,11 @@ trait PadUpdatePubMsgHdlr {
       bus.outGW.send(msgEvent)
     }
 
-    if (Pads.hasAccess(liveMeeting, msg.body.externalId, msg.header.userId)) {
+    //if (Pads.hasAccess(liveMeeting, msg.body.externalId, msg.header.userId)) {
       Pads.getGroup(liveMeeting.pads, msg.body.externalId) match {
         case Some(group) => broadcastEvent(group.groupId, msg.body.externalId, msg.body.text)
         case _           =>
       }
-    }
+    //}
   }
 }

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/upload/FileUploadedSysMsgHdlr.scala

@@ -0,0 +1,36 @@
+package org.bigbluebutton.core.apps.upload
+
+import org.bigbluebutton.common2.msgs._
+import org.bigbluebutton.core.bus.MessageBus
+import org.bigbluebutton.core.running.LiveMeeting
+
+trait FileUploadedSysMsgHdlr {
+  this: UploadApp2x =>
+
+  def handle(
+      msg:         FileUploadedSysMsg,
+      liveMeeting: LiveMeeting,
+      bus:         MessageBus
+  ): Unit = {
+
+    val meetingId = liveMeeting.props.meetingProp.intId
+    val userId = msg.header.userId
+
+    def broadcastFileUploadedEvtMsg(msg: FileUploadedSysMsg): Unit = {
+      val uploadId = msg.body.uploadId
+      val source = msg.body.source
+      val filename = msg.body.filename
+
+      val routing = Routing.addMsgToClientRouting(MessageTypes.DIRECT, meetingId, userId)
+      val envelope = BbbCoreEnvelope(FileUploadedEvtMsg.NAME, routing)
+      val header = BbbClientMsgHeader(FileUploadedEvtMsg.NAME, meetingId, userId)
+      val body = FileUploadedEvtMsgBody(uploadId, source, filename)
+      val event = FileUploadedEvtMsg(header, body)
+      val msgEvent = BbbCommonEnvCoreMsg(envelope, event)
+
+      bus.outGW.send(msgEvent)
+    }
+
+    broadcastFileUploadedEvtMsg(msg)
+  }
+}

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/upload/UploadApp2x.scala

@@ -0,0 +1,11 @@
+package org.bigbluebutton.core.apps.upload
+
+import akka.actor.ActorContext
+import akka.event.Logging
+
+class UploadApp2x(implicit val context: ActorContext)
+  extends UploadRequestReqMsgHdlr
+  with FileUploadedSysMsgHdlr {
+
+  val log = Logging(context.system, getClass)
+}

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/upload/UploadRequestReqMsgHdlr.scala

@@ -0,0 +1,65 @@
+package org.bigbluebutton.core.apps.upload
+
+import org.bigbluebutton.common2.msgs._
+import org.bigbluebutton.core.bus.MessageBus
+import org.bigbluebutton.core.running.LiveMeeting
+import org.bigbluebutton.core.apps.{ PermissionCheck, RightsManagementTrait }
+import org.bigbluebutton.core.util.RandomStringGenerator
+
+trait UploadRequestReqMsgHdlr extends RightsManagementTrait {
+  this: UploadApp2x =>
+
+  def handle(
+      msg:         UploadRequestReqMsg,
+      liveMeeting: LiveMeeting,
+      bus:         MessageBus
+  ): Unit = {
+
+    val meetingId = liveMeeting.props.meetingProp.intId
+    val userId = msg.header.userId
+    val source = msg.body.source
+    val filename = msg.body.filename
+    val timestamp = msg.body.timestamp
+
+    // To system
+    def broadcastUploadRequestSysMsg(
+        msg:   UploadRequestReqMsg,
+        token: String
+    ): Unit = {
+
+      val routing = collection.immutable.HashMap("sender" -> "bbb-apps-akka")
+      val envelope = BbbCoreEnvelope(UploadRequestSysMsg.NAME, routing)
+      val header = BbbCoreHeaderWithMeetingId(UploadRequestSysMsg.NAME, meetingId)
+      val body = UploadRequestSysMsgBody(source, filename, userId, token)
+      val event = UploadRequestSysMsg(header, body)
+      val msgEvent = BbbCommonEnvCoreMsg(envelope, event)
+
+      bus.outGW.send(msgEvent)
+    }
+
+    // To client
+    def broadcastUploadRequestRespMsg(
+        msg:     UploadRequestReqMsg,
+        success: Boolean             = false,
+        token:   String              = null
+    ): Unit = {
+
+      val routing = Routing.addMsgToClientRouting(MessageTypes.DIRECT, meetingId, userId)
+      val envelope = BbbCoreEnvelope(UploadRequestRespMsg.NAME, routing)
+      val header = BbbClientMsgHeader(UploadRequestRespMsg.NAME, meetingId, userId)
+      val body = UploadRequestRespMsgBody(source, filename, userId, success, timestamp, token)
+      val event = UploadRequestRespMsg(header, body)
+      val msgEvent = BbbCommonEnvCoreMsg(envelope, event)
+
+      bus.outGW.send(msgEvent)
+    }
+
+    if (permissionFailed(PermissionCheck.GUEST_LEVEL, PermissionCheck.MOD_LEVEL, liveMeeting.users2x, userId)) {
+      broadcastUploadRequestRespMsg(msg)
+    } else {
+      val token = RandomStringGenerator.randomAlphanumericString(32)
+      broadcastUploadRequestSysMsg(msg, token)
+      broadcastUploadRequestRespMsg(msg, true, token)
+    }
+  }
+}

akka-bbb-apps/src/main/scala/org/bigbluebutton/core/apps/users/ChangeLockSettingsInMeetingCmdMsgHdlr.scala

@@ -27,6 +27,7 @@ trait ChangeLockSettingsInMeetingCmdMsgHdlr extends RightsManagementTrait {
         disablePubChat = msg.body.disablePubChat,
         disableNotes = msg.body.disableNotes,
         hideUserList = msg.body.hideUserList,
+        hideAnnotations = msg.body.hideAnnotations,
         lockedLayout = msg.body.lockedLayout,
         lockOnJoin = msg.body.lockOnJoin,
         lockOnJoinConfigurable = msg.body.lockOnJoinConfigurable,
@@ -65,6 +66,7 @@ trait ChangeLockSettingsInMeetingCmdMsgHdlr extends RightsManagementTrait {
           disablePubChat = settings.disablePubChat,
           disableNotes = settings.disableNotes,
           hideUserList = settings.hideUserList,
+          hideAnnotations = settings.hideAnnotations,
           lockedLayout = settings.lockedLayout,
           lockOnJoin = settings.lockOnJoin,
           lockOnJoinConfigurable = settings.lockOnJoinConfigurable,