talksik/nirvana
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cleaning up old files breaking deployment

Browse Source
This commit is contained in:
Arjun Patel
2022-02-06 20:19:25 -08:00
parent c34e59e7da
commit 13ed201d7c
15 changed files with 0 additions and 817 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/common/models/clientModels/conversationData.md → documentation/conversationData.md
View File
packages/common/models/announcement.ts
-25
View File
@@ -1,25 +0,0 @@
import { Timestamp } from "firebase/firestore";
export default class Announcement {
id: string;
teamId: string;
audioDataUrl: string; // link to cloud storage file
state: AnnouncementState = AnnouncementState.active;
createdByUserId: string;
createdDate: Timestamp;
lastUpdatedDate: Timestamp;
constructor(_audioUrl: string, _teamId: string, _createdByUserId: string) {
this.audioDataUrl = _audioUrl;
this.createdByUserId = _createdByUserId;
this.teamId = _teamId;
}
}
export enum AnnouncementState {
active = "active",
resolved = "resolved",
deleted = "deleted",
}
packages/common/models/firestoreSerializable.ts
-7
View File
@@ -1,7 +0,0 @@
export default interface IFirestoreSerializable {
id: string;
serialize: () => {};
// deserialize: (firestoreData: {}) => {};
}
packages/common/models/link.ts
-88
View File
@@ -1,88 +0,0 @@
import { Timestamp } from "firebase/firestore";
export default class Link {
id: string;
name: string;
description: string;
link: string; //url for file
state: LinkState = LinkState.active;
type: LinkType;
teamId: string;
// if it's not a teamAttachment, then have a list of members who it's for
recipients: string[]; // userIds
createdByUserId: string;
createdDate: Timestamp;
constructor(
_name: string,
_description: string,
_link: string,
_teamId: string,
recipientsArr: string[],
_createdByUserId: string
) {
this.name = _name;
this.description = _description;
this.link = _link;
this.teamId = _teamId;
this.recipients = recipientsArr;
this.createdByUserId = _createdByUserId;
if (!recipientsArr || recipientsArr?.length == 0) {
this.recipients = null;
} else {
this.recipients = recipientsArr;
}
this.type = Link.getLinkType(_link);
}
static getLinkType(url: string): LinkType {
if (url.includes(LinkType.github)) {
return LinkType.github;
} else if (url.includes(LinkType.atlassian)) {
return LinkType.atlassian;
} else if (
url.includes(LinkType.googleDrive) ||
url.includes("docs.google")
) {
return LinkType.googleDrive;
} else if (
url.includes(".png") ||
url.includes(".jpg") ||
url.includes(".svg") ||
url.includes(".gif") ||
url.includes(LinkType.pastePics)
) {
return LinkType.image;
} else if (url.includes(LinkType.pdf)) {
return LinkType.pdf;
} else if (url.includes(LinkType.codePile)) {
return LinkType.codePile;
} else {
return LinkType.default;
}
}
}
export enum LinkState {
active = "active",
archived = "archived",
deleted = "deleted",
}
export enum LinkType {
default = "default",
github = "github",
atlassian = "atlassian",
googleDrive = "drive.google",
onedrive = "onedrive",
image = "image",
pdf = "pdf",
codePile = "codepile",
pastePics = "paste.pics",
googleMeet = "googleMeet",
}
packages/common/models/message.ts
-15
View File
@@ -1,15 +0,0 @@
import { Timestamp } from "firebase/firestore";
export class Message {
id: string;
audioDataUrl: string;
senderUserId: string;
receiverUserId: string;
senderReceiver: string[]; // composite to make querying easier in the future
createdDate: Timestamp;
// firstListenDate: Timestamp;
}
packages/common/models/officeRoom.ts
-37
View File
@@ -1,37 +0,0 @@
import { Timestamp } from "firebase/firestore";
import { v4 as uuidv4 } from "uuid";
export default class OfficeRoom {
id: string = uuidv4();
teamId: string;
name: string; // entrance, kitchen, etc.
createdDate: Timestamp;
createdByUserId: string;
lastUpdatedDate: Timestamp;
members: string[] = []; // id's of users in the office room
state: OfficeRoomState;
constructor(
_name: string,
_teamId: string,
_createdBy: string,
_state: OfficeRoomState = OfficeRoomState.idle
) {
this.name = _name;
this.teamId = _teamId;
this.createdByUserId = _createdBy;
this.state = _state;
}
}
export enum OfficeRoomState {
active = "active",
idle = "idle",
archived = "archived",
}
packages/common/models/room.ts
-50
View File
@@ -1,50 +0,0 @@
import { Timestamp } from "firebase/firestore";
export default class Room {
id: string;
name: string;
description: string;
link: string; // google meet link for now
members: string[] = []; //userIds of "mandatory"/invited people including the person who created it
membersInRoom: string[] = [];
attachments: string[] = []; // the links themselves (NOT Ids)...there will be duplicate entries in the attachments table which will be created
type: RoomType;
status: RoomStatus = RoomStatus.empty;
approximateDateTime: string; // vaguely say when the meeting should be...give user pointers
scheduledDateTime: Timestamp;
// scheduledJsDateTime(): Date {
// return this.scheduledDateTime.toDate();
// }
createdDate: Timestamp;
// createdJsDate(): Date {
// return this.createdDate.toDate();
// }
createdByUserId: string;
teamId: string;
lastUpdatedDate: Timestamp;
}
export enum RoomType {
now = "now",
scheduled = "scheduled", // one time sort of standard meeting
recurring = "recurring", //daily standup
}
export enum RoomStatus {
live = "live",
empty = "empty",
archived = "archived", // user marks it over
}
packages/common/models/team.ts
-30
View File
@@ -1,30 +0,0 @@
import { Timestamp } from "firebase/firestore";
export class Team {
id: string;
name: string;
status: TeamStatus;
allowedUserCount: number = 2;
// subscriptionPlan: TeamSubscriptionPlan = TeamSubscriptionPlan.basic
companySite: string;
createdByUserId: string;
createdDate: Timestamp;
lastUpdatedDate: Timestamp;
}
export enum TeamStatus {
created = "created",
deactivated = "deactivated",
deleted = "deleted",
}
export enum TeamSubscriptionPlan {
free = "free",
basic = "basic",
pro = "pro",
}
packages/common/models/teamMember.ts
-26
View File
@@ -1,26 +0,0 @@
import { Timestamp } from "firebase/firestore";
export class TeamMember {
id: string;
userId: string;
teamId: string;
inviteEmailAddress: string;
invitedByUserId: string;
role: TeamMemberRole
status: TeamMemberStatus
createdDate: Timestamp
lastUpdatedDate: Timestamp
}
export enum TeamMemberRole {
admin = "admin"
}
export enum TeamMemberStatus {
invited = "invited",
activated = "activated",
deleted = "deleted"
}
packages/common/services/announcementService.tsx
-27
View File
@@ -1,27 +0,0 @@
import {
addDoc,
collection,
doc,
Firestore,
getFirestore,
serverTimestamp,
setDoc,
} from "firebase/firestore";
import { AnnouncementState } from "../models/announcement";
import { Collections } from "./collections";
export class AnnouncementService {
private db: Firestore = getFirestore();
async updateAnnouncementState(
announcementId: string,
newState: AnnouncementState
) {
const docRef = doc(this.db, Collections.announcements, announcementId);
await setDoc(
docRef,
{ state: newState, lastUpdatedDate: serverTimestamp() },
{ merge: true }
);
}
}
packages/common/services/linkService.tsx
-24
View File
@@ -1,24 +0,0 @@
import {
addDoc,
collection,
doc,
Firestore,
getFirestore,
serverTimestamp,
setDoc,
} from "firebase/firestore";
import Link, { LinkState } from "../models/link";
import { Collections } from "./collections";
export class LinkService {
private db: Firestore = getFirestore();
async updateLinkState(linkId: string, newState: LinkState) {
const docRef = doc(this.db, Collections.links, linkId);
await setDoc(
docRef,
{ state: newState, lastUpdatedDate: serverTimestamp() },
{ merge: true }
);
}
}
packages/common/services/officeRoomService.tsx
-93
View File
@@ -1,93 +0,0 @@
import {
addDoc,
collection,
doc,
FieldValue,
Firestore,
getFirestore,
serverTimestamp,
setDoc,
writeBatch,
} from "firebase/firestore";
import OfficeRoom, { OfficeRoomState } from "../models/officeRoom";
// import AgoraService from "./agoraService";
import { Collections } from "./collections";
export default class OfficeRoomService {
private db: Firestore = getFirestore();
private batch = writeBatch(this.db);
// private agoraService = new AgoraService();
async createInitialOfficeRooms(createdByUserId: string, teamId: string) {
const entrance = new OfficeRoom("Entrance", teamId, createdByUserId);
const kitchen = new OfficeRoom("Kitchen", teamId, createdByUserId);
const hallway = new OfficeRoom("Hallway", teamId, createdByUserId);
const corner = new OfficeRoom("Corner", teamId, createdByUserId);
const main = new OfficeRoom("Team Hub", teamId, createdByUserId);
const handsOnDeck = new OfficeRoom(
"All Hands On Deck",
teamId,
createdByUserId
);
const initialORs: OfficeRoom[] = [
entrance,
kitchen,
hallway,
corner,
main,
handsOnDeck,
];
initialORs.forEach((oR) => {
const oRRef = doc(this.db, Collections.officeRooms, oR.id);
this.batch.set(oRRef, { ...oR, createdDate: serverTimestamp() });
});
await this.batch.commit();
}
async joinOfficeRoom(officeRoom: OfficeRoom, userId: string) {
// get agoraToken
// const agoraToken = await this.agoraService.getAgoraToken();
// join channel
// await this.agoraService.handleJoinChannel(officeRoom.id, agoraToken);
// update members list in firestore
const newMembers = [...officeRoom.members, userId];
await this.updateMembersInOfficeRoom(officeRoom.id, newMembers);
}
async updateMembersInOfficeRoom(
officeRoomId: string,
newMembersInRoom: string[]
) {
// if the room is going to be empty, then change status accordingly
var state: OfficeRoomState = OfficeRoomState.active;
if (newMembersInRoom.length == 0) {
state = OfficeRoomState.idle;
}
const docRef = doc(this.db, Collections.officeRooms, officeRoomId);
await setDoc(
docRef,
{
state,
members: newMembersInRoom,
lastUpdatedDate: serverTimestamp(),
},
{ merge: true }
);
}
// async updateRoom(room: Room) {
// const docRef = doc(this.db, Collections.rooms, room.id);
// await setDoc(
// docRef,
// { ...room, lastUpdatedDate: serverTimestamp() },
// { merge: true }
// );
// }
}
packages/common/services/roomService.tsx
-56
View File
@@ -1,56 +0,0 @@
import {
addDoc,
collection,
doc,
Firestore,
getFirestore,
serverTimestamp,
setDoc,
} from "firebase/firestore";
import Room, { RoomStatus } from "../models/room";
import { Collections } from "./collections";
export default class RoomService {
private db: Firestore = getFirestore();
async createOrUpdateRoom(room: Room) {
if (room.id) {
//update
await this.updateRoom(room);
} else {
//create
const roomDocRef = await addDoc(collection(this.db, Collections.rooms), {
...room,
createdDate: serverTimestamp(),
});
}
}
async updateMembersInRoom(roomId: string, newMembersInRoom: string[]) {
// if the room is going to be empty, then change status accordingly
var status: RoomStatus = RoomStatus.live;
if (newMembersInRoom.length == 0) {
status = RoomStatus.empty;
}
const docRef = doc(this.db, Collections.rooms, roomId);
await setDoc(
docRef,
{
status,
membersInRoom: newMembersInRoom,
lastUpdatedDate: serverTimestamp(),
},
{ merge: true }
);
}
async updateRoom(room: Room) {
const docRef = doc(this.db, Collections.rooms, room.id);
await setDoc(
docRef,
{ ...room, lastUpdatedDate: serverTimestamp() },
{ merge: true }
);
}
}
packages/common/services/sendService.tsx
-42
View File
@@ -1,42 +0,0 @@
import {
addDoc,
collection,
Firestore,
getFirestore,
serverTimestamp,
} from "firebase/firestore";
import Announcement from "../models/announcement";
import Link from "../models/link";
import { Message } from "../models/message";
import { Collections } from "./collections";
export class SendService {
private db: Firestore = getFirestore();
async sendMessage(message: Message) {
// do quick stuff to create the composite for easier future querying
message.senderReceiver = [message.senderUserId, message.receiverUserId];
const teamDocRef = await addDoc(
collection(this.db, Collections.audioMessages),
{
...message,
createdDate: serverTimestamp(),
}
);
}
async sendLink(link: Link) {
await addDoc(collection(this.db, Collections.links), {
...link,
createdDate: serverTimestamp(),
});
}
async sendAnnouncement(announcement: Announcement) {
await addDoc(collection(this.db, Collections.announcements), {
...announcement,
createdDate: serverTimestamp(),
});
}
}
packages/common/services/teamService.tsx
-297
View File
@@ -1,297 +0,0 @@
import {
addDoc,
collection,
doc,
DocumentReference,
Firestore,
getDoc,
getDocs,
getFirestore,
orderBy,
query,
serverTimestamp,
setDoc,
where,
} from "firebase/firestore";
import { Team } from "../models/team";
import {
TeamMember,
TeamMemberRole,
TeamMemberStatus,
} from "../models/teamMember";
import { Collections } from "./collections";
import IService from "./IService";
export default class TeamService implements IService {
db: Firestore = getFirestore();
async createTeam(team: Team): Promise<string> {
// create team
const teamDocRef = await addDoc(collection(this.db, Collections.teams), {
...team,
createdDate: serverTimestamp(),
});
const teamMember = new TeamMember();
teamMember.role = TeamMemberRole.admin;
teamMember.teamId = teamDocRef.id;
teamMember.userId = team.createdByUserId;
teamMember.status = TeamMemberStatus.activated;
// create team member as admin who created the team
const teamMemberRef = await addDoc(
collection(this.db, Collections.teamMembers),
{
...teamMember,
createdDate: serverTimestamp(),
}
);
console.log("created team");
return teamDocRef.id;
}
async updateTeam(team: Team) {
const docRef = doc(this.db, Collections.teams, team.id);
await setDoc(
docRef,
{ ...team, lastUpdatedDate: serverTimestamp() },
{ merge: true }
);
}
async getTeam(teamId: string): Promise<Team | null> {
const docRef = doc(this.db, Collections.teams, teamId);
const docSnap = await getDoc(docRef);
if (docSnap.exists()) {
console.log("got team data");
let team: Team = docSnap.data() as Team;
team.id = docSnap.id;
return team;
} else {
// doc.data() will be undefined in this case
console.log("team not found!");
return null;
}
}
async getTeamMemberByUserId(
teamId: string,
userId: string
): Promise<TeamMember | null> {
const q = query(
collection(this.db, Collections.teamMembers),
where("teamId", "==", teamId),
where("userId", "==", userId)
);
const querySnapshot = await getDocs(q);
if (querySnapshot.size > 1) {
console.log(
"there are multiple teammembers for this user...error in teamservice"
);
}
var teamMember: TeamMember | null = null;
querySnapshot.forEach((doc) => {
// doc.data() is never undefined for query doc snapshots
// get the first one and just return...shouldn't be more
console.log("got teammember data");
teamMember = doc.data() as TeamMember;
teamMember.id = doc.id;
});
return teamMember;
}
async getTeamMemberByEmailInvite(
teamId: string,
emailAddress: string
): Promise<TeamMember | null> {
const q = query(
collection(this.db, Collections.teamMembers),
where("teamId", "==", teamId),
where("inviteEmailAddress", "==", emailAddress)
);
const querySnapshot = await getDocs(q);
if (querySnapshot.size > 1) {
console.log(
"there are multiple teammembers for this user...error in teamservice"
);
}
var teamMember: TeamMember | null = null;
querySnapshot.forEach((doc) => {
// doc.data() is never undefined for query doc snapshots
// get the first one and just return...shouldn't be more
console.log("got teammember data");
teamMember = doc.data() as TeamMember;
teamMember.id = doc.id;
});
return teamMember;
}
async getTeamMembersByEmailInvite(
emailAddress: string
): Promise<TeamMember[]> {
const q = query(
collection(this.db, Collections.teamMembers),
where("inviteEmailAddress", "==", emailAddress)
);
const querySnapshot = await getDocs(q);
var teamMembers: TeamMember[] = [];
querySnapshot.forEach((doc) => {
// doc.data() is never undefined for query doc snapshots
// get the first one and just return...shouldn't be more
console.log("got teammember data");
let teamMember: TeamMember = doc.data() as TeamMember;
teamMember.id = doc.id;
teamMembers.push(teamMember);
});
return teamMembers;
}
async getTeamMembersByUserId(userId: string): Promise<TeamMember[]> {
const q = query(
collection(this.db, Collections.teamMembers),
where("userId", "==", userId)
);
const querySnapshot = await getDocs(q);
if (querySnapshot.size > 1) {
console.log("this user is part of multiple teams");
}
var teamMembers: TeamMember[] = [];
querySnapshot.forEach((doc) => {
// doc.data() is never undefined for query doc snapshots
// get the first one and just return...shouldn't be more
console.log("got teammember data");
let teamMember: TeamMember = doc.data() as TeamMember;
teamMember.id = doc.id;
teamMembers.push(teamMember);
});
return teamMembers;
}
async getTeamMembersByTeamId(teamId: string): Promise<TeamMember[]> {
const q = query(
collection(this.db, Collections.teamMembers),
where("teamId", "==", teamId)
);
const querySnapshot = await getDocs(q);
var teamMembers: TeamMember[] = [];
querySnapshot.forEach((doc) => {
// doc.data() is never undefined for query doc snapshots
// get the first one and just return...shouldn't be more
let teamMember: TeamMember = doc.data() as TeamMember;
teamMember.id = doc.id;
teamMembers.push(teamMember);
});
return teamMembers;
}
async updateTeamMember(teamMember: TeamMember) {
const docRef = doc(this.db, Collections.teamMembers, teamMember.id);
await setDoc(
docRef,
{ ...teamMember, lastUpdatedDate: serverTimestamp() },
{ merge: true }
);
}
async createTeamInvite(teamMember: TeamMember) {
if (teamMember.status == TeamMemberStatus.activated) {
console.log('cannot invite this user, already active.')
return
}
// if a person was already invited, then update that record, otherwise create a new one
const existingTeamMember = await this.getTeamMemberByEmailInvite(
teamMember.teamId,
teamMember.inviteEmailAddress
);
if (!existingTeamMember) {
const teamMemberRef = await addDoc(
collection(this.db, Collections.teamMembers),
{
...teamMember,
createdDate: serverTimestamp(),
}
);
return;
}
// just update the current user to active since we are activating again
await this.updateTeamMemberStatus(
existingTeamMember.id,
TeamMemberStatus.invited
);
}
async updateTeamMemberStatus(teamMemberId: string, status: TeamMemberStatus) {
const docRef = doc(this.db, Collections.teamMembers, teamMemberId);
await setDoc(
docRef,
{ status, lastUpdatedDate: serverTimestamp() },
{ merge: true }
);
}
async getActiveOrInvitedTeamsbyUser(
userId: string,
email: string
): Promise<Team[]> {
// get all of the teammember entries for the user
const userTeamMembers = await this.getTeamMembersByUserId(userId);
const userTeamMembersByEmail = await this.getTeamMembersByEmailInvite(
email
);
// traverse through and get the teams for each
var teams: Promise<Team>[];
if (userTeamMembers) {
teams = userTeamMembers.map(async (tm) => {
if (tm.status != TeamMemberStatus.deleted) {
let team = await this.getTeam(tm.teamId);
return team;
}
});
}
var invitedToTeams: Promise<Team>[] = [];
invitedToTeams = userTeamMembersByEmail
.filter((tm) => tm.status == TeamMemberStatus.invited)
.map(async (tm) => {
let team = await this.getTeam(tm.teamId);
return team;
});
return Promise.all([...teams, ...invitedToTeams]);
}
}