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

Merge remote-tracking branch 'upstream/develop' into develop

Browse Source 
# Conflicts:
#	src/main/scala/code/bankconnectors/LocalMappedConnector.scala
#	src/test/scala/code/api/LocalMappedConnectorTestSetup.scala
This commit is contained in:
hongwei1 2017-02-28 10:12:37 +01:00
commit f80b3aa841
33 changed files with 769 additions and 437 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
sbt.sh
View File

@ -1,4 +1,7 @@
#!/bin/sh
export SBT_OPTS="-Xmx1024m -Xms1024m -Xss2048k -XX:MaxPermSize=1024m"
sbt $1 $2 $3 $4
echo "sbt $@"
sbt $@
#$1 $2 $3 $4

3
src/main/resources/common.conf
View File

@ -32,7 +32,7 @@ akka {
}
serialization-bindings {
//"net.liftweb.common.Full" = kryo,
"net.liftweb.common.Full" = kryo,
"net.liftweb.common.Empty" = kryo,
"net.liftweb.common.Box" = kryo,
"net.liftweb.common.ParamFailure" = kryo,
@ -40,6 +40,7 @@ akka {
"code.views.RemoteViewCaseClasses" = kryo,
"code.model.BankAccount" = kryo,
"code.model.View" = kryo,
"code.model.dataAccess.ViewImpl" = kryo,
"code.model.User" = kryo,
"code.model.ViewId" = kryo,
"code.model.ViewUID" = kryo,

2
src/main/resources/log4j.properties
View File

@ -1,4 +1,4 @@
log4j.rootCategory=DEBUG, CONSOLE
log4j.rootCategory=INFO, CONSOLE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout

10
src/main/scala/bootstrap/liftweb/Boot.scala
View File

@ -36,6 +36,7 @@ import java.util.Locale
import javax.mail.internet.MimeMessage
import java.util.concurrent.TimeUnit
import code.accountholder.MapperAccountHolders
import code.api.ResourceDocs1_4_0.ResourceDocs
import code.api._
import code.api.sandbox.SandboxApiCalls
@ -77,9 +78,9 @@ import code.api.Constant._
import code.cards.MappedPhysicalCard
import code.cards.PinReset
import code.fx.{MappedCurrency, MappedFXRate}
import code.remotedata.RemotedataActorSystem
import code.transaction.MappedTransaction
import code.transactionStatusScheduler.TransactionStatusScheduler
import code.views.RemoteDataActorSystem
/**
@ -356,7 +357,7 @@ class Boot extends Loggable{
if (!Props.getBool("enable_remotedata", false)) {
try {
RemoteDataActorSystem.startLocalWorkerSystem()
RemotedataActorSystem.startLocalWorkerSystem()
} catch {
case ex: Exception => logger.warn(s"RemoteDataActorSystem.startLocalWorkerSystem() could not start: $ex")
}
@ -426,7 +427,9 @@ object ToSchemify {
val modelsRemotedata = List(
ViewImpl,
ViewPrivileges,
ResourceUser)
ResourceUser,
MapperAccountHolders
)
val models = List(
AuthUser,
@ -434,7 +437,6 @@ object ToSchemify {
Nonce,
Token,
Consumer,
MappedAccountHolder,
MappedComment,
MappedNarrative,
MappedTag,

32
src/main/scala/code/accountholder/AccountHolders.scala Normal file
View File

@ -0,0 +1,32 @@
package code.accountholder
import code.model.{AccountId, BankId, User}
import net.liftweb.util.SimpleInjector
import code.remotedata.Remotedata
import net.liftweb.common.Box
object AccountHolders extends SimpleInjector {
val accountHolders = new Inject(buildOne _) {}
//def buildOne: AccountHolders = MapperAccountHolders
def buildOne: AccountHolders = Remotedata
}
trait AccountHolders {
def getAccountHolders(bankId: BankId, accountId: AccountId): Set[User]
def createAccountHolder(userId: Long, bankId: String, accountId: String, source: String = "MappedAccountHolder"): Boolean
def bulkDeleteAllAccountHolders(): Box[Boolean]
}
class AccountHoldersCaseClasses {
case class createAccountHolder(userId: Long, bankId: String, accountId: String, source: String = "MappedAccountHolder")
case class getAccountHolders(bankId: BankId, accountId: AccountId)
case class bulkDeleteAllAccountHolders()
}
object RemoteAccountHoldersCaseClasses extends AccountHoldersCaseClasses

56
src/main/scala/code/accountholder/MapperAccountHolders.scala Normal file
View File

@ -0,0 +1,56 @@
package code.accountholder
import code.model.{AccountId, BankId, User}
import code.model.dataAccess.ResourceUser
import code.users.Users
import net.liftweb.common._
import net.liftweb.mapper._
import net.liftweb.common.Box
class MapperAccountHolders extends LongKeyedMapper[MapperAccountHolders] with IdPK {
def getSingleton = MapperAccountHolders
object user extends MappedLongForeignKey(this, ResourceUser)
object accountBankPermalink extends MappedString(this, 255)
object accountPermalink extends MappedString(this, 255)
}
object MapperAccountHolders extends MapperAccountHolders with AccountHolders with LongKeyedMetaMapper[MapperAccountHolders] {
private val logger = Logger(classOf[AccountHolders])
override def dbIndexes = Index(accountBankPermalink, accountPermalink) :: Nil
def createAccountHolder(userId: Long, bankId: String, accountId: String, source: String = "MappedAccountHolder"): Boolean = {
val holder = MapperAccountHolders.create
.accountBankPermalink(bankId)
.accountPermalink(accountId)
.user(userId)
.saveMe
if(source != "MappedAccountHolder") logger.info(s"------------> created mappedUserHolder ${holder} at ${source}")
if(holder.saved_?)
true
else
false
}
def getAccountHolders(bankId: BankId, accountId: AccountId): Set[User] = {
val results = MapperAccountHolders.findAll(
By(MapperAccountHolders.accountBankPermalink, bankId.value),
By(MapperAccountHolders.accountPermalink, accountId.value))
results.flatMap { accHolder =>
ResourceUser.find(By(ResourceUser.id, accHolder.user))
}.toSet
}
def bulkDeleteAllAccountHolders(): Box[Boolean] = {
Full( MapperAccountHolders.bulkDelete_!!() )
}
}

25
src/main/scala/code/api/v2_0_0/JSONFactory2.0.0.scala
View File

@ -36,11 +36,12 @@ import java.util.Date
import code.TransactionTypes.TransactionType.TransactionType
import code.api.v1_2_1.ViewJSON
import code.api.v2_2_0.{AccountsJSON, AccountJSON}
import code.api.v2_2_0.{AccountJSON, AccountsJSON}
import code.entitlement.Entitlement
import code.meetings.Meeting
import code.model.dataAccess.AuthUser
import code.transactionrequests.TransactionRequests._
import code.users.Users
import net.liftweb.common.{Box, Full}
import net.liftweb.json
import net.liftweb.json.Extraction
@ -572,14 +573,20 @@ object JSONFactory200{
)
def createUserJSONfromAuthUser(user : AuthUser) : UserJSON = new UserJSON(
user_id = user.user.foreign.get.userId,
email = user.email,
username = stringOrNull(user.username),
provider_id = stringOrNull(user.provider),
provider = stringOrNull(user.provider),
entitlements = createEntitlementJSONs(user.user.foreign.get.assignedEntitlements)
)
def createUserJSONfromAuthUser(user : AuthUser) : UserJSON = {
val (userId, entitlements) = Users.users.vend.getUserByResourceUserId(user.user.get) match {
case Full(u) => (u.userId, u.assignedEntitlements)
case _ => ("", List())
}
new UserJSON(user_id = userId,
email = user.email,
username = stringOrNull(user.username),
provider_id = stringOrNull(user.provider),
provider = stringOrNull(user.provider),
entitlements = createEntitlementJSONs(entitlements)
)
}
def createUserJSON(user : User) : UserJSON = {

23
src/main/scala/code/bankconnectors/Connector.scala
View File

@ -2,6 +2,7 @@ package code.bankconnectors
import java.util.Date
import code.accountholder.{AccountHolders, MapperAccountHolders}
import code.api.util.APIUtil._
import code.api.util.ApiRole._
import code.api.util.ErrorMessages
@ -11,7 +12,7 @@ import code.fx.{FXRate, fx}
import code.management.ImporterAPI.ImporterTransaction
import code.metadata.counterparties.{CounterpartyTrait, MappedCounterparty}
import code.model.{Transaction, TransactionRequestType, User, _}
import code.model.dataAccess.{MappedAccountHolder, ResourceUser}
import code.model.dataAccess.ResourceUser
import code.transactionrequests.{TransactionRequestTypeCharge, TransactionRequests}
import code.transactionrequests.TransactionRequests._
import code.util.Helper._
@ -163,8 +164,12 @@ trait Connector {
posted: Option[CardPostedInfo]
) : Box[PhysicalCard]
//gets the users who are the legal owners/holders of the account
def getAccountHolders(bankId: BankId, accountID: AccountId) : Set[User]
def getAccountHolders(bankId: BankId, accountId: AccountId): Set[User] = {
AccountHolders.accountHolders.vend.getAccountHolders(bankId, accountId)
}
//Payments api: just return Failure("not supported") from makePaymentImpl if you don't want to implement it
@ -760,7 +765,9 @@ trait Connector {
initialBalance : BigDecimal, accountHolderName : String) : Box[BankAccount]
//sets a user as an account owner/holder
def setAccountHolder(bankAccountUID: BankAccountUID, user : User) : Unit
def setAccountHolder(bankAccountUID: BankAccountUID, user: User): Unit = {
AccountHolders.accountHolders.vend.createAccountHolder(user.resourceUserId.value, bankAccountUID.accountId.value, bankAccountUID.bankId.value)
}
//for sandbox use -> allows us to check if we can generate a new test account with the given number
def accountExists(bankId : BankId, accountNumber : String) : Boolean
@ -788,10 +795,10 @@ trait Connector {
def accountOwnerExists(user: ResourceUser, bankId: BankId, accountId: AccountId): Boolean = {
val res =
MappedAccountHolder.findAll(
By(MappedAccountHolder.user, user),
By(MappedAccountHolder.accountBankPermalink, bankId.value),
By(MappedAccountHolder.accountPermalink, accountId.value)
MapperAccountHolders.findAll(
By(MapperAccountHolders.user, user),
By(MapperAccountHolders.accountBankPermalink, bankId.value),
By(MapperAccountHolders.accountPermalink, accountId.value)
)
res.nonEmpty
@ -804,7 +811,7 @@ trait Connector {
resourceUserOwner match {
case Some(o) => {
if ( ! accountOwnerExists(o, bankId, accountId)) {
MappedAccountHolder.createMappedAccountHolder(o.resourceUserId.value, bankId.value, accountId.value, "KafkaMappedConnector")
MapperAccountHolders.createAccountHolder(o.resourceUserId.value, bankId.value, accountId.value, "KafkaMappedConnector")
}
}
case None => {

12
src/main/scala/code/bankconnectors/KafkaMappedConnector.scala
View File

@ -26,6 +26,7 @@ Berlin 13359, Germany
import java.text.SimpleDateFormat
import java.util.{Date, Locale, UUID}
import code.accountholder.{AccountHolders, MapperAccountHolders$}
import code.api.util.ErrorMessages
import code.api.v2_1_0.{BranchJsonPost, BranchJsonPut}
import code.branches.Branches.{Branch, BranchId}
@ -56,6 +57,7 @@ import code.products.MappedProduct
import code.products.Products.{Product, ProductCode}
import code.products.MappedProduct
import code.products.Products.{Product, ProductCode}
import code.users.Users
object KafkaMappedConnector extends Connector with Loggable {
@ -144,7 +146,7 @@ object KafkaMappedConnector extends Connector with Loggable {
acc.generate_accountants_view,
acc.generate_auditors_view
)}
existing_views <- tryo {Views.views.vend.views(new KafkaBankAccount(acc))}
existing_views <- tryo {Views.views.vend.views(BankAccountUID(BankId(acc.bankId), AccountId(acc.accountId)))}
} yield {
setAccountOwner(username, BankId(acc.bankId), AccountId(acc.accountId), acc.owners)
views.foreach(v => {
@ -497,12 +499,6 @@ object KafkaMappedConnector extends Connector with Loggable {
}
*/
//gets the users who are the legal owners/holders of the account
override def getAccountHolders(bankId: BankId, accountId: AccountId): Set[User] =
MappedAccountHolder.findAll(
By(MappedAccountHolder.accountBankPermalink, bankId.value),
By(MappedAccountHolder.accountPermalink, accountId.value)).map(accHolder => accHolder.user.obj).flatten.toSet
// Get all counterparties related to an account
override def getCounterpartiesFromTransaction(bankId: BankId, accountId: AccountId): List[Counterparty] =
@ -881,7 +877,7 @@ object KafkaMappedConnector extends Connector with Loggable {
//sets a user as an account owner/holder
override def setAccountHolder(bankAccountUID: BankAccountUID, user: User): Unit = {
MappedAccountHolder.createMappedAccountHolder(user.resourceUserId.value, bankAccountUID.accountId.value, bankAccountUID.bankId.value)
AccountHolders.accountHolders.vend.createAccountHolder(user.resourceUserId.value, bankAccountUID.accountId.value, bankAccountUID.bankId.value)
}
private def createAccountIfNotExisting(bankId: BankId, accountId: AccountId, accountNumber: String,

13
src/main/scala/code/bankconnectors/LocalConnector.scala
View File

@ -3,6 +3,7 @@ package code.bankconnectors
import java.text.SimpleDateFormat
import java.util.{Date, TimeZone, UUID}
import code.accountholder.MapperAccountHolders$
import code.api.v2_1_0.{BranchJsonPost, BranchJsonPut}
import code.branches.Branches.{Branch, BranchId}
import code.branches.MappedBranch
@ -26,11 +27,12 @@ import net.liftweb.util.Props
import org.bson.types.ObjectId
import code.products.MappedProduct
import code.products.Products.{Product, ProductCode}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent._
import code.products.MappedProduct
import code.products.Products.{Product, ProductCode}
import code.transactionrequests.{TransactionRequestTypeCharge}
import code.transactionrequests.TransactionRequestTypeCharge
private object LocalConnector extends Connector with Loggable {
@ -183,11 +185,6 @@ private object LocalConnector extends Connector with Loggable {
Empty
}
override def getAccountHolders(bankId: BankId, accountId: AccountId) : Set[User] = {
MappedAccountHolder.findAll(
By(MappedAccountHolder.accountBankPermalink, bankId.value),
By(MappedAccountHolder.accountPermalink, accountId.value)).map(accHolder => accHolder.user.obj).flatten.toSet
}
override protected def makePaymentImpl(fromAccount: Account, toAccount: Account, toCounterparty: CounterpartyTrait, amt: BigDecimal, description: String, transactionRequestType: TransactionRequestType, chargePolicy: String): Box[TransactionId] = {
val fromTransAmt = -amt //from account balance should decrease
@ -478,10 +475,6 @@ private object LocalConnector extends Connector with Loggable {
(hostedBank, createdAccount)
}
//sets a user as an account owner/holder
override def setAccountHolder(bankAccountUID: BankAccountUID, user: User): Unit = {
MappedAccountHolder.createMappedAccountHolder(user.resourceUserId.value, bankAccountUID.bankId.value, bankAccountUID.accountId.value)
}
//for sandbox use -> allows us to check if we can generate a new test account with the given number
override def accountExists(bankId: BankId, accountNumber: String): Boolean = {

14
src/main/scala/code/bankconnectors/LocalMappedConnector.scala
View File

@ -3,6 +3,7 @@ package code.bankconnectors
import java.util.{Date, UUID}
import code.TransactionTypes.TransactionType.TransactionTypeProvider
import code.accountholder.MapperAccountHolders$
import code.api.util.ErrorMessages
import code.api.v2_1_0.{BranchJsonPost, BranchJsonPut}
import code.branches.Branches.{Branch, BranchId}
@ -195,13 +196,6 @@ object LocalMappedConnector extends Connector with Loggable {
}
//gets the users who are the legal owners/holders of the account
override def getAccountHolders(bankId: BankId, accountId: AccountId): Set[User] =
MappedAccountHolder.findAll(
By(MappedAccountHolder.accountBankPermalink, bankId.value),
By(MappedAccountHolder.accountPermalink, accountId.value)).map(accHolder => accHolder.user.obj).flatten.toSet
def getCounterpartyFromTransaction(thisBankId: BankId, thisAccountId: AccountId, metadata: CounterpartyMetadata): Box[Counterparty] = {
//because we don't have a db backed model for OtherBankAccounts, we need to construct it from an
//OtherBankAccountMetadata and a transaction
@ -395,7 +389,7 @@ object LocalMappedConnector extends Connector with Loggable {
Perform a payment (in the sandbox)
Store one or more transactions
*/
protected override def makePaymentImpl(fromAccount: MappedBankAccount, toAccount: MappedBankAccount, toCounterparty: CounterpartyTrait, amt: BigDecimal, description: String, transactionRequestType: TransactionRequestType, chargePolicy: String): Box[TransactionId] = {
override def makePaymentImpl(fromAccount: MappedBankAccount, toAccount: MappedBankAccount, toCounterparty: CounterpartyTrait, amt: BigDecimal, description: String, transactionRequestType: TransactionRequestType, chargePolicy: String): Box[TransactionId] = {
//we need to save a copy of this payment as a transaction in each of the accounts involved, with opposite amounts
@ -688,10 +682,6 @@ Store one or more transactions
}
//sets a user as an account owner/holder
override def setAccountHolder(bankAccountUID: BankAccountUID, user: User): Unit = {
MappedAccountHolder.createMappedAccountHolder(user.resourceUserId.value, bankAccountUID.bankId.value, bankAccountUID.accountId.value)
}
private def createAccountIfNotExisting(bankId: BankId, accountId: AccountId, accountNumber: String,
accountType: String, accountLabel: String, currency: String,

16
src/main/scala/code/bankconnectors/ObpJvmMappedConnector.scala
View File

@ -6,6 +6,7 @@ import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter
import java.util.{Date, Locale, Optional, Properties, UUID}
import code.accountholder.MapperAccountHolders$
import code.api.util.ErrorMessages
import code.api.v2_1_0.BranchJsonPost
import code.fx.{FXRate, fx}
@ -141,7 +142,7 @@ object ObpJvmMappedConnector extends Connector with Loggable {
acc.generate_accountants_view,
acc.generate_auditors_view
)}
existing_views <- tryo {Views.views.vend.views(new ObpJvmBankAccount(acc))}
existing_views <- tryo {Views.views.vend.views(BankAccountUID(BankId(acc.bank), AccountId(acc.id)))}
} yield {
setAccountOwner(username, BankId(acc.bank), AccountId(acc.id), acc.owners)
views.foreach(v => {
@ -517,12 +518,6 @@ object ObpJvmMappedConnector extends Connector with Loggable {
}
*/
//gets the users who are the legal owners/holders of the account
override def getAccountHolders(bankId: BankId, accountId: AccountId): Set[User] =
MappedAccountHolder.findAll(
By(MappedAccountHolder.accountBankPermalink, bankId.value),
By(MappedAccountHolder.accountPermalink, accountId.value)).map(accHolder => accHolder.user.obj).flatten.toSet
// Get all counterparties related to an account
override def getCounterpartiesFromTransaction(bankId: BankId, accountId: AccountId): List[Counterparty] =
@ -898,7 +893,7 @@ private def saveTransaction(fromAccount: AccountType, toAccount: AccountType, am
commentsDeleted && narrativesDeleted && tagsDeleted && whereTagsDeleted && transactionImagesDeleted &&
transactionsDeleted && privilegesDeleted && viewsDeleted && accountDeleted
}
}
//creates a bank account for an existing bank, with the appropriate values set. Can fail if the bank doesn't exist
override def createSandboxBankAccount(bankId: BankId, accountId: AccountId, accountNumber: String,
@ -912,13 +907,8 @@ private def saveTransaction(fromAccount: AccountType, toAccount: AccountType, am
val balanceInSmallestCurrencyUnits = Helper.convertToSmallestCurrencyUnits(initialBalance, currency)
createAccountIfNotExisting(bankId, accountId, accountNumber, accountType, accountLabel, currency, balanceInSmallestCurrencyUnits, accountHolderName)
}
}
//sets a user as an account owner/holder
override def setAccountHolder(bankAccountUID: BankAccountUID, user: User): Unit = {
MappedAccountHolder.createMappedAccountHolder(user.resourceUserId.value, bankAccountUID.accountId.value, bankAccountUID.bankId.value)
}
private def createAccountIfNotExisting(bankId: BankId, accountId: AccountId, accountNumber: String,
accountType: String, accountLabel: String, currency: String,

2
src/main/scala/code/metadata/counterparties/Counterparties.scala
View File

@ -3,7 +3,7 @@ package code.metadata.counterparties
import net.liftweb.common.Box
import net.liftweb.util.SimpleInjector
import code.model.{AccountId, BankId, Counterparty, CounterpartyMetadata}
import code.views.AkkaMapperViews
import code.remotedata.Remotedata
object Counterparties extends SimpleInjector {

43
src/main/scala/code/model/BankingData.scala
View File

@ -172,7 +172,9 @@ trait Bank {
def nationalIdentifier : String
def accounts(user : Box[User]) : List[BankAccount] = {
Views.views.vend.getAllAccountsUserCanSee(this, user)
Views.views.vend.getAllAccountsUserCanSee(this, user).flatMap { a =>
BankAccount(a.bankId, a.accountId)
}
}
//This was the behaviour in v1.2 and earlier which has since been changed
@ -188,9 +190,16 @@ trait Bank {
}
}
def publicAccounts : List[BankAccount] = Views.views.vend.getPublicBankAccounts(this)
def publicAccounts : List[BankAccount] = {
Views.views.vend.getPublicBankAccounts(this).flatMap { a =>
BankAccount(a.bankId, a.accountId)
}
}
def nonPublicAccounts(user : User) : List[BankAccount] = {
Views.views.vend.getNonPublicBankAccounts(user, bankId)
Views.views.vend.getNonPublicBankAccounts(user, bankId).flatMap { a =>
BankAccount(a.bankId, a.accountId)
}
}
@deprecated(Helper.deprecatedJsonGenerationMessage)
@ -351,7 +360,7 @@ trait BankAccount {
final def permissions(user : User) : Box[List[Permission]] = {
//check if the user have access to the owner view in this the account
if(user.ownerAccess(this))
Full(Views.views.vend.permissions(this))
Full(Views.views.vend.permissions(BankAccountUID(this.bankId,this.accountId)))
else
Failure("user " + user.emailAddress + " does not have access to owner view on account " + accountId, Empty, Empty)
}
@ -367,7 +376,7 @@ trait BankAccount {
if(user.ownerAccess(this))
for{
u <- User.findByProviderId(otherUserProvider, otherUserIdGivenByProvider)
p <- Views.views.vend.permission(this, u)
p <- Views.views.vend.permission(BankAccountUID(this.bankId,this.accountId), u)
} yield p
else
Failure("user : " + user.emailAddress + " does not have access to owner view on account " + accountId, Empty, Empty)
@ -454,7 +463,7 @@ trait BankAccount {
final def views(user : User) : Box[List[View]] = {
//check if the user has access to the owner view in this the account
if(user.ownerAccess(this)) {
Full(Views.views.vend.views(this)) }
Full(Views.views.vend.views(BankAccountUID(this.bankId,this.accountId))) }
else
Failure("user : " + user.emailAddress + " does not have access to owner view on account " + accountId, Empty, Empty)
}
@ -463,7 +472,7 @@ trait BankAccount {
if(!userDoingTheCreate.ownerAccess(this)) {
Failure({"user: " + userDoingTheCreate.idGivenByProvider + " at provider " + userDoingTheCreate.provider + " does not have owner access"})
} else {
val view = Views.views.vend.createView(this, v)
val view = Views.views.vend.createView(BankAccountUID(this.bankId,this.accountId), v)
if(view.isDefined) {
log.info("user: " + userDoingTheCreate.idGivenByProvider + " at provider " + userDoingTheCreate.provider + " created view: " + view.get +
@ -478,7 +487,7 @@ trait BankAccount {
if(!userDoingTheUpdate.ownerAccess(this)) {
Failure({"user: " + userDoingTheUpdate.idGivenByProvider + " at provider " + userDoingTheUpdate.provider + " does not have owner access"})
} else {
val view = Views.views.vend.updateView(this, viewId, v)
val view = Views.views.vend.updateView(BankAccountUID(this.bankId,this.accountId), viewId, v)
if(view.isDefined) {
log.info("user: " + userDoingTheUpdate.idGivenByProvider + " at provider " + userDoingTheUpdate.provider + " updated view: " + view.get +
@ -493,7 +502,7 @@ trait BankAccount {
if(!userDoingTheRemove.ownerAccess(this)) {
return Failure({"user: " + userDoingTheRemove.idGivenByProvider + " at provider " + userDoingTheRemove.provider + " does not have owner access"})
} else {
val deleted = Views.views.vend.removeView(viewId, this)
val deleted = Views.views.vend.removeView(viewId, BankAccountUID(this.bankId,this.accountId))
if (deleted.isDefined) {
log.info("user: " + userDoingTheRemove.idGivenByProvider + " at provider " + userDoingTheRemove.provider + " deleted view: " + viewId +
@ -504,7 +513,7 @@ trait BankAccount {
}
}
final def publicViews : List[View] = Views.views.vend.publicViews(this)
final def publicViews : List[View] = Views.views.vend.publicViews(BankAccountUID(this.bankId,this.accountId))
final def moderatedTransaction(transactionId: TransactionId, view: View, user: Box[User]) : Box[ModeratedTransaction] = {
if(authorizedAccess(view, user))
@ -576,15 +585,21 @@ object BankAccount {
}
def publicAccounts : List[BankAccount] = {
Views.views.vend.getAllPublicAccounts
Views.views.vend.getAllPublicAccounts.flatMap { a =>
BankAccount(a.bankId, a.accountId)
}
}
def accounts(user : Box[User]) : List[BankAccount] = {
Views.views.vend.getAllAccountsUserCanSee(user)
Views.views.vend.getAllAccountsUserCanSee(user).flatMap { a =>
BankAccount(a.bankId, a.accountId)
}
}
def nonPublicAccounts(user : User) : List[BankAccount] = {
Views.views.vend.getNonPublicBankAccounts(user)
Views.views.vend.getNonPublicBankAccounts(user).flatMap { a =>
BankAccount(a.bankId, a.accountId)
}
}
}
@ -593,6 +608,8 @@ The other bank account or counterparty in a transaction
as see from the perspective of the original party.
*/
// Note: See also CounterpartyTrait
class Counterparty(
// The following four fields are older version, pleae first consider the V210

14
src/main/scala/code/model/User.scala
View File

@ -61,7 +61,7 @@ trait User {
def name : String
def permittedViews(bankAccount: BankAccount) : List[View] =
Views.views.vend.permittedViews(this, bankAccount)
Views.views.vend.permittedViews(this, BankAccountUID(bankAccount.bankId, bankAccount.accountId))
def canInitiateTransactions(bankAccount: BankAccount) : Box[Unit] ={
if(permittedViews(bankAccount).exists(_.canInitiateTransaction)){
@ -83,7 +83,11 @@ trait User {
/**
* @return the bank accounts where the user has at least access to a non public view (is_public==false)
*/
def nonPublicAccounts : List[BankAccount] = Views.views.vend.getNonPublicBankAccounts(this)
def nonPublicAccounts : List[BankAccount] = {
Views.views.vend.getNonPublicBankAccounts(this).flatMap { a =>
BankAccount(a.bankId, a.accountId)
}
}
def assignedEntitlements : List[Entitlement] = {
Entitlement.entitlement.vend.getEntitlements(userId) match {
@ -146,4 +150,8 @@ object User {
def saveResourceUser(ru: ResourceUser) = {
Users.users.vend.saveResourceUser(ru)
}
}
//def bulkDeleteAllResourceUsers(): Box[Boolean] = {
// Users.users.vend.bulkDeleteAllResourceUsers()
//}
}

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

@ -614,7 +614,7 @@ trait View {
object View {
def fromUrl(viewId: ViewId, account: BankAccount): Box[View] =
Views.views.vend.view(viewId, account)
Views.views.vend.view(viewId, BankAccountUID(account.bankId, account.accountId))
def fromUrl(viewId: ViewId, accountId: AccountId, bankId: BankId): Box[View] =
Views.views.vend.view(ViewUID(viewId, bankId, accountId))

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

@ -137,7 +137,7 @@ class AuthUser extends MegaProtoUser[AuthUser] with Logger {
}
override def delete_!(): Boolean = {
user.obj.map{_.delete_!}
user.obj.map(u => Users.users.vend.deleteResourceUser(u.id))
super.delete_!
}

32
src/main/scala/code/model/dataAccess/MappedAccountHolder.scala
View File

@ -1,32 +0,0 @@
package code.model.dataAccess
import net.liftweb.mapper._
import net.liftweb.common._
class MappedAccountHolder extends LongKeyedMapper[MappedAccountHolder] with IdPK {
def getSingleton = MappedAccountHolder
object user extends MappedLongForeignKey(this, ResourceUser)
object accountBankPermalink extends MappedString(this, 255)
object accountPermalink extends MappedString(this, 255)
}
object MappedAccountHolder extends MappedAccountHolder with LongKeyedMetaMapper[MappedAccountHolder] {
private val logger = Logger(classOf[MappedAccountHolder])
override def dbIndexes = Index(accountBankPermalink, accountPermalink) :: Nil
def createMappedAccountHolder(userId: Long, bankId: String, accountId: String, source: String = "MappedAccountHolder"): Boolean = {
val holder = MappedAccountHolder.create
.accountBankPermalink(bankId)
.accountPermalink(accountId)
.user(userId)
.saveMe
if(source != "MappedAccountHolder") logger.info(s"------------> created mappedUserHolder ${holder} at ${source}")
if(holder.saved_?) true else false
}
}

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

@ -34,8 +34,9 @@ package code.model.dataAccess
import code.util.MappedUUID
import net.liftweb.mapper._
import net.liftweb.util.Props
import code.model.{UserId, User, View}
import code.model.{BankAccountUID, User, UserId, View}
import code.views.Views
import net.liftweb.common.Full
class ResourceUser extends LongKeyedMapper[ResourceUser] with User with ManyToMany with OneToMany[Long, ResourceUser]{
def getSingleton = ResourceUser
@ -60,8 +61,6 @@ class ResourceUser extends LongKeyedMapper[ResourceUser] with User with ManyToMa
override def defaultValue = java.util.UUID.randomUUID.toString
}
object views_ extends MappedManyToMany(ViewPrivileges, ViewPrivileges.user, ViewPrivileges.view, ViewImpl)
def emailAddress = {
val e = email.get
if(e != null) e else ""
@ -74,7 +73,9 @@ class ResourceUser extends LongKeyedMapper[ResourceUser] with User with ManyToMa
def name : String = name_.get
def provider = provider_.get
def views: List[View] = views_.toList
def views: List[View] = Views.views.vend.getAllAccountsUserCanSee(Full(this)).flatMap { a =>
Views.views.vend.permittedViews(this, a)
}
}

7
src/main/scala/code/model/dataAccess/view.scala
View File

@ -36,6 +36,7 @@ import code.api.APIFailure
import net.liftweb.common.{Box, Full}
import net.liftweb.mapper._
import code.model._
import code.users.Users
import code.views.Views
import scala.collection.immutable.List
@ -67,7 +68,7 @@ class ViewImpl extends View with LongKeyedMapper[ViewImpl] with ManyToMany with
object permalink_ extends MappedString(this, 255)
def users : List[User] = users_.toList
//Important! If you add a field, be sure to handle it here in this function
def setFromViewData(viewData : ViewSpecification) = {
@ -457,8 +458,8 @@ object ViewImpl extends ViewImpl with LongKeyedMetaMapper[ViewImpl]{
//TODO: APIFailures with http response codes belong at a higher level in the code
}
def find(viewId : ViewId, bankAccount : BankAccount): Box[ViewImpl] = {
find(ViewUID(viewId, bankAccount.bankId, bankAccount.accountId))
def find(viewId : ViewId, bankAccountId : BankAccountUID): Box[ViewImpl] = {
find(ViewUID(viewId, bankAccountId.bankId, bankAccountId.accountId))
}
def accountFilter(bankId : BankId, accountId : AccountId) : List[QueryParam[ViewImpl]] = {

253
src/main/scala/code/views/AkkaMapperViews.scala → src/main/scala/code/remotedata/Remotedata.scala
View File

@ -1,31 +1,31 @@
package code.views
package code.remotedata
import akka.actor.{ActorKilledException, ActorSelection, ActorSystem}
import akka.pattern.ask
import akka.util.Timeout
import code.accountholder.{AccountHolders, RemoteAccountHoldersCaseClasses}
import code.api.APIFailure
import code.metadata.counterparties.{Counterparties, CounterpartyTrait, RemoteCounterpartiesCaseClasses}
import code.model.dataAccess.ResourceUser
import code.model.{CreateViewJSON, Permission, UpdateViewJSON, _}
import net.liftweb.common._
import scala.collection.immutable.List
import code.model._
import code.users.{RemoteUserCaseClasses, Users}
import code.views.{RemoteViewCaseClasses, Views}
import com.typesafe.config.ConfigFactory
import net.liftweb.common.Full
import net.liftweb.common.{Full, _}
import net.liftweb.util.Props
import scala.collection.immutable.List
import scala.concurrent.Await
import scala.concurrent.duration._
import akka.pattern.ask
import akka.actor.{ActorKilledException, ActorSelection, ActorSystem}
import akka.util.Timeout
import code.api.APIFailure
import code.model.dataAccess.ResourceUser
import code.users.{RemoteUserCaseClasses, Users}
import code.metadata.counterparties.{Counterparties, CounterpartyTrait, RemoteCounterpartiesCaseClasses}
object AkkaMapperViews extends Views with Users with Counterparties{
object Remotedata extends Views with Users with Counterparties with AccountHolders {
val TIMEOUT = 10 seconds
val r = RemoteViewCaseClasses
val ru = RemoteUserCaseClasses
val rViews = RemoteViewCaseClasses
val rUsers = RemoteUserCaseClasses
val rCounterparties = RemoteCounterpartiesCaseClasses
val rAccountHolders = RemoteAccountHoldersCaseClasses
implicit val timeout = Timeout(10000 milliseconds)
val remote = ActorSystem("LookupSystem", ConfigFactory.load("remotelookup"))
@ -46,7 +46,7 @@ object AkkaMapperViews extends Views with Users with Counterparties{
val res = try {
Full(
Await.result(
(viewsActor ? r.addPermissions(views, user)).mapTo[List[View]],
(viewsActor ? rViews.addPermissions(views, user)).mapTo[List[View]],
TIMEOUT
)
)
@ -58,10 +58,10 @@ object AkkaMapperViews extends Views with Users with Counterparties{
res
}
def permission(account: BankAccount, user: User): Box[Permission] = {
def permission(account: BankAccountUID, user: User): Box[Permission] = {
Full(
Await.result(
(viewsActor ? r.permission(account, user)).mapTo[Permission],
(viewsActor ? rViews.permission(account, user)).mapTo[Permission],
TIMEOUT
)
)
@ -71,7 +71,7 @@ object AkkaMapperViews extends Views with Users with Counterparties{
val res = try {
Full(
Await.result(
(viewsActor ? r.addPermission(viewUID, user)).mapTo[View],
(viewsActor ? rViews.addPermission(viewUID, user)).mapTo[View],
TIMEOUT
)
)
@ -84,32 +84,35 @@ object AkkaMapperViews extends Views with Users with Counterparties{
}
//TODO Fix return values in order to better describe failures
def revokePermission(viewUID : ViewUID, user : User) : Box[Boolean] = {
val res = try {
Full(
Await.result(
(viewsActor ? r.revokePermission(viewUID, user)).mapTo[Boolean],
(viewsActor ? rViews.revokePermission(viewUID, user)).mapTo[Boolean],
TIMEOUT
)
)
}
catch {
case k: ActorKilledException => return Empty ~> APIFailure(s"View $viewUID. not found", 404)
case k: ClassCastException => k.getMessage match {
case "Cannot cast net.liftweb.common.Failure to java.lang.Boolean" =>
return Empty ~> APIFailure(s"View $viewUID. not removed", 400)
case "Cannot cast net.liftweb.common.ParamFailure to java.lang.Boolean" =>
return Empty ~> APIFailure(s"View $viewUID. not found", 404)
case _ =>
return Empty ~> APIFailure(s"Unknown error", 406)
}
case e: Throwable => throw e
}
if ( res.getOrElse(false) ) {
res
}
else
Empty ~> Failure("access cannot be revoked")
res
}
def revokeAllPermissions(bankId : BankId, accountId: AccountId, user : User) : Box[Boolean] = {
val res = try{
Full(
Await.result(
(viewsActor ? r.revokeAllPermissions(bankId, accountId, user)).mapTo[Boolean],
(viewsActor ? rViews.revokeAllPermissions(bankId, accountId, user)).mapTo[Boolean],
TIMEOUT
)
)
@ -127,7 +130,7 @@ object AkkaMapperViews extends Views with Users with Counterparties{
val res = try {
Full(
Await.result(
(viewsActor ? r.view(viewUID)).mapTo[View],
(viewsActor ? rViews.view(viewUID)).mapTo[View],
TIMEOUT
)
)
@ -139,92 +142,102 @@ object AkkaMapperViews extends Views with Users with Counterparties{
res
}
def view(viewId : ViewId, account: BankAccount) : Box[View] = {
def view(viewId : ViewId, account: BankAccountUID) : Box[View] = {
val res = try {
Full(
Await.result(
(viewsActor ? rViews.view(viewId, account)).mapTo[View],
TIMEOUT
)
)
}
catch {
case k: ActorKilledException => Empty ~> APIFailure(s"View $viewId. not found", 404)
case e: Throwable => throw e
}
res
}
def createView(bankAccountId: BankAccountUID, view: CreateViewJSON): Box[View] = {
Await.result(
(viewsActor ? r.view(viewId, account)).mapTo[Box[View]],
(viewsActor ? rViews.createView(bankAccountId, view)).mapTo[Box[View]],
TIMEOUT
)
}
def createView(bankAccount: BankAccount, view: CreateViewJSON): Box[View] = {
def updateView(bankAccountId : BankAccountUID, viewId: ViewId, viewUpdateJson : UpdateViewJSON) : Box[View] = {
Await.result(
(viewsActor ? r.createView(bankAccount, view)).mapTo[Box[View]],
(viewsActor ? rViews.updateView(bankAccountId, viewId, viewUpdateJson)).mapTo[Box[View]],
TIMEOUT
)
}
def updateView(bankAccount : BankAccount, viewId: ViewId, viewUpdateJson : UpdateViewJSON) : Box[View] = {
def removeView(viewId: ViewId, bankAccountId: BankAccountUID): Box[Unit] = {
Await.result(
(viewsActor ? r.updateView(bankAccount, viewId, viewUpdateJson)).mapTo[Box[View]],
(viewsActor ? rViews.removeView(viewId, bankAccountId)).mapTo[Box[Unit]],
TIMEOUT
)
}
def removeView(viewId: ViewId, bankAccount: BankAccount): Box[Unit] = {
def permissions(account : BankAccountUID) : List[Permission] = {
Await.result(
(viewsActor ? r.removeView(viewId, bankAccount)).mapTo[Box[Unit]],
(viewsActor ? rViews.permissions(account)).mapTo[List[Permission]],
TIMEOUT
)
}
def permissions(account : BankAccount) : List[Permission] = {
def views(bankAccountId : BankAccountUID) : List[View] = {
Await.result(
(viewsActor ? r.permissions(account)).mapTo[List[Permission]],
(viewsActor ? rViews.views(bankAccountId)).mapTo[List[View]],
TIMEOUT
)
}
def views(bankAccount : BankAccount) : List[View] = {
def permittedViews(user: User, bankAccountId: BankAccountUID): List[View] = {
Await.result(
(viewsActor ? r.views(bankAccount)).mapTo[List[View]],
(viewsActor ? rViews.permittedViews(user, bankAccountId)).mapTo[List[View]],
TIMEOUT
)
}
def permittedViews(user: User, bankAccount: BankAccount): List[View] = {
def publicViews(bankAccountId : BankAccountUID) : List[View] = {
Await.result(
(viewsActor ? r.permittedViews(user, bankAccount)).mapTo[List[View]],
(viewsActor ? rViews.publicViews(bankAccountId)).mapTo[List[View]],
TIMEOUT
)
}
def publicViews(bankAccount : BankAccount) : List[View] = {
def getAllPublicAccounts() : List[BankAccountUID] = {
Await.result(
(viewsActor ? r.publicViews(bankAccount)).mapTo[List[View]],
(viewsActor ? rViews.getAllPublicAccounts()).mapTo[List[BankAccountUID]],
TIMEOUT
)
}
def getAllPublicAccounts() : List[BankAccount] = {
def getPublicBankAccounts(bank : Bank) : List[BankAccountUID] = {
Await.result(
(viewsActor ? r.getAllPublicAccounts()).mapTo[List[BankAccount]],
(viewsActor ? rViews.getPublicBankAccounts(bank)).mapTo[List[BankAccountUID]],
TIMEOUT
)
}
def getPublicBankAccounts(bank : Bank) : List[BankAccount] = {
Await.result(
(viewsActor ? r.getPublicBankAccounts(bank)).mapTo[List[BankAccount]],
TIMEOUT
)
}
def getAllAccountsUserCanSee(user : Box[User]) : List[BankAccount] = {
def getAllAccountsUserCanSee(user : Box[User]) : List[BankAccountUID] = {
user match {
case Full(theUser) => {
Await.result (
(viewsActor ? r.getAllAccountsUserCanSee(theUser)).mapTo[List[BankAccount]],
(viewsActor ? rViews.getAllAccountsUserCanSee(theUser)).mapTo[List[BankAccountUID]],
TIMEOUT)
}
case _ => getAllPublicAccounts()
}
}
def getAllAccountsUserCanSee(bank: Bank, user : Box[User]) : List[BankAccount] = {
def getAllAccountsUserCanSee(bank: Bank, user : Box[User]) : List[BankAccountUID] = {
user match {
case Full(theUser) => {
Await.result(
(viewsActor ? r.getAllAccountsUserCanSee(bank, theUser)).mapTo[List[BankAccount]],
(viewsActor ? rViews.getAllAccountsUserCanSee(bank, theUser)).mapTo[List[BankAccountUID]],
TIMEOUT
)
}
@ -232,37 +245,44 @@ object AkkaMapperViews extends Views with Users with Counterparties{
}
}
def getNonPublicBankAccounts(user : User) : List[BankAccount] = {
def getNonPublicBankAccounts(user : User) : List[BankAccountUID] = {
Await.result(
(viewsActor ? r.getNonPublicBankAccounts(user)).mapTo[List[BankAccount]],
(viewsActor ? rViews.getNonPublicBankAccounts(user)).mapTo[List[BankAccountUID]],
TIMEOUT
)
}
def getNonPublicBankAccounts(user : User, bankId : BankId) : List[BankAccount] = {
def getNonPublicBankAccounts(user : User, bankId : BankId) : List[BankAccountUID] = {
Await.result(
(viewsActor ? r.getNonPublicBankAccounts(user, bankId)).mapTo[List[BankAccount]],
(viewsActor ? rViews.getNonPublicBankAccounts(user, bankId)).mapTo[List[BankAccountUID]],
TIMEOUT
)
}
def grantAccessToAllExistingViews(user : User) = {
Await.result(
(viewsActor ? r.grantAccessToAllExistingViews(user)).mapTo[Boolean],
(viewsActor ? rViews.grantAccessToAllExistingViews(user)).mapTo[Boolean],
TIMEOUT
)
}
def grantAccessToView(user : User, view : View) = {
Await.result(
(viewsActor ? r.grantAccessToView(user, view)).mapTo[Boolean],
(viewsActor ? rViews.grantAccessToView(user, view)).mapTo[Boolean],
TIMEOUT
)
}
def getOwners(view: View) : Set[User] = {
Await.result(
(viewsActor ? rViews.getOwners(view)).mapTo[Set[User]],
TIMEOUT
)
}
def createOwnerView(bankId: BankId, accountId: AccountId, description: String) : Box[View] = {
Full(Await.result(
(viewsActor ? r.createOwnerView(bankId, accountId, description)).mapTo[View],
(viewsActor ? rViews.createOwnerView(bankId, accountId, description)).mapTo[View],
TIMEOUT
)
)
@ -270,7 +290,7 @@ object AkkaMapperViews extends Views with Users with Counterparties{
def createPublicView(bankId: BankId, accountId: AccountId, description: String) : Box[View] = {
Full(Await.result(
(viewsActor ? r.createPublicView(bankId, accountId, description)).mapTo[View],
(viewsActor ? rViews.createPublicView(bankId, accountId, description)).mapTo[View],
TIMEOUT
)
)
@ -278,7 +298,7 @@ object AkkaMapperViews extends Views with Users with Counterparties{
def createAccountantsView(bankId: BankId, accountId: AccountId, description: String) : Box[View] = {
Full(Await.result(
(viewsActor ? r.createAccountantsView(bankId, accountId, description)).mapTo[View],
(viewsActor ? rViews.createAccountantsView(bankId, accountId, description)).mapTo[View],
TIMEOUT
)
)
@ -286,7 +306,7 @@ object AkkaMapperViews extends Views with Users with Counterparties{
def createAuditorsView(bankId: BankId, accountId: AccountId, description: String) : Box[View] = {
Full(Await.result(
(viewsActor ? r.createAuditorsView(bankId, accountId, description)).mapTo[View],
(viewsActor ? rViews.createAuditorsView(bankId, accountId, description)).mapTo[View],
TIMEOUT
)
)
@ -294,7 +314,7 @@ object AkkaMapperViews extends Views with Users with Counterparties{
def createRandomView(bankId: BankId, accountId: AccountId) : Box[View] = {
Full(Await.result(
(viewsActor ? r.createRandomView(bankId, accountId)).mapTo[View],
(viewsActor ? rViews.createRandomView(bankId, accountId)).mapTo[View],
TIMEOUT
)
)
@ -302,30 +322,31 @@ object AkkaMapperViews extends Views with Users with Counterparties{
def viewExists(bankId: BankId, accountId: AccountId, name: String): Boolean = {
Await.result(
(viewsActor ? r.viewExists(bankId, accountId, name)).mapTo[Boolean],
(viewsActor ? rViews.viewExists(bankId, accountId, name)).mapTo[Boolean],
TIMEOUT
)
}
def removeAllViews(bankId: BankId, accountId: AccountId): Boolean = {
Await.result(
(viewsActor ? r.removeAllViews(bankId, accountId)).mapTo[Boolean],
(viewsActor ? rViews.removeAllViews(bankId, accountId)).mapTo[Boolean],
TIMEOUT
)
}
def removeAllPermissions(bankId: BankId, accountId: AccountId): Boolean = {
Await.result(
(viewsActor ? r.removeAllViews(bankId, accountId)).mapTo[Boolean],
(viewsActor ? rViews.removeAllViews(bankId, accountId)).mapTo[Boolean],
TIMEOUT
)
}
// Resource user part
def getUserByResourceUserId(id : Long) : Box[User] = {
val res = try {
Full(
Await.result(
(viewsActor ? ru.getUserByResourceUserId(id)).mapTo[User],
(viewsActor ? rUsers.getUserByResourceUserId(id)).mapTo[User],
TIMEOUT
)
)
@ -341,7 +362,7 @@ object AkkaMapperViews extends Views with Users with Counterparties{
val res = try {
Full(
Await.result(
(viewsActor ? ru.getResourceUserByResourceUserId(id)).mapTo[ResourceUser],
(viewsActor ? rUsers.getResourceUserByResourceUserId(id)).mapTo[ResourceUser],
TIMEOUT
)
)
@ -357,7 +378,7 @@ object AkkaMapperViews extends Views with Users with Counterparties{
val res = try {
Full(
Await.result(
(viewsActor ? ru.getUserByProviderId(provider, idGivenByProvider)).mapTo[User],
(viewsActor ? rUsers.getUserByProviderId(provider, idGivenByProvider)).mapTo[User],
TIMEOUT
)
)
@ -373,7 +394,7 @@ object AkkaMapperViews extends Views with Users with Counterparties{
val res = try {
Full(
Await.result(
(viewsActor ? ru.getUserByUserId(userId)).mapTo[User],
(viewsActor ? rUsers.getUserByUserId(userId)).mapTo[User],
TIMEOUT
)
)
@ -384,11 +405,12 @@ object AkkaMapperViews extends Views with Users with Counterparties{
}
res
}
def getUserByUserName(userName : String) : Box[ResourceUser] = {
val res = try {
Full(
Await.result(
(viewsActor ? ru.getUserByUserName(userName)).mapTo[ResourceUser],
(viewsActor ? rUsers.getUserByUserName(userName)).mapTo[ResourceUser],
TIMEOUT
)
)
@ -399,11 +421,12 @@ object AkkaMapperViews extends Views with Users with Counterparties{
}
res
}
def getUserByEmail(email : String) : Box[List[ResourceUser]] = {
val res = try {
Full(
Await.result(
(viewsActor ? ru.getUserByEmail(email)).mapTo[List[ResourceUser]],
(viewsActor ? rUsers.getUserByEmail(email)).mapTo[List[ResourceUser]],
TIMEOUT
)
)
@ -414,11 +437,12 @@ object AkkaMapperViews extends Views with Users with Counterparties{
}
res
}
def getAllUsers() : Box[List[ResourceUser]] = {
val res = try {
Full(
Await.result(
(viewsActor ? ru.getAllUsers()).mapTo[List[ResourceUser]],
(viewsActor ? rUsers.getAllUsers()).mapTo[List[ResourceUser]],
TIMEOUT
)
)
@ -429,11 +453,12 @@ object AkkaMapperViews extends Views with Users with Counterparties{
}
res
}
def createResourceUser(provider: String, providerId: Option[String], name: Option[String], email: Option[String], userId: Option[String]) : Box[ResourceUser] = {
val res = try {
Full(
Await.result(
(viewsActor ? ru.createResourceUser(provider, providerId, name, email, userId)).mapTo[ResourceUser],
(viewsActor ? rUsers.createResourceUser(provider, providerId, name, email, userId)).mapTo[ResourceUser],
TIMEOUT
)
)
@ -444,11 +469,12 @@ object AkkaMapperViews extends Views with Users with Counterparties{
}
res
}
def createUnsavedResourceUser(provider: String, providerId: Option[String], name: Option[String], email: Option[String], userId: Option[String]) : Box[ResourceUser] = {
val res = try {
Full(
Await.result(
(viewsActor ? ru.createUnsavedResourceUser(provider, providerId, name, email, userId)).mapTo[ResourceUser],
(viewsActor ? rUsers.createUnsavedResourceUser(provider, providerId, name, email, userId)).mapTo[ResourceUser],
TIMEOUT
)
)
@ -459,11 +485,12 @@ object AkkaMapperViews extends Views with Users with Counterparties{
}
res
}
def saveResourceUser(resourceUser: ResourceUser) : Box[ResourceUser] = {
val res = try {
Full(
Await.result(
(viewsActor ? ru.saveResourceUser(resourceUser)).mapTo[ResourceUser],
(viewsActor ? rUsers.saveResourceUser(resourceUser)).mapTo[ResourceUser],
TIMEOUT
)
)
@ -475,6 +502,22 @@ object AkkaMapperViews extends Views with Users with Counterparties{
res
}
def deleteResourceUser(userId: Long) : Box[Boolean] = {
val res = try{
Full(
Await.result(
(viewsActor ? rUsers.deleteResourceUser(userId)).mapTo[Boolean],
TIMEOUT
)
)
}
catch {
case k: ActorKilledException => Empty ~> APIFailure(s"User not deleted", 404)
case e: Throwable => throw e
}
res
}
override def getOrCreateMetadata(originalPartyBankId: BankId, originalPartyAccountId: AccountId, otherParty: Counterparty): Box[CounterpartyMetadata] = {
val res = try {
Full(
@ -579,5 +622,49 @@ object AkkaMapperViews extends Views with Users with Counterparties{
TIMEOUT
)
}
override def createAccountHolder(userId: Long, bankId: String, accountId: String, source: String = "MappedAccountHolder"): Boolean = {
Await.result(
(viewsActor ? rAccountHolders.createAccountHolder(userId, bankId, accountId, source)).mapTo[Boolean],
TIMEOUT
)
}
override def getAccountHolders(bankId: BankId, accountId: AccountId): Set[User] = {
Await.result(
(viewsActor ? rAccountHolders.getAccountHolders(bankId, accountId)).mapTo[Set[User]],
TIMEOUT
)
}
// bulkDeletes for tests
def bulkDeleteAllPermissionsAndViews(): Boolean = {
Await.result(
(viewsActor ? rViews.bulkDeleteAllPermissionsAndViews()).mapTo[Boolean],
TIMEOUT
)
}
def bulkDeleteAllAccountHolders(): Box[Boolean] = {
Full(
Await.result(
(viewsActor ? rAccountHolders.bulkDeleteAllAccountHolders()).mapTo[Boolean],
TIMEOUT
)
)
}
def bulkDeleteAllResourceUsers(): Box[Boolean] = {
Full(
Await.result(
(viewsActor ? rUsers.bulkDeleteAllResourceUsers()).mapTo[Boolean],
TIMEOUT
)
)
}
}

353
src/main/scala/code/views/AkkaMapperViewsActor.scala → src/main/scala/code/remotedata/RemotedataActor.scala
View File

@ -1,332 +1,364 @@
package code.views
package code.remotedata
import akka.actor.{Actor, ActorSystem, Props => ActorProps}
import akka.event.Logging
import akka.util.Timeout
import bootstrap.liftweb.ToSchemify
import code.accountholder.{MapperAccountHolders, RemoteAccountHoldersCaseClasses}
import code.metadata.counterparties.{CounterpartyTrait, MapperCounterparties, RemoteCounterpartiesCaseClasses}
import code.model._
import code.model.dataAccess.ResourceUser
import code.users.{LiftUsers, RemoteUserCaseClasses}
import code.views.{MapperViews, RemoteViewCaseClasses}
import com.typesafe.config.ConfigFactory
import net.liftweb.common.{Box, Empty, Full, Loggable}
import net.liftweb.common._
import net.liftweb.db.StandardDBVendor
import net.liftweb.http.LiftRules
import net.liftweb.mapper.{DB, Schemifier}
import net.liftweb.util.Props
import akka.actor.{Actor, ActorSystem, Props => ActorProps}
import net.liftweb.util.ControlHelpers.tryo
import scala.concurrent.duration._
import akka.event.Logging
import akka.util.Timeout
import bootstrap.liftweb.ToSchemify
import code.model.dataAccess.ResourceUser
import code.users.{LiftUsers, RemoteUserCaseClasses}
import code.metadata.counterparties.{CounterpartyTrait, MapperCounterparties, RemoteCounterpartiesCaseClasses}
class AkkaMapperViewsActor extends Actor {
class RemotedataActor extends Actor {
val logger = Logging(context.system, this)
Schemifier.schemify(true, Schemifier.infoF _, ToSchemify.modelsRemotedata: _*)
val v = MapperViews
val r = RemoteViewCaseClasses
val mViews = MapperViews
val rViews = RemoteViewCaseClasses
val vu = LiftUsers
val ru = RemoteUserCaseClasses
val mUsers = LiftUsers
val rUsers = RemoteUserCaseClasses
val vCounterparties = MapperCounterparties
val mCounterparties = MapperCounterparties
val rCounterparties = RemoteCounterpartiesCaseClasses
val mAccountHolders = MapperAccountHolders
val rAccountHolders = RemoteAccountHoldersCaseClasses
def receive = {
case r.addPermissions(views : List[ViewUID], user : User) =>
case rViews.addPermissions(views : List[ViewUID], user : User) =>
logger.info("addPermissions(" + views +"," + user +")")
{
for {
res <- v.addPermissions(views, user)
res <- mViews.addPermissions(views, user)
} yield {
sender ! res.asInstanceOf[List[View]]
}
}.getOrElse( context.stop(sender) )
case r.addPermission(viewUID : ViewUID, user : User) =>
case rViews.addPermission(viewUID : ViewUID, user : User) =>
logger.info("addPermission(" + viewUID +"," + user +")")
{
for {
res <- v.addPermission(viewUID, user)
res <- mViews.addPermission(viewUID, user)
} yield {
sender ! res.asInstanceOf[View]
}
}.getOrElse( context.stop(sender) )
case r.permission(account : BankAccount, user: User) =>
case rViews.permission(account : BankAccountUID, user: User) =>
logger.info("permission(" + account +"," + user +")")
{
for {
res <- v.permission(account, user)
res <- mViews.permission(account, user)
} yield {
sender ! res.asInstanceOf[Permission]
}
}.getOrElse( context.stop(sender) )
case r.revokePermission(viewUID : ViewUID, user : User) =>
//TODO Fix return values in order to better describe failures
case rViews.revokePermission(viewUID : ViewUID, user : User) =>
logger.info("revokePermission(" + viewUID +"," + user +")")
{
for {
res <- v.revokePermission(viewUID, user)
} yield {
sender ! res.asInstanceOf[Boolean]
}
}.getOrElse(context.stop(sender))
val res = mViews.revokePermission(viewUID, user)
res match {
case Full(r) => sender ! r
case f => sender ! f
}
case r.revokeAllPermissions(bankId : BankId, accountId : AccountId, user : User) =>
case rViews.revokeAllPermissions(bankId : BankId, accountId : AccountId, user : User) =>
logger.info("revokeAllPermissions(" + bankId +"," + accountId +","+ user +")")
{
for {
res <- v.revokeAllPermissions(bankId, accountId, user)
res <- mViews.revokeAllPermissions(bankId, accountId, user)
} yield {
sender ! res.asInstanceOf[Boolean]
}
}.getOrElse( context.stop(sender) )
case r.view(viewUID : ViewUID) =>
case rViews.view(viewUID : ViewUID) =>
logger.info("view(" + viewUID +")")
{
for {
res <- v.view(viewUID)
res <- mViews.view(viewUID)
} yield {
sender ! res.asInstanceOf[View]
}
}.getOrElse( context.stop(sender) )
case r.createView(bankAccount : BankAccount, view: CreateViewJSON) =>
logger.info("createView(" + bankAccount +","+ view +")")
sender ! v.createView(bankAccount, view)
case rViews.view(viewId: ViewId, bankAccountId: BankAccountUID) =>
case r.updateView(bankAccount : BankAccount, viewId : ViewId, viewUpdateJson : UpdateViewJSON) =>
logger.info("updateView(" + bankAccount +","+ viewId +","+ viewUpdateJson +")")
sender ! v.updateView(bankAccount, viewId, viewUpdateJson)
logger.info("view(" + viewId +", "+ bankAccountId + ")")
case r.view(viewId: ViewId, bankAccount: BankAccount) =>
logger.info("view(" + viewId +","+ bankAccount +")")
sender ! v.view(ViewId(viewId.value), bankAccount)
{
for {
res <- mViews.view(viewId, bankAccountId)
} yield {
sender ! res.asInstanceOf[View]
}
}.getOrElse( context.stop(sender) )
case r.removeView(viewId : ViewId, bankAccount: BankAccount) =>
logger.info("removeView(" + viewId +","+ bankAccount +")")
sender ! v.removeView(viewId, bankAccount)
case rViews.createView(bankAccountId : BankAccountUID, view: CreateViewJSON) =>
logger.info("createView(" + bankAccountId +","+ view +")")
sender ! mViews.createView(bankAccountId, view)
case r.permissions(bankAccount : BankAccount) =>
logger.info("premissions(" + bankAccount +")")
sender ! v.permissions(bankAccount)
case rViews.updateView(bankAccountId : BankAccountUID, viewId : ViewId, viewUpdateJson : UpdateViewJSON) =>
logger.info("updateView(" + bankAccountId +","+ viewId +","+ viewUpdateJson +")")
sender ! mViews.updateView(bankAccountId, viewId, viewUpdateJson)
case r.views(bankAccount : BankAccount) =>
logger.info("views(" + bankAccount +")")
sender ! v.views(bankAccount)
//case r.view(viewId: ViewId, bankAccountId: BankAccountUID) =>
// logger.info("view(" + viewId +","+ bankAccountId +")")
// sender ! v.view(ViewId(viewId.value), bankAccountId)
case r.permittedViews(user: User, bankAccount: BankAccount) =>
logger.info("permittedViews(" + user +", " + bankAccount +")")
sender ! v.permittedViews(user, bankAccount)
case rViews.removeView(viewId : ViewId, bankAccountId: BankAccountUID) =>
logger.info("removeView(" + viewId +","+ bankAccountId +")")
sender ! mViews.removeView(viewId, bankAccountId)
case r.publicViews(bankAccount : BankAccount) =>
logger.info("publicViews(" + bankAccount +")")
sender ! v.publicViews(bankAccount)
case rViews.permissions(bankAccountId : BankAccountUID) =>
logger.info("premissions(" + bankAccountId +")")
sender ! mViews.permissions(bankAccountId)
case r.getAllPublicAccounts() =>
case rViews.views(bankAccountId : BankAccountUID) =>
logger.info("views(" + bankAccountId +")")
sender ! mViews.views(bankAccountId)
case rViews.permittedViews(user: User, bankAccountId: BankAccountUID) =>
logger.info("permittedViews(" + user +", " + bankAccountId +")")
sender ! mViews.permittedViews(user, bankAccountId)
case rViews.publicViews(bankAccountId : BankAccountUID) =>
logger.info("publicViews(" + bankAccountId +")")
sender ! mViews.publicViews(bankAccountId)
case rViews.getAllPublicAccounts() =>
logger.info("getAllPublicAccounts()")
sender ! v.getAllPublicAccounts
sender ! mViews.getAllPublicAccounts
case r.getPublicBankAccounts(bank : Bank) =>
case rViews.getPublicBankAccounts(bank : Bank) =>
logger.info("getPublicBankAccounts(" + bank +")")
sender ! v.getPublicBankAccounts(bank)
sender ! mViews.getPublicBankAccounts(bank)
case r.getAllAccountsUserCanSee(user : Box[User]) =>
case rViews.getAllAccountsUserCanSee(user : Box[User]) =>
logger.info("getAllAccountsUserCanSee(" + user +")")
sender ! v.getAllAccountsUserCanSee(user)
sender ! mViews.getAllAccountsUserCanSee(user)
case r.getAllAccountsUserCanSee(user : User) =>
case rViews.getAllAccountsUserCanSee(user : User) =>
logger.info("getAllAccountsUserCanSee(" + user +")")
sender ! v.getAllAccountsUserCanSee(Full(user))
sender ! mViews.getAllAccountsUserCanSee(Full(user))
case r.getAllAccountsUserCanSee(bank: Bank, user : Box[User]) =>
case rViews.getAllAccountsUserCanSee(bank: Bank, user : Box[User]) =>
logger.info("getAllAccountsUserCanSee(" + bank +", "+ user +")")
sender ! v.getAllAccountsUserCanSee(bank, user)
sender ! mViews.getAllAccountsUserCanSee(bank, user)
case r.getAllAccountsUserCanSee(bank: Bank, user : User) =>
case rViews.getAllAccountsUserCanSee(bank: Bank, user : User) =>
logger.info("getAllAccountsUserCanSee(" + bank +", "+ user +")")
sender ! v.getAllAccountsUserCanSee(bank, Full(user))
sender ! mViews.getAllAccountsUserCanSee(bank, Full(user))
case r.getNonPublicBankAccounts(user: User, bankId: BankId) =>
case rViews.getNonPublicBankAccounts(user: User, bankId: BankId) =>
logger.info("getNonPublicBankAccounts(" + user +", "+ bankId +")")
sender ! v.getNonPublicBankAccounts(user, bankId)
sender ! mViews.getNonPublicBankAccounts(user, bankId)
case r.getNonPublicBankAccounts(user: User) =>
case rViews.getNonPublicBankAccounts(user: User) =>
logger.info("getNonPublicBankAccounts(" + user +")")
sender ! v.getNonPublicBankAccounts(user)
sender ! mViews.getNonPublicBankAccounts(user)
case r.createOwnerView(bankId, accountId, description) =>
case rViews.createOwnerView(bankId, accountId, description) =>
logger.info("createOwnerView(" + bankId +", "+ accountId +", "+ description +")")
sender ! v.createOwnerView(bankId, accountId, description).orNull
sender ! mViews.createOwnerView(bankId, accountId, description).orNull
case r.createPublicView(bankId, accountId, description) =>
case rViews.createPublicView(bankId, accountId, description) =>
logger.info("createPublicView(" + bankId +", "+ accountId +", "+ description +")")
sender ! v.createPublicView(bankId, accountId, description).orNull
sender ! mViews.createPublicView(bankId, accountId, description).orNull
case r.createAccountantsView(bankId, accountId, description) =>
case rViews.createAccountantsView(bankId, accountId, description) =>
logger.info("createAccountantsView(" + bankId +", "+ accountId +", "+ description +")")
sender ! v.createAccountantsView(bankId, accountId, description).orNull
sender ! mViews.createAccountantsView(bankId, accountId, description).orNull
case r.createAuditorsView(bankId, accountId, description) =>
case rViews.createAuditorsView(bankId, accountId, description) =>
logger.info("createAuditorsView(" + bankId +", "+ accountId +", "+ description +")")
sender ! v.createAuditorsView(bankId, accountId, description).orNull
sender ! mViews.createAuditorsView(bankId, accountId, description).orNull
case r.createRandomView(bankId, accountId) =>
case rViews.createRandomView(bankId, accountId) =>
logger.info("createRandomView(" + bankId +", "+ accountId +")")
sender ! v.createRandomView(bankId, accountId).orNull
sender ! mViews.createRandomView(bankId, accountId).orNull
case r.grantAccessToView(user, view) =>
case rViews.getOwners(view) =>
logger.info("getOwners(" + view +")")
sender ! mViews.getOwners(view)
case rViews.grantAccessToView(user, view) =>
logger.info("grantAccessToView(" + user +", "+ view +")")
sender ! v.grantAccessToView(user, view)
sender ! mViews.grantAccessToView(user, view)
case r.grantAccessToAllExistingViews(user) =>
case rViews.grantAccessToAllExistingViews(user) =>
logger.info("grantAccessToAllExistingViews(" + user +")")
sender ! v.grantAccessToAllExistingViews(user)
sender ! mViews.grantAccessToAllExistingViews(user)
case r.removeAllPermissions(bankId, accountId) =>
case rViews.removeAllPermissions(bankId, accountId) =>
logger.info("removeAllPermissions(" + bankId +", "+ accountId +")")
sender ! v.removeAllPermissions(bankId, accountId)
sender ! mViews.removeAllPermissions(bankId, accountId)
case r.removeAllViews(bankId, accountId) =>
case rViews.removeAllViews(bankId, accountId) =>
logger.info("removeAllViews(" + bankId +", "+ accountId +")")
sender ! v.removeAllViews(bankId, accountId)
sender ! mViews.removeAllViews(bankId, accountId)
// Resource User part
case ru.getUserByResourceUserId(id: Long) =>
case rUsers.getUserByResourceUserId(id: Long) =>
logger.info("getUserByResourceUserId(" + id +")")
{
for {
res <- vu.getUserByResourceUserId(id)
res <- mUsers.getUserByResourceUserId(id)
} yield {
sender ! res.asInstanceOf[User]
}
}.getOrElse( context.stop(sender) )
case ru.getResourceUserByResourceUserId(id: Long) =>
case rUsers.getResourceUserByResourceUserId(id: Long) =>
logger.info("getResourceUserByResourceUserId(" + id +")")
{
for {
res <- vu.getResourceUserByResourceUserId(id)
res <- mUsers.getResourceUserByResourceUserId(id)
} yield {
sender ! res.asInstanceOf[ResourceUser]
}
}.getOrElse( context.stop(sender) )
case ru.getUserByProviderId(provider : String, idGivenByProvider : String) =>
case rUsers.getUserByProviderId(provider : String, idGivenByProvider : String) =>
logger.info("getUserByProviderId(" + provider +"," + idGivenByProvider +")")
{
for {
res <- vu.getUserByProviderId(provider, idGivenByProvider)
res <- mUsers.getUserByProviderId(provider, idGivenByProvider)
} yield {
sender ! res.asInstanceOf[User]
}
}.getOrElse( context.stop(sender) )
case ru.getUserByUserId(userId: String) =>
case rUsers.getUserByUserId(userId: String) =>
logger.info("getUserByUserId(" + userId +")")
{
for {
res <- vu.getUserByUserId(userId)
res <- mUsers.getUserByUserId(userId)
} yield {
sender ! res.asInstanceOf[User]
}
}.getOrElse( context.stop(sender) )
case ru.getUserByUserName(userName: String) =>
case rUsers.getUserByUserName(userName: String) =>
logger.info("getUserByUserName(" + userName +")")
{
for {
res <- vu.getUserByUserName(userName)
res <- mUsers.getUserByUserName(userName)
} yield {
sender ! res.asInstanceOf[ResourceUser]
}
}.getOrElse( context.stop(sender) )
case ru.getUserByEmail(email: String) =>
case rUsers.getUserByEmail(email: String) =>
logger.info("getUserByEmail(" + email +")")
{
for {
res <- vu.getUserByEmail(email)
res <- mUsers.getUserByEmail(email)
} yield {
sender ! res
}
}.getOrElse( context.stop(sender) )
case ru.getAllUsers() =>
case rUsers.getAllUsers() =>
logger.info("getAllUsers()")
{
for {
res <- vu.getAllUsers()
res <- mUsers.getAllUsers()
} yield {
sender ! res
}
}.getOrElse( context.stop(sender) )
case ru.createResourceUser(provider: String, providerId: Option[String], name: Option[String], email: Option[String], userId: Option[String]) =>
case rUsers.createResourceUser(provider: String, providerId: Option[String], name: Option[String], email: Option[String], userId: Option[String]) =>
logger.info("createResourceUser(" + provider + ", " + providerId.getOrElse("None") + ", " + name.getOrElse("None") + ", " + email.getOrElse("None") + ", " + userId.getOrElse("None") + ")")
{
for {
res <- vu.createResourceUser(provider, providerId, name, email, userId)
res <- mUsers.createResourceUser(provider, providerId, name, email, userId)
} yield {
sender ! res.asInstanceOf[ResourceUser]
}
}.getOrElse( context.stop(sender) )
case ru.createUnsavedResourceUser(provider: String, providerId: Option[String], name: Option[String], email: Option[String], userId: Option[String]) =>
case rUsers.createUnsavedResourceUser(provider: String, providerId: Option[String], name: Option[String], email: Option[String], userId: Option[String]) =>
logger.info("createUnsavedResourceUser(" + provider + ", " + providerId.getOrElse("None") + ", " + name.getOrElse("None") + ", " + email.getOrElse("None") + ", " + userId.getOrElse("None") + ")")
{
for {
res <- vu.createUnsavedResourceUser(provider, providerId, name, email, userId)
res <- mUsers.createUnsavedResourceUser(provider, providerId, name, email, userId)
} yield {
sender ! res.asInstanceOf[ResourceUser]
}
}.getOrElse( context.stop(sender) )
case ru.saveResourceUser(resourceUser: ResourceUser) =>
case rUsers.saveResourceUser(resourceUser: ResourceUser) =>
logger.info("saveResourceUser")
{
for {
res <- vu.saveResourceUser(resourceUser)
res <- mUsers.saveResourceUser(resourceUser)
} yield {
sender ! res.asInstanceOf[ResourceUser]
}
}.getOrElse( context.stop(sender) )
case rUsers.deleteResourceUser(id: Long) =>
logger.info("deleteResourceUser(" + id +")")
{
for {
res <- tryo{mUsers.deleteResourceUser(id)}
} yield {
sender ! res.asInstanceOf[Boolean]
}
}.getOrElse( context.stop(sender) )
case rCounterparties.checkCounterpartyAvailable(name: String, thisBankId: String, thisAccountId: String, thisViewId: String)=>
logger.info("checkCounterpartyAvailable(" + name +", "+ thisBankId +", "+ thisAccountId +", "+ thisViewId +")")
sender ! vCounterparties.checkCounterpartyAvailable(name: String, thisBankId: String, thisAccountId: String, thisViewId: String)
sender ! mCounterparties.checkCounterpartyAvailable(name: String, thisBankId: String, thisAccountId: String, thisViewId: String)
case rCounterparties.createCounterparty(createdByUserId, thisBankId, thisAccountId, thisViewId, name, otherBankId, otherAccountId,
otherAccountRoutingScheme, otherAccountRoutingAddress, otherBankRoutingScheme, otherBankRoutingAddress,
@ -336,7 +368,7 @@ class AkkaMapperViewsActor extends Actor {
{
for {
res <- vCounterparties.createCounterparty(createdByUserId, thisBankId, thisAccountId, thisViewId, name, otherBankId, otherAccountId,
res <- mCounterparties.createCounterparty(createdByUserId, thisBankId, thisAccountId, thisViewId, name, otherBankId, otherAccountId,
otherAccountRoutingScheme, otherAccountRoutingAddress, otherBankRoutingScheme, otherBankRoutingAddress,
isBeneficiary)
} yield {
@ -351,7 +383,7 @@ class AkkaMapperViewsActor extends Actor {
{
for {
res <- vCounterparties.getOrCreateMetadata(originalPartyBankId: BankId, originalPartyAccountId: AccountId, otherParty: Counterparty)
res <- mCounterparties.getOrCreateMetadata(originalPartyBankId: BankId, originalPartyAccountId: AccountId, otherParty: Counterparty)
} yield {
sender ! res.asInstanceOf[CounterpartyMetadata]
}
@ -362,7 +394,7 @@ class AkkaMapperViewsActor extends Actor {
Full({
for {
res <- Full(vCounterparties.getMetadatas(originalPartyBankId: BankId, originalPartyAccountId: AccountId))
res <- Full(mCounterparties.getMetadatas(originalPartyBankId: BankId, originalPartyAccountId: AccountId))
} yield {
sender ! res.asInstanceOf[List[CounterpartyMetadata]]
}
@ -374,7 +406,7 @@ class AkkaMapperViewsActor extends Actor {
{
for {
res <- vCounterparties.getMetadata(originalPartyBankId: BankId, originalPartyAccountId: AccountId, counterpartyMetadataId: String)
res <- mCounterparties.getMetadata(originalPartyBankId: BankId, originalPartyAccountId: AccountId, counterpartyMetadataId: String)
} yield {
sender ! res.asInstanceOf[CounterpartyMetadata]
}
@ -387,7 +419,7 @@ class AkkaMapperViewsActor extends Actor {
{
for {
res <- vCounterparties.getCounterparty(counterPartyId: String)
res <- mCounterparties.getCounterparty(counterPartyId: String)
} yield {
sender ! res.asInstanceOf[CounterpartyTrait]
}
@ -400,29 +432,108 @@ class AkkaMapperViewsActor extends Actor {
{
for {
res <- vCounterparties.getCounterpartyByIban(iban: String)
res <- mCounterparties.getCounterpartyByIban(iban: String)
} yield {
sender ! res.asInstanceOf[CounterpartyTrait]
}
}.getOrElse( context.stop(sender) )
case rAccountHolders.createAccountHolder(userId: Long, bankId: String, accountId: String, source: String) =>
logger.info("createAccountHolder(" + userId +", "+ bankId +", "+ accountId +", "+ source +")")
{
for {
res <- tryo{mAccountHolders.createAccountHolder(userId, bankId, accountId, source)}
} yield {
sender ! res.asInstanceOf[Boolean]
}
}.getOrElse( context.stop(sender) )
case rAccountHolders.getAccountHolders(bankId: BankId, accountId: AccountId) =>
logger.info("getAccountHolders(" + bankId +", "+ accountId +")")
{
for {
res <- tryo{mAccountHolders.getAccountHolders(bankId, accountId)}
} yield {
sender ! res.asInstanceOf[Set[User]]
}
}.getOrElse( context.stop(sender) )
case rAccountHolders.bulkDeleteAllAccountHolders() =>
logger.info("bulkDeleteAllAccountHolders()")
{
for {
res <- mAccountHolders.bulkDeleteAllAccountHolders()
} yield {
sender ! res.asInstanceOf[Boolean]
}
}.getOrElse( context.stop(sender) )
case rUsers.bulkDeleteAllResourceUsers() =>
logger.info("bulkDeleteAllResourceUsers()")
{
for {
res <- mUsers.bulkDeleteAllResourceUsers()
} yield {
sender ! res.asInstanceOf[Boolean]
}
}.getOrElse( context.stop(sender) )
case rViews.bulkDeleteAllPermissionsAndViews() =>
logger.info("bulkDeleteAllPermissionsAndViews()")
{
for {
res <- tryo{mViews.bulkDeleteAllPermissionsAndViews()}
} yield {
sender ! res.asInstanceOf[Boolean]
}
}.getOrElse( context.stop(sender) )
case message => logger.info("[AKKA ACTOR ERROR - REQUEST NOT RECOGNIZED] " + message)
}
}
object RemoteDataActorSystem extends Loggable {
object RemotedataActorSystem extends Loggable {
implicit val timeout = Timeout(1 seconds)
def startRemoteWorkerSystem(): Unit = {
val remote = ActorSystem("OBPDataWorkerSystem", ConfigFactory.load("obpremotedata"))
val actor = remote.actorOf(ActorProps[AkkaMapperViewsActor], name = "OBPRemoteDataActor")
val actor = remote.actorOf(ActorProps[RemotedataActor], name = "OBPRemoteDataActor")
logger.info("Started OBPDataWorkerSystem")
}
def startLocalWorkerSystem(): Unit = {
val remote = ActorSystem("OBPDataWorkerSystem", ConfigFactory.load("obplocaldata"))
val actor = remote.actorOf(ActorProps[AkkaMapperViewsActor], name = "OBPLocalDataActor")
val actor = remote.actorOf(ActorProps[RemotedataActor], name = "OBPLocalDataActor")
logger.info("Started OBPDataWorkerSystem locally")
}

5
src/main/scala/code/sandbox/OBPDataImport.scala
View File

@ -3,12 +3,13 @@ package code.sandbox
import java.text.SimpleDateFormat
import java.util.{Date, UUID}
import code.accountholder.{AccountHolders, MapperAccountHolders, MapperAccountHolders$}
import code.crm.CrmEvent.CrmEvent
import code.metadata.counterparties.{Counterparties, MapperCounterparties}
import code.products.Products
import code.products.Products.{Product, ProductCode}
import code.bankconnectors.{Connector, OBPLimit, OBPOffset}
import code.model.dataAccess.{MappedAccountHolder, ResourceUser}
import code.model.dataAccess.ResourceUser
import code.model._
import code.branches.Branches.Branch
import code.atms.Atms.Atm
@ -167,7 +168,7 @@ trait OBPDataImport extends Loggable {
resourceUserOwner match {
case Some(o) => {
MappedAccountHolder.createMappedAccountHolder(o.resourceUserId.value, account.bankId.value, account.accountId.value, "OBPDataImport")
AccountHolders.accountHolders.vend.createAccountHolder(o.resourceUserId.value, account.bankId.value, account.accountId.value, "OBPDataImport")
}
case None => {
//This shouldn't happen as AuthUser should generate the ResourceUsers when saved

14
src/main/scala/code/users/LiftUsers.scala
View File

@ -87,5 +87,17 @@ object LiftUsers extends Users {
val r = Full(ru.saveMe())
r
}
override def bulkDeleteAllResourceUsers(): Box[Boolean] = {
Full( ResourceUser.bulkDelete_!!() )
}
override def deleteResourceUser(userId: Long): Box[Boolean] = {
for {
u <- ResourceUser.find(By(ResourceUser.id, userId))
} yield {
u.delete_!
}
}
}
}

14
src/main/scala/code/users/Users.scala
View File

@ -4,14 +4,14 @@ import net.liftweb.util.SimpleInjector
import net.liftweb.common.Box
import code.model.User
import code.model.dataAccess.ResourceUser
import code.views.AkkaMapperViews
import code.remotedata.Remotedata
object Users extends SimpleInjector {
val users = new Inject(buildOne _) {}
def buildOne: Users = LiftUsers
//def buildOne: Users = AkkaMapperViews
//def buildOne: Users = LiftUsers
def buildOne: Users = Remotedata
}
@ -35,6 +35,10 @@ trait Users {
def createUnsavedResourceUser(provider: String, providerId: Option[String], name: Option[String], email: Option[String], userId: Option[String]) : Box[ResourceUser]
def saveResourceUser(resourceUser: ResourceUser) : Box[ResourceUser]
def deleteResourceUser(userId: Long) : Box[Boolean]
def bulkDeleteAllResourceUsers() : Box[Boolean]
}
class RemoteUserCaseClasses {
@ -48,6 +52,8 @@ class RemoteUserCaseClasses {
case class createResourceUser(provider: String, providerId: Option[String], name: Option[String], email: Option[String], userId: Option[String])
case class createUnsavedResourceUser(provider: String, providerId: Option[String], name: Option[String], email: Option[String], userId: Option[String])
case class saveResourceUser(resourceUser: ResourceUser)
case class deleteResourceUser(userId: Long)
case class bulkDeleteAllResourceUsers()
}
object RemoteUserCaseClasses extends RemoteUserCaseClasses
object RemoteUserCaseClasses extends RemoteUserCaseClasses

108
src/main/scala/code/views/MapperViews.scala
View File

@ -1,10 +1,10 @@
package code.views
import bootstrap.liftweb.ToSchemify
import code.accountholder.{AccountHolders, MapperAccountHolders}
import code.api.APIFailure
import code.bankconnectors.Connector
import code.model.dataAccess.ViewImpl.create
import code.model.dataAccess.{ViewImpl, ViewPrivileges}
import code.model.dataAccess.{ResourceUser, ViewImpl, ViewPrivileges}
import code.model.{CreateViewJSON, Permission, UpdateViewJSON, User, _}
import net.liftweb.common._
import net.liftweb.mapper.{By, Schemifier}
@ -13,14 +13,14 @@ import net.liftweb.util.Helpers._
import scala.collection.immutable.List
//TODO: Replace BankAccounts with bankPermalink + accountPermalink
//TODO: Replace BankAccountUIDs with bankPermalink + accountPermalink
object MapperViews extends Views with Loggable {
Schemifier.schemify(true, Schemifier.infoF _, ToSchemify.modelsRemotedata: _*)
def permissions(account : BankAccount) : List[Permission] = {
def permissions(account : BankAccountUID) : List[Permission] = {
val views: List[ViewImpl] = ViewImpl.findAll(By(ViewImpl.isPublic_, false) ::
ViewImpl.accountFilter(account.bankId, account.accountId): _*)
@ -37,7 +37,7 @@ object MapperViews extends Views with Loggable {
permissions
}
def permission(account: BankAccount, user: User): Box[Permission] = {
def permission(account: BankAccountUID, user: User): Box[Permission] = {
//search ViewPrivileges to get all views for user and then filter the views
// by bankPermalink and accountPermalink
@ -100,17 +100,13 @@ object MapperViews extends Views with Loggable {
def revokePermission(viewUID : ViewUID, user : User) : Box[Boolean] = {
val res =
for{
for {
viewImpl <- ViewImpl.find(viewUID)
vp: ViewPrivileges <- ViewPrivileges.find(By(ViewPrivileges.user, user.resourceUserId.value), By(ViewPrivileges.view, viewImpl.id))
deletable <- accessRemovableAsBox(viewImpl, user)
} yield {
val r =
vp.delete_!
return Full(r)
vp.delete_!
}
if (res == Failure("access cannot be revoked"))
return Full(false)
res
}
@ -125,7 +121,10 @@ object MapperViews extends Views with Loggable {
if(viewImpl.viewId == ViewId("owner")) {
//if the user is an account holder, we can't revoke access to the owner view
if(Connector.connector.vend.getAccountHolders(viewImpl.bankId, viewImpl.accountId).contains(user)) {
val accountHolders = MapperAccountHolders.getAccountHolders(viewImpl.bankId, viewImpl.accountId)
if(accountHolders.map {h =>
h.resourceUserId
}.contains(user.resourceUserId)) {
false
} else {
// if it's the owner view, we can only revoke access if there would then still be someone else
@ -170,8 +169,8 @@ object MapperViews extends Views with Loggable {
}
def view(viewId : ViewId, account: BankAccount) : Box[View] = {
view(ViewUID(viewId, account.bankId, account.accountId))
def view(viewId : ViewId, account: BankAccountUID) : Box[View] = {
ViewImpl.find(ViewUID(viewId, account.bankId, account.accountId))
}
def view(viewUID : ViewUID) : Box[View] = {
@ -181,7 +180,7 @@ object MapperViews extends Views with Loggable {
/*
Create View based on the Specification (name, alias behavior, what fields can be seen, actions are allowed etc. )
* */
def createView(bankAccount: BankAccount, view: CreateViewJSON): Box[View] = {
def createView(bankAccountId: BankAccountUID, view: CreateViewJSON): Box[View] = {
if(view.name.contentEquals("")) {
return Failure("You cannot create a View with an empty Name")
}
@ -192,7 +191,7 @@ object MapperViews extends Views with Loggable {
val existing = ViewImpl.count(
By(ViewImpl.permalink_, newViewPermalink) ::
ViewImpl.accountFilter(bankAccount.bankId, bankAccount.accountId): _*
ViewImpl.accountFilter(bankAccountId.bankId, bankAccountId.accountId): _*
) == 1
if (existing)
@ -201,8 +200,8 @@ object MapperViews extends Views with Loggable {
val createdView = ViewImpl.create.
name_(view.name).
permalink_(newViewPermalink).
bankPermalink(bankAccount.bankId.value).
accountPermalink(bankAccount.accountId.value)
bankPermalink(bankAccountId.bankId.value).
accountPermalink(bankAccountId.accountId.value)
createdView.setFromViewData(view)
Full(createdView.saveMe)
@ -211,58 +210,58 @@ object MapperViews extends Views with Loggable {
/* Update the specification of the view (what data/actions are allowed) */
def updateView(bankAccount : BankAccount, viewId: ViewId, viewUpdateJson : UpdateViewJSON) : Box[View] = {
def updateView(bankAccountId : BankAccountUID, viewId: ViewId, viewUpdateJson : UpdateViewJSON) : Box[View] = {
for {
view <- ViewImpl.find(viewId, bankAccount)
view <- ViewImpl.find(viewId, bankAccountId)
} yield {
view.setFromViewData(viewUpdateJson)
view.saveMe
}
}
def removeView(viewId: ViewId, bankAccount: BankAccount): Box[Unit] = {
def removeView(viewId: ViewId, bankAccountId: BankAccountUID): Box[Unit] = {
if(viewId.value == "owner")
Failure("you cannot delete the owner view")
else {
for {
view <- ViewImpl.find(viewId, bankAccount)
view <- ViewImpl.find(viewId, bankAccountId)
if(view.delete_!)
} yield {
}
}
}
def views(bankAccount : BankAccount) : List[View] = {
ViewImpl.findAll(ViewImpl.accountFilter(bankAccount.bankId, bankAccount.accountId): _*)
def views(bankAccountId : BankAccountUID) : List[View] = {
ViewImpl.findAll(ViewImpl.accountFilter(bankAccountId.bankId, bankAccountId.accountId): _*)
}
def permittedViews(user: User, bankAccount: BankAccount): List[View] = {
def permittedViews(user: User, bankAccountId: BankAccountUID): List[View] = {
//TODO: do this more efficiently?
val allUserPrivs = ViewPrivileges.findAll(By(ViewPrivileges.user, user.resourceUserId.value))
val userNonPublicViewsForAccount = allUserPrivs.flatMap(p => {
p.view.obj match {
case Full(v) => if(
!v.isPublic &&
v.bankId == bankAccount.bankId&&
v.accountId == bankAccount.accountId){
v.bankId == bankAccountId.bankId&&
v.accountId == bankAccountId.accountId){
Some(v)
} else None
case _ => None
}
})
userNonPublicViewsForAccount ++ publicViews(bankAccount)
userNonPublicViewsForAccount ++ publicViews(bankAccountId)
}
def publicViews(bankAccount : BankAccount) : List[View] = {
def publicViews(bankAccountId : BankAccountUID) : List[View] = {
//TODO: do this more efficiently?
ViewImpl.findAll(ViewImpl.accountFilter(bankAccount.bankId, bankAccount.accountId): _*).filter(v => {
ViewImpl.findAll(ViewImpl.accountFilter(bankAccountId.bankId, bankAccountId.accountId): _*).filter(v => {
v.isPublic == true
})
}
def getAllPublicAccounts() : List[BankAccount] = {
def getAllPublicAccounts() : List[BankAccountUID] = {
//TODO: do this more efficiently
// An account is considered public if it contains a public view
@ -274,13 +273,13 @@ object MapperViews extends Views with Loggable {
val accountsList = bankAndAccountIds.map {
case (bankId, accountId) => {
(bankId, accountId)
BankAccountUID(bankId, accountId)
}
}
Connector.connector.vend.getBankAccounts(accountsList)
accountsList
}
def getPublicBankAccounts(bank : Bank) : List[BankAccount] = {
def getPublicBankAccounts(bank : Bank) : List[BankAccountUID] = {
//TODO: do this more efficiently
val accountIds : List[AccountId] =
@ -289,16 +288,16 @@ object MapperViews extends Views with Loggable {
}).distinct //we remove duplicates here
val accountsList = accountIds.map(accountId => {
(bank.bankId, accountId)
BankAccountUID(bank.bankId, accountId)
})
Connector.connector.vend.getBankAccounts(accountsList)
accountsList
}
/**
* @param user
* @return the bank accounts the @user can see (public + private if @user is Full, public if @user is Empty)
*/
def getAllAccountsUserCanSee(user : Box[User]) : List[BankAccount] = {
def getAllAccountsUserCanSee(user : Box[User]) : List[BankAccountUID] = {
user match {
case Full(theuser) => {
//TODO: this could be quite a bit more efficient...
@ -319,10 +318,10 @@ object MapperViews extends Views with Loggable {
val accountsList = visibleBankAndAccountIds.map {
case (bankId, accountId) => {
(bankId, accountId)
BankAccountUID(bankId, accountId)
}
}
Connector.connector.vend.getBankAccounts(accountsList)
accountsList
}
case _ => getAllPublicAccounts()
}
@ -332,7 +331,7 @@ object MapperViews extends Views with Loggable {
* @param user
* @return the bank accounts at @bank the @user can see (public + private if @user is Full, public if @user is Empty)
*/
def getAllAccountsUserCanSee(bank: Bank, user : Box[User]) : List[BankAccount] = {
def getAllAccountsUserCanSee(bank: Bank, user : Box[User]) : List[BankAccountUID] = {
user match {
case Full(theuser) => {
//TODO: this could be quite a bit more efficient...
@ -356,10 +355,10 @@ object MapperViews extends Views with Loggable {
val accountsList = visibleBankAndAccountIds.map {
case (bankId, accountId) => {
(bankId, accountId)
BankAccountUID(bankId, accountId)
}
}
Connector.connector.vend.getBankAccounts(accountsList)
accountsList
}
case _ => getPublicBankAccounts(bank)
}
@ -368,7 +367,7 @@ object MapperViews extends Views with Loggable {
/**
* @return the bank accounts where the user has at least access to a non public view (is_public==false)
*/
def getNonPublicBankAccounts(user : User) : List[BankAccount] = {
def getNonPublicBankAccounts(user : User) : List[BankAccountUID] = {
//TODO: make this more efficient
val userPrivileges : List[ViewPrivileges] = ViewPrivileges.findAll(By(ViewPrivileges.user, user.resourceUserId.value))
val userNonPublicViews : List[ViewImpl] = userPrivileges.map(_.view.obj).flatten.filter(!_.isPublic)
@ -379,16 +378,16 @@ object MapperViews extends Views with Loggable {
val accountsList = nonPublicViewBankAndAccountIds.map {
case(bankId, accountId) => {
(bankId, accountId)
BankAccountUID(bankId, accountId)
}
}
Connector.connector.vend.getBankAccounts(accountsList)
accountsList
}
/**
* @return the bank accounts where the user has at least access to a non public view (is_public==false) for a specific bank
*/
def getNonPublicBankAccounts(user : User, bankId : BankId) : List[BankAccount] = {
def getNonPublicBankAccounts(user : User, bankId : BankId) : List[BankAccountUID] = {
val userPrivileges : List[ViewPrivileges] = ViewPrivileges.findAll(By(ViewPrivileges.user, user.resourceUserId.value))
val userNonPublicViewsForBank : List[ViewImpl] =
userPrivileges.map(_.view.obj).flatten.filter(v => !v.isPublic && v.bankId == bankId)
@ -397,9 +396,9 @@ object MapperViews extends Views with Loggable {
map(_.accountId).distinct //we remove duplicates here
val accountsList = nonPublicViewAccountIds.map { accountId =>
(bankId, accountId)
BankAccountUID(bankId, accountId)
}
Connector.connector.vend.getBankAccounts(accountsList)
accountsList
}
def createOwnerView(bankId: BankId, accountId: AccountId, description: String = "Owner View") : Box[View] = {
@ -409,6 +408,13 @@ object MapperViews extends Views with Loggable {
}
}
def getOwners(view: View) : Set[User] = {
val viewUid = ViewImpl.find(view.uid)
val privileges = ViewPrivileges.findAll(By(ViewPrivileges.view, viewUid))
val users: List[User] = privileges.flatMap(_.user.obj)
users.toSet
}
def createPublicView(bankId: BankId, accountId: AccountId, description: String = "Public View") : Box[View] = {
getExistingView(bankId, accountId, "Public") match {
case Empty=> createDefaultPublicView(bankId, accountId, description)
@ -574,7 +580,6 @@ object MapperViews extends Views with Loggable {
privilegesDeleted
}
def removeAllViews(bankId: BankId, accountId: AccountId) : Boolean = {
ViewImpl.bulkDelete_!!(
By(ViewImpl.bankPermalink, bankId.value),
@ -582,6 +587,11 @@ object MapperViews extends Views with Loggable {
)
}
def bulkDeleteAllPermissionsAndViews() : Boolean = {
ViewImpl.bulkDelete_!!()
ViewPrivileges.bulkDelete_!!()
true
}
def unsavedOwnerView(bankId : BankId, accountId: AccountId, description: String) : ViewImpl = {
create

63
src/main/scala/code/views/Views.scala
View File

@ -5,42 +5,43 @@ import code.model._
import net.liftweb.util.SimpleInjector
import code.model.Permission
import code.model.CreateViewJSON
import code.remotedata.Remotedata
object Views extends SimpleInjector {
val views = new Inject(buildOne _) {}
//TODO Remove MapperViews when AkkaMapperViews is optimized and stable
def buildOne: Views = MapperViews
//def buildOne: Views = AkkaMapperViews
//TODO Remove MapperViews when Remotedata is optimized and stable
//def buildOne: Views = MapperViews
def buildOne: Views = Remotedata
}
trait Views {
def permissions(account : BankAccount) : List[Permission]
def permission(account : BankAccount, user: User) : Box[Permission]
def permissions(account : BankAccountUID) : List[Permission]
def permission(account : BankAccountUID, user: User) : Box[Permission]
def addPermission(viewUID : ViewUID, user : User) : Box[View]
def addPermissions(views : List[ViewUID], user : User) : Box[List[View]]
def revokePermission(viewUID : ViewUID, user : User) : Box[Boolean]
def revokeAllPermissions(bankId : BankId, accountId : AccountId, user : User) : Box[Boolean]
def view(viewId : ViewId, bankAccount: BankAccount) : Box[View]
def view(viewId : ViewId, bankAccountId: BankAccountUID) : Box[View]
def view(viewUID : ViewUID) : Box[View]
def createView(bankAccount : BankAccount, view: CreateViewJSON) : Box[View]
def removeView(viewId : ViewId, bankAccount: BankAccount): Box[Unit]
def updateView(bankAccount : BankAccount, viewId : ViewId, viewUpdateJson : UpdateViewJSON) : Box[View]
def views(bankAccount : BankAccount) : List[View]
def permittedViews(user: User, bankAccount: BankAccount): List[View]
def publicViews(bankAccount : BankAccount) : List[View]
def createView(bankAccountId: BankAccountUID, view: CreateViewJSON): Box[View]
def removeView(viewId: ViewId, bankAccountId: BankAccountUID): Box[Unit]
def updateView(bankAccountId : BankAccountUID, viewId : ViewId, viewUpdateJson : UpdateViewJSON) : Box[View]
def views(bankAccountId : BankAccountUID) : List[View]
def permittedViews(user: User, bankAccountId: BankAccountUID): List[View]
def publicViews(bankAccountId : BankAccountUID) : List[View]
def getAllPublicAccounts : List[BankAccount]
def getPublicBankAccounts(bank : Bank) : List[BankAccount]
def getAllAccountsUserCanSee(user : Box[User]) : List[BankAccount]
def getAllAccountsUserCanSee(bank: Bank, user : Box[User]) : List[BankAccount]
def getNonPublicBankAccounts(user : User) : List[BankAccount]
def getNonPublicBankAccounts(user : User, bankId : BankId) : List[BankAccount]
def getAllPublicAccounts : List[BankAccountUID]
def getPublicBankAccounts(bank : Bank) : List[BankAccountUID]
def getAllAccountsUserCanSee(user : Box[User]) : List[BankAccountUID]
def getAllAccountsUserCanSee(bank: Bank, user : Box[User]) : List[BankAccountUID]
def getNonPublicBankAccounts(user : User) : List[BankAccountUID]
def getNonPublicBankAccounts(user : User, bankId : BankId) : List[BankAccountUID]
def createOwnerView(bankId: BankId, accountId: AccountId, description: String) : Box[View]
def createPublicView(bankId: BankId, accountId: AccountId, description: String) : Box[View]
@ -48,6 +49,8 @@ trait Views {
def createAuditorsView(bankId: BankId, accountId: AccountId, description: String) : Box[View]
def createRandomView(bankId: BankId, accountId: AccountId) : Box[View]
def getOwners(view: View): Set[User]
def grantAccessToView(user : User, view : View) : Boolean
def grantAccessToAllExistingViews(user : User) : Boolean
@ -55,23 +58,25 @@ trait Views {
def removeAllPermissions(bankId: BankId, accountId: AccountId) : Boolean
def removeAllViews(bankId: BankId, accountId: AccountId) : Boolean
def bulkDeleteAllPermissionsAndViews() : Boolean
}
class RemoteViewCaseClasses {
case class permissions(account: BankAccount)
case class permission(account: BankAccount, user: User)
case class permissions(account: BankAccountUID)
case class permission(account: BankAccountUID, user: User)
case class addPermission(viewUID: ViewUID, user: User)
case class addPermissions(views: List[ViewUID], user: User)
case class revokePermission(viewUID: ViewUID, user: User)
case class revokeAllPermissions(bankId: BankId, accountId: AccountId, user: User)
case class createView(bankAccount: BankAccount, view: CreateViewJSON)
case class removeView(viewId: ViewId, bankAccount: BankAccount)
case class updateView(bankAccount: BankAccount, viewId: ViewId, viewUpdateJson: UpdateViewJSON)
case class views(bankAccount: BankAccount)
case class permittedViews(user: User, bankAccount: BankAccount)
case class publicViews(bankAccount: BankAccount)
case class createView(bankAccountId: BankAccountUID, view: CreateViewJSON)
case class removeView(viewId: ViewId, bankAccountId: BankAccountUID)
case class updateView(bankAccountId: BankAccountUID, viewId: ViewId, viewUpdateJson: UpdateViewJSON)
case class views(bankAccountId: BankAccountUID)
case class permittedViews(user: User, bankAccountId: BankAccountUID)
case class publicViews(bankAccountId: BankAccountUID)
case class getAllPublicAccounts()
case class getPublicBankAccounts(bank: Bank)
case class getAllAccountsUserCanSee(pars: Any*) {
@ -84,7 +89,7 @@ class RemoteViewCaseClasses {
}
case class view(pars: Any*) {
def apply(viewUID: ViewUID): Box[View] = this (viewUID)
def apply(viewId: ViewId, bankAccount: BankAccount): Box[View] = this (viewId, bankAccount)
def apply(viewId: ViewId, bankAccountId: BankAccountUID): Box[View] = this (viewId, bankAccountId)
}
case class createOwnerView(bankId: BankId, accountId: AccountId, description: String)
case class createPublicView(bankId: BankId, accountId: AccountId, description: String)
@ -92,12 +97,16 @@ class RemoteViewCaseClasses {
case class createAuditorsView(bankId: BankId, accountId: AccountId, description: String)
case class createRandomView(bankId: BankId, accountId: AccountId)
case class getOwners(view: View)
case class grantAccessToView(user : User, view : View)
case class grantAccessToAllExistingViews(user : User)
case class viewExists(bank: BankId, accountId: AccountId, name: String)
case class removeAllPermissions(bankId: BankId, accountId: AccountId)
case class removeAllViews(bankId: BankId, accountId: AccountId)
case class bulkDeleteAllPermissionsAndViews()
}
object RemoteViewCaseClasses extends RemoteViewCaseClasses

22
src/test/scala/code/api/API121Test.scala
View File

@ -1965,19 +1965,19 @@ class API1_2_1Test extends User1AllPrivileges with DefaultUsers with PrivateUser
val bankAccount : AccountJSON = randomPrivateAccount(bankId)
val viewId = ViewId("owner")
val view = Views.views.vend.view(ViewUID(viewId, BankId(bankId), AccountId(bankAccount.id))).get
if(view.users.length == 0){
if(Views.views.vend.getOwners(view).toList.length == 0){
val userId = authuser2.idGivenByProvider
grantUserAccessToView(bankId, bankAccount.id, userId, viewId.value, user1)
}
while(view.users.length > 1){
revokeUserAccessToView(bankId, bankAccount.id, view.users(0).idGivenByProvider, viewId.value, user1)
while(Views.views.vend.getOwners(view).toList.length > 1){
revokeUserAccessToView(bankId, bankAccount.id, Views.views.vend.getOwners(view).toList(0).idGivenByProvider, viewId.value, user1)
}
val viewUsersBefore = view.users
val viewUsersBefore = Views.views.vend.getOwners(view).toList
When("the request is sent")
val reply = revokeUserAccessToView(bankId, bankAccount.id, viewUsersBefore(0).idGivenByProvider, viewId.value, user1)
Then("we should get a 400 code")
reply.code should equal (400)
val viewUsersAfter = view.users
val viewUsersAfter = Views.views.vend.getOwners(view).toList
viewUsersAfter.length should equal(viewUsersBefore.length)
}
@ -2009,7 +2009,7 @@ class API1_2_1Test extends User1AllPrivileges with DefaultUsers with PrivateUser
And("The account holder should still have access to the owner view")
val view = Views.views.vend.view(ViewUID(ownerViewId, BankId(bankId), AccountId(bankAccount.id))).get
view.users should contain (authuser3)
Views.views.vend.getOwners(view).toList should contain (authuser3)
}
scenario("we cannot revoke a user access to a view on an bank account because the view does not exist", API1_2, DeletePermission) {
@ -2093,8 +2093,8 @@ class API1_2_1Test extends User1AllPrivileges with DefaultUsers with PrivateUser
val view = Views.views.vend.view(ViewUID(viewId, BankId(bankId), AccountId(bankAccount.id))).get
val userId = authuser1.idGivenByProvider
view.users.length should equal(1)
view.users(0).idGivenByProvider should equal(userId)
Views.views.vend.getOwners(view).toList.length should equal(1)
Views.views.vend.getOwners(view).toList(0).idGivenByProvider should equal(userId)
When("the request is sent")
val reply = revokeUserAccessToAllViews(bankId, bankAccount.id, userId, user1)
@ -2102,8 +2102,8 @@ class API1_2_1Test extends User1AllPrivileges with DefaultUsers with PrivateUser
reply.code should equal (400)
And("The user should not have had his access revoked")
view.users.length should equal(1)
view.users(0).idGivenByProvider should equal(userId)
Views.views.vend.getOwners(view).toList.length should equal(1)
Views.views.vend.getOwners(view).toList(0).idGivenByProvider should equal(userId)
}
scenario("we cannot revoke the access of a user to owner view on a bank account via a revoke all views call" +
@ -2125,7 +2125,7 @@ class API1_2_1Test extends User1AllPrivileges with DefaultUsers with PrivateUser
And("The user should not have had his access revoked")
val view = Views.views.vend.view(ViewUID(ViewId("owner"), BankId(bankId), AccountId(bankAccount.id))).get
view.users should contain (authuser3)
Views.views.vend.getOwners(view).toList should contain (authuser3)
}
}

12
src/test/scala/code/api/API12Test.scala
View File

@ -1401,19 +1401,19 @@ class API1_2Test extends User1AllPrivileges with DefaultUsers {
val bankAccount : AccountJSON = randomPrivateAccount(bankId)
val viewId = ViewId("owner")
val view = Views.views.vend.view(ViewUID(viewId, BankId(bankId), AccountId(bankAccount.id))).get
if(view.users.length == 0){
if(Views.views.vend.getOwners(view).toList.length == 0){
val userId = authuser2.idGivenByProvider
grantUserAccessToView(bankId, bankAccount.id, userId, viewId.value, user1)
}
while(view.users.length > 1){
revokeUserAccessToView(bankId, bankAccount.id, view.users(0).idGivenByProvider, viewId.value, user1)
while(Views.views.vend.getOwners(view).toList.length > 1){
revokeUserAccessToView(bankId, bankAccount.id, Views.views.vend.getOwners(view).toList(0).idGivenByProvider, viewId.value, user1)
}
val viewUsersBefore = view.users
val viewUsersBefore = Views.views.vend.getOwners(view).toList
When("the request is sent")
val reply = revokeUserAccessToView(bankId, bankAccount.id, viewUsersBefore(0).idGivenByProvider, viewId.value, user1)
Then("we should get a 400 code")
reply.code should equal (400)
val viewUsersAfter = view.users
val viewUsersAfter = Views.views.vend.getOwners(view).toList
viewUsersAfter.length should equal(viewUsersBefore.length)
}
@ -1449,6 +1449,7 @@ class API1_2Test extends User1AllPrivileges with DefaultUsers {
reply.code should equal (400)
}
}
feature("Revoke a user access to all the views on a bank account"){
scenario("we will revoke the access of a user to all the views on an bank account", API1_2, DeletePermissions) {
Given("We will use an access token")
@ -1463,7 +1464,6 @@ class API1_2Test extends User1AllPrivileges with DefaultUsers {
Then("we should get a 204 no content code")
reply.code should equal (204)
}
scenario("we cannot revoke the access to a user that does not exist", API1_2, DeletePermissions) {
Given("We will use an access token with a random user Id")
val bankId = randomBank

12
src/test/scala/code/api/LocalMappedConnectorTestSetup.scala
View File

@ -1,16 +1,21 @@
package code.api
import java.util.{Date, UUID}
import java.beans.Introspector
import bootstrap.liftweb.ToSchemify
import code.accountholder.AccountHolders
import code.model._
import code.model.dataAccess._
import net.liftweb.common.Box
import net.liftweb.mapper.MetaMapper
import net.liftweb.util.Props
import net.liftweb.mapper.{MappedString, MetaMapper}
import net.liftweb.util.Helpers._
import code.entitlement.{Entitlement, MappedEntitlement}
import code.metadata.counterparties.{CounterpartyTrait, MappedCounterparty, MappedCounterpartyMetadata}
import code.transaction.MappedTransaction
import code.views.Views
import scala.util.Random
@ -118,6 +123,11 @@ trait LocalMappedConnectorTestSetup extends TestConnectorSetupWithStandardPermis
//empty the relational db tables after each test
ToSchemify.models.filterNot(exclusion).foreach(_.bulkDelete_!!())
ToSchemify.modelsRemotedata.filterNot(exclusion).foreach(_.bulkDelete_!!())
if (!Props.getBool("enable_remotedata", false)) {
ToSchemify.modelsRemotedata.filterNot(exclusion).foreach(_.bulkDelete_!!())
} else {
Views.views.vend.bulkDeleteAllPermissionsAndViews()
AccountHolders.accountHolders.vend.bulkDeleteAllAccountHolders()
}
}
}

9
src/test/scala/code/api/TestConnectorSetupWithStandardPermissions.scala
View File

@ -1,12 +1,14 @@
package code.api
import bootstrap.liftweb.ToSchemify
import code.accountholder.AccountHolders
import code.model.dataAccess._
import code.model._
import code.views.Views
import net.liftweb.mapper.MetaMapper
import net.liftweb.mongodb._
import net.liftweb.util.Helpers._
import net.liftweb.util.Props
/**
* Handles setting up views and permissions and account holders using ViewImpls, ViewPrivileges,
@ -15,7 +17,7 @@ import net.liftweb.util.Helpers._
trait TestConnectorSetupWithStandardPermissions extends TestConnectorSetup {
override protected def setAccountHolder(user: User, bankId : BankId, accountId : AccountId) = {
MappedAccountHolder.createMappedAccountHolder(user.resourceUserId.value, bankId.value, accountId.value, "TestConnectorSetupWithStandardPermissions")
AccountHolders.accountHolders.vend.createAccountHolder(user.resourceUserId.value, bankId.value, accountId.value, "TestConnectorSetupWithStandardPermissions")
}
override protected def grantAccessToAllExistingViews(user : User) = {
@ -51,6 +53,11 @@ trait TestConnectorSetupWithStandardPermissions extends TestConnectorSetup {
//empty the relational db tables after each test
ToSchemify.models.filterNot(exclusion).foreach(_.bulkDelete_!!())
if (!Props.getBool("enable_remotedata", false)) {
ToSchemify.modelsRemotedata.filterNot(exclusion).foreach(_.bulkDelete_!!())
} else {
Views.views.vend.bulkDeleteAllPermissionsAndViews()
AccountHolders.accountHolders.vend.bulkDeleteAllAccountHolders()
}
}
}

2
src/test/scala/code/bankaccountcreation/BankAccountCreationListenerTest.scala
View File

@ -52,7 +52,7 @@ class BankAccountCreationListenerTest extends ServerSetup with DefaultConnectorT
createdAccount.accountId.value.nonEmpty should be(true)
createdAccount.bankId.value should equal(expectedBankId)
createdAccount.number should equal(accountNumber)
createdAccount.accountId should equal(accountNumber)
And("The account holder should be set correctly")
Connector.connector.vend.getAccountHolders(BankId(expectedBankId), createdAccount.accountId) should equal(Set(user))

15
src/test/scala/code/sandbox/SandboxDataLoadingTest.scala
View File

@ -36,6 +36,7 @@ import java.util.Date
import bootstrap.liftweb.ToSchemify
import code.TestServer
import code.accountholder.AccountHolders
import code.api.{APIResponse, SendServerRequests}
import code.api.v1_2_1.APIMethods121
import code.atms.Atms
@ -48,7 +49,7 @@ import code.crm.CrmEvent.{CrmEvent, CrmEventId}
import code.products.Products
import code.products.Products.{Product, ProductCode, countOfProducts}
import code.model.dataAccess._
import code.model.{AccountId, BankId, TransactionId}
import code.model._
import code.products.Products.ProductCode
import code.users.Users
import code.views.Views
@ -91,7 +92,13 @@ class SandboxDataLoadingTest extends FlatSpec with SendServerRequests with Shoul
//drop database tables before
//MongoDB.getDb(DefaultMongoIdentifier).foreach(_.dropDatabase())
ToSchemify.models.foreach(_.bulkDelete_!!())
ToSchemify.modelsRemotedata.foreach(_.bulkDelete_!!())
if (!Props.getBool("enable_remotedata", false)) {
ToSchemify.modelsRemotedata.foreach(_.bulkDelete_!!())
} else {
Views.views.vend.bulkDeleteAllPermissionsAndViews()
Users.users.vend.bulkDeleteAllResourceUsers()
AccountHolders.accountHolders.vend.bulkDeleteAllAccountHolders()
}
}
@ -294,12 +301,12 @@ class SandboxDataLoadingTest extends FlatSpec with SendServerRequests with Shoul
val owner = Users.users.vend.getUserByProviderId(defaultProvider, foundAccount.owners.toList.head.name).get
//there should be an owner view
val views = Views.views.vend.permittedViews(owner, foundAccount)
val views = Views.views.vend.permittedViews(owner, BankAccountUID(foundAccount.bankId, foundAccount.accountId))
val ownerView = views.find(v => v.viewId.value == "owner")
ownerView.isDefined should equal(true)
//and the owners should have access to it
ownerView.get.users.map(_.idGivenByProvider).toSet should equal(account.owners.toSet)
Views.views.vend.getOwners(ownerView.get).map(_.idGivenByProvider) should equal(account.owners.toSet)
}
def verifyTransactionCreated(transaction : SandboxTransactionImport, accountsUsed : List[SandboxAccountImport]) = {