उपयोगकर्ता प्राप्त करें और सभी अनुमतियां भरें

Question

मैं स्कैला के लिए नया हूं और यहां तक ​​कि जो भी मैं हासिल करने की कोशिश कर रहा हूं वह जावा के साथ बहुत आसान है, मुझे स्कैला से उलझन में लग रहा है।

मैं क्या चाहता हूँ एक User मिल और फिर अपने Permission भरने एक और क्वेरी का उपयोग और उसके Role और उसके अलग-अलग Permissions के आधार पर की जाती है।

तक जानता हूँ कि मैं निम्नलिखित कोड है:

/** 
* Finds a user by its loginInfo. 
* 
* @param loginInfo The loginInfo of the user to find. 
* @return The found user or None if no user for the given login info could be found. 
*/ 
def find(loginInfo: LoginInfo): Future[Option[models.admin.User]] = { 

val userQuery = for { 
    dbLoginInfo <- loginInfoQuery(loginInfo) 
    dbUserLoginInfo <- Userlogininfo.filter(_.logininfoid === dbLoginInfo.id) 
    dbUser <- User.filter(_.userid === dbUserLoginInfo.userid) 
    user <- dbUser match { 
    case u => 
     val permissionQuery = for { 
     dbUserPermission <- Userpermission.filter(_.userid === u.userid) 
     dbPermission <- Permission.filter(_.id === dbUserPermission.permissionid) 
     } yield dbPermission 

     val rolePermissionQuery = for { 
     dbUserRole <- Userrole.filter(_.userid === u.userid) 
     dbRole <- Role.filter(_.id === dbUserRole.roleid) 
     dbRolePermission <- Rolepermission.filter(_.roleid === dbRole.id) 
     dbPermission <- Permission.filter(_.id === dbRolePermission.permissionid) 
     } yield dbPermission 

     val unionPermissionQuery = permissionQuery union rolePermissionQuery 

     db.run(unionPermissionQuery.result).map(_.map(_.name).toList).map { permission => 

     models.admin.User(
      UUID.fromString(u.userid.toString), 
      u.firstname.toString, 
      u.lastname.toString, 
      u.jobtitle.toString, 
      loginInfo, 
      u.email.toString, 
      false, 
      Some(permission), 
      false) 
     } 
    case None => None 
    } 
} yield user 

db.run(userQuery.result.headOption) 

} 

मैं निम्नलिखित त्रुटियाँ गया:

pattern type is incompatible with expected type; 
[error] found : None.type 
[error] required: UserDAOImpl.this.User 
[error]   case None => None 
[error]   ^
[error] play/modules/admin/app/models/daos/impl/UserDAOImpl.scala:36: value map is not a member of Object 
[error]  user <- dbUser match { 
[error]     ^
[error] play/modules/admin/app/models/daos/impl/UserDAOImpl.scala:34: type mismatch; 
[error] found : UserDAOImpl.this.Userlogininfo => slick.lifted.Query[Nothing,Nothing,Seq] 
[error] required: UserDAOImpl.this.Userlogininfo => slick.lifted.Query[Nothing,T,Seq] 
[error]  dbUserLoginInfo <- Userlogininfo.filter(_.logininfoid === dbLoginInfo.id) 
[error]      ^
[error] play/modules/admin/app/models/daos/impl/UserDAOImpl.scala:33: type mismatch; 
[error] found : UserDAOImpl.this.Logininfo => slick.lifted.Query[Nothing,Nothing,Seq] 
[error] required: UserDAOImpl.this.Logininfo => slick.lifted.Query[Nothing,T,Seq] 
[error]  dbLoginInfo <- loginInfoQuery(loginInfo) 
[error]     ^
[error] play/modules/admin/app/models/daos/impl/UserDAOImpl.scala:69: value headOption is not a member of UserDAOImpl.this.driver.DriverAction[Seq[Nothing],UserDAOImpl.this.driver.api.NoStream,slick.dbio.Effect.Read] 
[error]  db.run(userQuery.result.headOption) 
[error]       ^
[error] 5 errors found 

Answer 1

जब भी आप के साथ काम एक एक yield आप के साथ-समझ के लिए यह समझना होगा कि आप एक कुछ प्रकार के "लपेटा" मूल्य (मोनड) के साथ काम करना। यह Future, List, Option, या कुछ भी जो मोनैडिक हो सकता है।

for { 
    someValue <- someWrappedValue() 
    someOtherValue <- someWrappedOtherValue(someValue) 
} yield someOtherValue 

आप Future साथ काम कर रहे हैं, तो आप इन नियमों का उपयोग कर सकते हैं::

• एक <- के अधिकार के लिए सब कुछ एक होना चाहिए

  तो पैटर्न इस तरह तरह का है Future

• <- के बाईं ओर सबकुछ "अनचाहे" मान
• है के लिए-समझ पूरे का मूल्य हो जाएगा जो कुछ yield एक Future

में लिपटे नियम List, Option, आदि के लिए ही कर रहे हैं पर है लेकिन आप एक ही के लिए-समझ के भीतर मिश्रण और मिलान नहीं कर सकते।

त्रुटियों में से एक संकेत देता है कि आपके match कथन का परिणाम Object है, जिसका अर्थ है कि स्कैला मैच में सभी मामलों के लिए एक सामान्य प्रकार का पता नहीं लगा सका। आप सभी मामलों को Future उत्पन्न करना चाहते हैं (क्योंकि यही वह है जिसे हम इस समझ में काम कर रहे हैं)। साथ

case None => None 

:

मेरा अनुमान है, तो आप को बदलने के लिए की जरूरत है

case None => Future.successful(None) 

लेकिन यह अधिक जानकारी के बिना निश्चित रूप से जानना मुश्किल है।

जावा में यह आसान होने के बारे में: बिल्कुल नहीं। यह थोड़ा और जटिल बनाता है भाषा नहीं है, लेकिन तथ्य यह है कि कई विधियां असीमित हैं। यदि आप इसे स्कैला में समकालिक रूप से करना चाहते थे, तो यह जावा के जितना आसान होगा, अगर अधिक नहीं। लेकिन फिर जब भी आप परिणामों की प्रतीक्षा कर रहे हों तो आप एक धागे को अवरुद्ध कर देंगे, जो जावा (सिंक्रोनस कॉल मानते हुए) के मामले में है।