artin/OBP-API
1
0
Fork 0
mirror of https://github.com/OpenBankProject/OBP-API.git synced 2026-02-06 13:07:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'experimental' of github.com:OpenBankProject/OBP-API into experimental

Browse Source
This commit is contained in:
Petar Bozin 2017-04-05 17:21:03 +00:00
commit 11d12f983d
6 changed files with 129 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
src/main/scala/code/model/dataAccess/AuthUser.scala
View File

@ -78,18 +78,38 @@ class AuthUser extends MegaProtoUser[AuthUser] with Logger {
/**
* The username field for the User.
*/
//lazy val username: userName = new userName()
//class userName extends MappedString(this, 64) {
// override def displayName = S.?("username")
// override def dbIndexed_? = true
// override def validations = valUnique(S.?("unique.username")) _ :: super.validations
// override val fieldId = Some(Text("txtUsername"))
lazy val username: userName = new userName()
class userName extends MappedString(this, 64) {
//override def displayName = S.?("username")
//override def dbIndexed_? = true
//override def validations = valUnique(S.?("unique.username")) _ :: super.validations
//override val fieldId = Some(Text("txtUsername"))
override def get = Users.users.vend.getResourceUserByUserId(resourceUserId.get) match {
case Full(u) => println("++++++++++++++++++++++> " + u); u.name
case Empty => println("+++++++++++++++++++++++get"); ""
}
override def defaultValue = Users.users.vend.getResourceUserByUserId(resourceUserId.get) match {
case Full(u) => println("++++++++++++++++++++++> " + u); u.name
case Empty => println("+++++++++++++++++++++++defaultValue" + Users.users.vend.getResourceUserByUserId(resourceUserId.get)); ""
}
override def set(u: String) = {println("#########################################################" + u); u}
}
//lazy val username = new Username()
//class Username {
// def apply( name: String ) : String =
// Users.users.vend.getResourceUserByUserId(resourceUserId.get) match {
// case Full(u) => u.name
// case Empty => println("++++++++++++++++++++++++"); ""
// }
//
// def get : String =
// Users.users.vend.getResourceUserByUserId(resourceUserId.get) match {
// case Full(u) => u.name
// case Empty => println("++++++++++++++++++++++++"); ""
// }
//}
def username: String = Users.users.vend.getResourceUserByUserId(resourceUserId.get) match {
case Full(u) => u.name
case Empty => println("++++++++++++++++++++++++"); ""
}
//class Username {
//private final var username_ = Users.users.vend.getResourceUserByUserId(resourceUserId.get).get.name
//def apply( u: String ) : Box[String] = {
@ -239,10 +259,10 @@ import net.liftweb.util.Helpers._
override def screenWrap = Full(<lift:surround with="default" at="content"><lift:bind /></lift:surround>)
// define the order fields will appear in forms and output
// override def fieldOrder = List(id, firstName, lastName, email, username, password, provider)
// override def signupFields = List(firstName, lastName, email, username, password)
override def fieldOrder = List(id, firstName, lastName, email, password, provider)
override def signupFields = List(firstName, lastName, email, password)
override def fieldOrder = List(id, firstName, lastName, email, username, password, provider)
override def signupFields = List(firstName, lastName, email, username, password)
//override def fieldOrder = List(id, firstName, lastName, email, password, provider)
//override def signupFields = List(firstName, lastName, email, password)
// If we want to validate email addresses set this to false
override def skipEmailValidation = Props.getBool("authUser.skipEmailValidation", true)
@ -273,7 +293,7 @@ import net.liftweb.util.Helpers._
def getCurrentUserUsername: String = {
for {
current <- AuthUser.currentUser
username <- tryo{current.username}
username <- tryo{current.username.get}
if (username.nonEmpty)
} yield {
return username
@ -477,20 +497,37 @@ import net.liftweb.util.Helpers._
def createAuthUser(mail: String, uname: String, pass: String): AuthUser = {
val prov = getProvider()
Users.users.vend.createResourceUser(
prov,
Some(prov),
Some(uname),
Some(mail),
Some(resourceUserId.get))
AuthUser.create
.firstName(uname)
.email(mail)
//.username(uname)
// No need to store password, so store dummy string instead
.password(pass)
.validated(true)
.saveMe
val generatedId = java.util.UUID.randomUUID.toString
Users.users.vend.getResourceUserByUserId(resourceUserId.get) match {
case Full(u) => AuthUser.find(By(AuthUser.resourceUserId, resourceUserId.get)).get
case Empty =>
val au = Users.users.vend.createResourceUser(
prov,
Some(generatedId),
Some(uname),
Some(mail),
Some(generatedId)) match {
case Empty => null
case Full(r) if r.userId == generatedId =>
AuthUser.create
.firstName(uname)
.email(mail)
.password(pass)
.resourceUserId(r.userId)
case Full(r) if r.userId != generatedId =>
null
}
val validationErrors = au.validate
if(validationErrors.nonEmpty) {
au
}
else {
au.saveMe
}
}
}

2
src/main/scala/code/model/dataAccess/ResourceUser.scala
View File

@ -43,7 +43,7 @@ class ResourceUser extends LongKeyedMapper[ResourceUser] with User with ManyToMa
def primaryKeyField = id
object id extends MappedLongIndex(this)
object userId_ extends MappedUUID(this)
object userId_ extends MappedString(this, 64)
object email extends MappedEmail(this, 48){
override def required_? = false
}

37
src/main/scala/code/sandbox/CreateAuthUsers.scala Normal file
View File

@ -0,0 +1,37 @@
package code.sandbox
import code.model.dataAccess.{AuthUser, ResourceUser}
import net.liftweb.common.{Box, Failure}
trait CreateAuthUsers {
self : OBPDataImport =>
override protected def createUser(u : SandboxUserImport) : Box[ResourceUser] = {
val existingAuthUser = AuthUser.findUserByUsername(u.user_name)
if(existingAuthUser.isDefined) {
logger.warn(s"Existing AuthUser with email ${u.email} detected in data import where no ResourceUser was found")
Failure(s"User with email ${u.email} already exist (and may be different (e.g. different display_name)")
} else {
val authUser = AuthUser.createAuthUser(
u.email,
u.user_name,
u.password
)
val validationErrors = authUser.validate
if(validationErrors.nonEmpty) Failure(s"Errors: ${validationErrors.map(_.msg)}")
else {
authUser.validated(true)
authUser.saveMe
val resourceUser = authUser.user.obj
resourceUser
}
}
}
}

74
src/main/scala/code/sandbox/CreateOBPUsers.scala
View File

@ -1,74 +0,0 @@
package code.sandbox
import code.model.dataAccess.{AuthUser, ResourceUser}
import code.users.Users
import net.liftweb.common.{Box, Failure, Full}
import net.liftweb.mapper.By
import net.liftweb.util.Props
trait CreateAuthUsers {
self : OBPDataImport =>
override protected def createUser(u : SandboxUserImport) : Box[ResourceUser] = {
val existingAuthUser = AuthUser.findUserByUsername(u.user_name)
if(existingAuthUser.isDefined) {
logger.warn(s"Existing AuthUser with email ${u.email} detected in data import where no ResourceUser was found")
Failure(s"User with email ${u.email} already exist (and may be different (e.g. different display_name)")
} else {
val authUser = AuthUser.createAuthUser(
u.email,
u.user_name,
u.password
)
//AuthUser.create
//.email(u.email)
//.lastName(u.user_name)
//.username(u.user_name)
//.password(u.password)
//.validated(true)
println("--------------------------------> " + authUser)
val validationErrors = authUser.validate
if(validationErrors.nonEmpty) Failure(s"Errors: ${validationErrors.map(_.msg)}")
else {
val resourceUser = authUser.user.obj //Users.users.vend.createResourceUser(
//authUser.provider,
//Some(authUser.provider),
//Some(u.user_name),
//Some(u.email),
//Some(authUser.resourceUserId)
//)
//authUser.save()
println("--------------------------------> " + authUser)
println("--------------------------------> " + resourceUser)
resourceUser
}
}
}
}
/*
def createAuthUser(mail: String, prov: String, uname: String, pass: String): AuthUser = {
Users.users.vend.createResourceUser(
prov,
Some(resourceUserId.get),
Some(uname),
Some(mail),
Some(resourceUserId.get))
AuthUser.create
.firstName(uname)
.email(mail)
.username(uname)
// No need to store password, so store dummy string instead
.password(pass)
.provider(prov)
.validated(true)
.saveMe
}
*/

24
src/test/scala/code/api/directloginTest.scala
View File

@ -33,15 +33,9 @@ class directloginTest extends ServerSetup with BeforeAndAfter {
EMAIL,
USERNAME,
PASSWORD
)
//AuthUser.create.
// email(EMAIL).
// username(USERNAME).
// password(PASSWORD).
// validated(true).
// firstName(randomString(10)).
// lastName(randomString(10)).
// saveMe
) .firstName(randomString(10))
.lastName(randomString(10))
.validated(true)
if (Consumers.consumers.vend.getConsumerByConsumerKey(KEY).isEmpty)
Consumers.consumers.vend.createConsumer(Some(KEY), Some(SECRET), Some(true), Some("test application"), None, None, None, None, None).get
@ -52,15 +46,9 @@ class directloginTest extends ServerSetup with BeforeAndAfter {
EMAIL_DISABLED,
USERNAME_DISABLED,
PASSWORD_DISABLED
)
//AuthUser.create.
// email(EMAIL_DISABLED).
// username(USERNAME_DISABLED).
// password(PASSWORD_DISABLED).
// validated(true).
// firstName(randomString(10)).
// lastName(randomString(10)).
// saveMe
) .firstName(randomString(10))
.lastName(randomString(10))
.validated(true)
if (Consumers.consumers.vend.getConsumerByConsumerKey(KEY_DISABLED).isEmpty)
Consumers.consumers.vend.createConsumer(Some(KEY_DISABLED), Some(SECRET_DISABLED), Some(false), Some("test application disabled"), None, None, None, None, None).get

51
src/test/scala/code/api/oauthTest.scala
View File

@ -79,15 +79,9 @@ class OAuthTest extends ServerSetup {
)
.firstName(randomString(10))
.lastName(randomString(10))
.validated(true)
.saveMe
//AuthUser.create.
// email(randomString(3)+"@example.com").
// username(randomString(9)).
// password(user1Password).
// validated(true).
// firstName(randomString(10)).
// lastName(randomString(10)).
// saveMe
lazy val user2Password = randomString(10)
lazy val user2 =
@ -99,15 +93,8 @@ class OAuthTest extends ServerSetup {
.firstName(randomString(10))
.lastName(randomString(10))
.validated(false)
.saveMe
//AuthUser.create.
// email(randomString(3)+"@example.com").
// username(randomString(9)).
// password(user2Password).
// validated(false).
// firstName(randomString(10)).
// lastName(randomString(10)).
// saveMe
lazy val consumer = new Consumer (testConsumer.key,testConsumer.secret)
lazy val disabledConsumer = new Consumer (disabledTestConsumer.key, disabledTestConsumer.secret)
@ -254,7 +241,7 @@ class OAuthTest extends ServerSetup {
val reply = getRequestToken(consumer, selfCallback)
val requestToken = extractToken(reply.body)
When("the browser is launched to login")
val verifier = getVerifier(requestToken.value, user1.username, user1Password)
val verifier = getVerifier(requestToken.value, user1.username.get, user1Password)
Then("we should get a verifier")
verifier.get.nonEmpty should equal (true)
}
@ -263,21 +250,21 @@ class OAuthTest extends ServerSetup {
val reply = getRequestToken(consumer, oob)
val requestToken = extractToken(reply.body)
When("the browser is launched to login")
val verifier = getVerifier(requestToken.value, user1.username, user1Password)
val verifier = getVerifier(requestToken.value, user1.username.get, user1Password)
Then("we should get a verifier")
verifier.isEmpty should equal (false)
}
scenario("the user cannot login because there is no token", Verifier, Oauth){
Given("there will be no token")
When("the browser is launched to login")
val verifier = getVerifier(user1.username, user1Password)
val verifier = getVerifier(user1.username.get, user1Password)
Then("we should not get a verifier")
verifier.isEmpty should equal (true)
}
scenario("the user cannot login because the token does not exist", Verifier, Oauth){
Given("we will use a random request token")
When("the browser is launched to login")
val verifier = getVerifier(randomString(4), user1.username, user1Password)
val verifier = getVerifier(randomString(4), user1.username.get, user1Password)
Then("we should not get a verifier")
verifier.isEmpty should equal (true)
}
@ -287,7 +274,7 @@ class OAuthTest extends ServerSetup {
Given("we will first get a request token and a verifier")
val reply = getRequestToken(consumer, oob)
val requestToken = extractToken(reply.body)
val verifier = getVerifier(requestToken.value, user1.username, user1Password)
val verifier = getVerifier(requestToken.value, user1.username.get, user1Password)
When("when we ask for an access token")
val accessToken = getAccessToken(consumer, requestToken, verifier.get)
Then("we should get an access token")
@ -297,7 +284,7 @@ class OAuthTest extends ServerSetup {
Given("we will first get a request token and a verifier")
val reply = getRequestToken(consumer, selfCallback)
val requestToken = extractToken(reply.body)
val verifier = getVerifier(requestToken.value, user1.username, user1Password)
val verifier = getVerifier(requestToken.value, user1.username.get, user1Password)
When("when we ask for an access token")
val accessToken = getAccessToken(consumer, requestToken, verifier.get)
Then("we should get an access token")
@ -316,7 +303,7 @@ class OAuthTest extends ServerSetup {
Given("we will first get request token and a verifier")
val reply = getRequestToken(consumer, selfCallback)
val requestToken = extractToken(reply.body)
val verifier = getVerifier(requestToken.value, user1.username, user1Password)
val verifier = getVerifier(requestToken.value, user1.username.get, user1Password)
When("when we ask for an access token with a request token")
val randomRequestToken = Token(randomString(5), randomString(5))
val accessTokenReply = getAccessToken(consumer, randomRequestToken, verifier.get)
@ -342,26 +329,26 @@ class OAuthTest extends ServerSetup {
Then("we set the valid username, invalid password and try more than 5 times")
val invalidPassword = "wrongpassword"
var verifier = getVerifier(requestToken.value, user1.username, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username, invalidPassword)
var verifier = getVerifier(requestToken.value, user1.username.get, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username.get, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username.get, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username.get, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username.get, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username.get, invalidPassword)
verifier = getVerifier(requestToken.value, user1.username.get, invalidPassword)
Then("we should get a locked account verifier")
verifier.asInstanceOf[Failure].msg.contains(ErrorMessages.UsernameHasBeenLocked)
Then("We login in with valid username and password, it will still be failed")
verifier = getVerifier(requestToken.value, user1.username, user1Password)
verifier = getVerifier(requestToken.value, user1.username.get, user1Password)
Then("we should get a locked account verifier")
verifier.asInstanceOf[Failure].msg.contains(ErrorMessages.UsernameHasBeenLocked)
Then("We unlock the username")
LoginAttempt.resetBadLoginAttempts(user1.username)
LoginAttempt.resetBadLoginAttempts(user1.username.get)
}
}