2vb/snow
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

What it do flight crew

Browse Source
This commit is contained in:
Eccentric 2024-01-30 16:34:17 +00:00
parent d16d9dd3ec
commit 9275e8fcd4
5 changed files with 79 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
handlers/friends.go
View File

@ -14,13 +14,13 @@ func GetFriendList(c *fiber.Ctx) error {
person := c.Locals("person").(*p.Person)
result := []aid.JSON{}
person.IncomingRelationships.Range(func(key string, value *p.Relationship[p.RelationshipInboundDirection]) bool {
result = append(result, value.GenerateFortniteFriendEntry())
return true
})
person.OutgoingRelationships.Range(func(key string, value *p.Relationship[p.RelationshipOutboundDirection]) bool {
result = append(result, value.GenerateFortniteFriendEntry())
person.Relationships.Range(func(key string, value *p.Relationship) bool {
switch value.Direction {
case p.RelationshipInboundDirection:
result = append(result, value.GenerateFortniteFriendEntry(p.GenerateTypeTowardsPerson))
case p.RelationshipOutboundDirection:
result = append(result, value.GenerateFortniteFriendEntry(p.GenerateTypeFromPerson))
}
return true
})
@ -28,53 +28,27 @@ func GetFriendList(c *fiber.Ctx) error {
}
func PostCreateFriend(c *fiber.Ctx) error {
person := c.Locals("person").(*p.Person)
wanted := c.Params("wanted")
direction, err := person.CreateRelationship(wanted)
relationship, err := c.Locals("person").(*p.Person).CreateRelationship(c.Params("wanted"))
if err != nil {
aid.Print(fmt.Sprintf("Error creating relationship: %s", err.Error()))
return c.Status(400).JSON(aid.ErrorBadRequest(err.Error()))
}
socket.JabberSockets.Range(func(key string, value *socket.Socket[socket.JabberData]) bool {
aid.Print(fmt.Sprintf("Checking socket: %s", key, value))
return true
})
personSocket, found := socket.GetJabberSocketByPersonID(wanted)
aid.Print(fmt.Sprintf("Found socket: %t", found), fmt.Sprintf("Direction: %s", direction))
from, found := socket.GetJabberSocketByPersonID(relationship.From.ID)
if found {
payload := aid.JSON{}
switch direction {
case "INBOUND":
payload = personSocket.Person.IncomingRelationships.MustGet(wanted).GenerateFortniteFriendEntry()
case "OUTBOUND":
payload = personSocket.Person.OutgoingRelationships.MustGet(wanted).GenerateFortniteFriendEntry()
}
personSocket.JabberSendMessageToPerson(aid.JSON{
from.JabberSendMessageToPerson(aid.JSON{
"type": "com.epicgames.friends.core.apiobjects.Friend",
"timestamp": time.Now().Format(time.RFC3339),
"payload": payload,
"payload": relationship.GenerateFortniteFriendEntry(p.GenerateTypeFromPerson),
})
}
friendSocket, found := socket.GetJabberSocketByPersonID(wanted)
aid.Print(fmt.Sprintf("Found friend socket: %t", found), fmt.Sprintf("Direction: %s", direction))
towards, found := socket.GetJabberSocketByPersonID(relationship.Towards.ID)
if found {
payload := aid.JSON{}
switch direction {
case "INBOUND":
payload = friendSocket.Person.OutgoingRelationships.MustGet(person.ID).GenerateFortniteFriendEntry()
case "OUTBOUND":
payload = friendSocket.Person.IncomingRelationships.MustGet(person.ID).GenerateFortniteFriendEntry()
}
friendSocket.JabberSendMessageToPerson(aid.JSON{
towards.JabberSendMessageToPerson(aid.JSON{
"type": "com.epicgames.friends.core.apiobjects.Friend",
"timestamp": time.Now().Format(time.RFC3339),
"payload": payload,
"payload": relationship.GenerateFortniteFriendEntry(p.GenerateTypeTowardsPerson),
})
}

6
person/person.go
View File

@ -18,8 +18,7 @@ type Person struct {
CollectionsProfile *Profile
CreativeProfile *Profile
Discord *storage.DB_DiscordPerson
OutgoingRelationships aid.GenericSyncMap[Relationship[RelationshipOutboundDirection]]
IncomingRelationships aid.GenericSyncMap[Relationship[RelationshipInboundDirection]]
Relationships aid.GenericSyncMap[Relationship]
}
func NewPerson() *Person {
@ -194,8 +193,7 @@ func findHelper(databasePerson *storage.DB_Person, shallow bool, save bool) *Per
CollectionsProfile: collectionsProfile,
CreativeProfile: creativeProfile,
Discord: &databasePerson.Discord,
OutgoingRelationships: aid.GenericSyncMap[Relationship[RelationshipOutboundDirection]]{},
IncomingRelationships: aid.GenericSyncMap[Relationship[RelationshipInboundDirection]]{},
Relationships: aid.GenericSyncMap[Relationship]{},
}
if !shallow {

164
person/relationships.go
View File

@ -8,134 +8,106 @@ import (
)
type RelationshipDirection string
const RelationshipInboundDirection RelationshipDirection = "INBOUND"
const RelationshipOutboundDirection RelationshipDirection = "OUTBOUND"
type RelationshipInboundDirection RelationshipDirection
const RelationshipInboundDirectionValue RelationshipInboundDirection = "INBOUND"
type RelationshipGenerateType string
const GenerateTypeFromPerson RelationshipGenerateType = "FROM_PERSON"
const GenerateTypeTowardsPerson RelationshipGenerateType = "TOWARDS_PERSON"
type RelationshipOutboundDirection RelationshipDirection
const RelationshipOutboundDirectionValue RelationshipOutboundDirection = "OUTBOUND"
type Relationship[T RelationshipInboundDirection | RelationshipOutboundDirection] struct {
Me *Person
type Relationship struct {
From *Person
Towards *Person
Status string
Direction T
Direction RelationshipDirection
}
func (r *Relationship[T]) ToDatabase() *storage.DB_Relationship {
func (r *Relationship) ToDatabase() *storage.DB_Relationship {
return &storage.DB_Relationship{
IncomingPersonID: r.Me.ID,
OutgoingPersonID: r.Towards.ID,
FromPersonID: r.From.ID,
TowardsPersonID: r.Towards.ID,
Status: r.Status,
}
}
func (r *Relationship[T]) GenerateFortniteFriendEntry() aid.JSON {
return aid.JSON{
"accountId": r.Towards.ID,
func (r *Relationship) GenerateFortniteFriendEntry(t RelationshipGenerateType) aid.JSON {
result := aid.JSON{
"status": r.Status,
"direction": string(r.Direction),
"created": "0000-00-00T00:00:00.000Z",
"favorite": false,
}
switch t {
case GenerateTypeFromPerson:
result["direction"] = "OUTBOUND"
result["accountId"] = r.Towards.ID
case GenerateTypeTowardsPerson:
result["direction"] = "INBOUND"
result["accountId"] = r.From.ID
}
func (r *Relationship[T]) Save() {
return result
}
func (r *Relationship) Save() (*Relationship, error) {
storage.Repo.Storage.SaveRelationship(r.ToDatabase())
r.From.Relationships.Set(r.Towards.ID, r)
r.Towards.Relationships.Set(r.From.ID, r)
return r, nil
}
func (r *Relationship[T]) Delete() {
func (r *Relationship) Delete() error {
storage.Repo.Storage.DeleteRelationship(r.ToDatabase())
return nil
}
func (p *Person) LoadRelationships() {
incoming := storage.Repo.Storage.GetIncomingRelationships(p.ID)
for _, entry := range incoming {
relationship := &Relationship[RelationshipInboundDirection]{
Status: entry.Status,
Me: p,
Towards: FindShallow(entry.OutgoingPersonID),
Direction: RelationshipInboundDirectionValue,
}
p.IncomingRelationships.Set(entry.OutgoingPersonID, relationship)
}
outgoing := storage.Repo.Storage.GetOutgoingRelationships(p.ID)
for _, entry := range outgoing {
relationship := &Relationship[RelationshipOutboundDirection]{
Status: entry.Status,
Me: p,
Towards: FindShallow(entry.IncomingPersonID),
Direction: RelationshipOutboundDirectionValue,
}
p.OutgoingRelationships.Set(entry.IncomingPersonID, relationship)
}
}
func (p *Person) CreateRelationship(personId string) (string, error) {
if p.ID == personId {
return "", fmt.Errorf("cannot create relationship with yourself")
}
if p.IncomingRelationships.Has(personId) {
return "INBOUND", p.createAcceptInboundRelationship(personId)
}
return "OUTBOUND", p.createOutboundRelationship(personId)
}
func (p *Person) createOutboundRelationship(towards string) error {
towardsPerson := Find(towards)
if towardsPerson == nil {
return fmt.Errorf("person not found")
}
relationship := &Relationship[RelationshipOutboundDirection]{
Me: p,
Towards: towardsPerson,
Status: "PENDING",
Direction: RelationshipOutboundDirectionValue,
}
relationship.Save()
p.OutgoingRelationships.Set(towards, relationship)
tempRelationship := &Relationship[RelationshipInboundDirection]{
Me: towardsPerson,
relationship := &Relationship{
From: Find(entry.FromPersonID),
Towards: p,
Status: entry.Status,
Direction: RelationshipInboundDirection,
}
p.Relationships.Set(entry.FromPersonID, relationship)
}
}
func (p *Person) CreateRelationship(personId string) (*Relationship, error) {
exists, okay := p.Relationships.Get(personId)
if !okay {
return p.createOutboundRelationship(personId)
}
if exists.Status != "PENDING" {
return nil, fmt.Errorf("relationship already exists")
}
if exists.Towards.ID == p.ID {
return p.createAcceptInboundRelationship(personId)
}
return nil, fmt.Errorf("relationship already exists")
}
func (p *Person) createOutboundRelationship(towards string) (*Relationship, error) {
relationship := &Relationship{
From: p,
Towards: Find(towards),
Status: "PENDING",
Direction: RelationshipInboundDirectionValue,
Direction: RelationshipOutboundDirection,
}
tempRelationship.Save()
towardsPerson.IncomingRelationships.Set(p.ID, tempRelationship)
return nil
return relationship.Save()
}
func (p *Person) createAcceptInboundRelationship(towards string) error {
towardsPerson := Find(towards)
if towardsPerson == nil {
return fmt.Errorf("person not found")
}
relationship := &Relationship[RelationshipInboundDirection]{
Me: p,
Towards: towardsPerson,
Status: "ACCEPTED",
Direction: RelationshipInboundDirectionValue,
}
relationship.Save()
p.IncomingRelationships.Set(towards, relationship)
tempRelationship := &Relationship[RelationshipOutboundDirection]{
Me: towardsPerson,
func (p *Person) createAcceptInboundRelationship(towards string) (*Relationship, error) {
relationship := &Relationship{
From: Find(towards),
Towards: p,
Status: "ACCEPTED",
Direction: RelationshipOutboundDirectionValue,
Direction: RelationshipInboundDirection,
}
tempRelationship.Save()
towardsPerson.OutgoingRelationships.Set(p.ID, tempRelationship)
return nil
return relationship.Save()
}

6
storage/postgres.go
View File

@ -184,13 +184,13 @@ func (s *PostgresStorage) DeletePerson(personId string) {
func (s *PostgresStorage) GetIncomingRelationships(personId string) []*DB_Relationship {
var dbRelationships []*DB_Relationship
s.Postgres.Model(&DB_Relationship{}).Where("incoming_person_id = ?", personId).Find(&dbRelationships)
s.Postgres.Model(&DB_Relationship{}).Where("towards_person_id = ?", personId).Find(&dbRelationships)
return dbRelationships
}
func (s *PostgresStorage) GetOutgoingRelationships(personId string) []*DB_Relationship {
var dbRelationships []*DB_Relationship
s.Postgres.Model(&DB_Relationship{}).Where("outgoing_person_id = ?", personId).Find(&dbRelationships)
s.Postgres.Model(&DB_Relationship{}).Where("from_person_id = ?", personId).Find(&dbRelationships)
return dbRelationships
}
@ -199,7 +199,7 @@ func (s *PostgresStorage) SaveRelationship(relationship *DB_Relationship) {
}
func (s *PostgresStorage) DeleteRelationship(relationship *DB_Relationship) {
s.Postgres.Delete(&DB_Relationship{}, "incoming_person_id = ? AND outgoing_person_id = ?", relationship.IncomingPersonID, relationship.OutgoingPersonID)
s.Postgres.Delete(relationship)
}
func (s *PostgresStorage) SaveProfile(profile *DB_Profile) {

4
storage/tables.go
View File

@ -21,8 +21,8 @@ func (DB_Person) TableName() string {
}
type DB_Relationship struct {
OutgoingPersonID string `gorm:"primary_key"`
IncomingPersonID string `gorm:"primary_key"`
FromPersonID string `gorm:"primary_key"`
TowardsPersonID string `gorm:"primary_key"`
Status string
}