import * as Sequelize from 'sequelize'
-
import {
- isUserUsernameValid,
- isAccountPublicKeyValid,
- isAccountUrlValid,
- isAccountPrivateKeyValid,
+ activityPubContextify,
isAccountFollowersCountValid,
isAccountFollowingCountValid,
- isAccountInboxValid,
- isAccountOutboxValid,
- isAccountSharedInboxValid,
- isAccountFollowersValid,
- isAccountFollowingValid,
- activityPubContextify
+ isAccountPrivateKeyValid,
+ isAccountPublicKeyValid,
+ isUserUsernameValid
} from '../../helpers'
-
-import { addMethodsToModel, getSort } from '../utils'
-import {
- AccountInstance,
- AccountAttributes,
-
- AccountMethods
-} from './account-interface'
-import { sendDeleteAccount } from '../../lib/activitypub/send-request'
+import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
import { CONFIG, CONSTRAINTS_FIELDS } from '../../initializers/constants'
+import { sendDeleteAccount } from '../../lib/activitypub/send/send-delete'
+import { addMethodsToModel } from '../utils'
+import { AccountAttributes, AccountInstance, AccountMethods } from './account-interface'
let Account: Sequelize.Model<AccountInstance, AccountAttributes>
-let loadAccountByServerAndUUID: AccountMethods.LoadAccountByServerAndUUID
let load: AccountMethods.Load
let loadApplication: AccountMethods.LoadApplication
let loadByUUID: AccountMethods.LoadByUUID
let loadByUrl: AccountMethods.LoadByUrl
let loadLocalByName: AccountMethods.LoadLocalByName
let loadByNameAndHost: AccountMethods.LoadByNameAndHost
-let listOwned: AccountMethods.ListOwned
+let listByFollowersUrls: AccountMethods.ListByFollowersUrls
let isOwned: AccountMethods.IsOwned
let toActivityPubObject: AccountMethods.ToActivityPubObject
let toFormattedJSON: AccountMethods.ToFormattedJSON
allowNull: false,
validate: {
urlValid: value => {
- const res = isAccountUrlValid(value)
+ const res = isActivityPubUrlValid(value)
if (res === false) throw new Error('URL is not valid.')
}
}
},
publicKey: {
type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.PUBLIC_KEY.max),
- allowNull: false,
+ allowNull: true,
validate: {
publicKeyValid: value => {
const res = isAccountPublicKeyValid(value)
allowNull: false,
validate: {
inboxUrlValid: value => {
- const res = isAccountInboxValid(value)
+ const res = isActivityPubUrlValid(value)
if (res === false) throw new Error('Inbox URL is not valid.')
}
}
allowNull: false,
validate: {
outboxUrlValid: value => {
- const res = isAccountOutboxValid(value)
+ const res = isActivityPubUrlValid(value)
if (res === false) throw new Error('Outbox URL is not valid.')
}
}
allowNull: false,
validate: {
sharedInboxUrlValid: value => {
- const res = isAccountSharedInboxValid(value)
+ const res = isActivityPubUrlValid(value)
if (res === false) throw new Error('Shared inbox URL is not valid.')
}
}
allowNull: false,
validate: {
followersUrlValid: value => {
- const res = isAccountFollowersValid(value)
+ const res = isActivityPubUrlValid(value)
if (res === false) throw new Error('Followers URL is not valid.')
}
}
allowNull: false,
validate: {
followingUrlValid: value => {
- const res = isAccountFollowingValid(value)
+ const res = isActivityPubUrlValid(value)
if (res === false) throw new Error('Following URL is not valid.')
}
}
const classMethods = [
associate,
- loadAccountByServerAndUUID,
loadApplication,
load,
loadByUUID,
loadByUrl,
loadLocalByName,
loadByNameAndHost,
- listOwned
+ listByFollowersUrls
]
const instanceMethods = [
isOwned,
name: 'accountId',
allowNull: false
},
- as: 'following',
onDelete: 'cascade'
})
return this.serverId === null
}
-getFollowerSharedInboxUrls = function (this: AccountInstance) {
+getFollowerSharedInboxUrls = function (this: AccountInstance, t: Sequelize.Transaction) {
const query: Sequelize.FindOptions<AccountAttributes> = {
attributes: [ 'sharedInboxUrl' ],
include: [
targetAccountId: this.id
}
}
- ]
+ ],
+ transaction: t
}
return Account.findAll(query)
// ------------------------------ STATICS ------------------------------
-listOwned = function () {
- const query: Sequelize.FindOptions<AccountAttributes> = {
- where: {
- serverId: null
- }
- }
-
- return Account.findAll(query)
-}
-
loadApplication = function () {
return Account.findOne({
include: [
return Account.findOne(query)
}
-loadAccountByServerAndUUID = function (uuid: string, serverId: number, transaction: Sequelize.Transaction) {
+listByFollowersUrls = function (followersUrls: string[], transaction?: Sequelize.Transaction) {
const query: Sequelize.FindOptions<AccountAttributes> = {
where: {
- serverId,
- uuid
+ followersUrl: {
+ [Sequelize.Op.in]: followersUrls
+ }
},
transaction
}
- return Account.find(query)
+ return Account.findAll(query)
}