Sunny Negi / Meteor-projects

Browse Code »

Commit 9db2d9cbe39c62fcc5425d4c8f3143a9f355efba

Authored by Deepak 2017-04-06 04:08:39 -0400

1 parent 167dd6325a

Exists in master

fixed error in csvupload

Showing 3 changed files with 15 additions and 10 deletions Show diff stats

imports/collections/staff/methods.js

Diff comments View file @9db2d9c

 // import {Parents } from '/imports/collections/parents/methods'
 import _                                  from 'lodash';
 import { Meteor }                         from 'meteor/meteor';
 import { ValidatedMethod }                from 'meteor/mdg:validated-method';
 import { SimpleSchema }                   from 'meteor/aldeed:simple-schema';
 import { DDPRateLimiter }                 from 'meteor/ddp-rate-limiter';
 import { Bert }                           from 'meteor/themeteorchef:bert';
 import { Users }                          from '/imports/collections/users/index';
 import { Staffs }                         from '/imports/collections/staff/index';
 import { Orgs }                           from '/imports/collections/orgs/index';
 export const staffMethods = new ValidatedMethod({
   name: 'staff.method',
   validate: new SimpleSchema({
     itemId: { type: String },
   }).validator(),
   run({itemId}) {
     return {};
   },
 });
 export const staffAddNew = new ValidatedMethod({
   name: 'staff.addNew',
   validate: new SimpleSchema({
     employeeId:     { type: String },
     firstName:      { type: String },
     lastName:       { type: String },
     martialStatus:  { type: String },
     gender:         { type: String },
     dob:            { type: String },
     email:          { type: String },
     phone:          { type: String },
     address:        { type: String },
     type:           { type: String },
     doj:            { type: String },
     teaching:       { type: String },
     qualifaication: { type: String },
     specialization: { type: String },
     university:     { type: String },
     degreeFrom:     { type: String },
     degreeEnded:    { type: String },
   }).validator(),
   run(data) {
     const user = Users.findOne({_id: Meteor.userId()});
     if(!user) return false;
     const org = Orgs.findOne({_id: user.orgId});
     if(!org) return false;
     // console.log(data);return true;
     orgId = user.orgId;
     newUserId = Users.insert({
       emails:     [{address:data.email, verified: false}],
       phones:     [{number:data.phone, verified: false}],
       firstName:  data.firstName,
       lastName:   data.lastName,
       address:    data.address,
       orgId:      orgId,
       role:       'STAFF'
     });
     console.log("newUserId");
     console.log(newUserId);
     if(newUserId){
       newStaffId = Staffs.insert({
         userId: newUserId,
         orgId: orgId,
         employeeId:  data.employeeId,
         martialStatus:data.martialStatus,
         gender: data.gender,
         dob: data.dob,
         teaching: data.teaching,
         type: data.type,
         qualifaication: data.qualifaication,
         specialization: data.specialization,
         university: data.university,
         degreeFrom: data.degreeFrom,
-        degreeEnded: data.degreeEnded
+        degreeEnded: data.degreeEnded,
+        doj: data.doj
       });
     }
     console.log("newStaffId");
     console.log(newStaffId);
     return {};
   },
 });

imports/collections/students/index.js

Diff comments View file @9db2d9c

