refactoring

bot/src/main/scala/com/lbs/bot/telegram/package.scala

@@ -12,34 +12,28 @@ package object telegram {
   object TelegramModelConverters extends ModelConverters {
     implicit val TelegramCommandToCommandConverter:
       ObjectConverter[TelegramEvent, Command] =
-      new ObjectConverter[TelegramEvent, Command] {
-        override def convert[Z <: TelegramEvent](data: Z): Command = {
+      (data: TelegramEvent) => {
         Command(
           source = MessageSource(TelegramMessageSourceSystem, data.msg.chat.id.toString),
           message = Message(data.msg.messageId.toString, data.msg.text),
           callbackData = data.callbackData
         )
       }
-      }
 
     implicit val TelegramMessageToMessageConverter:
       ObjectConverter[BMessage, Message] =
-      new ObjectConverter[BMessage, Message] {
-        override def convert[Z <: BMessage](data: Z): Message = {
+      (data: BMessage) => {
         Message(data.messageId.toString, data.text)
       }
-      }
 
     implicit val InlineKeyboardToInlineKeyboardMarkup:
       ObjectConverter[InlineKeyboard, InlineKeyboardMarkup] =
-      new ObjectConverter[InlineKeyboard, InlineKeyboardMarkup] {
-        override def convert[Z <: InlineKeyboard](inlineKeyboard: Z): InlineKeyboardMarkup = {
+      (inlineKeyboard: InlineKeyboard) => {
         val buttons = inlineKeyboard.buttons.map { row =>
           row.map(createInlineKeyboardButton)
         }
         InlineKeyboardMarkup(buttons)
       }
-      }
 
     private def createInlineKeyboardButton(button: Button) = {
       button match {

common/src/main/scala/com/lbs/common/ModelConverters.scala

@@ -1,25 +1,22 @@
 
 package com.lbs.common
 
-import scala.collection.generic.CanBuildFrom
 import scala.language.{higherKinds, implicitConversions}
 
 trait ModelConverters {
 
-  trait CollectionConverter[-In, Out] {
-    def convert[Z <: In, Col[X] <: Iterable[X]](col: Col[Z])(implicit bf: CanBuildFrom[Col[Z], Out, Col[Out]]): Col[Out]
-  }
-
-  trait ObjectConverter[-In, Out] {
-    def convert[Z <: In](any: Z): Out
-  }
-
-  implicit class CollectionOps[From, Col[X] <: Iterable[X]](col: Col[From]) {
-    def mapTo[To](implicit converter: CollectionConverter[From, To], bf: CanBuildFrom[Col[From], To, Col[To]]): Col[To] = converter.convert(col)
+  trait ObjectConverter[-In, +Out] {
+    def convert(any: In): Out
   }
 
   implicit class ObjectOps[From](anyRef: From) {
     def mapTo[To](implicit converter: ObjectConverter[From, To]): To = converter.convert(anyRef)
   }
 
+  implicit def sequenceConverters[From, To](implicit objectConverter: ObjectConverter[From, To]): ObjectConverter[Seq[From], Seq[To]] = {
+    collection: Seq[From] => {
+      collection.map(objectConverter.convert)
+    }
+  }
+
 }

server/src/main/scala/com/lbs/server/service/DataService.scala

@@ -20,19 +20,19 @@ class DataService {
   private[service] var dataRepository: DataRepository = _
 
   def getLatestCities(accountId: Long): Seq[IdName] = {
-    dataRepository.getCityHistory(accountId).mapTo[IdName]
+    dataRepository.getCityHistory(accountId).mapTo[Seq[IdName]]
   }
 
   def getLatestClinicsByCityId(userId: Long, cityId: Long): Seq[IdName] = {
-    dataRepository.getClinicHistory(userId, cityId).mapTo[IdName]
+    dataRepository.getClinicHistory(userId, cityId).mapTo[Seq[IdName]]
   }
 
   def getLatestServicesByCityIdAndClinicId(userId: Long, cityId: Long, clinicId: Option[Long]): Seq[IdName] = {
-    dataRepository.getServiceHistory(userId, cityId, clinicId).mapTo[IdName]
+    dataRepository.getServiceHistory(userId, cityId, clinicId).mapTo[Seq[IdName]]
   }
 
   def getLatestDoctorsByCityIdAndClinicIdAndServiceId(userId: Long, cityId: Long, clinicId: Option[Long], serviceId: Long): Seq[IdName] = {
-    dataRepository.getDoctorHistory(userId, cityId, clinicId, serviceId).mapTo[IdName]
+    dataRepository.getDoctorHistory(userId, cityId, clinicId, serviceId).mapTo[Seq[IdName]]
   }
 
   def getCredentials(accountId: Long): Option[Credentials] = {

server/src/main/scala/com/lbs/server/util/package.scala

@@ -12,7 +12,6 @@ import com.lbs.server.conversation.Book.BookingData
 import com.lbs.server.conversation.Login.UserId
 import com.lbs.server.repository.model.{History, Monitoring}
 
-import scala.collection.generic.CanBuildFrom
 import scala.language.{higherKinds, implicitConversions}
 import scala.util.Try
 
@@ -23,9 +22,8 @@ package object util {
 
     implicit val BookingDataToMonitoringConverter:
       ObjectConverter[(UserId, BookingData), Monitoring] =
-      new ObjectConverter[(UserId, BookingData), Monitoring] {
-        override def convert[Z <: (UserId, BookingData)](data: Z): Monitoring = {
-          val (userId, bookingData) = data.asInstanceOf[(UserId, BookingData)]
+      (data: (UserId, BookingData)) => {
+        val (userId, bookingData) = data
         Monitoring(
           userId = userId.userId,
           accountId = userId.accountId,
@@ -49,12 +47,10 @@ package object util {
           offset = bookingData.offset
         )
       }
-      }
 
     implicit val AvailableVisitsTermPresentationToTemporaryReservationRequestConverter:
       ObjectConverter[AvailableVisitsTermPresentation, TemporaryReservationRequest] =
-      new ObjectConverter[AvailableVisitsTermPresentation, TemporaryReservationRequest] {
-        override def convert[Z <: AvailableVisitsTermPresentation](term: Z): TemporaryReservationRequest = {
+      (term: AvailableVisitsTermPresentation) => {
         TemporaryReservationRequest(
           clinicId = term.clinic.id,
           doctorId = term.doctor.id,
@@ -65,13 +61,11 @@ package object util {
           startDateTime = term.visitDate.startDateTime
         )
       }
-      }
 
     implicit val TmpReservationIdWithValuationsToReservationRequestConverter:
       ObjectConverter[(Long, VisitTermVariant, AvailableVisitsTermPresentation), ReservationRequest] =
-      new ObjectConverter[(Long, VisitTermVariant, AvailableVisitsTermPresentation), ReservationRequest] {
-        override def convert[Z <: (Long, VisitTermVariant, AvailableVisitsTermPresentation)](any: Z): ReservationRequest = {
-          val (tmpReservationId, valuations, term) = any.asInstanceOf[(Long, VisitTermVariant, AvailableVisitsTermPresentation)]
+      (any: (Long, VisitTermVariant, AvailableVisitsTermPresentation)) => {
+        val (tmpReservationId, valuations, term) = any
         ReservationRequest(
           clinicId = term.clinic.id,
           doctorId = term.doctor.id,
@@ -82,12 +76,10 @@ package object util {
           temporaryReservationId = tmpReservationId
         )
       }
-      }
 
     implicit val AvailableVisitsTermPresentationToValuationRequestConverter:
       ObjectConverter[AvailableVisitsTermPresentation, ValuationsRequest] =
-      new ObjectConverter[AvailableVisitsTermPresentation, ValuationsRequest] {
-        override def convert[Z <: AvailableVisitsTermPresentation](term: Z): ValuationsRequest = {
+      (term: AvailableVisitsTermPresentation) => {
         ValuationsRequest(
           clinicId = term.clinic.id,
           doctorId = term.doctor.id,
@@ -98,13 +90,9 @@ package object util {
           startDateTime = term.visitDate.startDateTime
         )
       }
-      }
 
-    implicit val HistoryToIdNameConverter: CollectionConverter[History, IdName] = new CollectionConverter[History, IdName] {
-      override def convert[Z <: History, Col[X] <: Iterable[X]](col: Col[Z])(implicit bf: CanBuildFrom[Col[Z], IdName, Col[IdName]]): Col[IdName] = {
-        col.map(history => IdName(history.id, history.name))(collection.breakOut)
-      }
-    }
+    implicit val HistoryToIdNameConverter: ObjectConverter[History, IdName] =
+      (history: History) => IdName(history.id, history.name)
   }
 
   object MessageExtractors {