133 lines
5.0 KiB
Forth
133 lines
5.0 KiB
Forth
// Learn more about F# at http://docs.microsoft.com/dotnet/fsharp
|
|
|
|
open FSharp.Control.Tasks
|
|
open System
|
|
open System.Linq
|
|
open JobsJobsJobs.Api.Data
|
|
open JobsJobsJobs.Domain
|
|
open JobsJobsJobs.Server.Data
|
|
open Microsoft.EntityFrameworkCore
|
|
open Microsoft.Extensions.Hosting
|
|
open Microsoft.Extensions.DependencyInjection
|
|
open Microsoft.Extensions.Logging
|
|
open RethinkDb.Driver.Net
|
|
|
|
/// Create the host (reads configuration and initializes both databases)
|
|
let createHostBuilder argv =
|
|
Host.CreateDefaultBuilder(argv)
|
|
.ConfigureServices(
|
|
Action<HostBuilderContext, IServiceCollection> (
|
|
fun hostCtx svcs ->
|
|
svcs.AddSingleton hostCtx.Configuration |> ignore
|
|
// PostgreSQL via EF Core
|
|
svcs.AddDbContext<JobsDbContext>(fun options ->
|
|
options.UseNpgsql(hostCtx.Configuration.["ConnectionStrings:JobsDb"],
|
|
fun o -> o.UseNodaTime() |> ignore)
|
|
|> ignore)
|
|
|> ignore
|
|
// RethinkDB
|
|
let cfg = hostCtx.Configuration.GetSection "Rethink"
|
|
let log = svcs.BuildServiceProvider().GetRequiredService<ILoggerFactory>().CreateLogger "Data"
|
|
let conn = Startup.createConnection cfg log
|
|
svcs.AddSingleton conn |> ignore
|
|
Startup.establishEnvironment cfg log conn |> awaitIgnore
|
|
))
|
|
.Build()
|
|
|
|
[<EntryPoint>]
|
|
let main argv =
|
|
let host = createHostBuilder argv
|
|
let r = RethinkDb.Driver.RethinkDB.R
|
|
|
|
use db = host.Services.GetRequiredService<JobsDbContext> ()
|
|
let conn = host.Services.GetRequiredService<IConnection> ()
|
|
|
|
task {
|
|
// Migrate continents
|
|
let mutable continentXref = Map.empty<string, Types.ContinentId>
|
|
let! continents = db.Continents.AsNoTracking().ToListAsync ()
|
|
let reContinents =
|
|
continents
|
|
|> Seq.map (fun c ->
|
|
let reContinentId = ContinentId.create ()
|
|
continentXref <- continentXref.Add (string c.Id, reContinentId)
|
|
let it : Types.Continent = {
|
|
id = reContinentId
|
|
name = c.Name
|
|
}
|
|
it)
|
|
|> List.ofSeq
|
|
let! _ = r.Table(Table.Continent).Insert(reContinents).RunWriteAsync conn
|
|
|
|
// Migrate citizens
|
|
let mutable citizenXref = Map.empty<string, Types.CitizenId>
|
|
let! citizens = db.Citizens.AsNoTracking().ToListAsync ()
|
|
let reCitizens =
|
|
citizens
|
|
|> Seq.map (fun c ->
|
|
let reCitizenId = CitizenId.create ()
|
|
citizenXref <- citizenXref.Add (string c.Id, reCitizenId)
|
|
let it : Types.Citizen = {
|
|
id = reCitizenId
|
|
naUser = c.NaUser
|
|
displayName = Option.ofObj c.DisplayName
|
|
realName = Option.ofObj c.RealName
|
|
profileUrl = c.ProfileUrl
|
|
joinedOn = c.JoinedOn
|
|
lastSeenOn = c.LastSeenOn
|
|
}
|
|
it)
|
|
let! _ = r.Table(Table.Citizen).Insert(reCitizens).RunWriteAsync conn
|
|
|
|
// Migrate profile information (includes skills)
|
|
let! profiles = db.Profiles.AsNoTracking().ToListAsync ()
|
|
let reProfiles =
|
|
profiles
|
|
|> Seq.map (fun p ->
|
|
let skills = db.Skills.AsNoTracking().Where(fun s -> s.CitizenId = p.Id).ToList ()
|
|
let reSkills =
|
|
skills
|
|
|> Seq.map (fun skill ->
|
|
let it : Types.Skill = {
|
|
id = SkillId.create()
|
|
description = skill.Description
|
|
notes = Option.ofObj skill.Notes
|
|
}
|
|
it)
|
|
|> List.ofSeq
|
|
let it : Types.Profile = {
|
|
id = citizenXref.[string p.Id]
|
|
seekingEmployment = p.SeekingEmployment
|
|
isPublic = p.IsPublic
|
|
continentId = continentXref.[string p.ContinentId]
|
|
region = p.Region
|
|
remoteWork = p.RemoteWork
|
|
fullTime = p.FullTime
|
|
biography = Types.Text (string p.Biography)
|
|
lastUpdatedOn = p.LastUpdatedOn
|
|
experience = match p.Experience with null -> None | x -> (string >> Types.Text >> Some) x
|
|
skills = reSkills
|
|
}
|
|
it)
|
|
let! _ = r.Table(Table.Profile).Insert(reProfiles).RunWriteAsync conn
|
|
|
|
// Migrate success stories
|
|
let! successes = db.Successes.AsNoTracking().ToListAsync ()
|
|
let reSuccesses =
|
|
successes
|
|
|> Seq.map (fun s ->
|
|
let it : Types.Success = {
|
|
id = SuccessId.create ()
|
|
citizenId = citizenXref.[string s.CitizenId]
|
|
recordedOn = s.RecordedOn
|
|
fromHere = s.FromHere
|
|
source = "profile"
|
|
story = match s.Story with null -> None | x -> (string >> Types.Text >> Some) x
|
|
}
|
|
it)
|
|
let! _ = r.Table(Table.Success).Insert(reSuccesses).RunWriteAsync conn
|
|
()
|
|
}
|
|
|> awaitIgnore
|
|
|
|
0 |