288 lines
11 KiB
Forth
288 lines
11 KiB
Forth
[<AutoOpen>]
|
|
module PrayerTracker.DataAccess
|
|
|
|
open System.Linq
|
|
open PrayerTracker.Entities
|
|
|
|
[<AutoOpen>]
|
|
module private Helpers =
|
|
|
|
/// Central place to append sort criteria for prayer request queries
|
|
let reqSort sort (q : IQueryable<PrayerRequest>) =
|
|
match sort with
|
|
| SortByDate ->
|
|
q.OrderByDescending(fun req -> req.updatedDate)
|
|
.ThenByDescending(fun req -> req.enteredDate)
|
|
.ThenBy (fun req -> req.requestor)
|
|
| SortByRequestor ->
|
|
q.OrderBy(fun req -> req.requestor)
|
|
.ThenByDescending(fun req -> req.updatedDate)
|
|
.ThenByDescending (fun req -> req.enteredDate)
|
|
|
|
/// Paginate a prayer request query
|
|
let paginate pageNbr pageSize (q : IQueryable<PrayerRequest>) =
|
|
q.Skip((pageNbr - 1) * pageSize).Take pageSize
|
|
|
|
|
|
open System.Collections.Generic
|
|
open Microsoft.EntityFrameworkCore
|
|
open Microsoft.FSharpLu
|
|
|
|
type AppDbContext with
|
|
|
|
(*-- DISCONNECTED DATA EXTENSIONS --*)
|
|
|
|
/// Add an entity entry to the tracked data context with the status of Added
|
|
member this.AddEntry<'TEntity when 'TEntity : not struct> (e : 'TEntity) =
|
|
this.Entry<'TEntity>(e).State <- EntityState.Added
|
|
|
|
/// Add an entity entry to the tracked data context with the status of Updated
|
|
member this.UpdateEntry<'TEntity when 'TEntity : not struct> (e : 'TEntity) =
|
|
this.Entry<'TEntity>(e).State <- EntityState.Modified
|
|
|
|
/// Add an entity entry to the tracked data context with the status of Deleted
|
|
member this.RemoveEntry<'TEntity when 'TEntity : not struct> (e : 'TEntity) =
|
|
this.Entry<'TEntity>(e).State <- EntityState.Deleted
|
|
|
|
(*-- CHURCH EXTENSIONS --*)
|
|
|
|
/// Find a church by its Id
|
|
member this.TryChurchById cId = backgroundTask {
|
|
let! church = this.Churches.SingleOrDefaultAsync (fun ch -> ch.churchId = cId)
|
|
return Option.fromObject church
|
|
}
|
|
|
|
/// Find all churches
|
|
member this.AllChurches () = backgroundTask {
|
|
let! churches = this.Churches.OrderBy(fun ch -> ch.name).ToListAsync ()
|
|
return List.ofSeq churches
|
|
}
|
|
|
|
(*-- MEMBER EXTENSIONS --*)
|
|
|
|
/// Get a small group member by its Id
|
|
member this.TryMemberById mbrId = backgroundTask {
|
|
let! mbr = this.Members.SingleOrDefaultAsync (fun m -> m.memberId = mbrId)
|
|
return Option.fromObject mbr
|
|
}
|
|
|
|
/// Find all members for a small group
|
|
member this.AllMembersForSmallGroup gId = backgroundTask {
|
|
let! members =
|
|
this.Members.Where(fun mbr -> mbr.smallGroupId = gId)
|
|
.OrderBy(fun mbr -> mbr.memberName)
|
|
.ToListAsync ()
|
|
return List.ofSeq members
|
|
}
|
|
|
|
/// Count members for a small group
|
|
member this.CountMembersForSmallGroup gId = backgroundTask {
|
|
return! this.Members.CountAsync (fun m -> m.smallGroupId = gId)
|
|
}
|
|
|
|
(*-- PRAYER REQUEST EXTENSIONS --*)
|
|
|
|
/// Get a prayer request by its Id
|
|
member this.TryRequestById reqId = backgroundTask {
|
|
let! req = this.PrayerRequests.SingleOrDefaultAsync (fun r -> r.prayerRequestId = reqId)
|
|
return Option.fromObject req
|
|
}
|
|
|
|
/// Get all (or active) requests for a small group as of now or the specified date
|
|
member this.AllRequestsForSmallGroup (grp : SmallGroup) clock listDate activeOnly pageNbr = backgroundTask {
|
|
let theDate = match listDate with Some dt -> dt | _ -> grp.localDateNow clock
|
|
let query =
|
|
this.PrayerRequests.Where(fun req -> req.smallGroupId = grp.smallGroupId)
|
|
|> function
|
|
| q when activeOnly ->
|
|
let asOf = theDate.AddDays(-(float grp.preferences.daysToExpire)).Date
|
|
q.Where(fun req ->
|
|
( req.updatedDate > asOf
|
|
|| req.expiration = Manual
|
|
|| req.requestType = LongTermRequest
|
|
|| req.requestType = Expecting)
|
|
&& req.expiration <> Forced)
|
|
|> reqSort grp.preferences.requestSort
|
|
|> paginate pageNbr grp.preferences.pageSize
|
|
| q -> reqSort grp.preferences.requestSort q
|
|
let! reqs = query.ToListAsync ()
|
|
return List.ofSeq reqs
|
|
}
|
|
|
|
/// Count prayer requests for the given small group Id
|
|
member this.CountRequestsBySmallGroup gId = backgroundTask {
|
|
return! this.PrayerRequests.CountAsync (fun pr -> pr.smallGroupId = gId)
|
|
}
|
|
|
|
/// Count prayer requests for the given church Id
|
|
member this.CountRequestsByChurch cId = backgroundTask {
|
|
return! this.PrayerRequests.CountAsync (fun pr -> pr.smallGroup.churchId = cId)
|
|
}
|
|
|
|
/// Get all (or active) requests for a small group as of now or the specified date
|
|
member this.SearchRequestsForSmallGroup (grp : SmallGroup) (searchTerm : string) pageNbr = backgroundTask {
|
|
let sql = """
|
|
SELECT * FROM pt."PrayerRequest" WHERE "SmallGroupId" = {0} AND "Text" ILIKE {1}
|
|
UNION
|
|
SELECT * FROM pt."PrayerRequest" WHERE "SmallGroupId" = {0} AND COALESCE("Requestor", '') ILIKE {1}"""
|
|
let like = sprintf "%%%s%%"
|
|
let query =
|
|
this.PrayerRequests.FromSqlRaw(sql, grp.smallGroupId, like searchTerm)
|
|
|> reqSort grp.preferences.requestSort
|
|
|> paginate pageNbr grp.preferences.pageSize
|
|
let! reqs = query.ToListAsync ()
|
|
return List.ofSeq reqs
|
|
}
|
|
|
|
(*-- SMALL GROUP EXTENSIONS --*)
|
|
|
|
/// Find a small group by its Id
|
|
member this.TryGroupById gId = backgroundTask {
|
|
let! grp =
|
|
this.SmallGroups.Include(fun sg -> sg.preferences)
|
|
.SingleOrDefaultAsync (fun sg -> sg.smallGroupId = gId)
|
|
return Option.fromObject grp
|
|
}
|
|
|
|
/// Get small groups that are public or password protected
|
|
member this.PublicAndProtectedGroups () = backgroundTask {
|
|
let! groups =
|
|
this.SmallGroups.Include(fun sg -> sg.preferences).Include(fun sg -> sg.church)
|
|
.Where(fun sg ->
|
|
sg.preferences.isPublic
|
|
|| (sg.preferences.groupPassword <> null && sg.preferences.groupPassword <> ""))
|
|
.OrderBy(fun sg -> sg.church.name).ThenBy(fun sg -> sg.name)
|
|
.ToListAsync ()
|
|
return List.ofSeq groups
|
|
}
|
|
|
|
/// Get small groups that are password protected
|
|
member this.ProtectedGroups () = backgroundTask {
|
|
let! groups =
|
|
this.SmallGroups.Include(fun sg -> sg.church)
|
|
.Where(fun sg -> sg.preferences.groupPassword <> null && sg.preferences.groupPassword <> "")
|
|
.OrderBy(fun sg -> sg.church.name).ThenBy(fun sg -> sg.name)
|
|
.ToListAsync ()
|
|
return List.ofSeq groups
|
|
}
|
|
|
|
/// Get all small groups
|
|
member this.AllGroups () = backgroundTask {
|
|
let! groups =
|
|
this.SmallGroups
|
|
.Include(fun sg -> sg.church)
|
|
.Include(fun sg -> sg.preferences)
|
|
.Include(fun sg -> sg.preferences.timeZone)
|
|
.OrderBy(fun sg -> sg.name)
|
|
.ToListAsync ()
|
|
return List.ofSeq groups
|
|
}
|
|
|
|
/// Get a small group list by their Id, with their church prepended to their name
|
|
member this.GroupList () = backgroundTask {
|
|
let! groups =
|
|
this.SmallGroups.Include(fun sg -> sg.church)
|
|
.OrderBy(fun sg -> sg.church.name).ThenBy(fun sg -> sg.name)
|
|
.ToListAsync ()
|
|
return groups
|
|
|> Seq.map (fun sg -> sg.smallGroupId.ToString "N", $"{sg.church.name} | {sg.name}")
|
|
|> List.ofSeq
|
|
}
|
|
|
|
/// Log on a small group
|
|
member this.TryGroupLogOnByPassword gId pw = backgroundTask {
|
|
match! this.TryGroupById gId with
|
|
| None -> return None
|
|
| Some grp -> return if pw = grp.preferences.groupPassword then Some grp else None
|
|
}
|
|
|
|
/// Check a cookie log on for a small group
|
|
member this.TryGroupLogOnByCookie gId pwHash (hasher : string -> string) = backgroundTask {
|
|
match! this.TryGroupById gId with
|
|
| None -> return None
|
|
| Some grp -> return if pwHash = hasher grp.preferences.groupPassword then Some grp else None
|
|
}
|
|
|
|
/// Count small groups for the given church Id
|
|
member this.CountGroupsByChurch cId = backgroundTask {
|
|
return! this.SmallGroups.CountAsync (fun sg -> sg.churchId = cId)
|
|
}
|
|
|
|
(*-- TIME ZONE EXTENSIONS --*)
|
|
|
|
/// Get a time zone by its Id
|
|
member this.TryTimeZoneById tzId = backgroundTask {
|
|
let! zone = this.TimeZones.SingleOrDefaultAsync (fun tz -> tz.timeZoneId = tzId)
|
|
return Option.fromObject zone
|
|
}
|
|
|
|
/// Get all time zones
|
|
member this.AllTimeZones () = backgroundTask {
|
|
let! zones = this.TimeZones.OrderBy(fun tz -> tz.sortOrder).ToListAsync ()
|
|
return List.ofSeq zones
|
|
}
|
|
|
|
(*-- USER EXTENSIONS --*)
|
|
|
|
/// Find a user by its Id
|
|
member this.TryUserById uId = backgroundTask {
|
|
let! usr = this.Users.SingleOrDefaultAsync (fun u -> u.userId = uId)
|
|
return Option.fromObject usr
|
|
}
|
|
|
|
/// Find a user by its e-mail address and authorized small group
|
|
member this.TryUserByEmailAndGroup email gId = backgroundTask {
|
|
let! usr =
|
|
this.Users.SingleOrDefaultAsync (fun u ->
|
|
u.emailAddress = email && u.smallGroups.Any (fun xref -> xref.smallGroupId = gId))
|
|
return Option.fromObject usr
|
|
}
|
|
|
|
/// Find a user by its Id, eagerly loading the user's groups
|
|
member this.TryUserByIdWithGroups uId = backgroundTask {
|
|
let! usr = this.Users.Include(fun u -> u.smallGroups).SingleOrDefaultAsync (fun u -> u.userId = uId)
|
|
return Option.fromObject usr
|
|
}
|
|
|
|
/// Get a list of all users
|
|
member this.AllUsers () = backgroundTask {
|
|
let! users = this.Users.OrderBy(fun u -> u.lastName).ThenBy(fun u -> u.firstName).ToListAsync ()
|
|
return List.ofSeq users
|
|
}
|
|
|
|
/// Get all PrayerTracker users as members (used to send e-mails)
|
|
member this.AllUsersAsMembers () = backgroundTask {
|
|
let! users = this.AllUsers ()
|
|
return users |> List.map (fun u -> { Member.empty with email = u.emailAddress; memberName = u.fullName })
|
|
}
|
|
|
|
/// Find a user based on their credentials
|
|
member this.TryUserLogOnByPassword email pwHash gId = backgroundTask {
|
|
let! usr =
|
|
this.Users.SingleOrDefaultAsync (fun u ->
|
|
u.emailAddress = email
|
|
&& u.passwordHash = pwHash
|
|
&& u.smallGroups.Any (fun xref -> xref.smallGroupId = gId))
|
|
return Option.fromObject usr
|
|
}
|
|
|
|
/// Find a user based on credentials stored in a cookie
|
|
member this.TryUserLogOnByCookie uId gId pwHash = backgroundTask {
|
|
match! this.TryUserByIdWithGroups uId with
|
|
| None -> return None
|
|
| Some usr ->
|
|
if pwHash = usr.passwordHash && usr.smallGroups |> Seq.exists (fun xref -> xref.smallGroupId = gId) then
|
|
return Some { usr with passwordHash = ""; salt = None; smallGroups = List<UserSmallGroup>() }
|
|
else return None
|
|
}
|
|
|
|
/// Count the number of users for a small group
|
|
member this.CountUsersBySmallGroup gId = backgroundTask {
|
|
return! this.Users.CountAsync (fun u -> u.smallGroups.Any (fun xref -> xref.smallGroupId = gId))
|
|
}
|
|
|
|
/// Count the number of users for a church
|
|
member this.CountUsersByChurch cId = backgroundTask {
|
|
return! this.Users.CountAsync (fun u -> u.smallGroups.Any (fun xref -> xref.smallGroup.churchId = cId))
|
|
}
|