benkyd/note-service-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

db abstractions done

Browse Source
This commit is contained in:
plane000
2018-09-07 21:09:46 +01:00
parent 0c8977d4d0
commit 301f255d0d
4 changed files with 343 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/models/database/baseDatabase.js
View File

@@ -16,6 +16,8 @@ export class BaseDatabase {
static get User() {return User}
static get Auth() {return Auth}
static get PermaNote() {return PermaNote}
static get Group() {return Group}
static get Note() {return Note}
static async init() {
Logger.info('Connecting to SQLite Database');
@@ -104,6 +106,11 @@ export class BaseDatabase {
type: Sequelize.TEXT,
allowNull: true
},
endpoint: {
type: Sequelize.TEXT,
allowNull: true,
unique: true
},
lastupdated: Sequelize.TEXT
}, {
tableName: `note`

91
src/models/database/notegroups.js
View File

@@ -2,5 +2,96 @@ import {BaseDatabase} from './baseDatabase';
import {Logger} from '../logger';
export class NoteGroupTools extends BaseDatabase {
static async newGroup(id, creatorid, order) {
let Group = BaseDatabase.Group;
try {
let group = await Group.create({
id: id,
creatorid: creatorid,
order: order,
lastupdated: new Date().getTime()
});
return group;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async deleteGroup(id) {
let Group = BaseDatabase.Group;
try {
await Group.destroy({where: {id: id}});
return 1;
} catch (e) {
Logger.error(`An error occured while deleting group ${id}: ${e}`);
return -1;
}
}
static async renameGroup(id, newName) {
let Group = BaseDatabase.Group;
try {
await Group.update({name: newName}, {where: {id: id}});
await this.updateLastUpdatedTime(id);
return 1;
} catch (e) {
Logger.error(`An error occured while updating group ${id}: ${e}`);
return -1;
}
}
static async reorderGroup(id, newPosition) {
let Group = BaseDatabase.Group;
try {
await Group.update({order: newPosition}, {where: {id: id}});
await this.updateLastUpdatedTime(id);
return 1;
} catch (e) {
Logger.error(`An error occured while updating group ${id}: ${e}`);
return -1;
}
}
static async getGroupByID(id) {
let Group = BaseDatabase.Group;
try {
let group = await Group.findOne({where: {id: id}});
if (group == null) return -1;
return group;
} catch (e) {
Logger.error(`An error occured while getting group ${id}: ${e}`);
return -1;
}
}
static async getAllUsersGroups(userid) {
let Group = BaseDatabase.Group;
try {
let group = Group.findAll({where: {creatorid: userid}});
if (group == null) return -1;
return group;
} catch (e) {
Logger.error(`An error occured while getting groups from ${userid}: ${e}`);
return -1;
}
}
static async updateLastUpdatedTime(id) {
let Group = BaseDatabase.Group;
try {
await Group.update({lastupdated: new Date().getTime()}, {where: {id: id}});
return 1;
} catch (e) {
Logger.error(`An error occured while updating group ${id}: ${e}`);
return -1;
}
}
}

162
src/models/database/notes.js
View File

@@ -2,5 +2,165 @@ import {BaseDatabase} from './baseDatabase';
import {Logger} from '../logger';
export class NoteTools extends BaseDatabase {
static async newNote(id, content, creatorid, order, parentgroup) {
parentgroup = parentgroup || null;
let Note = BaseDatabase.Note;
}
try {
let note = await Note.create({
id: id,
content: content,
parentgroup: parentgroup,
creatorid: creatorid,
order: order,
catergory: null,
endpoint: null,
lastupdated: new Date().getTime()
});
return note;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async deleteNote(id) {
let Note = BaseDatabase.Note;
try {
await Note.destroy({where: {id: id}});
return 1;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async makePermaLink(id, endpoint) {
let Note = BaseDatabase.Note;
try {
await Note.update({endpoint: endpoint}, {where: {id: id}});
await this.updateLastUpdateTime(id);
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async getNoteByEndpoint(endpoint) {
let Note = BaseDatabase.Note;
try {
let note = await Note.findOne({where: {endpoint: endpoint}});
if (note == null) return -1;
return note;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async updateNote(id, newContent) {
let Note = BaseDatabase.Note;
try {
await Note.update({content: newContent}, {where: {id: id}});
await this.updateLastUpdatedTime(id);
return 1;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async updateCatergory(id, newCatergory) {
let Note = BaseDatabase.Note;
try {
await Note.update({catergory: newCatergory}, {where: {id: id}});
await this.updateLastUpdatedTime(id);
return 1;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async reorderNote(id, newOrder) {
let Note = BaseDatabase.Note;
try {
await Note.update({order: newOrder}, {where: {id: id}});
await this.updateLastUpdatedTime(id);
return 1;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async renameNote(id, newName) {
let Note = BaseDatabase.Note;
try {
await Note.update({name: newName}, {where: {id: id}});
await this.updateLastUpdatedTime(id);
return 1;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async getNoteByID(id) {
let Note = BaseDatabase.Note;
try {
let note = await Note.findOne({where: {id: id}});
if (note == null) return -1;
return note;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async getAllUserNotes(userid) {
let Note = BaseDatabase.Note;
try {
let note = await Note.findAll({where: {creatorid: userid}});
if (note == null) return -1;
return note;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async getAllGroupedNotes(groupid) {
let Note = BaseDatabase.Note;
try {
let note = await Note.findAll({where: {parentgroup: groupid}});
if (note == null) return -1;
return note;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
static async updateLastUpdateTime(id) {
let Note = BaseDatabase.Note;
try {
await Note.update({lastupdated: new Date().getTime()}, {where: {id: id}});
return 1;
} catch (e) {
Logger.error(`An error occured while inserting group ${id}: ${e}`);
return -1;
}
}
}