Meteor.startup(function () {
createJobs();
createUsers();
var filepath = '/Users/michaelbattcock/Desktop/test.txt';
Meteor.methods({
'writeFileTest': function () {
console.log('write file test success!');
fs.writeFileSync('/Users/michaelbattcock/Desktop/test.txt', "HelloWorld");
}
});
});
Meteor.methods({
// CREATES A NEW CONVERSATION
createNewConversation:function(title:string, sender:string, recipient:string, message:string){
check(title, String); check(sender, String); check(recipient, String); check(message, String);
var dateCreated = moment().format('MMMM Do YYYY, h:mm:ss a');
var first = Users.find({"_id":sender}).fetch()[0].profile.firstname;
var last = Users.find({"_id":sender}).fetch()[0].profile.lastname;
var senderName = first + " " + last;
ConversationStreams.insert({
title:title,
created: dateCreated,
subscribers:[
{'user':sender, 'unread':0, 'subscribed':1},
{'user':recipient, 'unread':1, 'subscribed':1}
],
messages:[
new Message(dateCreated, senderName, message)
]
}, (err, insertionID)=>{
if(err){
// message insertion failed
console.log(err);
}else{
// Insert new conversation reference in the users subscriptions
updateUserSubscription(sender, insertionID, 'sender');
updateUserSubscription(recipient, insertionID, 'recipient');
// console.log('maybe we got it right!');
}
});
},
// SENDS A MESSAGE
sendMessage:function(conversationID:string, sender:string, message:string){
check(conversationID, String); check(sender, String); check(message, String);
var sent = moment().format('MMMM Do YYYY, h:mm:ss a');
var senderName = getSenderName(sender);
var recipientList = getRecipient(conversationID, sender);
updateUnread(conversationID, recipientList);
// insert message into ConversationStream
ConversationStreams.update({"_id":conversationID}, {$addToSet:{
'messages':new Message(sent, senderName, message)
}});
// insert conversation into recipient if they have deleted it
for(var i = 0; i < recipientList.length; i++){
if(recipientList[i] != Meteor.userId()){
var convSubsID = Users.find({'_id':recipientList[i]}).fetch()[0].profile.conversationSubs;
ConversationSubscriptions.update({'_id':convSubsID}, {$addToSet: {
'conversations':conversationID
}});
}
}
},
// Delete Conversation
deleteConversation:function(conversationID:string, conversationStreamID:string){
// unsubscribe user in conversationStream
unsubscribeConversation(conversationStreamID);
// delete subscription from user conversationSubscriptions
var userConvSubs = Users.find({'_id':Meteor.userId()}).fetch()[0].profile.conversationSubs;
ConversationSubscriptions.update({'_id':userConvSubs}, {$pull : {
conversations : conversationID
}});
},
//Clear conversation unread count
clearConversationUnread:function(conversationStreamID:string){
//ConversationsStream Level
var subscribers = ConversationStreams.find({'_id':conversationStreamID}).fetch()[0].subscribers;
var unread = 0;
for(var i = 0; i < subscribers.length; i++){
if(subscribers[i].user == Meteor.userId()){
unread = subscribers[i].unread;
}
}
// Clear ConversationStream Level
ConversationStreams.update({'_id':conversationStreamID, 'subscribers':{$elemMatch: {'user':Meteor.userId()}}}, {
$set : {'subscribers.$.unread':0}
});
// ConversationSubscription Level
// Decrease the unread counter by the number of unread messages in the opened conversation
var conversationSubsID = Users.find({'_id':Meteor.userId()}).fetch()[0].profile.conversationSubs;
unread *= -1; // Make the unread value negative
ConversationSubscriptions.update({'_id':conversationSubsID}, {
$inc : {'unread':unread}
});
}
})
Meteor.methods({
// Create new task in the given ProjectStream
createNewTask: function(streamID:string, title:string, duedate:string, description:string){
var now = new Date().toString();
var assigner = getName(Meteor.userId());
var task = new Task(now, assigner, title, description, duedate);
ProjectsStream.update({'_id':streamID}, {$addToSet:{
'pending': task
}});
},
// Changes Project Visibility Field (public field)
changeProjectVisibility: function(projectID:string, visibility:boolean){
ProjectsStream.update({'_id':projectID}, {$set: {
'public':visibility
}});
},
checkProjectVisibility: function(projectID:string){
// get the visibility of the project
var visibility = ProjectsStream.find({'_id':projectID}).fetch()[0].public;
if(!visibility){
// Get array of all users allowed into the project
var exceptions = ProjectsStream.find({'_id':projectID}).fetch()[0].allowed;
if(exceptions.indexOf(Meteor.userId()) != -1){
// user was found on list
return {permission:true};
}else{
// user was not found on list
return {permission:false};
}
}else{
// Project visibility is open to everyone
return {permission:true};
}
},
//
});
import { Meteor } from 'meteor/meteor';
import { course_search } from './search.ts'
Meteor.methods({
'search_courses': function(text: string, results_per_page: number, page_no: number) {
var courseAsync = Meteor.wrapAsync(course_search);
var result;
var error;
courseAsync(text, results_per_page, page_no, function(res, err) {
if(err) {
result = null;
error = err;
}
else {
result = res;
error = null;
}
});
if(error) {
throw new Meteor.Error("Search Error");
}
else {
return result;
}
}
});
import { Posts } from './posts';
import { Meteor } from 'meteor/meteor';
Meteor.methods({
simpanPost(post) {
Posts.insert(post);
},
hapusPost(post) {
Posts.remove(post);
}
});
Meteor.methods({
invite: function (partyId:string, userId:string) {
check(partyId, String);
check(userId, String);
let party = Parties.findOne(partyId);
if (!party)
throw new Meteor.Error('404', 'No such party!');
if (party.public)
throw new Meteor.Error('400', 'That party is public. No need to invite people.');
if (party.owner !== this.userId)
throw new Meteor.Error('403', 'No permissions!');
if (userId !== party.owner && (party.invited || []).indexOf(userId) == -1) {
Parties.update(partyId, {$addToSet: {invited: userId}});
let from = getContactEmail(Meteor.users.findOne(this.userId));
let to = getContactEmail(Meteor.users.findOne(userId));
if (Meteor.isServer && to) {
Email.send({
from: '*****@*****.**',
to: to,
replyTo: from || undefined,
subject: 'PARTY: ' + party.name,
text: `Hi, I just invited you to ${party.name} on Socially.
\n\nCome check it out: ${Meteor.absoluteUrl()}\n`
});
}
}
},
reply: function(partyId: string, rsvp: string) {
check(partyId, String);
check(rsvp, String);
if (!this.userId)
throw new Meteor.Error('403', 'You must be logged-in to reply');
if (['yes', 'no', 'maybe'].indexOf(rsvp) === -1)
throw new Meteor.Error('400', 'Invalid RSVP');
let party = Parties.findOne({ _id: partyId });
if (!party)
throw new Meteor.Error('404', 'No such party');
if (party.owner === this.userId)
throw new Meteor.Error('500', 'You are the owner!');
if (!party.public && (!party.invited || party.invited.indexOf(this.userId) == -1))
throw new Meteor.Error('403', 'No such party'); // its private, but let's not tell this to the user
let rsvpIndex = party.rsvps ? party.rsvps.findIndex((rsvp) => rsvp.userId === this.userId) : -1;
if (rsvpIndex !== -1) {
// update existing rsvp entry
if (Meteor.isServer) {
// update the appropriate rsvp entry with $
Parties.update(
{ _id: partyId, 'rsvps.userId': this.userId },
{ $set: { 'rsvps.$.response': rsvp } });
} else {
// minimongo doesn't yet support $ in modifier. as a temporary
// workaround, make a modifier that uses an index. this is
// safe on the client since there's only one thread.
let modifier = { $set: {} };
modifier.$set['rsvps.' + rsvpIndex + '.response'] = rsvp;
Parties.update(partyId, modifier);
}
} else {
// add new rsvp entry
Parties.update(partyId,
{ $push: { rsvps: { userId: this.userId, response: rsvp } } });
}
}
});
export let Tasks = new MongoObservable.Collection<TodoTask>('tasks');
Meteor.methods({
'tasks.addTask': function(text: string) {
Tasks.insert({
text: text,
checked: false,
private: false,
createdAt: new Date()
})
},
'tasks.deleteTask': function(taskId) {
Tasks.remove(taskId);
},
'tasks.setChecked': function(taskId, setChecked) {
let task = Tasks.findOne(taskId);
Tasks.update(taskId, {
$set: { checked: setChecked }
});
},
'tasks.setPrivate': function(taskId, setToPrivate) {
let task = Tasks.findOne(taskId);
Tasks.update(taskId, {
$set: { private: setToPrivate }
});
}
});
if (Meteor.isServer) {
import { Meteor } from 'meteor/meteor';
import {Locales} from '../imports/api/locales';
Meteor.publish('locales', function () {
return Locales.find({});
});
Meteor.methods({
'locales.insert'(locale) {
var self = this;
Locales.insert(locale);
},
'locales.remove'(localeId) {
Locales.remove(localeId);
},
'locales.update'(localeId, action) {
Locales.update(localeId, action);
},
});
return MediaLibraries.find({ "$and": [{ "heading": search }, { "customerId": customerId }] }, options)
});
// Meteor.publish('mediaLibraries', (options: Object, searchString: string) => {
// console.log("options")
// }
// );
Meteor.methods({
'mediaLibraries.insert'(ml) {
MediaLibraries.insert(ml);
},
'mediaLibraries.remove'(mlId) {
MediaLibraries.remove(mlId);
},
'mediaLibraries.update'(mlId, action) {
MediaLibraries.update(mlId, action);
},
});
// console.dir(selector)
// console.dir(options)
// console.log("searchString" + searchString)
// return Meteor.users.find(selector , options);
// });
Meteor.methods({
'users.insert'(user) {
Meteor.users.insert(user);
},
'users.remove'(userId) {
Meteor.users.remove(userId);
},
'users.update'(userId, action) {
Meteor.users.update(userId, action);
},
'users.getUsers'() {
console.log('on server, Meteor.users.find({}) called');
return Meteor.users.find({}).fetch();
},
});
Meteor.users.allow({
insert: function () {
return true;
},
update: function () {
return true;
