hub.user.service — hub.service/user 0.3.21

Service implementation details.

create! clj

(create! data)

(create! type data)

Inputs: ([data :- us/CreateInput] [type :- us/SignupType data :- us/CreateInput]) Returns: (s/either us/User OpError)

Creates a full user document using the supplied method; returns the created FullUser or PendingUser. For non-pending users, given email and username (if specified) must be unique.

delete-by-id! clj

(delete-by-id! user-id)

Inputs: [user-id :- us/UserID] Returns: s/Bool

Deletes the given FullUser or PendingUser, returns true if the id was deleted, or false if not.

email-and-username-ok? clj

(email-and-username-ok? prev-user type updates)

Inputs: [prev-user :- (s/named s/Any "previous user fragment.") type :- UserType updates :- (s/named s/Any "user fragment")] Returns: OpStatus

If the email or username is different in the proposed updates, it will check to see if they are allowed (for FullUsers). Email here is an EmailMap.

fulluser-table clj

(fulluser-table)

Returns a command for the full user table, suitable for chaining with other commands.

generate-user clj multimethod

Generates a user document off of the information provided for the supplied type. Signup gives username and password only, for example. Facebook gives a bit more.

generate-username clj

(generate-username {:keys [email first-name last-name]})

Inputs: [{:keys [email first-name last-name]} :- GenOptions] Returns: s/Str

Generates a random username for the supplied GenOptions map of seeding options. Tries concatenating the first and last names, taking just the first initial and last name, and the email prefix (before the @ sign). After that, attempts to generate a username. NOT guaranteed to terminate, but extremely likely :)

GenOptions clj

Options for username generation.

get-all-full-users clj

(get-all-full-users)

Inputs: [] Returns: [us/FullUser]

get-all-pending-users clj

(get-all-pending-users)

Inputs: [] Returns: [us/PendingUser]

get-user-by-email clj

(get-user-by-email email-address)

Inputs: [email-address :- s/Str] Returns: {:fulluser (s/maybe us/FullUser), :pending [us/PendingUser]}

Returns all matching full users and pending users for the given email.

get-user-by-fb-id clj

(get-user-by-fb-id fb-id)

Inputs: [fb-id :- s/Str] Returns: (s/maybe us/FullUser)

Does a lookup for a FullUser by facebook id.

get-user-by-id clj

(get-user-by-id id)

Inputs: [id :- us/UserID] Returns: (s/maybe us/User)

Returns the user for the given id. Could be a full user or pending user.

get-user-by-reset-code clj

(get-user-by-reset-code reset-code)

Inputs: [reset-code :- s/Str] Returns: (s/maybe us/FullUser)

get-users-by-emails clj

(get-users-by-emails emails)

Inputs: [emails :- [us/EMailAddress]] Returns: {:full {us/EMailAddress us/FullUser}, :pending {us/EMailAddress [us/PendingUser]}}

Returns all users that match the given emails, lower cased. Checks FullUsers (one match per email) and PendingUsers (might be multiple matches). Returns lowercased emails to Users.

get-users-by-ids clj

(get-users-by-ids ids)

Inputs: [ids :- [us/UserID]] Returns: {:full {us/UserID us/FullUser}, :pending {us/UserID us/PendingUser}}

Returns all users that match the given ids. Checks FullUsers and PendingUsers. Only one match per ID.

get-users-by-names clj

(get-users-by-names names)

Inputs: [names :- [us/FullName]] Returns: {:full {us/FullName [us/FullUser]}, :pending {us/FullName [us/PendingUser]}}

Returns those users (full and pending) that match the given name query with whitespace removed, and lowercased. We return downcased FullName to matches.

get-users-by-usernames clj

(get-users-by-usernames usernames)

Inputs: [usernames :- [us/UserName]] Returns: {:full {us/UserName us/FullUser}}

Returns the usernames for the given users. No pending users, each username only matches to one fulluser. Does a lowercase= match. Returns lowercased usernames to FullUser.

LookupValue clj

map-by clj

(map-by key-func val-func coll)

map-values clj

(map-values f m)

Maps the keyspace using the supplied function. Any duplicate keys will get knocked out in a nondeterministic order, so be careful!

merge-users! clj

(merge-users! {:keys [profile] :as primary-user-id} absorbed-user-id)

Inputs: [{:keys [profile], :as primary-user-id} :- us/UserID absorbed-user-id :- us/UserID] Returns: (s/maybe us/User)

Merges absorbed user into primary user. Returns the primary with the newly merged fields. You can merge pending into pending, full into full, pending into full, but NOT full into pending.

OpError clj

OpStatus clj

OpSuccess clj

pendinguser-table clj

(pendinguser-table)

Returns a command for the pending user table, suitable for chaining with other commands.

put! clj

(put! {:keys [id] :as new-user})

Inputs: [{:keys [id], :as new-user} :- us/User] Returns: (s/either us/User OpError)

Puts the user-doc with the desired changes. Cant change id. Email and username must be unique for FullUsers. Works for FullUsers and PendingUsers. Returns the newly put user, if the id was valid.

put-bulk! clj

(put-bulk! docs)

Inputs: [docs :- [us/User]]

run-fulluser clj/s macro

(run-fulluser & commands)

Runs a command on the user table.

run-pendinguser clj/s macro

(run-pendinguser & commands)

Runs a command on the user table.

search-full clj

(search-full query)

Inputs: [query :- s/Str]

Searches first name, last name, full name, email address, and username.

search-pending clj

(search-pending query)

Inputs: [query :- s/Str]

Searches name (or fragment) and email address.

try-lower-case clj

(try-lower-case s)

Inputs: [s :- (s/maybe s/Str)] Returns: (s/maybe s/Str)

try-remove-spaces clj

(try-remove-spaces s)

Inputs: [s :- (s/maybe s/Str)] Returns: (s/maybe s/Str)

update! clj

(update! user updates)

Inputs: [user :- (s/either us/UserID us/User) updates :- {s/Any s/Any}] Returns: (s/either us/User OpError)

Updates the user with the given id by merging it with the new map. Can't update id. Works for FullUsers and PendingUsers. Returns the record for the updated user, or nil if the user-id was invalid. Note that this is a deep merge - nested fields get merged in, other keys in the nested field are unaffected.

user-type clj

(user-type user)

Inputs: [user :- us/User] Returns: UserType

Returns the user type, depending on whether or not a :username is present.

UserType clj

winner clj

(winner candidates)

Inputs: [candidates :- [(s/maybe s/Str)]] Returns: (s/maybe s/Str)

Queries the database for all supplied username candidates. Returns the first candidate that doesn't already exist in the database, or nil if they all do.