1	// import {Students } from '/imports/collections/students/index'	1	// import {Students } from '/imports/collections/students/index'
2		2
3	import _ from 'lodash';	3	import _ from 'lodash';
4	import { Meteor } from 'meteor/meteor';	4	import { Meteor } from 'meteor/meteor';
5	import { Mongo } from 'meteor/mongo';	5	import { Mongo } from 'meteor/mongo';
6	import { SimpleSchema } from 'meteor/aldeed:simple-schema';	6	import { SimpleSchema } from 'meteor/aldeed:simple-schema';
7		7
8	import { Orgs } from '/imports/collections/orgs/index';	8	import { Orgs } from '/imports/collections/orgs/index';
9	import { Users } from '/imports/collections/users/index';	9	import { Users } from '/imports/collections/users/index';
10		10
11	class Student {	11	class Student {
12	constructor(doc) {	12	constructor(doc) {
13	_.assign(this, doc);	13	_.assign(this, doc);
14	};	14	};
15		15
16	getUserIds() {	16	getUserIds() {
17	return _.filter(_.map(this.users, 'userId'));	17	return _.filter(_.map(this.users, 'userId'));
18	};	18	};
19	};	19	};
20	export { Student };	20	export { Student };
21		21
22	class StudentsCollection extends Mongo.Collection {	22	class StudentsCollection extends Mongo.Collection {
23	insert(item, callback) {	23	insert(item, callback) {
24	_.assign(item, {	24	_.assign(item, {
25	createdAt: new Date().getTime(),	25	createdAt: new Date().getTime(),
26	});	26	});
27	return super.insert(item, callback);	27	return super.insert(item, callback);
28	};	28	};
29	};	29	};
30		30
31	export const Students = new StudentsCollection('Students', {	31	export const Students = new StudentsCollection('Students', {
32	transform: (item) => {	32	transform: (item) => {
33	return new Student(item);	33	return new Student(item);
34	},	34	},
35	});	35	});
36		36
37	_.assign(Students, {	37	_.assign(Students, {
38	allStudents: () => {	38	allStudents: () => {
39	const user = Users.current();	39	const user = Users.current();
40	if(!user) return null;	40	if(!user) return null;
41	return Orgs.find({'users.userId': user._id});	41	return Orgs.find({'users.userId': user._id});
42	},	42	},
43	current: () => {	43	current: () => {
44	const user = Users.current();	44	const user = Users.current();
45	if(!user) return null;	45	if(!user) return null;
46	return Orgs.findOne({_id: user.orgId});	46	return Orgs.findOne({_id: user.orgId});
47	},	47	},
48	currentOrgUsers: () => {	48	currentOrgUsers: () => {
49	const OrgsArr = Orgs.current();	49	const OrgsArr = Orgs.current();
50	if(!OrgsArr) return null;	50	if(!OrgsArr) return null;
51	return OrgsArr.users;	51	return OrgsArr.users;
52	},	52	},
53		53
54	});	54	});
55		55
56	Students.deny({	56	Students.deny({
57	insert() { return true; },	57	insert() { return true; },
58	update() { return true; },	58	update() { return true; },
59	remove() { return true; },	59	remove() { return true; },
60	});	60	});
61		61
62		62
63	Students.schema = new SimpleSchema({	63	Students.schema = new SimpleSchema({
64	userId: { type: String },	64	userId: { type: String },
65	orgId: { type: String },	65	orgId: { type: String },
66	admissionId: { type: String, optional: true ,unique: true,},	66	admissionId: { type: String, optional: true },
67	enrollmentDate: { type: String, optional: true },	67	enrollmentDate: { type: String, optional: true },
68	address: { type: String, optional: true },	68	address: { type: String, optional: true },
69	prefix: { type: String, optional: true },	69	prefix: { type: String, optional: true },
70	firstName: { type: String, optional: true },	70	firstName: { type: String, optional: true },
71	middlename: { type: String, optional: true },	71	middlename: { type: String, optional: true },
72	lastName: { type: String, optional: true },	72	lastName: { type: String, optional: true },
73	gender: { type: String, optional: true },	73	gender: { type: String, optional: true },
74	dob: { type: String, optional: true },	74	dob: { type: String, optional: true },
75	rollNo: { type: String, optional: true },	75	rollNo: { type: String, optional: true },
76	class: { type: String, optional: true },	76	class: { type: String, optional: true },
77	section: { type: String, optional: true },	77	section: { type: String, optional: true },
78	bloodGroup: { type: String, optional: true },	78	bloodGroup: { type: String, optional: true },
79	community: { type: String, optional: true },	79	community: { type: String, optional: true },
80	nationality: { type: String, optional: true },	80	nationality: { type: String, optional: true },
81	motherTongue: { type: String, optional: true },	81	motherTongue: { type: String, optional: true },
82	religion: { type: String, optional: true },	82	religion: { type: String, optional: true },
83	permanentAddress: {	83	permanentAddress: {
84	type: new SimpleSchema({	84	type: new SimpleSchema({
85	home: { type: String, optional: true },	85	home: { type: String, optional: true },
86	street: { type: String, optional: true },	86	street: { type: String, optional: true },
87	town: { type: String, optional: true },	87	town: { type: String, optional: true },
88	city: { type: String, optional: true },	88	city: { type: String, optional: true },
89	state: { type: String, optional: true },	89	state: { type: String, optional: true },
90	zip: { type: String, optional: true },	90	zip: { type: String, optional: true },
91	}),	91	}),
92	optional: true	92	optional: true
93	},	93	},
94	parent: {	94	parent: {
95	type: [new SimpleSchema({	95	type: [new SimpleSchema({
96	id: { type: String, },	96	id: { type: String, },
97	relatinship: { type: String, },	97	relatinship: { type: String, },
98	})],	98	})],
99	optional: true	99	optional: true
100	},	100	},
101	prevInstitute: {	101	prevInstitute: {
102	type: [new SimpleSchema({	102	type: [new SimpleSchema({
103	name: { type: String, },	103	name: { type: String, },
104	fromYear: { type: String, },	104	fromYear: { type: String, },
105	toYear: { type: String, },	105	toYear: { type: String, },
106	fromClass: { type: String, },	106	fromClass: { type: String, },
107	toClass: { type: String, },	107	toClass: { type: String, },
108	})],	108	})],
109	optional: true	109	optional: true
110	},	110	},
111		111
112	services: {	112	services: {
113	type: Object,	113	type: Object,
114	optional: true,	114	optional: true,
115	blackbox: true,	115	blackbox: true,
116	},	116	},
117		117
118	isMetaUser: { type: Boolean, optional: true },	118	isMetaUser: { type: Boolean, optional: true },
119		119
120	createdAt: { type: Date, autoValue: function(){return new Date();}}	120	createdAt: { type: Date, autoValue: function(){return new Date();}}
121		121
122	});	122	});
123		123
124	Students.attachSchema(Students.schema);	124	Students.attachSchema(Students.schema);
125		125
126	Students.privateFields = {	126	Students.privateFields = {
127	orgId: 1,	127	orgId: 1,
128	address: 1,	128	address: 1,
129		129
130	firstName: 1,	130	firstName: 1,
131	lastName: 1,	131	lastName: 1,
132	emails: 1,	132	emails: 1,
133	phones: 1,	133	phones: 1,
134		134
135	isMetaUser: 1,	135	isMetaUser: 1,
136	createdAt: 1,	136	createdAt: 1,
137	};	137	};
138		138
139	Students.publicFields = {	139	Students.publicFields = {
140	firstName: 1,	140	firstName: 1,
141	lastName: 1,	141	lastName: 1,
142	emails: 1,	142	emails: 1,
143		143
144	createdAt: 1,	144	createdAt: 1,
145	};	145	};
146		146

