Project

General

Profile

« Previous | Next » 

Revision 54788

[trunk]: Admin (Connect): Remove unnecessary logs

View differences:

modules/uoa-admin-portal/trunk/src/app/pages/zenodo-communities/manage-zenodo-communities.component.ts
111 111
          return false;
112 112
        });
113 113

  
114
        console.info("ngAfterViewInit");
114
        //console.info("ngAfterViewInit");
115 115
        this.searchUtils.totalResults = this.selectedCommunities.length;
116 116

  
117 117
     }
......
150 150
     */
151 151
     triggerInitialLoad(){
152 152
       this.triggered = true;
153
       console.info("triggerInitialLoad");
153
       //console.info("triggerInitialLoad");
154 154
       setTimeout(function(){
155 155
         var table = (<any>$('#dpTable')).DataTable();
156 156
         table.page( 0  ).draw( false );
......
165 165
         table.page( page - 1  ).draw( false );
166 166

  
167 167
         var info = table.page.info();
168
         console.info("records: "+info.recordsDisplay);
169 168
         this.searchUtils.totalResults = info.recordsDisplay;
170 169
     }
171 170

  
172 171
    public confirmedDeleteCommunity(data : any) {
173 172

  
174 173
      if(!Session.isLoggedIn()){
175
        console.info(this._router.url);
176 174
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
177 175
      } else {
178
        console.info("REMOVE: "+ this.communityId + " "+this.selectedToDelete.openaireId);
179 176
         this._manageZenodoCommunitiesService.removeZCommunity(this.properties, this.communityId,this.selectedToDelete.openaireId ).subscribe(
180 177
          data => {
181 178
             var pos = -1;
......
196 193

  
197 194
          },
198 195
          err => {
199
            console.info("error remove");
200 196
            console.log(err.status);
201
          },
197
          }/*,
202 198
          () => {
203 199
            console.info("completed remove");
204
          }
200
          }*/
205 201
        )
206 202
      }
207 203
    }
208 204

  
209 205
    public removeCommunity( comm) {
210 206
      if(!Session.isLoggedIn()){
211
        console.info(this._router.url);
212 207
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
213 208
      } else {
214 209
        this.selectedToDelete = comm;
modules/uoa-admin-portal/trunk/src/app/services/help-content.service.ts
338 338

  
339 339
    getCommunityStatistics(apiUrl: string, communityId: string): Observable<StatisticsSummary> {
340 340
        const url = `${apiUrl}communities/${communityId}`;
341
        console.log(`getting statistics summary from: ${url}`);
341
        //console.log(`getting statistics summary from: ${url}`);
342 342
        return this.http.get(url)
343 343
            .map(res => <any>res.json())
344
            .do(res => { console.log(res); })
345
            .map(res => res.statistics)
346
            .do(res => { console.log(res); });
344
            .map(res => res.statistics);
347 345
    }
348 346

  
349 347
    getCommunityAdminStatisticsChoices(apiUrl: string, communityId: string): Observable<StatisticsDisplay> {
350 348
        const url = `${apiUrl}statistics/${communityId}`;
351
        console.log(`getting admin choices for statistics from: ${url}`);
349
        //console.log(`getting admin choices for statistics from: ${url}`);
352 350
        return this.http.get(url)
353 351
            .map(stats => <StatisticsDisplay>stats.json())
354 352
            .catch(this.handleError);
......
362 360
                                        status: boolean,
363 361
                                        monitor: boolean): Observable<any> {
364 362
        const url = `${apiUrl}statistics/${communityId}/${entity}/${chartsOrNumbers}?status=${status.toString()}&monitor=${monitor.toString()}`;
365
        console.log(`getting admin choices for statistics from: ${url}`);
363
        //console.log(`getting admin choices for statistics from: ${url}`);
366 364

  
367 365
        return this.http.post(url, title, CustomOptions.getAuthOptionsWithBody())
368 366
            .map(stats => <any>stats.json())
modules/uoa-admin-portal/trunk/src/app/pages/htmlpagecontent/edit-htmlpage-content.component.ts
82 82

  
83 83
    private getPage(communityId: string, pageId: string) {
84 84
      if(!Session.isLoggedIn()){
85
        console.info(this.router.url);
86 85
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
87 86
      } else {
88 87
        this._helpContentService.getPage(pageId, this.properties.adminToolsAPIURL).subscribe(
......
96 95

  
97 96
    private getHtmlPageContent(communityId: string, pageRoute: string) {
98 97
      if(!Session.isLoggedIn()){
99
        console.info(this.router.url);
100 98
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
101 99
      } else {
102 100
        this.showLoading = true;
......
121 119

  
122 120
    private saveCustom() {
123 121
      if(!Session.isLoggedIn()){
124
        console.info(this.router.url);
125 122
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
126 123
      } else {
127 124
        this.formComponent.myForm.value.content = this.formComponent.myeditor.instance.getData();
......
131 128
            //this.mode = "";
132 129

  
133 130
            let htmlPageContent : HtmlPageContent = this.formComponent.myForm.value;
134
            console.info(htmlPageContent.community);
135 131
            this._htmlContentService.updateHtmlPageContent(htmlPageContent, this.properties.adminToolsAPIURL).subscribe(
136 132
                _ => {
137 133
                  //this.mode = "preview";
......
165 161
    }
166 162

  
167 163
    public scroll() {
168
      console.info("scroll into view");
169 164
      if (typeof document !== 'undefined') {
170 165
         this.element.nativeElement.scrollIntoView();
171 166
      }
modules/uoa-admin-portal/trunk/src/app/pages/page/page-form.component.ts
43 43

  
44 44
    public toggle() {
45 45
      if(!Session.isLoggedIn()){
46
        console.info(this._router.url);
47 46
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
48 47
      } else {
49 48
        this.myForm.value.isCollapsed = !this.myForm.value.isCollapsed;
......
76 75

  
77 76
    public getEntities(includedEntities: Set<String>) {
78 77
      if(!Session.isLoggedIn()){
79
        console.info(this._router.url);
80 78
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
81 79
      } else {
82 80
        this.showLoading = true;
......
142 140

  
143 141
    public toggleEntity(status : boolean, id : string, entity: Entity) {
144 142
      if(!Session.isLoggedIn()){
145
        console.info(this._router.url);
146 143
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
147 144
      } else {
148 145
        let index: number = -1;
modules/uoa-admin-portal/trunk/src/app/pages/divId/divId-form.component.ts
48 48

  
49 49
    getPages(includedPages: Set<String>) {
50 50
      if(!Session.isLoggedIn()){
51
        console.info(this._router.url);
52 51
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
53 52
      } else {
54 53
        this.showLoading = true;
......
73 72

  
74 73
    public toggle() {
75 74
      if(!Session.isLoggedIn()){
76
        console.info(this._router.url);
77 75
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
78 76
      } else {
79 77
        this.myForm.value.isCollapsed = !this.myForm.value.isCollapsed;
......
163 161
      }*/
164 162

  
165 163
      if(!Session.isLoggedIn()){
166
        console.info(this._router.url);
167 164
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
168 165
      } else {
169 166
        let index: number = -1;
modules/uoa-admin-portal/trunk/src/app/dashboard.component.ts
40 40
  }
41 41

  
42 42
  public scroll() {
43
    console.info("scroll into view");
44 43
    if (typeof document !== 'undefined') {
45 44
       this.element.nativeElement.scrollIntoView();
46 45
    }
modules/uoa-admin-portal/trunk/src/app/pages/faq/questions.component.ts
143 143
            topics.push(topic._id)
144 144
        }
145 145
        question.topics = topics;
146
        console.log(question);
147 146
        this.formGroup.patchValue(question);
148 147
        this.updateModal.showModal();
149 148
    }
......
163 162
    }
164 163

  
165 164
    public saveQuestion(data : any):void {
166
        console.log(data);
167 165
        this._faqService.saveQuestion(data).subscribe(
168 166
            question => this.questionSavedSuccessfully(question),
169 167
            error => this.handleError(<any>error)
......
240 238
            this.errorMessage = 'System error saving topic (Server responded: ' + error + ')';
241 239
        }
242 240
    }
243
}
241
}
modules/uoa-admin-portal/trunk/src/app/services/manageContentProviders.service.ts
16 16
    let options = new RequestOptions({headers: headers, body: id});
17 17

  
18 18
    let url = properties.communityAPI+communityId+"/contentproviders";
19
    console.info(url);
20

  
21 19
    return this.http.delete(url, options)
22 20
  }
23 21

  
......
26 24
      let options = new RequestOptions({headers: headers});
27 25

  
28 26
      let url = properties.communityAPI+communityId+"/contentproviders";
29
      console.info(url);
30 27

  
31 28
      let communityContentProvider = this.convertSearchContentProviderToCommunityContentProvider(contentProvider, communityId);
32
      console.info(contentProvider);
33
      console.info(communityContentProvider);
34 29

  
35 30
      return this.http.post(url, JSON.stringify(communityContentProvider), options)
36 31
                      .map(res => <any> res.json())
modules/uoa-admin-portal/trunk/src/app/pages/usernotifications/manage-user-notifications.component.ts
73 73
                                    this.userNotifications = JSON.parse(JSON.stringify( this.initialUserNotifications ));
74 74

  
75 75
                                    //TODO remove after final testing
76
                                    console.log("Before: ", userNotifications);
77
                                    console.log("After: ", this.initialUserNotifications);
78 76
                                    this.showLoading = false;
79 77
                                },
80 78
                                error => {
81
                                    console.log(error.status);
82 79
                                    if (error.status == '404') {
83 80
                                        this.initialUserNotifications = this.initiateUserNotifications();
84
                                        console.log(this.initialUserNotifications);
85 81
                                        this.userNotifications = JSON.parse(JSON.stringify( this.initialUserNotifications ));
86 82
                                    } else {
87 83
                                        this.handleError('System error retrieving user notifications', error)
......
108 104

  
109 105
    public updateUserNotifications() {
110 106
        if(!Session.isLoggedIn()){
111
          console.info(this._router.url);
112 107
          this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
113 108
        } else {
114 109
          if (this.communityId != null && this.communityId != '') {
......
117 112
              this.successfulSaveMessage = "";
118 113
              this.showLoading = true;
119 114
              var userNotifications = this.parseUpdatedUserNotifications();
120
              console.log(userNotifications);
121 115

  
122 116
              this._manageUserNotificationsService.updateUserNotifications(this.properties.adminToolsAPIURL + "community/" + this.communityId + "/notifications", userNotifications).subscribe(
123 117
                  userNotifications => {
......
168 162

  
169 163
        */
170 164
        if(!Session.isLoggedIn()){
171
          console.info(this._router.url);
172 165
          this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
173 166
        } else {
174 167
          this.mailPrefs.restoreNotification(0);
......
187 180

  
188 181
    public changeValueForNewManagers(notifyForManagers : any) {
189 182
      if(!Session.isLoggedIn()){
190
        console.info(this._router.url);
191 183
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
192 184
      } else {
193 185
        this.userNotifications.notifyForNewManagers = !notifyForManagers;
......
197 189

  
198 190
    public changeValueForNewSubscribers(notifyForSubscribers : any) {
199 191
      if(!Session.isLoggedIn()){
200
        console.info(this._router.url);
201 192
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
202 193
      } else {
203 194
        this.userNotifications.notifyForNewSubscribers = !notifyForSubscribers;
......
209 200
        this.hasChanged = true;
210 201
        this.successfulSaveMessage = '';
211 202
        this.successfulResetMessage = '';
212
        // TODO remove after testing
213
        console.log('I have changed: I AM TRUE');
214 203
    }
215 204

  
216 205
    private resetChange() {
217 206
        this.hasChanged = false;
218
        // TODO remove after testing
219
        console.log('I have changed: I AM FALSE');
220 207
    }
221 208

  
222 209
    public mailPrefsChanged(): boolean {
223 210
      if(!Session.isLoggedIn()){
224
        console.info(this._router.url);
225 211
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
226 212
      } else {
227 213
        return this.mailPrefs.prefsChanged["0"];//(0);
......
253 239
    }
254 240

  
255 241
    public scroll() {
256
      console.info("scroll into view");
257 242
      if (typeof document !== 'undefined') {
258 243
         this.element.nativeElement.scrollIntoView();
259 244
      }
modules/uoa-admin-portal/trunk/src/app/services/manageProjects.service.ts
16 16
    let options = new RequestOptions({headers: headers, body: id});
17 17

  
18 18
    let url = properties.communityAPI+communityId+"/projects";
19
    console.info(url);
20

  
21 19
    return this.http.delete(url, options)
22 20
  }
23 21

  
......
26 24
      let options = new RequestOptions({headers: headers});
27 25

  
28 26
      let url = properties.communityAPI+communityId+"/projects";
29
      console.info(url);
30 27

  
31 28
      let communityProject = this.convertSearchProjectToCommunityProject(project, communityId);
32
      console.info(project);
33
      console.info(communityProject);
34 29
      let testProject: any = {
35 30
        "acronym": "test",
36 31
        "communityId": "egi",
modules/uoa-admin-portal/trunk/src/app/services/manageZenodoCommunities.service.ts
16 16
    let options = new RequestOptions({headers: headers, body: id});
17 17

  
18 18
    let url = properties.communityAPI+communityId+"/zenodocommunities";
19
    console.info(url);
20 19

  
21 20
    return this.http.delete(url, options)
22 21
  }
......
26 25
      let options = new RequestOptions({headers: headers});
27 26

  
28 27
      let url = properties.communityAPI+communityId+"/zenodocommunities";
29
      console.info(url);
30 28
      var zCommunity: any = {
31 29
        "communityId": communityId,
32 30

  
33 31
        "zenodoid": zenodoid
34 32
      };
35
       console.info(zCommunity);
36 33
      return this.http.post(url, JSON.stringify(zCommunity), options)
37 34
                      .map(res => <any> res.json())
38 35
    }
modules/uoa-admin-portal/trunk/src/app/pages/entity/entities.component.ts
75 75
    constructor(private element: ElementRef, private route: ActivatedRoute, private _router: Router, private _helpContentService: HelpContentService) {}
76 76
    getEntities(community_pid: string) {
77 77
      if(!Session.isLoggedIn()){
78
        console.info(this._router.url);
79 78
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
80 79
      } else {
81 80
        this.showLoading = true;
......
107 106
    }
108 107

  
109 108
    public applyCheck(flag : boolean) {
110
      console.info("applyCheck "+flag);
111 109
        this.checkboxes.forEach(_ => _.checked = flag);
112 110
    }
113 111

  
......
138 136

  
139 137
    private confirmDeleteEntitiesModalOpen() {
140 138
      if(!Session.isLoggedIn()){
141
        console.info(this._router.url);
142 139
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
143 140
      } else {
144 141
        this.alertModalDeleteEntities.cancelButton = true;
......
152 149

  
153 150
    public confirmedDeleteEntities(data: any) {
154 151
      if(!Session.isLoggedIn()){
155
        console.info(this._router.url);
156 152
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
157 153
      } else {
158 154
        this.showLoading = true;
......
184 180

  
185 181
    private entitiesModalOpen(modal: any, title: string, yesBtn: string) {
186 182
      if(!Session.isLoggedIn()){
187
        console.info(this._router.url);
188 183
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
189 184
      } else {
190 185
        modal.cancelButton = true;
......
197 192

  
198 193
    public entitySaveConfirmed(data: any) {
199 194
      if(!Session.isLoggedIn()){
200
        console.info(this._router.url);
201 195
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
202 196
      } else {
203 197
        if(!this.formGroup.valid) {
......
217 211

  
218 212
    public entityUpdateConfirmed(data: any) {
219 213
      if(!Session.isLoggedIn()){
220
        console.info(this._router.url);
221 214
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
222 215
      } else {
223 216
        if(!this.formGroup.valid) {
......
292 285

  
293 286
    private confirmRelatedPagesModalOpen() {
294 287
      if(!Session.isLoggedIn()){
295
        console.info(this._router.url);
296 288
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
297 289
      } else {
298 290
        this.alertModalRelatedPages.cancelButton = true;
......
306 298

  
307 299
    public continueToggling(event: any) {
308 300
      if(!Session.isLoggedIn()){
309
        console.info(this._router.url);
310 301
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
311 302
      } else {
312 303
        this.showLoading = true;
......
327 318
    }
328 319

  
329 320
    public scroll() {
330
      console.info("scroll into view");
331 321
      if (typeof document !== 'undefined') {
332 322
         this.element.nativeElement.scrollIntoView();
333 323
      }
modules/uoa-admin-portal/trunk/src/app/pages/subjects/subjects-edit-form/subjects-edit-form.component.ts
64 64
                this.communityId = communityId['communityId'];
65 65

  
66 66
                if(!Session.isLoggedIn()){
67
                  console.info(this._router.url);
68 67
                  this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
69 68
                } else {
70 69
                  if (this.communityId != null && this.communityId != '') {
......
97 96

  
98 97
  public addSubject() {
99 98
    if(!Session.isLoggedIn()){
100
      console.info(this._router.url);
101 99
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
102 100
    } else {
103 101
          this.community.subjects.push("");
......
106 104

  
107 105
  public removeSubject(i: any) {
108 106
    if(!Session.isLoggedIn()){
109
      console.info(this._router.url);
110 107
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
111 108
    } else {
112 109
          this.community.subjects.splice(i, 1);
......
115 112

  
116 113
  public resetForm(communityId: string) {
117 114
    if(!Session.isLoggedIn()){
118
      console.info(this._router.url);
119 115
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
120 116
    } else {
121 117
      if (communityId != null && communityId != '') {
......
170 166
 }
171 167
  public updateSubjects() {
172 168
    if(!Session.isLoggedIn()){
173
      console.info(this._router.url);
174 169
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
175 170
    } else {
176 171
      if (this.communityId != null && this.communityId != '') {
......
184 179
            let obs = concat(this._subjectsService.addSubjects(this.properties.communityAPI + this.communityId + "/subjects", subjectsToAdd),
185 180
            this._subjectsService.removeSubjects(this.properties.communityAPI + this.communityId + "/subjects", subjectsToDelete));
186 181
             obs.subscribe(res => {
187
               console.log(res);
188 182
               if (res["method"] == "delete") {
189 183
                this.afterUpdateActions(res);
190 184
               }
......
193 187
            );
194 188
          }else if (subjectsToAddAr.length > 0){
195 189
            this._subjectsService.addSubjects(this.properties.communityAPI + this.communityId +"/subjects", subjectsToAdd).subscribe(res => {
196
               console.log(res);
197 190
                 this.afterUpdateActions(res);
198 191

  
199 192
             },
......
201 194
            );
202 195
          }else if (subjectsToDeleteAr.length > 0) {
203 196
            this._subjectsService.removeSubjects(this.properties.communityAPI + this.communityId + "/subjects", subjectsToDelete).subscribe(res => {
204
               console.log(res);
205 197
                 this.afterUpdateActions(res);
206 198

  
207 199
             },
......
240 232
      let j = 0;
241 233
      for (let i = 0; i < length; i++) {
242 234
          if (this.isEmpty(data[i])) {
243
               // console.log(data[i]);
244 235
          } else if (this.isNonEmpty(data[i])) {
245 236
               arrayNonEmpty[j] = data[i];
246 237
               j++;
247
               // console.log(data[i]);
248 238
          }
249 239
      }
250 240
      return arrayNonEmpty;
......
252 242

  
253 243
  private hasFilled(data: any): boolean {
254 244
      if (this.isNonEmpty(data) && !this.isEmpty(data)) {
255
          // TODO remove console message after final testing
256
          console.log("NAME IS NOT EMPTY");
257 245
          return true;
258 246
      }
259
      // TODO remove console message after final testing
260
      console.log("NAME IS EMPTY");
261 247
      return false;
262 248
  }
263 249

  
......
281 267
      for (let i = 0; i < length; i++) {
282 268
          if (!this.emailValidator(data['managers'][i])){
283 269
              // TODO remove console message after final testing
284
              console.log("INVALID EMAIL");
270
              //console.log("INVALID EMAIL");
285 271
              return false;
286 272
          }
287 273
      }
288 274
      // TODO remove console message after final testing
289
      console.log("ALL EMAILS ARE VALID");
275
      //console.log("ALL EMAILS ARE VALID");
290 276
      return true;
291 277
  }
292 278

  
......
301 287
      this.hasChanged = true;
302 288
      this.successfulSaveMessage = '';
303 289
      this.successfulResetMessage = '';
304
      // TODO remove after testing
305
      console.log('I have changed: I AM TRUE');
306 290
  }
307 291

  
308 292
  private resetChange() {
309 293
      this.hasChanged = false;
310
      // TODO remove after testing
311
      console.log('I have changed: I AM FALSE');
312 294
  }
313 295

  
314 296
  public get form() {
......
354 336
  }
355 337

  
356 338
  public scroll() {
357
    console.info("scroll into view");
358 339
    if (typeof document !== 'undefined') {
359 340
       this.element.nativeElement.scrollIntoView();
360 341
    }
modules/uoa-admin-portal/trunk/src/app/pages/subjects/subjects.service.ts
15 15

  
16 16
      let body = JSON.stringify(subjects);
17 17

  
18
      console.log(body);
19

  
20 18
      return this.http.post(url, body, options)
21
                        .do(request => console.log("Insert Response:"+request.status))
19
                        //.do(request => console.log("Insert Response:"+request.status))
22 20
                        .map(res => res.json())
23 21
                        .map(res => {
24 22
                          res["method"]="post";
......
32 30
      let body = JSON.stringify(subjects);
33 31
      let options = new RequestOptions({headers: headers,body:body});
34 32

  
35

  
36
      console.log(body);
37

  
38 33
      return this.http.delete(url, options)
39
                        .do(request => console.log("Delete Response:"+request.status))
34
                        //.do(request => console.log("Delete Response:"+request.status))
40 35
                        .map(res => res.json())
41 36
                        .map(res => {
42 37
                          res["method"]="delete";
modules/uoa-admin-portal/trunk/src/app/pages/modal-form.component.ts
92 92
                       data => this.emmitObject.emit(data),
93 93
                       error => this.emmitError.emit(error)
94 94
                    );
95
                    console.info(<Community> obj);
96 95

  
97 96
                  } else if(this.saveText == 'Save') {
98 97
                    this._helpService.saveCommunity(<Community> obj, this.properties.adminToolsAPIURL).subscribe(
99 98
                       data => this.emmitObject.emit(data),
100 99
                       error => this.emmitError.emit(error)
101 100
                    );
102
                    console.info(<Community> obj);
103 101
                  }
104 102
              } else if (this.type == 'page') {
105 103
                  if(this.saveText == 'Update') {
modules/uoa-admin-portal/trunk/src/app/pages/helpcontent/page-help-content-form.component.ts
41 41
             this.properties = data.envSpecific;
42 42

  
43 43
             if(!Session.isLoggedIn()){
44
               console.info(this._router.url);
45 44
               this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
46 45
             } else {
47 46
               this._helpContentService.getPages(this.properties.adminToolsAPIURL, this.communityPid).subscribe(
modules/uoa-admin-portal/trunk/src/app/pages/helpcontent/edit-page-help-content.component.ts
76 76

  
77 77
    private getPageHelpContent(pageContentId: string) {
78 78
      if(!Session.isLoggedIn()){
79
        console.info(this.router.url);
80 79
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
81 80
      } else {
82 81
        this.showLoading = true;
......
94 93

  
95 94
    private updateForm(pageHelpContent : PageHelpContent) {
96 95
        this.pageHelpContent = pageHelpContent;
97
        console.info(pageHelpContent);
98 96
        this.formComponent.myForm.patchValue((pageHelpContent));
99 97
        // console.log("patching",pageHelpContent);
100 98
    }
101 99

  
102 100
    private saveCustom() {
103 101
      if(!Session.isLoggedIn()){
104
        console.info(this.router.url);
105 102
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
106 103
      } else {
107 104
        if(this.formComponent.myForm.valid) {
......
109 106
            this.updateErrorMessage = "";
110 107

  
111 108
            let pageHelpContent : PageHelpContent = this.formComponent.myForm.value;
112
            console.info(pageHelpContent.community);
113 109
            this._helpContentService.updatePageHelpContent(pageHelpContent, this.properties.adminToolsAPIURL).subscribe(
114 110
                _ => {
115 111
                  if(this.pageId) {
......
139 135
    }
140 136

  
141 137
    public scroll() {
142
      console.info("scroll into view");
143 138
      if (typeof document !== 'undefined') {
144 139
         this.element.nativeElement.scrollIntoView();
145 140
      }
modules/uoa-admin-portal/trunk/src/app/pages/helpcontent/page-help-contents.component.ts
94 94

  
95 95
    getPage(pageId: string) {
96 96
      if(!Session.isLoggedIn()){
97
        console.info(this.router.url);
98 97
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
99 98
      } else {
100 99
        this.showLoading = true;
......
112 111

  
113 112
    getPages(community_pid: string) {
114 113
      if(!Session.isLoggedIn()){
115
        console.info(this.router.url);
116 114
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
117 115
      } else {
118 116
        this.showLoading = true;
......
143 141

  
144 142
    getPageHelpContents(community_pid: string) {
145 143
      if(!Session.isLoggedIn()){
146
        console.info(this.router.url);
147 144
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
148 145
      } else {
149 146
        this._helpService.getCommunityPageHelpContents(community_pid, this.properties.adminToolsAPIURL).subscribe(
......
204 201

  
205 202
    private confirmModalOpen() {
206 203
      if(!Session.isLoggedIn()){
207
        console.info(this.router.url);
208 204
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
209 205
      } else {
210 206
        this.alertModalDeletePageHelpContents.cancelButton = true;
......
218 214

  
219 215
    public confirmedDeletePageHelpContents(data: any) {
220 216
      if(!Session.isLoggedIn()){
221
        console.info(this.router.url);
222 217
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
223 218
      } else {
224 219
        this.showLoading = true;
......
255 250

  
256 251
    public togglePageHelpContents(status : boolean, ids : string[]) {
257 252
      if(!Session.isLoggedIn()){
258
        console.info(this.router.url);
259 253
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
260 254
      } else {
261 255
        this.showLoading = true;
......
265 259
            () => {
266 260
                for(let id of ids) {
267 261
                    let i = this.checkboxes.findIndex(_ => _.pageHelpContent._id == id);
268
                    console.info(i);
269 262
                    this.checkboxes[i].pageHelpContent.isActive=status;
270 263
                }
271 264
                this.countPageHelpContents();
......
357 350
    }
358 351

  
359 352
    public scroll() {
360
      console.info("scroll into view");
361 353
      if (typeof document !== 'undefined') {
362 354
         this.element.nativeElement.scrollIntoView();
363 355
      }
modules/uoa-admin-portal/trunk/src/app/pages/helpcontent/new-page-help-content.component.ts
53 53

  
54 54
    private saveCustom() {
55 55
      if(!Session.isLoggedIn()){
56
        console.info(this.router.url);
57 56
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
58 57
      } else {
59 58
        //this.errorMessage = null;
......
97 96
    }
98 97

  
99 98
    public scroll() {
100
      console.info("scroll into view");
101 99
      if (typeof document !== 'undefined') {
102 100
         this.element.nativeElement.scrollIntoView();
103 101
      }
modules/uoa-admin-portal/trunk/src/app/pages/community/communities.component.ts
62 62
        this.route.data
63 63
          .subscribe((data: { envSpecific: EnvProperties }) => {
64 64
             this.scroll();
65
             
65

  
66 66
             this.properties = data.envSpecific;
67 67
             this.getCommunities();
68 68
          });
......
73 73

  
74 74
    getCommunities() {
75 75
      if(!Session.isLoggedIn()){
76
        console.info(this._router.url);
77 76
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
78 77
      } else {
79 78
        this.showLoading = true;
......
102 101
    }
103 102

  
104 103
    public applyCheck(flag : boolean) {
105
      console.info("applyCheck "+flag);
106 104
        this.checkboxes.forEach(_ => _.checked = flag);
107 105
    }
108 106

  
......
133 131

  
134 132
    private confirmModalOpen() {
135 133
      if(!Session.isLoggedIn()){
136
        console.info(this._router.url);
137 134
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
138 135
      } else {
139 136
        this.alertModalDeleteCommunities.cancelButton = true;
......
147 144

  
148 145
    public confirmedDeleteCommunities(data: any) {
149 146
      if(!Session.isLoggedIn()){
150
        console.info(this._router.url);
151 147
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
152 148
      } else {
153 149
        this.showLoading = true;
......
179 175

  
180 176
    private communitiesModalOpen(modal: any, title: string, yesBtn: string) {
181 177
      if(!Session.isLoggedIn()){
182
        console.info(this._router.url);
183 178
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
184 179
      } else {
185 180
        modal.cancelButton = true;
......
192 187

  
193 188
    public communitySaveConfirmed(data: any) {
194 189
      if(!Session.isLoggedIn()){
195
        console.info(this._router.url);
196 190
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
197 191
      } else {
198 192
        if(!this.formGroup.valid) {
......
212 206

  
213 207
    public communityUpdateConfirmed(data: any) {
214 208
      if(!Session.isLoggedIn()){
215
        console.info(this._router.url);
216 209
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
217 210
      } else {
218 211
        if(!this.formGroup.valid) {
......
231 224

  
232 225
    public communitySavedSuccessfully(community: Community) {
233 226
        this.checkboxes.push(<CheckCommunity>{community : community, checked : false});
234
        console.info("checkboxes length: "+this.checkboxes.length);
235 227
        this.applyCheck(false);
236 228
    }
237 229

  
......
276 268
    }
277 269

  
278 270
    public scroll() {
279
      console.info("scroll into view");
280 271
      if (typeof document !== 'undefined') {
281 272
         this.element.nativeElement.scrollIntoView();
282 273
      }
modules/uoa-admin-portal/trunk/src/app/pages/community/content-providers/add-content-providers.component.ts
83 83

  
84 84
  public addContentProvider(contenProvider: SearchResult) {
85 85
    if(!Session.isLoggedIn()){
86
      console.info(this._router.url);
87 86
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
88 87
    } else {
89
      console.info("Add: "+ contenProvider.id);
90 88
      this.subAdd = this._manageCommunityContentProvidersService.addContentProvider(this.properties, this.community, contenProvider).subscribe(
91 89
        data => {
92
          console.info("data ADD");
93
          console.info(data);
94 90
          this.undo[contenProvider.id] = data.id;
95 91
        },
96 92
        err => {
97
          console.info("error ADD");
98 93
          console.log(err.status);
99
        },
94
        }/*,
100 95
        () => {
101 96
          console.info("completed ADD");
102
        }
103
      )
97
        }*/
98
      );
104 99
    }
105 100
  }
106 101

  
107 102
  public removeContentProvider(contentProviderId: string, communityContentProviderId: string) {
108 103
    if(!Session.isLoggedIn()){
109
      console.info(this._router.url);
110 104
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
111 105
    } else {
112
      console.info("REMOVE: "+ contentProviderId);
113 106
      this.subRemove = this._manageCommunityContentProvidersService.removeContentProvider(this.properties, this.community, contentProviderId).subscribe(
114 107
        data => {
115
          console.info("data REMOVE");
116
          console.info(data);
108
          //console.info(data);
117 109
        },
118 110
        err => {
119
          console.info("error REMOVE");
120 111
          console.log(err);
121 112
        },
122 113
        () => {
123
          console.info("completed REMOVE");
124 114
          this.undo[communityContentProviderId] = "";
125 115
        }
126 116
      )
......
142 132

  
143 133
  private _getOpenaireContentProviders(parameters:string, page: number, size: number){
144 134
    if(!Session.isLoggedIn()){
145
      console.info(this._router.url);
146 135
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
147 136
    } else {
148
      console.info("_getOpenaireContentProviders");
149 137
      if(page > this.pagingLimit) {
150 138
        size=0;
151 139
      }
......
160 148
        this.subResults = this._searchContentProvidersService.searchDataproviders(parameters, null, page, size, [], this.properties).subscribe(
161 149
          data => {
162 150
              this.undo = {};
163
              console.info("total openaire content providers = "+data[0]);
164 151
              this.openaireSearchUtils.totalResults = data[0];
165 152
              this.openaireContentProviders = data[1];
166 153

  
modules/uoa-admin-portal/trunk/src/app/pages/community/content-providers/manage-content-providers.component.ts
57 57

  
58 58
  public updateCommunityContentProviders() {
59 59
    if(!Session.isLoggedIn()){
60
      console.info(this._router.url);
61 60
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
62 61
    } else {
63 62
      this.scroll();
......
69 68

  
70 69
        this.removeContentProvidersComponent._getCommunityContentProviders();
71 70
        this.addContentProvidersComponent.undo = {};
72
        console.info("In remove");
73 71
      } else {
74 72
        this.updateCommunityContentProvidersOnToggle = false;
75 73
        this.pageTitle = "Search content providers";
76 74
        //this.toggleLinkMessage = "Manage content providers";
77
        console.info("In add");
78 75
      }
79 76
    }
80 77
  }
......
84 81
  }
85 82

  
86 83
  public scroll() {
87
    console.info("scroll into view");
88 84
    if (typeof document !== 'undefined') {
89 85
       this.element.nativeElement.scrollIntoView();
90 86
    }
modules/uoa-admin-portal/trunk/src/app/pages/community/content-providers/remove-content-providers.component.ts
128 128
       return false;
129 129
     });
130 130

  
131
     console.info("ngAfterViewInit");
131
     //console.info("ngAfterViewInit");
132 132
  }
133 133

  
134 134
  filterData(row: any, query: string) {
......
165 165
  */
166 166
  triggerInitialLoad(){
167 167
    this.triggered = true;
168
    console.info("triggerInitialLoad");
168
    //console.info("triggerInitialLoad");
169 169
    setTimeout(function(){
170 170
      var table = (<any>$('#dpTable')).DataTable();
171 171
      table.page( 0  ).draw( false );
......
180 180
      table.page( page - 1  ).draw( false );
181 181

  
182 182
      var info = table.page.info();
183
      console.info("records: "+info.recordsDisplay);
184 183
      this.communitySearchUtils.totalResults = info.recordsDisplay;
185 184
  }
186 185

  
......
194 193

  
195 194
  public confirmedDeleteContentProvider(data : any) {
196 195
    if(!Session.isLoggedIn()){
197
      console.info(this._router.url);
198 196
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
199 197
    } else {
200
      console.info("REMOVE: "+ this.selectedCommunityContentProvider.id);
201 198
      this.subRemove = this._manageCommunityContentProvidersService.removeContentProvider(this.properties, this.community, this.selectedCommunityContentProvider.id).subscribe(
202 199
        data => {
203
          console.info("data REMOVE");
204
          console.info(data);
200
          //console.info(data);
205 201
        },
206 202
        err => {
207
          console.info("error REMOVE");
208 203
          console.log(err);
209 204
        },
210 205
        () => {
211
          console.info("completed REMOVE");
212 206
          let index = this.communityContentProviders.indexOf(this.selectedCommunityContentProvider);
213 207
          this.communityContentProviders.splice(index, 1);
214 208

  
......
223 217

  
224 218
  public removeContentProvider(communityContentProvider: any) {
225 219
    if(!Session.isLoggedIn()){
226
      console.info(this._router.url);
227 220
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
228 221
    } else {
229 222
      this.selectedCommunityContentProvider = communityContentProvider;
......
255 248

  
256 249
  public _getCommunityContentProviders(){
257 250
    if(!Session.isLoggedIn()){
258
      console.info(this._router.url);
259 251
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
260 252
    } else {
261
      console.info("_getCommunityContentProviders");
262 253
      this.communitySearchUtils.status = this.errorCodes.LOADING;
263 254
      this.disableForms = true;
264 255
      this.communityContentProviders = [];
......
268 259

  
269 260
      this.subResults = this._searchCommunityContentProvidersService.searchDataproviders(this.properties, this.community).subscribe(
270 261
          data => {
271
            console.info(data);
272
            console.info("search Content Providers [total communityContentProviders:"+data.length+"]");
262
            //console.info("search Content Providers [total communityContentProviders:"+data.length+"]");
273 263
            this.communityContentProviders = data;
274 264

  
275 265
            this.communitySearchUtils.totalResults = data.length;
modules/uoa-admin-portal/trunk/src/app/pages/community/community-edit-form/community-edit-form.component.ts
77 77
                    this.emailToInform = {body: "", subject: "", recipients: []};
78 78

  
79 79
                    if(!Session.isLoggedIn()){
80
                      console.info(this._router.url);
81 80
                      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
82 81
                    } else {
83 82
                      if (this.communityId != null && this.communityId != '') {
......
90 89
                                  this.community = community;
91 90
                                  this.params = {community: encodeURIComponent('"'+community.queryId+'"')};
92 91
                                  this.firstVersionOfManagers = community.managers.slice();
93
                                  console.log("First version of managers " + this.firstVersionOfManagers);
94
                                  console.log(community);
95 92
                                  this.showLoading = false;
96 93
                            },
97 94
                            error => this.handleError('System error retrieving community profile', error)
......
103 100
    }
104 101

  
105 102
    public scroll() {
106
      console.info("scroll into view");
107 103
      if (typeof document !== 'undefined') {
108 104
         this.element.nativeElement.scrollIntoView();
109 105
      }
......
127 123

  
128 124
    public resetForm(communityId: string) {
129 125
      if(!Session.isLoggedIn()){
130
        console.info(this._router.url);
131 126
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
132 127
      } else {
133 128
        if (communityId != null && communityId != '') {
......
151 146

  
152 147
    public updateCommunity() {
153 148
      if(!Session.isLoggedIn()){
154
        console.info(this._router.url);
155 149
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
156 150
      } else {
157 151
        if (this.communityId != null && this.communityId != '') {
158 152
            this.showLoading = true;
159 153
            var community = this.parseUpdatedCommunity();
160 154

  
161
            // TODO delete after testing
162
            console.log(community);
163

  
164 155
            if (!Validator.hasValidEmails(community['managers']) || !this.hasFilled(community["name"])) {
165 156
                this._router.navigate(['/community-edit-form'], {queryParams: { "communityId": this.communityId}});
166 157
            } else {
......
168 159
                this._communityService.updateCommunity(this.properties.communityAPI+this.communityId, community).subscribe(
169 160

  
170 161
                    community => {
171
                        // TODO delete after testing
172
                        console.log("New managers in component: " + newManagers);
173 162
                        if (newManagers !== null) {
174 163
                            this.sendMailToNewManagers(newManagers);
175
                            console.log("Old managers in component: " + this.firstVersionOfManagers);
176 164
                            this.informOldManagersForTheNewOnes(this.firstVersionOfManagers);
177 165
                            for (let i = 0; i < newManagers.length; i++) {
178
                                console.log(newManagers[i]);
179 166
                                this._subscribeService.subscribeToCommunity(this.communityId, newManagers[i], this.properties.adminToolsAPIURL).subscribe(
180 167
                                    res => {
181
                                        console.log(res);
168
                                        //console.log(res);
182 169
                                    }
183 170
                                );
184 171
                                this._subscribeService.getCommunitySubscribers(this.communityId, this.properties.adminToolsAPIURL).subscribe(
185 172
                                    res => {
186
                                        console.log(res);
173
                                        //console.log(res);
187 174
                                    }
188 175
                                );
189 176
                            }
......
230 217
                newManagers.push(this.community['managers'][i]);
231 218
            }
232 219
        }
233
        console.log("New managers are: " + newManagers);
234 220
        return newManagers;
235 221
    }
236 222

  
......
238 224
        this._emailService.sendEmail(this.properties.adminToolsAPIURL + "/sendMail/",
239 225
                                     Composer.composeEmailForNewManager(this.communityId, this.community.title, managers)).subscribe(
240 226
              res => {
241
                console.log("The email has been sent successfully!")
227
                //console.log("The email has been sent successfully!")
242 228
              },
243 229
              error => console.log(error)
244 230
        );
......
250 236
                                                                                           this.firstVersionOfManagers,
251 237
                                                                                           this.community.managers)).subscribe(
252 238
              res => {
253
                console.log("The email has been sent successfully!")
239
                //console.log("The email has been sent successfully!")
254 240
              },
255 241
              error => console.log(error)
256 242
        );
......
279 265

  
280 266
    private hasFilled(data: any): boolean {
281 267
        if (this.isNonEmpty(data) && !this.isEmpty(data)) {
282
            // TODO remove console message after final testing
283
            console.log("NAME IS NOT EMPTY");
284 268
            return true;
285 269
        }
286
        // TODO remove console message after final testing
287
        console.log("NAME IS EMPTY");
288 270
        return false;
289 271
    }
290 272

  
......
306 288
        this.hasChanged = true;
307 289
        this.successfulSaveMessage = '';
308 290
        this.successfulResetMessage = '';
309
        // TODO remove after testing
310
        console.log('I have changed: I AM TRUE');
311 291
    }
312 292

  
313 293
    private resetChange() {
314 294
        this.hasChanged = false;
315
        // TODO remove after testing
316
        console.log('I have changed: I AM FALSE');
317 295
    }
318 296

  
319 297
    public get form() {
modules/uoa-admin-portal/trunk/src/app/pages/community/projects/add-projects.component.ts
94 94

  
95 95
  public addProject(project: SearchResult) {
96 96
    if(!Session.isLoggedIn()){
97
      console.info(this._router.url);
98 97
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
99 98
    } else {
100
      console.info("Add: "+ project.id);
101 99
      this.subAdd = this._manageCommunityProjectsService.addProject(this.properties, this.community, project).subscribe(
102 100
        data => {
103
          console.info("data ADD");
104
          console.info(data);
105 101
          this.undo[project.id] = data.id;
106 102
        },
107 103
        err => {
108
          console.info("error ADD");
109 104
          console.log(err.status);
110
        },
105
        }/*,
111 106
        () => {
112 107
          console.info("completed ADD");
113
        }
114
      )
108
        }*/
109
      );
115 110
    }
116 111
  }
117 112

  
118 113
  public removeProject(projectId: string, communityProjectId: string) {
119 114
    if(!Session.isLoggedIn()){
120
      console.info(this._router.url);
121 115
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
122 116
    } else {
123
      console.info("REMOVE: "+ projectId);
124 117
      this.subRemove = this._manageCommunityProjectsService.removeProject(this.properties, this.community, projectId).subscribe(
125 118
        data => {
126
          console.info("data REMOVE");
127
          console.info(data);
119
          //console.info(data);
128 120
        },
129 121
        err => {
130
          console.info("error REMOVE");
131 122
          console.log(err);
132 123
        },
133 124
        () => {
134
          console.info("completed REMOVE");
135 125
          this.undo[communityProjectId] = "";
136 126
        }
137 127
      )
......
148 138
    }
149 139

  
150 140
    if(this.undo[project.id]) {
151
      console.info("true: "+ this.undo[project.id])
152 141
      return true;
153
    } else {
154
      console.info("false: "+ this.undo[project.id])
155 142
    }
156 143
    return false;
157 144
  }
158 145

  
159 146
  getFunders ()  {
160 147
    if(!Session.isLoggedIn()){
161
      console.info(this._router.url);
162 148
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
163 149
    } else {
164
      console.info("Getting Funders....");
165 150
      this.subFunders = this._searchProjectsService.getFunders(this.properties).subscribe(
166 151
        data => {
167 152
          this.funders = data[1];
......
173 158

  
174 159
  private _getOpenaireProjects(parameters:string, page: number, size: number){
175 160
    if(!Session.isLoggedIn()){
176
      console.info(this._router.url);
177 161
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
178 162
    } else {
179
      console.info("_getOpenaireProjects");
180 163
      if(page > this.pagingLimit) {
181 164
        size=0;
182 165
      }
......
191 174
        this.subResults = this._searchProjectsService.searchProjects(parameters, null, page, size, [], this.properties).subscribe(
192 175
          data => {
193 176
              this.undo = {};
194
              console.info("total openaire projects = "+data[0]);
177
              //console.info("total openaire projects = "+data[0]);
195 178
              this.openaireSearchUtils.totalResults = data[0];
196 179
              this.openaireProjects = data[1];
197 180

  
modules/uoa-admin-portal/trunk/src/app/pages/community/projects/manage-projects.component.ts
57 57

  
58 58
  public updateCommunityProjects() {
59 59
    if(!Session.isLoggedIn()){
60
      console.info(this._router.url);
61 60
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
62 61
    } else {
63 62
      this.scroll();
......
84 83
  }
85 84

  
86 85
  public scroll() {
87
    console.info("scroll into view");
88 86
    if (typeof document !== 'undefined') {
89 87
       this.element.nativeElement.scrollIntoView();
90 88
    }
modules/uoa-admin-portal/trunk/src/app/pages/community/projects/remove-projects.component.ts
136 136
       return false;
137 137
     });
138 138

  
139
     console.info("ngAfterViewInit");
139
     //console.info("ngAfterViewInit");
140 140
  }
141 141

  
142 142
  filterData(row: any, query: string, selectedFunder: string) {
......
177 177
  */
178 178
  triggerInitialLoad(){
179 179
    this.triggered = true;
180
    console.info("triggerInitialLoad");
180
    //console.info("triggerInitialLoad");
181 181
    setTimeout(function(){
182 182
      var table = (<any>$('#dpTable')).DataTable();
183 183
      table.page( 0  ).draw( false );
......
205 205
      table.page( page - 1  ).draw( false );
206 206

  
207 207
      var info = table.page.info();
208
      console.info("records: "+info.recordsDisplay);
209 208
      this.communitySearchUtils.totalResults = info.recordsDisplay;
210 209
  }
211 210

  
......
219 218

  
220 219
  public confirmedDeleteProject(data : any) {
221 220
    if(!Session.isLoggedIn()){
222
      console.info(this._router.url);
223 221
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
224 222
    } else {
225
      console.info("REMOVE: "+ this.selectedCommunityProject.id);
226 223
      this.subRemove = this._manageCommunityProjectsService.removeProject(this.properties, this.community, this.selectedCommunityProject.id).subscribe(
227 224
        data => {
228
          console.info("data REMOVE");
229
          console.info(data);
225
          //console.info(data);
230 226
        },
231 227
        err => {
232
          console.info("error REMOVE");
233 228
          console.log(err);
234 229
        },
235 230
        () => {
236
          console.info("completed REMOVE");
237 231
          let index = this.communityProjects.indexOf(this.selectedCommunityProject);
238 232
          this.communityProjects.splice(index, 1);
239 233

  
......
248 242

  
249 243
  public removeProject(communityProject: any) {
250 244
    if(!Session.isLoggedIn()){
251
      console.info(this._router.url);
252 245
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
253 246
    } else {
254 247
      this.selectedCommunityProject = communityProject;
......
280 273

  
281 274
  public _getCommunityProjects(){
282 275
    if(!Session.isLoggedIn()){
283
      console.info(this._router.url);
284 276
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
285 277
    } else {
286 278
      this.communitySearchUtils.status = this.errorCodes.LOADING;
......
293 285

  
294 286
      this.subResults = this._searchCommunityProjectsService.searchProjects(this.properties, this.community).subscribe(
295 287
          data => {
296
            console.info(data);
297
            console.info("search Projects [total communityProjects:"+data.length+"]");
288
            //console.info("search Projects [total communityProjects:"+data.length+"]");
298 289
            this.communityProjects = data;
299 290

  
300 291
            this.communitySearchUtils.totalResults = data.length;
......
353 344
        this.funders.add(funder);
354 345
      }
355 346
    }
356
    console.info(this.funders);
357 347
    return this.funders;
358 348
  }
359 349
}
modules/uoa-admin-portal/trunk/src/app/pages/divhelpcontent/div-help-content-form.component.ts
53 53
           this.route.queryParams.subscribe(params => {
54 54

  
55 55
             if(!Session.isLoggedIn()){
56
               console.info(this._router.url);
57 56
               this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
58 57
             } else {
59 58
               if(this.pageId) {
......
79 78

  
80 79
    public pageSelected(event) {
81 80
      if(!Session.isLoggedIn()){
82
        console.info(this._router.url);
83 81
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
84 82
      } else {
85 83
        this.getDivs(event.target.value);
......
92 90

  
93 91
    public getCommunity(communityPid: string) {
94 92
      if(!Session.isLoggedIn()){
95
        console.info(this._router.url);
96 93
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
97 94
      } else {
98 95
        this.showLoading = true;
......
114 111

  
115 112
    public getDivs(pageId: string) {
116 113
      if(!Session.isLoggedIn()){
117
        console.info(this._router.url);
118 114
        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
119 115
      } else {
120 116
        this.showLoading = true;
modules/uoa-admin-portal/trunk/src/app/pages/divhelpcontent/div-help-contents.component.ts
81 81

  
82 82
    getPage(pageId: string) {
83 83
      if(!Session.isLoggedIn()){
84
        console.info(this.router.url);
85 84
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
86 85
      } else {
87 86
        this.showLoading = true;
......
99 98

  
100 99
    getPages(community_pid: string) {
101 100
      if(!Session.isLoggedIn()){
102
        console.info(this.router.url);
103 101
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
104 102
      } else {
105 103
        this.showLoading = true;
......
130 128

  
131 129
    getDivHelpContents(community_pid: string) {
132 130
      if(!Session.isLoggedIn()){
133
        console.info(this.router.url);
134 131
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
135 132
      } else {
136 133
        this._helpService.getCommunityDivHelpContents(community_pid, this.properties.adminToolsAPIURL).subscribe(
......
190 187

  
191 188
    private confirmModalOpen() {
192 189
      if(!Session.isLoggedIn()){
193
        console.info(this.router.url);
194 190
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
195 191
      } else {
196 192
        this.alertModalDeleteDivHelpContents.cancelButton = true;
......
204 200

  
205 201
    public confirmedDeleteDivHelpContents(data: any) {
206 202
      if(!Session.isLoggedIn()){
207
        console.info(this.router.url);
208 203
        this.router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this.router.url} });
209 204
      } else {
210 205
        this.showLoading = true;
......
241 236

  
242 237
    public toggleDivHelpContents(status : boolean, ids : string[]) {
243 238
      if(!Session.isLoggedIn()){
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff