487 lines
15 KiB
Go
487 lines
15 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/agnivade/levenshtein"
|
|
"github.com/slack-go/slack"
|
|
)
|
|
|
|
// Update planning center database tables with data from PC API.
|
|
func UpdatePCData() {
|
|
// Get all people.
|
|
allPeople, err := PCGetAll("/services/v2/people")
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
// For each person, parse data and save to database.
|
|
for _, data := range allPeople {
|
|
// Parse the ID and attributes.
|
|
id := data.GetUint64("id")
|
|
attributes := data.GetDict("attributes")
|
|
|
|
// Check if this person is already in our database.
|
|
var p People
|
|
app.db.Where("id = ?", id).First(&p)
|
|
|
|
// Update all fields with new data.
|
|
p.UpdatedAt = attributes.GetDate("updated_at")
|
|
p.ArchivedAt = attributes.GetDate("archived_at")
|
|
p.Birthdate = attributes.GetDate("birthdate")
|
|
p.Anniversary = attributes.GetDate("anniversary")
|
|
p.Status = attributes.GetString("status")
|
|
p.Permissions = attributes.GetString("permissions")
|
|
p.FirstName = attributes.GetString("first_name")
|
|
p.LastName = attributes.GetString("last_name")
|
|
p.FacebookID = attributes.GetUint64("facebook_id")
|
|
|
|
// If the person wasn't in the database, create it.
|
|
if p.ID == 0 {
|
|
p.ID = id
|
|
p.CreatedAt = attributes.GetDate("created_at")
|
|
app.db.Create(&p)
|
|
} else {
|
|
// If th e person was in the database, update it.
|
|
app.db.Save(&p)
|
|
}
|
|
}
|
|
|
|
// Get service types.
|
|
allServiceTypes, err := PCGetAll("/services/v2/service_types")
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
// Keep track of service type IDs incase no filter is supplied.
|
|
var allServiceTypeIDs []uint64
|
|
// For each service type, parse data and save to database.
|
|
for _, data := range allServiceTypes {
|
|
// Get the service ID and attributes.
|
|
id := data.GetUint64("id")
|
|
allServiceTypeIDs = append(allServiceTypeIDs, id)
|
|
attributes := data.GetDict("attributes")
|
|
|
|
// Check if service type was already in database.
|
|
var s ServiceTypes
|
|
app.db.Where("id = ?", id).First(&s)
|
|
|
|
// Update fields with new data.
|
|
s.UpdatedAt = attributes.GetDate("updated_at")
|
|
s.ArchivedAt = attributes.GetDate("archived_at")
|
|
s.DeletedAt = attributes.GetDate("deleted_at")
|
|
s.Name = attributes.GetString("name")
|
|
|
|
// If service type wasn't already existing, create it.
|
|
if s.ID == 0 {
|
|
s.ID = id
|
|
s.CreatedAt = attributes.GetDate("created_at")
|
|
app.db.Create(&s)
|
|
} else {
|
|
// Save if already existing/
|
|
app.db.Save(&s)
|
|
}
|
|
}
|
|
|
|
// Get service type filter from the config.
|
|
servicesTypesToPull := app.config.PlanningCenter.ServiceTypeIDs
|
|
// If no filter, use the found service types above.
|
|
if len(servicesTypesToPull) == 0 {
|
|
servicesTypesToPull = allServiceTypeIDs
|
|
}
|
|
|
|
// For each service type, pull plans and plan info.
|
|
for _, serviceTypeID := range servicesTypesToPull {
|
|
// Get the plans for this service type.
|
|
allPlans, err := PCGetAll(fmt.Sprintf("/services/v2/service_types/%d/plans", serviceTypeID))
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
// For each plan, update data in database and pull other plan releated items for updates.
|
|
for _, data := range allPlans {
|
|
// Get the plan ID and attributes.
|
|
planID := data.GetUint64("id")
|
|
attributes := data.GetDict("attributes")
|
|
|
|
// Check if plan was already in the database.
|
|
var p Plans
|
|
app.db.Where("id = ?", planID).First(&p)
|
|
|
|
// Update with new data.
|
|
p.UpdatedAt = attributes.GetDate("updated_at")
|
|
p.SeriesTitle = attributes.GetString("series_title")
|
|
p.Title = attributes.GetString("title")
|
|
p.FirstTimeAt = attributes.GetDate("sort_date")
|
|
p.LastTimeAt = attributes.GetDate("last_time_at")
|
|
p.MultiDay = attributes.GetBool("multi_day")
|
|
p.Dates = attributes.GetString("dates")
|
|
|
|
// If plan wasn't already created, create it.
|
|
if p.ID == 0 {
|
|
p.ID = planID
|
|
p.CreatedAt = attributes.GetDate("created_at")
|
|
p.ServiceType = serviceTypeID
|
|
app.db.Create(&p)
|
|
} else {
|
|
// Save plan if already existing.
|
|
app.db.Save(&p)
|
|
}
|
|
|
|
// Get all times for this plan.
|
|
allPlanTimes, err := PCGetAll(fmt.Sprintf("/services/v2/service_types/%d/plans/%d/plan_times", serviceTypeID, planID))
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
// With each time, save it to the database.
|
|
for _, data := range allPlanTimes {
|
|
// Get the plan time ID and attributes.
|
|
id := data.GetUint64("id")
|
|
attributes := data.GetDict("attributes")
|
|
|
|
// Get from database if already existing.
|
|
var p PlanTimes
|
|
app.db.Where("id = ?", id).First(&p)
|
|
|
|
// Update data.
|
|
p.UpdatedAt = attributes.GetDate("updated_at")
|
|
p.Name = attributes.GetString("name")
|
|
p.TimeType = attributes.GetString("time_type")
|
|
p.StartsAt = attributes.GetDate("starts_at")
|
|
p.EndsAt = attributes.GetDate("ends_at")
|
|
p.LiveStartsAt = attributes.GetDate("live_starts_at")
|
|
p.LiveEndsAt = attributes.GetDate("live_ends_at")
|
|
|
|
// If not already existing, create it.
|
|
if p.ID == 0 {
|
|
p.ID = id
|
|
p.CreatedAt = attributes.GetDate("created_at")
|
|
p.Plan = planID
|
|
app.db.Create(&p)
|
|
} else {
|
|
// If already existing, save it.
|
|
app.db.Save(&p)
|
|
}
|
|
}
|
|
|
|
// Get all members of the plan.
|
|
allTeamMembers, err := PCGetAll(fmt.Sprintf("/services/v2/service_types/%d/plans/%d/team_members", serviceTypeID, planID))
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
// With each member, update the database.
|
|
for _, data := range allTeamMembers {
|
|
// Get the member ID and attributes.
|
|
id := data.GetUint64("id")
|
|
attributes := data.GetDict("attributes")
|
|
|
|
// Get person data from the database.
|
|
var p PlanPeople
|
|
app.db.Where("id = ?", id).First(&p)
|
|
|
|
// Update data.
|
|
p.UpdatedAt = attributes.GetDate("updated_at")
|
|
p.Status = attributes.GetString("status")
|
|
p.TeamPositionName = attributes.GetString("team_position_name")
|
|
|
|
// If person wasn't existing, create them.
|
|
if p.ID == 0 {
|
|
p.ID = id
|
|
p.CreatedAt = attributes.GetDate("created_at")
|
|
p.Person = data.GetDict("relationships").GetDict("person").GetDict("data").GetUint64("id")
|
|
p.Plan = planID
|
|
app.db.Create(&p)
|
|
} else {
|
|
// Otherwise save new info.
|
|
app.db.Save(&p)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Update slack information.
|
|
func UpdateSlackData() {
|
|
// Get all users from Slack.
|
|
users, err := app.slack.GetUsers()
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
// If no users returned, error as we should have some...
|
|
if len(users) == 0 {
|
|
log.Fatalln("No users found in Slack.")
|
|
}
|
|
// With each user, update the database.
|
|
for _, user := range users {
|
|
// Check if user already is in database.
|
|
var u SlackUsers
|
|
app.db.Where("id = ?", user.ID).First(&u)
|
|
|
|
// Update data.
|
|
u.Name = user.Name
|
|
u.RealName = user.RealName
|
|
u.FirstName = user.Profile.FirstName
|
|
u.LastName = user.Profile.LastName
|
|
u.Email = user.Profile.Email
|
|
u.Phone = user.Profile.Phone
|
|
u.Deleted = user.Deleted
|
|
u.IsBot = user.IsBot
|
|
u.IsAdmin = user.IsAdmin
|
|
u.IsOwner = user.IsOwner
|
|
u.IsPrimaryOwner = user.IsPrimaryOwner
|
|
u.IsRestricted = user.IsRestricted
|
|
u.IsUltraRestricted = user.IsUltraRestricted
|
|
u.IsStranger = user.IsStranger
|
|
u.IsAppUser = user.IsAppUser
|
|
u.IsInvitedUser = user.IsInvitedUser
|
|
u.Updated = user.Updated.Time()
|
|
|
|
// Try and find a match for this Slack user to the Planning Center people.
|
|
var people []People
|
|
// Get all people from Planning Center.
|
|
app.db.Find(&people)
|
|
if len(people) != 0 {
|
|
// For each person, compute how close of a match they are to the Slack user.
|
|
for i, person := range people {
|
|
distance := levenshtein.ComputeDistance(u.Name, person.FirstName+" "+person.LastName)
|
|
newDistance := levenshtein.ComputeDistance(u.RealName, person.FirstName+" "+person.LastName)
|
|
// The lowest score of the first+lastname match is used.
|
|
if newDistance < distance {
|
|
distance = newDistance
|
|
}
|
|
// Compute a score of first+last name.
|
|
newDistance = levenshtein.ComputeDistance(u.FirstName, person.FirstName)
|
|
newDistance += levenshtein.ComputeDistance(u.LastName, person.LastName)
|
|
// If this score is lower than the last score, return it.
|
|
if newDistance < distance {
|
|
distance = newDistance
|
|
}
|
|
// Update the distance on the user for sorting.
|
|
people[i].Distance = uint64(distance)
|
|
}
|
|
|
|
// Sort all Planning Center people by the score computed.
|
|
sort.Slice(people, func(i, j int) bool {
|
|
return people[i].Distance < people[j].Distance
|
|
})
|
|
|
|
// Debug output for comparing scores.
|
|
// for _, person := range people {
|
|
// fmt.Printf("%d %s (%s) %s\n", person.Distance, u.Name, u.RealName, person.FirstName+" "+person.LastName)
|
|
// }
|
|
|
|
// Set the planning center ID to nothing at first.
|
|
u.PCID = 0
|
|
// If score of the first person is less than 7,
|
|
// consider them a match and assign thier ID to the slack user.
|
|
if people[0].Distance < 7 {
|
|
u.PCID = people[0].ID
|
|
}
|
|
}
|
|
|
|
// If not already existing in the database, create them.
|
|
if u.ID == "" {
|
|
u.ID = user.ID
|
|
app.db.Create(&u)
|
|
} else {
|
|
// if already existing, update the user.
|
|
app.db.Save(&u)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create slack channels for upcoming services.
|
|
func CreateSlackChannels() {
|
|
// For now, we're using the start time of now. I want to update this later to allow
|
|
// setting a day of the week for slack channels to be created on.
|
|
// Doing a day of the week will allow for channels to be created ahead of time, then
|
|
// if people are added to the plan later on, they can be added at the next cron run.
|
|
startDate := time.Now()
|
|
// Last date is start date plus duration of create channels ahead.
|
|
lastDate := startDate.Add(app.config.Slack.CreateChannelsAhead)
|
|
|
|
// Get plan times that match.
|
|
var planTimes []PlanTimes
|
|
app.db.Where("time_type='service' AND starts_at > ? AND starts_at < ?", startDate, lastDate).Find(&planTimes)
|
|
// If no plan times matched, exit here.
|
|
if len(planTimes) == 0 {
|
|
log.Fatalln("No services found for this time frame.")
|
|
}
|
|
|
|
// With each plan time found, create a slack channel.
|
|
for _, planTime := range planTimes {
|
|
// Get the plan associated with the plan time.
|
|
var plan Plans
|
|
app.db.Where("id = ?", planTime.Plan).First(&plan)
|
|
if plan.ID == 0 {
|
|
log.Println("Unable to find plan:", planTime.Plan)
|
|
continue
|
|
}
|
|
|
|
// Get the service type associated with the plan.
|
|
var serviceType ServiceTypes
|
|
app.db.Where("id = ?", plan.ServiceType).First(&serviceType)
|
|
if serviceType.ID == 0 {
|
|
log.Println("Unable to find service type:", planTime.Plan)
|
|
continue
|
|
}
|
|
|
|
// Find people assigned to the plan.
|
|
var peopleOnPlan []PlanPeople
|
|
app.db.Where("plan = ?", plan.ID).Find(&peopleOnPlan)
|
|
if len(peopleOnPlan) == 0 {
|
|
log.Println("No people assigned to plan:", planTime.Plan)
|
|
continue
|
|
}
|
|
|
|
// Check if a channel was already created for this plan.
|
|
var channel SlackChannels
|
|
app.db.Where("pc_plan = ?", plan.ID).First(&channel)
|
|
|
|
// Set the topic/description based on servie type, and title/series title.
|
|
topic := serviceType.Name
|
|
if plan.SeriesTitle == "" && plan.Title != "" {
|
|
topic = topic + " - " + plan.Title
|
|
} else if plan.SeriesTitle != "" && plan.Title != "" {
|
|
topic = topic + " - " + plan.SeriesTitle + " (" + plan.Title + ")"
|
|
} else if plan.SeriesTitle != "" {
|
|
topic = topic + " - " + plan.SeriesTitle
|
|
}
|
|
|
|
// If the channel already exists, we do not need to create it...
|
|
// However, we should check if the description is changed
|
|
// and we should check if people were added.
|
|
if channel.ID != "" {
|
|
if channel.Description != topic {
|
|
app.slack.SetTopicOfConversation(channel.ID, topic)
|
|
app.slack.SetPurposeOfConversation(channel.ID, topic)
|
|
channel.Description = topic
|
|
app.db.Save(&channel)
|
|
}
|
|
} else {
|
|
// If the channel is being created, set the name to the starts at date.
|
|
channel.Name = planTime.StartsAt.Format("2006-01-02")
|
|
// Its possible that a duplicate channel already exists, if so we should append
|
|
// a channel number. Duplicate channels typically happen if multiple plans
|
|
// exists on the same day.
|
|
startingID := 1
|
|
for {
|
|
var duplicateChannel SlackChannels
|
|
app.db.Where("name = ?", channel.Name).First(&duplicateChannel)
|
|
if duplicateChannel.ID == "" {
|
|
break
|
|
}
|
|
startingID++
|
|
channel.Name = fmt.Sprintf("%s_%d", planTime.StartsAt.Format("2006-01-02"), startingID)
|
|
}
|
|
|
|
// Create the channel.
|
|
channelInfo := slack.CreateConversationParams{
|
|
ChannelName: channel.Name,
|
|
IsPrivate: true,
|
|
}
|
|
log.Println("Creating channel:", channel.Name)
|
|
schan, err := app.slack.CreateConversation(channelInfo)
|
|
if err != nil {
|
|
log.Fatalln("Failed to create channel:", err)
|
|
}
|
|
|
|
// If topic is defined, set the topic and purpose.
|
|
if topic != "" {
|
|
// Sleep before, as it takes time for Slack APIs
|
|
// to recongize the channel was created.
|
|
time.Sleep(10 * time.Second)
|
|
_, err = app.slack.SetTopicOfConversation(channel.ID, topic)
|
|
if err != nil {
|
|
log.Println("Failed to set topic:", err)
|
|
}
|
|
_, err = app.slack.SetPurposeOfConversation(channel.ID, topic)
|
|
if err != nil {
|
|
log.Println("Failed to set purpose:", err)
|
|
}
|
|
}
|
|
|
|
// Save the channel to the database.
|
|
channel.ID = schan.ID
|
|
channel.PCPlan = planTime.Plan
|
|
channel.StartsAt = planTime.StartsAt
|
|
channel.EndsAt = planTime.EndsAt
|
|
channel.Description = topic
|
|
app.db.Create(&channel)
|
|
}
|
|
|
|
|
|
// Get the previous users that were invited to the channel.
|
|
invited := strings.Split(channel.UsersInvited, ",")
|
|
// If nothing is previous, reset the slice to nil.
|
|
if len(invited) == 1 && invited[0] == "" {
|
|
invited = nil
|
|
}
|
|
|
|
// Keep a list of users we need to invite as they are new.
|
|
var usersToInvite []string
|
|
|
|
// For each person on the plan, see if we need to invite them.
|
|
for _, personOnPlan := range peopleOnPlan {
|
|
// Find the slack user for the planning center person.
|
|
var slackUser SlackUsers
|
|
app.db.Where("pc_id = ?", personOnPlan.Person).First(&slackUser)
|
|
if slackUser.ID == "" {
|
|
continue
|
|
}
|
|
|
|
// Check if they were already invited.
|
|
alreadyInvited := false
|
|
for _, uid := range invited {
|
|
if uid == slackUser.ID {
|
|
alreadyInvited = true
|
|
break
|
|
}
|
|
}
|
|
|
|
// Make sure they were not already added to the list of users.
|
|
// A person can be assigned to multiple teams on a plan.
|
|
for _, uid := range usersToInvite {
|
|
if uid == slackUser.ID {
|
|
alreadyInvited = true
|
|
break
|
|
}
|
|
}
|
|
|
|
// If not already invited, add to the list of users to invite.
|
|
if !alreadyInvited {
|
|
usersToInvite = append(usersToInvite, slackUser.ID)
|
|
}
|
|
}
|
|
|
|
// If there are users to invite, invite them.
|
|
if len(usersToInvite) != 0 {
|
|
// Update the invited users list.
|
|
invited = append(invited, usersToInvite...)
|
|
channel.UsersInvited = strings.Join(invited, ",")
|
|
// Invite the users.
|
|
_, err := app.slack.InviteUsersToConversation(channel.ID, usersToInvite...)
|
|
if err != nil {
|
|
log.Println("Failed to invite users to channel:", err)
|
|
}
|
|
// Update the channel on database with the new list of users invited.
|
|
app.db.Save(&channel)
|
|
}
|
|
}
|
|
|
|
// Find old channels to archive. Any channel which start at date is before the start date.
|
|
var channelsToArchive []SlackChannels
|
|
app.db.Where("starts_at < ? AND archived != 1", startDate).Find(&channelsToArchive)
|
|
// Archive channels which are old.
|
|
for _, channel := range channelsToArchive {
|
|
err := app.slack.ArchiveConversation(channel.ID)
|
|
if err != nil {
|
|
log.Println("Error closing old channel:", err)
|
|
}
|
|
// Mark as archived on the database.
|
|
channel.Archived = true
|
|
app.db.Save(&channel)
|
|
}
|
|
}
|