imports/collections/students/serverCsvUpload.js

Diff comments View file @9db2d9c

 // import { } from '/imports/collections/orgs/methods';
 import _                                  from 'lodash';
 import { Meteor }                         from 'meteor/meteor';
 import Papa                               from 'meteor/harrison:papa-parse'
 import csv                                from 'csv2json-convertor'
 import { ValidatedMethod }                from 'meteor/mdg:validated-method';
 import { SimpleSchema }                   from 'meteor/aldeed:simple-schema';
 import { DDPRateLimiter }                 from 'meteor/ddp-rate-limiter';
 import { Bert }                           from 'meteor/themeteorchef:bert';
 import { Users }                          from '/imports/collections/users/index';
 import { Orgs }                           from '/imports/collections/orgs/index';
 import { Students }                       from '/imports/collections/students/index'
 import { Parents }                        from '/imports/collections/parents/index';
 import csv1                               from 'csv2json-convertor'
 import json2csv                           from 'json2csv'
 import fs                                 from 'fs'
 import Validation                         from '/imports/validation/validationMethods';
 import Constants                          from '/imports/constants/constants'
 export const studenCsvtMethod = new ValidatedMethod({
   name: 'student.csvMethod',
   validate: new SimpleSchema({
     itemId: { type: String },
   }).validator(),
   run({itemId}) {
     return {};
   },
 });
 export const save_csv_data = new ValidatedMethod({
   name: 'save_csv_data',
   validate: null,
   run({item,filename,csv_fiels}) {
     if ((item.length))
     { console.log("++++++++++++++++++"+item.length)
       var csv = json2csv({
       data: item,
       fields: csv_fiels
                       });
     fs.writeFile(filename, csv,function(err) {
       if (err) throw err;
     });
     }
   },
 });
 export const addStudentCSV= new ValidatedMethod({
   name: 'student.addCSV',
   validate: null,
   run(item){
     data = item ;
     console.log("data");
     console.log(data);
    // return true;
     const user = Users.findOne({_id: this.userId});
     orgId = user.orgId;
     newStudentId = Users.insert({
      // emails:     [{address:data.email, verified: false}],
       //username:   data["First Name*"],
       firstName:  data["First Name*"],
       lastName:   data['Last Name*'],
       orgId:      orgId,
       role:       'STUDENT'
     });
     newParentUserId = Users.insert({
       //emails:     [{address:data.parentEmail, verified: false}],
       //3:   data['Parent Name*'],
       firstName:  data['Parent Name*'],
       orgId:      orgId,
       role:       'PARENT'
     });
     if(newParentUserId){
       newParentId = Parents.insert({
         userId: newParentUserId,
         orgId: orgId,
         profession: data['Parent Profession']
       });
       console.log("newParentUserId");
       console.log(newParentUserId);
     }
     console.log("newUserId");
     console.log(newStudentId);
     if(newStudentId){
       Students.insert({
         userId: newStudentId,
         orgId: orgId,
         admissionId:  data['Student Admission ID*'],
         enrollmentDate: data['Enrollment Date(YYYY-MM-DD)*'],
         gender:       data['Gender(male/female)*'],
         dob:          data['Birthday(YYYY-MM-DD)*'],
         bloodGroup:   data['Blood Group*'],
         nationality:  data['Nationality*'],
         motherTongue: data['Mother Tongue*'],
         religion:     data['Religion*'],
         community:    data['Community'],
         rollNo:       data['Student Roll*'],
         class:        data['Student Class Name*'],
         section:      data['Student Section Name*'],
         prevInstitute: [{ name:     data['Previous Institution Name'],
                          fromYear:  data['Class-From'],
                          toYear:    data['Class-To'],
                          fromClass: data['From-Year'],
                          toClass:   data['To-Year']
                        }],
         permanentAddress: { street: data['Student Line Adress*'],
                             city:   data['Student City*'],
                             state:  data['Student State*'],
                             zip:    data['Student Zip Code*']
                           },
         parent:       [{id: newParentUserId, relatinship: data['Parent Relation*']}]
       });
     }
     return {newStudentId};
   },
 });
 export const studentUploadCsv = new ValidatedMethod({
   name: 'student.uploadCsv',
   validate: null,
   run({data}) {
    let validation = new Validation();
    let constants = new Constants();
    //console.log("++++++++++++++++++++++++"+constants.csv_students_data());
    temp = constants.csv_students_data();
   //
    console.log(temp);
   //  var data_1=csv1.csvtojson(("/Users/satheeshnagaraj/Downloads/11.csv")); //csvtojson is function that accepts csv filenames and returns JSON object
    //console.log(data);''
  //  Stores  = new Mongo.Collection('stores');
   //  data = data_1;
             var CSV_valid_buffer   = [];
             var CSV_invalid_buffer = [];
             var filename           = "Student" + new Date().getTime().toString();
-            var csv_filepath = '/Users/satheeshnagaraj/Documents/Workspace/Meteor/Youngdesk/ydapp/CSV_Files/';
+            var csv_filepath = '/Users/deepak/dev/yd/csv';
             for (let i = 0; i < data.length; i++)
                 {
                   //let item= {Errors:""};
                   let item = data[i];
                   delete item['Errors'];
                   var formate_validation = 1;
                   var is_not_null = 1;
                   var errors = [];
                   for (var key in item)
                       {
                           var value = item[key];
                           var n = key.indexOf("*");
                           if(n!=-1) {
                                        if(!(validation.notNull(value)))
                                        {
                                          errors.push(key+"is Empty");
                                        }
                                        is_not_null = is_not_null && validation.notNull(value);
                                     }
                       }
                   //console.log(validation.mobileNumber(item["Parent Mobile*"]));
                   var formate_validation = validation.validateEmail(item["Parent Email*"]) && validation.mobileNumber(item["Parent Mobile*"]) ; //&& validation.validateEmail(item["Parent Mobile"]) );
                   if (!(validation.validateEmail(item["Parent Email*"])))
                   {
                       errors.push('Parent Email is invalid');
                   }
                   if (!(validation.mobileNumber(item["Parent Mobile*"])))
                   {
                         errors.push('Parent Mobile is invalid');
                   }
                   var is_valid = formate_validation && is_not_null ;
                  // console.log(formate_validation);
                     if (is_valid)
                        {
                             CSV_valid_buffer.push(item);
                             console.log("----------------------------------------1");
+                            console.log("----------------------------------------item");
+                            console.log(item);
+                            console.log (Users.findOne({"firstName": item["First Name*"],"lastName": item["Last Name*"]}));
                             Meteor.call('student.addCSV',item);
                             console.log("----------------------------------------2");
                          //   exists = Stores.findOne({
                          //                               "Student 'Admission' ID*": item["Student Admission ID*"]
                           //                          });
                          //   if (!exists)
                           //     {
                          //        Stores.insert(item);
                           //     }
                           //  else
                            //    {
                           //       console.warn('Rejected. This item already exists.');
                            //    }
                         }
                     else
                        {
                        var str = errors.toString();
                        item.Errors = str;
                        CSV_invalid_buffer.push(item);
                        //console.log(str);
                        // console.log(CSV_invalid_buffer);
                        }
                 }
             Meteor.call('save_csv_data',{ item : CSV_invalid_buffer, filename: csv_filepath+filename+"_CSV_invalid_data"+".csv",csv_fiels :constants.csv_students_data()});
             Meteor.call('save_csv_data',{ item : CSV_valid_buffer,filename: csv_filepath+filename+"_CSV_valid_data"+".csv",csv_fiels :constants.csv_students_data()});
     return {};
   },
 });